Verificar em Python o endereço de E-mail válido?
Existe uma boa maneira de verificar uma entrada de formulário usando a regex para se certificar de que é um endereço de E-mail de estilo apropriado? Tenho procurado desde ontem à noite e toda a gente que respondeu às perguntas das pessoas sobre este tópico também parece ter problemas com ele se for um endereço de email subdominado.
18 answers
@
, e pelo menos um .
na parte após a @
:
[^@]+@[^@]+\.[^@]+
Você provavelmente também gostaria de desautorizar espaços em branco -- provavelmente existem endereços de E-mail válidos com espaços em branco neles, mas eu nunca vi nenhum, então as chances de ser um erro do usuário estão do seu lado.
Se quer a verificação completa, dê uma vista de olhos a esta pergunta.
Actualização: aqui está a forma como pode usar qualquer regex:
import re
if not re.match(r"... regex here ...", email):
# whatever
Observe o r
na frente da corda; desta forma, você não vai precisar escapar das coisas duplamente.
Se tiver um grande número de regexos para verificar, poderá ser mais rápido compilar o regex primeiro:
import re
EMAIL_REGEX = re.compile(r"... regex here ...")
if not EMAIL_REGEX.match(email):
# whatever
Outra opção é usar o validate_email
pacote, que realmente contacta o servidor SMTP para verificar se o endereço existe. Isto ainda não garante que pertence à pessoa certa.
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)
Para os interessados nos detalhes sujos, validate_email.py (fonte ) pretende ser fiel a RFC 2822.
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]+)
Nota, Isto irá funcionar quando tiver um espaço antes e depois do seu endereço de E-mail. se você não tem espaço ou tem alguns caracteres especiais, então você pode tentar modificá-lo.
Exemplo de trabalho:
string="Hello ABCD, here is my mail id [email protected] "
res = re.search("([^@|\s]+@[^@]+\.[^@|\s]+)",string,re.I)
res.group(1)
Isto vai acabar. [email protected] desta corda.
Além disso, note que esta pode não ser a resposta certa.. Mas eu postei aqui para ajudar alguém que tem requisitos específicos como eu.
O parseaddr acima mencionado ignoraria o rasto @.
from email.utils import parseaddr
parseaddr('aaa@[email protected]') ('', 'aaa@bbb')
{[[2]} provavelmente extrair o endereço e comparar com o original?
Alguém tentou validar.e-mail ?
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.