Python vérifier l'adresse email valide?

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.

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

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"

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)

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

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

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.

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

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

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 ?

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

voir validate_email docs .

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

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

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

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

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

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.