Python проверяет действительный адрес электронной почты?

стандартная библиотека Python поставляется с функцией анализа электронной почты:email.utils.parseaddr().

он возвращает два кортежа, содержащие реальное имя и фактические части адреса электронной почты:

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

и если синтаксический анализ не удался, он возвращает два кортежа пустых строк:

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

проблема с этим анализатором заключается в том, что он принимает все, что считается действительным адресом электронной почты для RFC-822 и друзей, включая многих вещи, которые явно не адресуются в широком Интернете:

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

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

Итак, как выразился @TokenMacGuy, единственный окончательный способ проверить адрес электронной почты-отправить электронное письмо на ожидаемый адрес и ждать, пока пользователь будет действовать на информацию внутри сообщения.

однако вы можете проверить, по крайней мере, наличие @-знака на втором элементе кортежа, как предлагает @bvukelic:

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

если вы хотите пойти дальше, вы можно установить dnspython проект и разрешить почтовые серверы для домена электронной почты (часть после"@"), только пытаясь отправить по электронной почте, если есть фактические MX сервера:

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

вы можете поймать как NoAnswer и NXDOMAIN, ловя dns.exception.DNSException.

И Да foo@bar@google.com является синтаксически допустимым адресом. Только последнее @ следует учитывать для определения того, где начинается часть домена.

Я не видел ответа уже здесь среди беспорядка пользовательских ответов Regex, но...

Python есть модуль под названием validate_email который имеет 3 уровня проверки электронной почты, включая запрос действительного SMTP-сервера, если адрес электронной почты действителен (без отправки электронной почты).

проверить строку электронной почты действителен формат:

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

проверьте, есть ли у хоста SMTP-сервер:

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

проверьте, имеет ли хост SMTP Сервер и электронная почта действительно существуют:

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

для тех, кто интересуется грязными деталями, validate_email.py (источник) стремится быть верным RFC 2822.

все, что мы действительно делаем, это сравнение входной строки с одной гигантское регулярное выражение лица. Но построение этого regexp и обеспечение его правильности, делается намного проще, собирая его из "токенов", определенных RFC. Каждый из этих токенов протестировано в сопроводительном файле модульных тестов.

для установки с pip

pip install validate_email

и вам понадобится модуль pyDNS для проверки SMTP-серверов

pip install pyDNS

или из Ubuntu

apt-get python3-dns

адреса электронной почты не так просты, как кажутся! Например, Bob_o'Reilly+tag@example.com, является действительным адресом электронной почты.

Мне повезло с пакетом lepl (http://www.acooke.org/lepl/). Он может проверять адреса электронной почты, как указано в RFC 3696:http://www.faqs.org/rfcs/rfc3696.html

нашел старый код:

import lepl.apps.rfc3696
email_validator = lepl.apps.rfc3696.Email()
if not email_validator("email@example.com"):
    print "Invalid email"

Я нашла отличные (и испытанный) способ проверить действительный адрес электронной почты. Я вставляю свой код здесь:

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

Я вижу здесь много сложных ответов. Некоторые из них, не знают простой, истинный адрес электронной почты или имеют ложные срабатывания. Ниже приведен самый простой способ проверки того, что строка будет действительной электронной почтой. Он тестирует против 2 и 3 букв TLD. Теперь, когда вы технически можете иметь большие, вы можете увеличить 3 до 4, 5 или даже 10.

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

Это обычно решается с помощью regex. Однако существует множество вариантов решений. В зависимости от того, насколько строго вы должны быть, и если у вас есть специальные требования для проверки, либо принимает любой действительный адрес электронной почты.

см. эту страницу для справки:http://www.regular-expressions.info/email.html

адреса электронной почты невероятно сложны. Вот образец регулярного выражения, который будет соответствовать каждому rfc822-действительному адресу: http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html

вы заметите, что это, вероятно, дольше, чем остальная часть вашей программы. Есть даже целые модули для Perl с целью проверки адреса электронной почты. Таким образом, вы, вероятно, не получите ничего, что на 100% идеально подходит в качестве регулярного выражения, а также читается. Вот пример рекурсивного спуска синтаксический анализатор: http://cpansearch.perl.org/src/ABIGAIL/RFC-RFC822-Address-2009110702/lib/RFC/RFC822/Address.pm

но вам нужно решить, нужен ли вам идеальный разбора или простой код.

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

Если вы хотите вынуть почту из длинной строки или файла, попробуйте это.

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

Примечание, это будет работать, когда у вас есть пространство до и после вашего адреса электронной почты. если у вас нет места или есть специальные символы, вы можете попробовать изменить его.

пример:

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

это выведет example@me.com из этой струны.

кроме того, обратите внимание, что это может быть неправильный ответ.. Но я разместил его здесь, чтобы помочь кому-то, кто имейте конкретное требование, как я

вышеупомянутый parseaddr проигнорирует трейлинг @.

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

вероятно, извлечь адрес и сравнить с оригиналом?

кто-нибудь пробовал проверить.электронная почта ?

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

посмотреть validate_email docs.

Поиск 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..

для проверки электронной почты используйте 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")

нашел, что это практическая реализация:

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

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

письмо

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

единственный действительно точный способ отличить реальные, действительные адреса электронной почты от недействительных - отправить ему почту. То, что считается электронной почтой, удивительно запутано ("John Doe" <john.doe@example.com>" фактически является действительным адресом электронной почты), и вы, скорее всего, хотите, чтобы адрес электронной почты действительно отправлял почту на него позже. После того, как он проходит некоторые основные проверки здравомыслия (например, в ответе Томаса, имеет @ и по крайней мере один . после @), вы должны, вероятно, просто отправить по электронной почте письмо-подтверждение на адрес и дождитесь, пока пользователь перейдет по ссылке, встроенной в сообщение, чтобы подтвердить, что письмо действительно.