Verificar em Python o endereço de E-mail válido?

A biblioteca padrão Python vem com uma função de processamento de E-mail: email.utils.parseaddr().

Devolve uma dupla-tupla contendo o nome verdadeiro e as partes do endereço actual do E-mail:

>>> from email.utils import parseaddr
>>> parseaddr('[email protected]')
('', '[email protected]')

>>> parseaddr('Full Name <[email protected]>')
('Full Name', '[email protected]')

>>> parseaddr('"Full Name with quotes and <[email protected]>" <[email protected]>')
('Full Name with quotes and <[email protected]>', '[email protected]')

E se a análise não for bem sucedida, devolve uma dupla-tupla de cadeias de caracteres vazias:

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

Um problema com este analisador é que ele está aceitando qualquer coisa que é considerado como um endereço de E-mail válido para RFC-822 e amigos, incluindo muitas coisas que claramente não são endereço na Internet:

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

>>> parseaddr('invalid-email')
('', 'invalid-email')

Assim, como @TokenMacGuy disse, a única forma definitiva de verificar um endereço de E-mail é enviar um e-mail para o endereço esperado e esperar que o utilizador actue sobre a informação dentro da mensagem.

No entanto, você pode querer verificar, pelo menos, a presença de um @ - sign no segundo elemento tuple, como @bvukelic sugere:

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

Se quiser ir mais longe, pode instalar o projectodnspython e resolver os servidores de E-mail para o domínio de E-mail (a parte a seguir ao '@'), só tentando enviar um e-mail se existirem servidores reais MX:

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

Podes apanhar ambos NoAnswer e NXDOMAIN capturando dns.exception.DNSException.

E sim, foo@[email protected] é um endereço sintaticamente válido. Apenas o último @ deve ser considerado para detectar onde a parte do domínio começa.

O Python tem um módulo chamado validate_ email que tem 3 níveis de validação de E-mail, incluindo perguntar a um servidor SMTP válido se o endereço de E-mail é válido (sem enviar um e-mail).

Verificar o texto de E-mail é um formato válido:

from validate_email import validate_email
is_valid = validate_email('[email protected]')

Verifique se a máquina tem um servidor de SMTP:

is_valid = validate_email('[email protected]',check_mx=True)

Verifique se a máquina tem o servidor de SMTP e o e-mail realmente existe:

is_valid = validate_email('[email protected]',verify=True)

Tudo o que estamos a fazer é comparar o texto de entrada com um uma expressão regular gigantesca. Mas construir aquele "regexp", e garantir a sua correcção, é facilitado pela sua montagem a partir dos" tokens " definidos pela RFC. Cada um destes símbolos é ensaiado no ensaio da unidade de acompanhamento arquivo.

Para instalar com o pip

pip install validate_email

E vai precisar do módulo pyDNS para verificar os servidores de SMTP

pip install pyDNS

Ou do Ubuntu

apt-get python3-dns

Encontrei um código antigo:

import lepl.apps.rfc3696
email_validator = lepl.apps.rfc3696.Email()
if not email_validator("[email protected]"):
    print "Invalid email"

Encontrei uma excelente (e testada) forma de verificar o endereço de E-mail válido. Eu colo o meu código aqui:

# 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 = ["[email protected]", "[email protected]", "wha.t.`1an?ug{}[email protected]"]
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)

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

Isto é normalmente resolvido usando a expressão regular. No entanto, existem muitas variações de soluções. Dependendo de quão rigoroso você precisa ser, e se você tem requisitos personalizados para validação, ou irá aceitar qualquer endereço de E-mail válido.

Ver esta página, para referência: http://www.regular-expressions.info/email.html

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()

Se quiser tirar o correio de um texto longo ou ficheiro, então tente isto.

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

Exemplo de trabalho:

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

O parseaddr acima mencionado ignoraria o rasto @.

from email.utils import parseaddr
parseaddr('aaa@[email protected]') ('', 'aaa@bbb')

import validator
is_valid = validate_email('[email protected]',verify=True)
if (is_valid==True):
    return 1
else:
    return 0

Ver validate_email docs .

A procurar o ID de E-mail:

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..

Para verificar o e-mail 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")

Considerei isto uma aplicação prática:

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

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

Validação por e-mail

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.'

A única maneira realmente precisa de distinguir os endereços de E-mail válidos dos Inválidos é para enviar e-mail para ele. O que conta como um e-mail é surpreendentemente complicado ({[[0]} na verdade é um endereço de E-mail válido), e você provavelmente quer que o endereço de E-mail realmente envie para ele mais tarde. Depois de passar algumas verificações básicas de sanidade (como na resposta de Thomas, tem um @ e pelo menos um . após o @), você provavelmente deveria enviar uma carta de verificação por e-mail para o endereço, e esperar que o usuário siga um link incorporado na mensagem para confirmar que o e-mail era válido.