¿Cómo comprobar la dirección de correo electrónico válida?

¿Hay una buena manera de verificar la entrada de un formulario usando expresiones regulares para asegurarse de que sea una dirección de correo electrónico de estilo adecuado? He estado buscando desde la noche anterior y todos los que han respondido a las preguntas de la gente sobre este tema también parecen tener problemas si es una dirección de correo electrónico subdominada.

No tiene sentido. Incluso si puede verificar que la dirección de correo electrónico es sintácticamente válida, aún deberá verificar que no haya sido mal escrita, y que realmente vaya a la persona que cree que es. La única forma de hacerlo es enviarles un correo electrónico y hacer que hagan clic en un enlace para verificarlo.

Por lo tanto, un chequeo más básico (por ejemplo, que no ingresaron accidentalmente en su dirección) es generalmente suficiente. Algo así como: tiene exactamente un signo @ , y al menos uno . en la parte posterior a la @ :

 [^@]+@[^@]+\.[^@]+ 

Probablemente también querrá rechazar los espacios en blanco: probablemente haya direcciones de correo electrónico válidas con espacios en blanco, pero nunca he visto una, por lo que las probabilidades de que esto sea un error de usuario están de su lado.

Si quieres el cheque completo, mira esta pregunta .


Actualización: aquí es cómo podría usar cualquier expresión regular:

 import re if not re.match(r"... regex here ...", email): # whatever 

Python ≥3.4 tiene re.fullmatch que es preferible a re.match .

Tenga en cuenta la r delante de la cadena; De esta manera, no necesitarás escapar de las cosas dos veces.

Si tiene una gran cantidad de expresiones regulares para verificar, puede ser más rápido comstackr la expresión regular primero:

 import re EMAIL_REGEX = re.compile(r"... regex here ...") if not EMAIL_REGEX.match(email): # whatever 

Otra opción es usar el paquete validate_email , que en realidad contacta con el servidor SMTP para verificar que la dirección existe. Sin embargo, esto todavía no garantiza que pertenezca a la persona adecuada.

La biblioteca estándar de Python viene con una función de análisis de correo electrónico: email.utils.parseaddr() .

Devuelve una tupla doble que contiene el nombre real y las partes de la dirección real del correo electrónico:

 >>> from email.utils import parseaddr >>> parseaddr('foo@example.com') ('', 'foo@example.com') >>> parseaddr('Full Name ') ('Full Name', 'full@example.com') >>> parseaddr('"Full Name with quotes and " ') ('Full Name with quotes and ', 'weird@example.com') 

Y si el análisis no tiene éxito, devuelve una tupla de dos cadenas vacías:

 >>> parseaddr('[invalid!email]') ('', '') 

Un problema con este analizador es que acepta cualquier cosa que se considere como una dirección de correo electrónico válida para RFC-822 y amigos, incluidas muchas cosas que claramente no son direccionables en Internet:

 >>> parseaddr('invalid@example,com') # notice the comma ('', 'invalid@example') >>> parseaddr('invalid-email') ('', 'invalid-email') 

Entonces, como lo expresó @TokenMacGuy, la única forma definitiva de verificar una dirección de correo electrónico es enviar un correo electrónico a la dirección esperada y esperar a que el usuario actúe sobre la información dentro del mensaje.

Sin embargo, es posible que desee comprobar, al menos, la presencia de un signo-@ en el segundo elemento de la tupla, como sugiere @bvukelic:

 >>> '@' in parseaddr("invalid-email")[1] False 

Si desea ir un paso más allá, puede instalar el proyecto dnspython y resolver los servidores de correo para el dominio de correo electrónico (la parte después de ‘@’), solo tratando de enviar un correo electrónico si hay servidores MX reales. :

 >>> from dns.resolver import query >>> domain = 'foo@bar@google.com'.rsplit('@', 1)[-1] >>> bool(query(domain, 'MX')) True >>> query('example.com', 'MX') Traceback (most recent call last): File "", line 1, in  [...] dns.resolver.NoAnswer >>> query('not-a-domain', 'MX') Traceback (most recent call last): File "", line 1, in  [...] dns.resolver.NXDOMAIN 

Puede detectar tanto NoAnswer como NXDOMAIN capturando dns.exception.DNSException .

Y sí, foo@bar@google.com es una dirección sintácticamente válida. Solo se debe considerar la última @ para detectar dónde comienza la parte del dominio.

No he visto la respuesta aquí entre el desorden de las respuestas Regex personalizadas, pero …

Existe una biblioteca de python llamada validate_email que tiene 3 niveles de validación de correo electrónico, incluida la solicitud a un servidor SMTP válido si la dirección de correo electrónico es válida (sin enviar un correo electrónico).

Comprobar la cadena de correo electrónico es un formato válido:

 from validate_email import validate_email is_valid = validate_email('example@example.com') 

Compruebe si el host tiene servidor SMTP:

 is_valid = validate_email('example@example.com',check_mx=True) 

Compruebe si el host tiene un servidor SMTP y si el correo electrónico existe realmente:

 is_valid = validate_email('example@example.com',verify=True) 

Para aquellos interesados ​​en los detalles sucios, validate_email.py ( fuente ) apunta a ser fiel a RFC 2822 .

Todo lo que realmente estamos haciendo es comparar la cadena de entrada con una expresión regular gigantesca. Pero construir esa expresión regular, y asegurar su corrección, se hace mucho más fácil al ensamblarla a partir de los “tokens” definidos por el RFC. Cada uno de estos tokens se prueba en el archivo de prueba de la unidad adjunto.


Para instalar con pip

 pip install validate_email 

y necesitarás el módulo pyDNS para verificar los servidores SMTP

 pip install pyDNS 

o desde Ubuntu

 apt-get python3-dns 

Las direcciones de correo electrónico no son tan simples como parecen! Por ejemplo, Bob_O’Reilly+tag@example.com, es una dirección de correo electrónico válida.

He tenido algo de suerte con el paquete lepl ( http://www.acooke.org/lepl/ ). Puede validar las direcciones de correo electrónico como se indica en RFC 3696: http://www.faqs.org/rfcs/rfc3696.html

Encontré algún código antiguo:

 import lepl.apps.rfc3696 email_validator = lepl.apps.rfc3696.Email() if not email_validator("email@example.com"): print "Invalid email" 

Encontré una forma excelente (y probada) de verificar la dirección de correo electrónico válida. Pego mi código aquí:

 # here i import the module that implements regular expressions import re # here is my function to check for valid email address def test_email(your_pattern): pattern = re.compile(your_pattern) # here is an example list of email to check it at the end emails = ["john@example.com", "python-list@python.org", "wha.t.`1an?ug{}ly@email.com"] for email in emails: if not re.match(pattern, email): print "You failed to match %s" % (email) elif not your_pattern: print "Forgot to enter a pattern!" else: print "Pass" # my pattern that is passed as argument in my function is here! pattern = r"\"?([-a-zA-Z0-9.`?{}]+@\w+\.\w+)\"?" # here i test my function passing my pattern test_email(pattern) 

Veo muchas respuestas complicadas aquí. Algunos de ellos no conocen la dirección de correo electrónico simple o verdadera o tienen falsos positivos. A continuación, es la forma más sencilla de probar que la cadena sería un correo electrónico válido. Prueba contra TLD de 2 y 3 letras. Ahora que técnicamente puede tener más grandes, puede que desee boost los 3 a 4, 5 o incluso 10.

 import re def valid_email(email): return bool(re.search(r"^[\w\.\+\-]+\@[\w]+\.[az]{2,3}$", email)) 

Esto normalmente se resuelve utilizando expresiones regulares. Sin embargo, hay muchas variaciones de soluciones. Dependiendo de qué tan estricto deba ser, y si tiene requisitos personalizados para la validación, o aceptará cualquier dirección de correo electrónico válida.

Ver esta página para referencia: http://www.regular-expressions.info/email.html

Las direcciones de correo electrónico son increíblemente complicadas. Aquí hay un ejemplo de expresión regular que coincidirá con cada dirección válida RFC822: http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html

Notarás que probablemente sea más largo que el rest de tu progtwig. Incluso hay módulos completos para Perl con el propósito de validar direcciones de correo electrónico. Por lo tanto, es probable que no obtenga nada que sea 100% perfecto como expresión regular y que también sea legible. Aquí hay un ejemplo de analizador de descenso recursivo: http://cpansearch.perl.org/src/ABIGAIL/RFC-RFC822-Address-2009110702/lib/RFC/RFC822/Address.pm

pero tendrá que decidir si necesita un análisis perfecto o un código simple.

Si desea sacar el correo de una larga cadena o archivo, intente esto.

 ([^@|\s]+@[^@]+\.[^@|\s]+) 

Tenga en cuenta que esto funcionará cuando tenga un espacio antes y después de su dirección de correo electrónico. Si no tiene espacio o tiene algunos caracteres especiales, puede intentar modificarlo.

Ejemplo de trabajo:

 string="Hello ABCD, here is my mail id example@me.com " res = re.search("([^@|\s]+@[^@]+\.[^@|\s]+)",string,re.I) res.group(1) 

Esto sacará example@me.com de esta cadena.

Además, tenga en cuenta que esta puede no ser la respuesta correcta. Pero lo he publicado aquí para ayudar a alguien que tiene un requisito específico como yo.

 import validator is_valid = validate_email('example@example.com',verify=True) if (is_valid==True): return 1 else: return 0 

Ver documentos de validate_email .

 import re def email(): email = raw_input("enter the mail address::") match = re.search(r'[\w.-]+@[\w.-]+.\w+', email) if match: print "valid email :::", match.group() else: print "not valid:::" email() 

Buscando ID de correo electrónico: encontrando captura de pantalla de IP

 import re a=open("aa.txt","r") #c=a.readlines() b=a.read() c=b.split("\n") print(c) for d in c: obj=re.search(r'[\w.]+\@[\w.]+',d) if obj: print(obj.group()) #for more calcification click on image above.. 

Encontramos que esto es una implementación práctica:

 [^@\s]+@[^@\s]+\.[^@\s]+ 

Para la verificación de correo electrónico use email_validator

 from email_validator import validate_email, EmailNotValidError def check_email(email): try: v = validate_email(email) # validate and get info email = v["email"] # replace with normalized form print("True") except EmailNotValidError as e: # email is not valid, exception message is human-readable print(str(e)) check_email("test@gmailcom") 

Use esta máscara de filtro en la entrada de correo electrónico: emailMask: /[\w.\-@'"!#$%&'*+/=?^_ {|} ~] / i`

 "^[\w\.\+\-]+\@[\w]+\.[az]{2,3}$" 

La única forma realmente precisa de distinguir las direcciones de correo electrónico válidas y reales de las no válidas es enviándole un correo . Lo que cuenta como un correo electrónico es sorprendentemente complicado ( "John Doe" " realidad es una dirección de correo electrónico válida), y lo más probable es que desee que la dirección de correo electrónico le envíe un correo electrónico más tarde. Algunas comprobaciones básicas (como en la respuesta de Thomas, tiene una @ y al menos una . después de la @ ), es probable que deba enviar una carta de verificación por correo electrónico a la dirección y esperar a que el usuario siga un enlace incrustado en el mensaje. para confirmar que el correo electrónico era válido.

validación de correo electrónico

 import re def validate(email): match=re.search(r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9]+\.[a-zA-Z0-9.]*\.*[com|org|edu]{3}$)",email) if match: return 'Valid email.' else: return 'Invalid email.'