Comment vérifier une adresse email valide?
Existe-t-il un moyen efficace de vérifier une entrée de formulaire à l’aide de regex afin de s’assurer qu’il s’agit bien d’une adresse électronique de style? Je cherche depuis hier soir et tout le monde qui a répondu aux questions des gens sur ce sujet semble également avoir des problèmes avec cela s'il s'agit d'une adresse email sous-dominée.
Il n'y a aucun intérêt. Même si vous pouvez vérifier que l'adresse électronique est syntaxiquement valide, vous devrez tout de même vérifier qu'elle n'a pas été mal saisie et qu'elle est effectivement transmise à la personne que vous croyez qu'elle possède. La seule façon de le faire est de leur envoyer un courrier électronique et de leur demander de cliquer sur un lien pour vérifier.
Par conséquent, une vérification élémentaire (par exemple, le fait qu’ils n’ont pas entré par inadvertance leur adresse postale) est généralement suffisante. Quelque chose comme: il y a exactement un signe @ et au moins un . dans la pièce après le @:
[^@]+@[^@]+\.[^@]+
Vous voudrez probablement aussi interdire les espaces blancs - il y a probablement des adresses électroniques valides contenant des espaces, mais je n'en ai jamais vu.
Si vous voulez la vérification complète, regardez cette question .
Mise à jour: Voici comment vous pouvez utiliser n'importe quelle regex:
import re
if not re.match(r"... regex here ...", email):
# whatever
Notez la r devant la chaîne; De cette façon, vous n'aurez pas besoin d'échapper deux fois.
Si vous avez un grand nombre de regex à vérifier, il peut être plus rapide de compiler le regex en premier:
import re
EMAIL_REGEX = re.compile(r"... regex here ...")
if not EMAIL_REGEX.match(email):
# whatever
Une autre option consiste à utiliser le paquet validate_email , qui contacte en réalité le serveur SMTP pour vérifier que l'adresse existe. Cela ne garantit toujours pas qu'il appartient à la bonne personne, cependant.
La bibliothèque standard Python est fournie avec une fonction d'analyse de courrier électronique: email.utils.parseaddr() .
Il retourne un deux -uple contenant le nom réel et les parties d'adresse réelle de l'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]')
Et si l'analyse échoue, elle retourne deux-Tuple de chaînes vides:
>>> parseaddr('[invalid!email]')
('', '')
Un problème avec cet analyseur est qu'il accepte tout ce qui est considéré comme une adresse électronique valide pour le RFC-822 et ses amis, y compris de nombreux éléments qui ne sont clairement pas adressables sur le vaste réseau Internet:
>>> parseaddr('invalid@example,com') # notice the comma
('', 'invalid@example')
>>> parseaddr('invalid-email')
('', 'invalid-email')
Ainsi, comme l'a dit @TokenMacGuy, le seul moyen de vérifier une adresse e-mail consiste à envoyer un e-mail à l'adresse attendue et à attendre que l'utilisateur agisse en fonction des informations contenues dans le message.
Toutefois, vous pouvez au moins vérifier la présence d'un signe @ sur le deuxième élément Tuple, comme le suggère @bvukelic:
>>> '@' in parseaddr("invalid-email")[1]
False
Si vous voulez aller plus loin, vous pouvez installer le projet dnspython project et résoudre les serveurs de messagerie pour le domaine de messagerie (partie après le '@'), en essayant uniquement d'envoyer un courrier électronique s'il y en a un. sont des serveurs MX réels:
>>> 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
Vous pouvez intercepter NoAnswer et NXDOMAIN en attrapant dns.exception.DNSException.
Et oui, foo@[email protected] est une adresse syntaxiquement valide. Seul le dernier @ doit être pris en compte pour détecter le début de la partie de domaine.
Je n'ai pas encore vu la réponse ici parmi le fouillis de réponses Regex personnalisées, mais ...
Python a un module appelé validate_email qui comporte 3 niveaux de validation du courrier électronique, y compris demander à un serveur SMTP valide si l’adresse électronique est valide (sans envoyer de courrier électronique).
Vérifiez que la chaîne de courrier électronique est au format valide:
from validate_email import validate_email
is_valid = validate_email('[email protected]')
Vérifiez si l'hôte dispose du serveur SMTP:
is_valid = validate_email('[email protected]',check_mx=True)
Vérifiez si l'hôte dispose du serveur SMTP et que le courrier électronique existe réellement:
is_valid = validate_email('[email protected]',verify=True)
Pour ceux qui sont intéressés par les détails sales, validate_email.py ( source ) vise à être fidèle à RFC 2822 .
Nous ne faisons que comparer la chaîne d'entrée à un expression régulière gigantesque. Mais construire cette expression rationnelle, et en s'assurant de son exactitude, est beaucoup plus facile en l'assemblant des "jetons" définis par le RFC. Chacun de ces jetons est testé dans le fichier de test unitaire joint.
À installer avec pip
pip install validate_email
et vous aurez besoin du module pyDNS pour vérifier les serveurs SMTP
pip install pyDNS
ou d'Ubuntu
apt-get python3-dns
Les adresses e-mail ne sont pas aussi simples qu'il y paraît! Par exemple, Bob_O'[email protected] est une adresse électronique valide.
J'ai eu un peu de chance avec le paquet Lepl ( http://www.acooke.org/lepl/ ). Il peut valider les adresses e-mail comme indiqué dans la RFC 3696: http://www.faqs.org/rfcs/rfc3696.html
Trouvé un ancien code:
import lepl.apps.rfc3696
email_validator = lepl.apps.rfc3696.Email()
if not email_validator("[email protected]"):
print "Invalid email"
J'ai trouvé un excellent moyen (et testé) de vérifier l'adresse e-mail valide. Je colle mon code ici:
# 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)
Je vois beaucoup de réponses compliquées ici. Certains d'entre eux échouent dans leur connaissance d'une adresse email simple et vraie ou ont des faux positifs. Ci-dessous, le moyen le plus simple de tester que la chaîne serait un email valide. Il teste contre les TLD de 2 et 3 lettres. Maintenant que vous pouvez techniquement en avoir de plus gros, vous pouvez augmenter le nombre de 3 à 4, 5 ou même 10.
import re
def valid_email(email):
return bool(re.search(r"^[\w\.\+\-]+\@[\w]+\.[a-z]{2,3}$", email))
Ceci est généralement résolu en utilisant regex. Il existe cependant de nombreuses variantes de solutions. Selon le degré de rigueur dont vous avez besoin et si vous avez des exigences personnalisées en matière de validation, vous accepterez toute adresse e-mail valide.
Voir cette page pour référence: http://www.regular-expressions.info/email.html
Les adresses e-mail sont incroyablement compliquées. Voici un exemple de regex qui correspond à chaque adresse valide par RFC822: http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html
Vous remarquerez que c'est probablement plus long que le reste de votre programme. Il existe même des modules entiers pour Perl dans le but de valider les adresses e-mail. Donc, vous n'obtiendrez probablement rien de parfait à 100% comme regex tout en restant lisible. Voici un exemple d'analyseur de descente récursif: http://cpansearch.Perl.org/src/ABIGAIL/RFC-RFC822-Address-2009110702/lib/RFC/RFC822/Address.pm
mais vous devrez décider si vous avez besoin d'analyses parfaites ou d'un code simple.
Le parseaddr mentionné ci-dessus ignorerait le @ suivi.
from email.utils import parseaddr
parseaddr('aaa@[email protected]') ('', 'aaa@bbb')
Extrait probablement l'adresse et compare à l'original?
Quelqu'un at-il essayé de valider.email?
Si vous souhaitez supprimer le courrier d'une longue chaîne ou d'un fichier, essayez ceci.
([^@|\s]+@[^@]+\.[^@|\s]+)
Notez que cela fonctionnera si vous avez un espace avant et après votre adresse email. si vous n'avez pas d'espace ou des caractères spéciaux, essayez de le modifier.
Exemple de travail:
string="Hello ABCD, here is my mail id [email protected] "
res = re.search("([^@|\s]+@[^@]+\.[^@|\s]+)",string,re.I)
res.group(1)
Cela supprimera [email protected] de cette chaîne.
En outre, notez que ceci peut ne pas être la bonne réponse .. Mais je l’a posté ici pour aider quelqu'un qui a des exigences spécifiques comme moi
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()
import validator
is_valid = validate_email('[email protected]',verify=True)
if (is_valid==True):
return 1
else:
return 0
Voir validate_email docs .
Utilisez ce masque de filtre pour la saisie de courrier électronique: EmailMask: /[\w.\-@'"!#$%&'*+/=?^_ {|} ~]/i`
Trouver Email-id: 
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..
Pour vérifier les emails, utilisez 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")
"^[\w\.\+\-]+\@[\w]+\.[a-z]{2,3}$"
J'ai trouvé que c'était une implémentation pratique:
[^@\s]+@[^@\s]+\.[^@\s]+