Python vérifier l'adresse email valide?

y a-t-il un bon moyen de vérifier l'entrée d'un formulaire à l'aide de regex pour s'assurer qu'il s'agit d'une adresse courriel de style approprié? J'ai cherché depuis la nuit dernière et tout le monde qui a répondu aux questions des gens concernant ce sujet semble également avoir des problèmes avec elle si elle est une adresse e-mail sous -dominé.

136
demandé sur user1937198 2011-11-05 23:05:23

18 réponses

ça ne sert à rien. Même si vous pouvez vérifier que l'adresse e-mail est valide sur le plan syntaxique, vous devrez tout de même vérifier qu'elle n'a pas été mal orthographiée et qu'elle va bien à la personne que vous pensez qu'elle est valide. La seule façon de le faire est d'envoyer un e-mail et leur demander de cliquer sur un lien pour vérifier.

par conséquent, une vérification de base (par exemple qu'ils n'ont pas entré accidentellement leur adresse municipale) est généralement suffisante. Quelque chose comme: il a exactement un @ signe, et au moins un . dans la partie après le @ :

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

vous voudriez probablement aussi interdire les espaces blancs -- il y a probablement des adresses email valides avec des espaces en elles, mais je n'en ai jamais vu un, donc les chances de ceci étant une erreur d'utilisateur sont de votre côté.

si vous voulez la vérification complète, jetez un oeil à cette question .


mise à jour: Voici comment vous pouvez utiliser un tel regex:

import re

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

Notez le r devant la corde; de cette façon, vous n'aurez pas besoin d'échapper aux choses deux fois.

si vous avez un grand nombre de regexes à 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 est d'utiliser le paquet validate_email , qui contacte en fait le serveur SMTP pour vérifier que le adresse existe. Cela ne garantit toujours pas qu'il appartient à la bonne personne, cependant.

203
répondu Thomas 2018-09-14 10:35:58

la bibliothèque standard de Python est dotée d'une fonction de parsing d'e-mail: email.utils.parseaddr() .

il retourne un double-tuple contenant le nom réel et l'adresse réelle parties de l'e-mail:

>>> from email.utils import parseaddr
>>> parseaddr('foo@example.com')
('', 'foo@example.com')

>>> parseaddr('Full Name <full@example.com>')
('Full Name', 'full@example.com')

>>> parseaddr('"Full Name with quotes and <weird@chars.com>" <weird@example.com>')
('Full Name with quotes and <weird@chars.com>', 'weird@example.com')

et si l'analyse est infructueuse, il renvoie un double-tuple de cordes vides:

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

un problème avec cet analyseur est qu'il est d'accepter tout ce qui est considéré comme un adresse e-mail valide pour RFC-822 et ses amis, y compris de nombreuses choses qui ne sont clairement pas adressables sur le large Internet:

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

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

donc, comme @TokenMacGuy l'a dit, la seule façon définitive de vérifier une adresse e-mail est d'envoyer un e-mail à l'adresse attendue et d'attendre que l'utilisateur agisse sur les informations contenues dans le message.

cependant, vous pourriez vouloir vérifier, au moins, la présence d'un @ - sign sur le deuxième élément de tuple, comme @bvukelic suggère:

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

si vous voulez aller un peu plus loin, vous pouvez installer le projet dnspython et résoudre les serveurs de messagerie pour le domaine e-mail (la partie après le '@'), en essayant seulement d'envoyer un e-mail s'il ya réelle MX serveurs:

>>> 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 "<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 attraper à la fois NoAnswer et NXDOMAIN en attrapant dns.exception.DNSException .

et oui, foo@bar@google.com est un syntaxiquement valide l'adresse. Seul le dernier @ doit être pris en compte pour la détection du point de départ de la partie domaine.

92
répondu LeoRochael 2018-06-27 18:45:31

Je n'ai pas vu la réponse déjà ici parmi le gâchis des réponses Regex personnalisées, mais...

Python a un module appelé validate_email qui a 3 niveaux de validation de courriel, y compris demander à un serveur SMTP valide si l'adresse de courriel est valide (sans envoyer de courriel).

vérifier la chaîne de courriel est le format valide:

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

vérifier si L'hôte a un serveur SMTP:

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

vérifier si L'hôte a le serveur SMTP et l'email existe vraiment:

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

pour ceux qui s'intéressent aux détails sales, validate_email.py ( source ) vise à être fidèle à RFC 2822 .

tout ce que nous faisons réellement est de comparer la chaîne de saisie à une expression régulière gigantesque. Mais construire ce regexp, et en assurant son exactitude, est rendue beaucoup plus facile en l'assemblant des "jetons" définis par la RFC. Chacun de ces jetons est testé dans le fichier de test unitaire d'accompagnement.


à installer avec pip

pip install validate_email

et vous aurez besoin du module pyDNS pour vérifier les serveurs SMTP

pip install pyDNS

ou de Ubuntu

apt-get python3-dns
39
répondu philshem 2018-09-14 08:57:44

les adresses Email ne sont pas aussi simples qu'elles semblent! Par exemple, Bob_o'Reilly+tag@example.com, est une adresse e-mail valide.

j'ai eu un peu de chance avec le paquet lepl ( http://www.acooke.org/lepl / ). Il peut valider les adresses email comme indiqué dans la RFC 3696: http://www.faqs.org/rfcs/rfc3696.html

a trouvé un vieux code:

import lepl.apps.rfc3696
email_validator = lepl.apps.rfc3696.Email()
if not email_validator("email@example.com"):
    print "Invalid email"
22
répondu bigendian 2013-05-27 15:22:55

j'ai trouvé un excellent (et testé) moyen de vérifier l'adresse de courriel 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 = ["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)
5
répondu James The Beard 2016-12-06 11:26:48

je vois beaucoup de réponses compliquées ici. Certains d'entre eux, ne parviennent pas à la connaissance simple, véritable adresse e-mail, ou ont de faux positifs. Ci-dessous, est la façon la plus simple de vérifier que la chaîne serait un email valide. Il teste contre des TLD de 2 et 3 lettres. Maintenant que vous pouvez techniquement en avoir de plus grandes, Vous pouvez augmenter le 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))
5
répondu PyTis 2017-05-12 12:23:32

ceci est généralement résolu en utilisant regex. Il existe de nombreuses variantes de solutions. En fonction de la rigueur que vous devez avoir, et si vous avez des exigences personnalisées pour la validation, ou acceptera toute adresse e-mail valide.

voir cette page pour référence: http://www.regular-expressions.info/email.html

4
répondu Mithon 2011-11-05 19:09:00
Les adresses e-mail

sont incroyablement compliquées. Voici un exemple de regex qui correspondra à chaque adresse valide de 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 complets pour Perl dans le but de valider les adresses e-mail. Donc vous n'obtiendrez probablement rien qui soit parfait à 100% en tant que regex tout en étant lisible. Voici un échantillon parser de descente récursive: 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'un parsing parfait ou d'un code simple.

2
répondu Dan 2011-11-05 19:09:44
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()
1
répondu nidhin 2014-08-13 17:15:45

si vous voulez retirer le courrier d'une longue chaîne de caractères ou d'un fichier, essayez ceci.

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

Remarque, cela fonctionne quand vous avez un espace avant et après votre adresse email. si vous n'avez pas l'espace ou qui ont des caractères spéciaux, vous pouvez essayer de le modifier.

exemple pratique:

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

ce sera retirer example@me.com de cette corde.

aussi, notez que cela peut ne pas être le droit réponse.. Mais je l'ai posté ici pour aider quelqu'un qui ont besoin spécifique comme moi

1
répondu Raj Chinna 2014-11-05 08:15:13

Précitée parseaddr serait ignorer la fuite @.

from email.utils import parseaddr
parseaddr('aaa@bbb@ccc.com') ('', 'aaa@bbb')

extrait probablement l'adresse et comparer à l'original?

a-t-on essayé de valider?e-mail ?

1
répondu Serge 2016-02-08 20:46:58
import validator
is_valid = validate_email('example@example.com',verify=True)
if (is_valid==True):
    return 1
else:
    return 0

voir validate_email docs .

1
répondu ali.etemadi77 2018-03-25 20:18:54

trouver Email-id: finding IP screenshot

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..
0
répondu Mani 2017-08-23 11:04:04

Pour le contrôle de l'utilisation du courrier électronique 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")
0
répondu Vladislav Koshenevskiy 2018-01-10 20:45:32

a trouvé qu'il s'agissait d'une mise en œuvre pratique:

[^@\s]+@[^@\s]+\.[^@\s]+
0
répondu juan Isaza 2018-09-12 02:28:10
"^[\w\.\+\-]+\@[\w]+\.[a-z]{2,3}$"
-1
répondu Anu 2015-02-13 13:39:51

l'email de validation

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.'
-1
répondu Gaurav Nagpure 2016-10-21 12:19:52

la seule façon vraiment précise de distinguer les adresses de courrier électronique réelles et valides de celles qui ne le sont pas est de envoyer le courrier à elle . Ce qui compte comme un e-mail est étonnamment alambiqué ( "John Doe" <john.doe@example.com>" est en fait une adresse e-mail valide), et vous voulez très probablement l'adresse e-mail pour réellement envoyer le courrier à elle plus tard. Après qu'il passe quelques contrôles de base de la santé mentale (comme dans la réponse de Thomas, a un @ et au moins un . après le @ ), vous devriez probablement envoyer un e-mail lettre de vérification de l'adresse, et d'attendre que l'utilisateur à suivre un lien dans le message pour confirmer que l'email est valide.

-2
répondu SingleNegationElimination 2011-11-05 19:28:02