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

В этом уроке вы узнаете, как :

• Установить безопасное соединение с использованием SMTP_SSL() и .starttls()

• Используйте встроенную библиотеку Python smtplib для отправки основных сообщений электронной почты

• Отправка электронных писем с HTML-содержимым и вложениями с использованием пакета электронной почты

• Отправка нескольких персонализированных электронных писем с использованием CSV-файла с контактными данными

• Используйте пакет Yagmail для отправки электронной почты через свою учетную запись Gmail, используя всего несколько строк кода

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

Начало работы

Python поставляется со встроенным модулем smtplib для отправки электронных писем с использованием простого протокола передачи почты (SMTP). smtplib использует протокол RFC 821 для SMTP. В примерах этого руководства для отправки электронных писем будет использоваться SMTP-сервер Gmail, но те же принципы применимы и к другим почтовым службам. Хотя большинство провайдеров электронной почты используют те же порты подключения, что и в этом руководстве, вы можете выполнить быстрый поиск в Google, чтобы подтвердить свой.

Чтобы начать работу с этим учебным пособием, настройте учетную запись Gmail для разработки или настройте сервер отладки SMTP, который отбрасывает отправленные вами электронные письма и вместо этого печатает их в командной строке. Оба варианта выложены для вас ниже. Локальный сервер отладки SMTP может быть полезен для устранения любых проблем с функциями электронной почты и обеспечения отсутствия ошибок в функциях электронной почты перед отправкой любых электронных писем.

Вариант 1. Настройка учетной записи Gmail для разработки

Если вы решите использовать учетную запись Gmail для отправки электронных писем, я настоятельно рекомендую настроить одноразовую учетную запись для разработки вашего кода.Это связано с тем, что вам придется настроить параметры безопасности вашей учетной записи Gmail, чтобы разрешить доступ из вашего кода Python, и потому что есть вероятность, что вы можете случайно раскрыть свои данные для входа. Кроме того, я обнаружил, что почтовый ящик моей тестовой учетной записи быстро заполняется тестовыми электронными письмами, что является достаточной причиной для создания новой учетной записи Gmail для разработки.

Приятной особенностью Gmail является то, что вы можете использовать знак + для добавления любых модификаторов к вашему адресу электронной почты, прямо перед знаком @ .Например, почта, отправленная на адреса [email protected] и [email protected] com , будет доставлена ​​на [email protected] . При тестировании функциональности электронной почты вы можете использовать это для эмуляции нескольких адресов, указывающих на один и тот же почтовый ящик.

Чтобы настроить адрес Gmail для тестирования кода, выполните следующие действия:

Если вы не хотите снижать настройки безопасности своей учетной записи Gmail, ознакомьтесь с документацией Google о том, как получить учетные данные для доступа к вашему скрипту Python, используя структуру авторизации OAuth3.

Вариант 2: Настройка локального SMTP-сервера

Вы можете протестировать работу электронной почты, запустив локальный сервер отладки SMTP с помощью модуля smtpd , который предварительно устанавливается вместе с Python. Вместо того, чтобы отправлять электронные письма на указанный адрес, он отбрасывает их и выводит их содержимое на консоль. Запуск локального сервера отладки означает, что нет необходимости иметь дело с шифрованием сообщений или использовать учетные данные для входа на сервер электронной почты.

Вы можете запустить локальный сервер отладки SMTP, введя в командной строке следующее:

  $ python -m smtpd -c DebuggingServer -n localhost:1025
  

В Linux используйте ту же команду с предшествующим кодом sudo .

Любые электронные письма, отправленные через этот сервер, будут отбрасываться и отображаться в окне терминала как объект размером байта для каждой строки:

  ---------- СООБЩЕНИЕ СЛЕДУЕТ ----------
b'X-Peer: ::1'
б''
b'От: [email protected]'
b'Кому: [email protected]'
b'Тема: местное тестовое письмо'
б''
b'Здравствуйте, вот тестовое письмо'
------------ КОНЕЦ СООБЩЕНИЯ ------------
  

В остальной части руководства я предполагаю, что вы используете учетную запись Gmail, но если вы используете локальный сервер отладки, просто убедитесь, что вы используете localhost в качестве своего SMTP-сервера и используете порт 1025, а не порт. 465 или 587.Кроме того, вам не нужно будет использовать login() или шифровать связь с помощью SSL/TLS.

Отправка обычного текстового сообщения электронной почты

Прежде чем мы углубимся в отправку электронных писем с содержимым HTML и вложениями, вы научитесь отправлять электронные письма в виде обычного текста с помощью Python. Это электронные письма, которые вы можете написать в простом текстовом редакторе. Там нет никаких причудливых вещей, таких как форматирование текста или гиперссылки. Вы узнаете это чуть позже.

Запуск безопасного SMTP-подключения

Когда вы отправляете электронные письма через Python, вы должны убедиться, что ваше SMTP-соединение зашифровано, чтобы другие не могли легко получить доступ к вашему сообщению и учетным данным для входа.SSL (Secure Sockets Layer) и TLS (Transport Layer Security) — это два протокола, которые можно использовать для шифрования SMTP-соединения. Нет необходимости использовать любой из них при использовании локального сервера отладки.

Есть два способа установить безопасное соединение с вашим почтовым сервером:

• Запустить SMTP-соединение, защищенное с самого начала с помощью SMTP_SSL() .
• Запустить незащищенное SMTP-соединение, которое затем можно зашифровать с помощью .starttls() .

В обоих случаях Gmail будет шифровать электронные письма с помощью TLS, так как это более безопасный преемник SSL. В соответствии с соображениями безопасности Python настоятельно рекомендуется использовать create_default_context() из модуля ssl . Это загрузит доверенные сертификаты ЦС системы, включит проверку имени хоста и сертификата, а также попытается выбрать достаточно безопасный протокол и параметры шифрования.

Если вы хотите проверить шифрование электронной почты в папке «Входящие» Gmail, перейдите по ссылке Еще → Показать исходный , чтобы увидеть тип шифрования, указанный в заголовке Получено .

smtplib — это встроенный в Python модуль для отправки электронной почты на любой интернет-компьютер с демоном прослушивателя SMTP или ESMTP.

Сначала я покажу вам, как использовать SMTP_SSL() , так как он устанавливает безопасное с самого начала соединение и является немного более кратким, чем альтернатива . starttls() . Имейте в виду, что Gmail требует подключения к порту 465 при использовании SMTP_SSL() и к порту 587 при использовании .starttls() .

Вариант 1: Использование

В приведенном ниже примере кода создается безопасное соединение с SMTP-сервером Gmail с использованием SMTP_SSL() из smtplib для инициирования соединения с шифрованием TLS. Контекст по умолчанию ssl проверяет имя хоста и его сертификаты и оптимизирует безопасность соединения. Обязательно укажите свой адрес электронной почты вместо [email protected] :

  импорт smtplib, ssl

порт = 465 # Для SSL
password = input("Введите пароль и нажмите Enter: ")

# Создать безопасный контекст SSL
контекст = SSL.create_default_context()

с smtplib.SMTP_SSL("smtp.gmail.com", порт, контекст=контекст) в качестве сервера:
    server.login("мой@gmail.com", пароль)
    # TODO: отправить электронное письмо сюда
  

Использование с smtplib. SMTP_SSL() в качестве сервера: обеспечивает автоматическое закрытие соединения в конце блока кода с отступом. Если порт равен нулю или не указан, .SMTP_SSL() будет использовать стандартный порт для SMTP через SSL (порт 465).

Небезопасно хранить пароль электронной почты в коде, особенно если вы собираетесь поделиться им с другими.Вместо этого используйте input() , чтобы позволить пользователю вводить свой пароль при запуске скрипта, как в примере выше. Если вы не хотите, чтобы ваш пароль отображался на экране при его вводе, вы можете импортировать модуль getpass и использовать вместо него .getpass() для слепого ввода пароля.

Вариант 2: Использование

Вместо использования .SMTP_SSL() для создания безопасного соединения с самого начала мы можем создать незащищенное SMTP-соединение и зашифровать его с помощью .стартлс() .

Для этого создайте экземпляр smtplib. SMTP , который инкапсулирует SMTP-соединение и позволит вам получить доступ к его методам. Я рекомендую указать ваш SMTP-сервер и порт в начале вашего скрипта, чтобы легко их настроить.

В приведенном ниже фрагменте кода используется конструкция server = SMTP() , а не формат с SMTP() в качестве server: , который мы использовали в предыдущем примере. Чтобы убедиться, что ваш код не сработает, когда что-то пойдет не так, поместите основной код в блок try и позвольте блоку , кроме , вывести все сообщения об ошибках на stdout :

  импорт smtplib, ssl

smtp_server = "SMTP.gmail.com"
port = 587 # Для starttls
sender_email = "мой@gmail.com"
password = input("Введите пароль и нажмите Enter: ")

# Создать безопасный контекст SSL
контекст = ssl.create_default_context()

# Попробуйте войти на сервер и отправить письмо
пытаться:
    сервер = smtplib.SMTP(smtp_server,порт)
    server.ehlo() # Можно опустить
    server. starttls(context=context) # Безопасное соединение
    server.ehlo() # Можно опустить
    server.login (адрес_отправителя, пароль)
    # TODO: отправить электронное письмо сюда
кроме Исключения как e:
    # Вывести все сообщения об ошибках на стандартный вывод
    печать (е)
наконец:
    сервер.покидать()
  

Чтобы идентифицировать себя на сервере, следует вызвать .helo() (SMTP) или .ehlo() (ESMTP) после создания объекта .SMTP() , а затем снова после .starttls() . Эта функция неявно вызывается .starttls() и .sendmail() , если это необходимо, поэтому, если вы не хотите проверять расширения службы SMTP сервера, нет необходимости использовать .helo() или . .ehlo() явно.

Отправка электронной почты в виде обычного текста

После того, как вы инициировали безопасное SMTP-соединение с помощью любого из вышеуказанных методов, вы можете отправить свою электронную почту, используя . sendmail() , что в значительной степени делает то, что написано на банке:

  server.sendmail(электронная_почта_отправителя, электронная почта_получателя, сообщение)
  

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

  sender_email = "[email protected]"
Receiver_email = "ваш@gmail.com"
сообщение = """\
Тема: Привет.

Это сообщение отправлено из Python."""

# Отправить письмо сюда
  

Строка сообщения начинается с «Тема: Привет» , за которой следуют две новые строки ( \n ).Это гарантирует, что Hi there отображается как тема электронного письма, а текст, следующий за новой строкой, будет рассматриваться как тело сообщения.

В приведенном ниже примере кода отправляется электронное письмо в виде обычного текста с использованием SMTP_SSL() :

  импорт smtplib, ssl

порт = 465 # Для SSL
smtp_server = "smtp.gmail.com"
sender_email = "[email protected]" # Введите свой адрес
Receiver_email = "[email protected]" # Введите адрес получателя
password = input("Введите пароль и нажмите Enter: ")
сообщение = """\
Тема: Привет.

Это сообщение отправлено из Python."""

контекст = ssl.create_default_context()
с smtplib.SMTP_SSL(smtp_server, port, context=context) в качестве сервера:
    server.login (адрес_отправителя, пароль)
    server.sendmail (электронная_почта_отправителя, электронная почта_получателя, сообщение)
  

Для сравнения, вот пример кода, который отправляет текстовое электронное письмо через SMTP-соединение, защищенное с помощью .starttls() . Строки server.ehlo() можно опустить, так как они вызываются неявно .starttls() и .sendmail() , если требуется:

  импорт smtplib, ssl

port = 587 # Для starttls
smtp_server = "SMTP.gmail.com"
sender_email = "мой@gmail. com"
Receiver_email = "ваш@gmail.com"
password = input("Введите пароль и нажмите Enter:")
сообщение = """\
Тема: Привет.

Это сообщение отправлено из Python."""

контекст = ssl.create_default_context()
с smtplib.SMTP(smtp_server, порт) в качестве сервера:
    server.ehlo() # Можно опустить
    server.starttls(контекст=контекст)
    server.ehlo() # Можно опустить
    server.login (адрес_отправителя, пароль)
    server.sendmail (электронная_почта_отправителя, электронная почта_получателя, сообщение)
  

Отправка причудливых писем

Встроенный пакет электронной почты Python позволяет вам структурировать более причудливые электронные письма, которые затем можно передавать с помощью smtplib , как вы уже делали.Ниже вы узнаете, как использовать пакет электронной почты для отправки электронных писем с содержимым HTML и вложениями.

Включая содержимое HTML

Если вы хотите отформатировать текст в своем электронном письме ( полужирный шрифт , курсив и т. д.) или если вы хотите добавить любые изображения, гиперссылки или адаптивный контент, тогда HTML очень удобен. На сегодняшний день наиболее распространенным типом электронной почты является MIME (многоцелевое расширение почты Интернета). Составная электронная почта, сочетающая HTML и обычный текст. Сообщения MIME обрабатываются электронной почтой Python .модуль mime . Подробное описание смотрите в документации.

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

В приведенном ниже примере наши объекты MIMEText() будут содержать HTML и текстовые версии нашего сообщения, а экземпляр MIMEMultipart("alternative") объединяет их в одно сообщение с двумя альтернативными вариантами отображения:

  импорт smtplib, ssl
из электронной почты. mime.text импорт MIMEText
из email.mime.multipart импортировать MIMEMultipart

sender_email = "мой@gmail.com"
Receiver_email = "ваш@gmail.com"
password = input("Введите пароль и нажмите Enter:")

сообщение = MIMEMMultipart("альтернатива")
message["Subject"] = "составной тест"
сообщение["От"] = sender_email
сообщение["Кому"] = email_получателя

# Создайте текстовую и HTML-версию вашего сообщения
текст = """\
Привет,
Как твои дела?
В Real Python есть много отличных руководств:
www.realpython.com"""
html="""\

  <тело>
    
Привет,

       Как дела?

       <а href="http://www.realpython.com">Настоящий Python
       имеет много отличных руководств.
    
  

"""

# Превратите их в обычные/html объекты MIMEText
часть1 = MIMEText (текст, «обычный»)
часть2 = MIMEText(html, "html")

# Добавить HTML/текстовые части в сообщение MIMEMMultipart
# Почтовый клиент сначала попытается отобразить последнюю часть
сообщение.attach (часть 1)
сообщение.attach (часть 2)

# Создать безопасное соединение с сервером и отправить письмо
контекст = ssl. create_default_context()
с помощью smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) в качестве сервера:
    server.login (адрес_отправителя, пароль)
    сервер.sendmail(
        отправитель_электронная почта, получатель_электронная почта, сообщение.как_строка()
    )
  

В этом примере вы сначала определяете обычный текст и HTML-сообщение как строковые литералы, а затем сохраняете их как объекты. Затем их можно добавить в указанном порядке в сообщение MIMEMultipart("alternative") и отправить через защищенное соединение с сервером электронной почты.Не забудьте добавить HTML-сообщение после простого текста, так как почтовые клиенты сначала попытаются отобразить последнюю часть.

Добавление вложений с помощью пакета электронной почты

Чтобы отправить двоичные файлы на сервер электронной почты, предназначенный для работы с текстовыми данными, их необходимо закодировать перед транспортировкой. Чаще всего это делается с использованием base64 , который кодирует двоичные данные в печатные символы ASCII.

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

  импорт электронной почты, smtplib, ssl

из кодировщиков импорта электронной почты
из электронной почты.mime.base импортирует MIMEBase
из email.mime.multipart импортировать MIMEMultipart
из email.mime.text импортировать MIMEText

subject = "Электронное письмо с вложением от Python"
body = "Это электронное письмо с вложением, отправленное с Python"
sender_email = "мой@gmail.com"
Receiver_email = "ваш@gmail.com"
password = input("Введите пароль и нажмите Enter:")

# Создать составное сообщение и установить заголовки
сообщение = MIMEMultipart()
сообщение["От"] = sender_email
сообщение["Кому"] = email_получателя
сообщение["Тема"] = тема
message["Bcc"] = Receiver_email # Рекомендуется для массовых рассылок

# Добавить тело в электронное письмо
сообщение.прикрепить (MIMEText (тело, "обычный"))

filename = "document.pdf" # В том же каталоге, что и скрипт

# Открыть файл PDF в двоичном режиме
с открытым (имя файла, "rb") в качестве вложения:
    # Добавить файл как приложение/октетный поток
    # Почтовый клиент обычно может автоматически загрузить это как вложение
    часть = MIMEBase ("приложение", "поток октетов")
    part. set_payload(attachment.read())

# Кодировать файл в символы ASCII для отправки по электронной почте
encoders.encode_base64 (часть)

# Добавить заголовок в виде пары ключ/значение в часть вложения
часть.add_header(
    «Содержание-диспозиция»,
    f"вложение; имя файла= {имя файла}",
)

# Добавить вложение к сообщению и преобразовать сообщение в строку
message.attach(часть)
текст = сообщение.as_string()

# Войдите на сервер, используя безопасный контекст, и отправьте электронное письмо
контекст = ssl.create_default_context()
с smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) в качестве сервера:
    server.login (адрес_отправителя, пароль)
    server.sendmail (электронная_почта_отправителя, электронная почта_получателя, текст)
  

Сообщение MIMEultipart() принимает параметры в форме пар ключ/значение в стиле RFC5233, которые хранятся в словаре и передаются в .Метод add_header базового класса Message .

Ознакомьтесь с документацией для модуля Python email. mime , чтобы узнать больше об использовании классов MIME.

Отправка нескольких персонализированных сообщений электронной почты

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

Создайте файл CSV с соответствующей личной информацией

Простая отправная точка для отправки нескольких персонализированных электронных писем — создать файл CSV (значения, разделенные запятыми), который содержит всю необходимую личную информацию. (Не делитесь личной информацией других людей без их согласия.) Файл CSV можно рассматривать как простую таблицу, где первая строка часто содержит заголовки столбцов.

Ниже приведено содержимое файла contact_file.csv , который я сохранил в той же папке, что и мой код Python. Он содержит имена, адреса и оценки для набора вымышленных людей. Я использовал конструкции [email protected] , чтобы убедиться, что все электронные письма попадают в мой собственный почтовый ящик, в данном примере это [email protected]mail.com:

  имя, адрес электронной почты, класс
Рон Очевидность, [email protected], B+
Кролик-убийца из Кербаннога, [email protected],A
Брайан Коэн, [email protected], C
  

При создании CSV-файла обязательно разделяйте значения запятой без каких-либо окружающих пробелов.

Цикл по строкам для отправки нескольких писем

В приведенном ниже примере кода показано, как открыть CSV-файл и перебрать строки его содержимого (пропустив строку заголовка). Чтобы убедиться, что код работает правильно, прежде чем вы отправите электронные письма всем своим контактам, я напечатал Отправка электронной почты на ... для каждого контакта, который мы можем позже заменить функцией, которая фактически отправляет электронные письма:

  импорт CSV

с открытым ("contacts_file. csv") в качестве файла:
    читатель = csv.читатель (файл)
    next(reader) # Пропустить строку заголовка
    для имени, электронной почты, оценки в читателе:
        print(f"Отправка электронной почты на {имя}")
        # Отправить письмо сюда
  

В приведенном выше примере использование с open(filename) в качестве файла: гарантирует, что ваш файл будет закрыт в конце блока кода. csv.reader() позволяет легко читать CSV-файл построчно и извлекать его значения. Строка next(reader) пропускает строку заголовка, поэтому следующая строка для имени, электронной почты, оценки в читателе: разбивает последующие строки на каждую запятую и сохраняет полученные значения в строках имя , электронная почта и марки для текущего контакта.

Если значения в вашем CSV-файле содержат пробелы с одной или обеих сторон, вы можете удалить их с помощью метода .strip() .

Персонализированный контент

Вы можете поместить персонализированное содержимое в сообщение, используя str. format() для заполнения фигурных скобок. Например, "привет, {имя}, вы {результат} своего задания".format(name="John", result="passed") даст вам "привет, Джон, вы выполнили задание" .

Начиная с Python 3.6 форматирование строк может быть выполнено более элегантно с использованием f-строк, но для этого требуется, чтобы заполнители были определены до самой f-строки. Чтобы определить сообщение электронной почты в начале сценария и заполнить заполнители для каждого контакта при циклическом просмотре CSV-файла, используется старый метод .format() .

Имея это в виду, вы можете настроить общее тело сообщения с заполнителями, которые можно настроить для отдельных лиц.

Пример кода

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

Общее сообщение определяется в начале скрипта, и для каждого контакта в файле CSV заполняются его заполнители {имя} и {класс} , а персонализированное электронное письмо отправляется через защищенное соединение с сервер Gmail, как вы уже видели:

  импорт CSV, smtplib, SSL

message = """Тема: Ваша оценка

Привет {name}, твоя оценка {grade}"""
from_address = "мой@gmail. ком"
password = input("Введите пароль и нажмите Enter: ")

контекст = ssl.create_default_context()
с smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) в качестве сервера:
    server.login(от_адреса, пароль)
    с открытым ("contacts_file.csv") в качестве файла:
        читатель = csv.reader (файл)
        next(reader) # Пропустить строку заголовка
        для имени, электронной почты, оценки в читателе:
            сервер.sendmail(
                от_адрес,
                Эл. адрес,
                message.format(имя=имя,оценка=оценка),
            )
  

Ягмаил

Существует несколько библиотек, предназначенных для упрощения отправки электронных писем, таких как Envelopes, Flanker и Yagmail.Yagmail разработан специально для работы с Gmail и значительно упрощает процесс отправки электронных писем через дружественный API, как вы можете видеть в примере кода ниже:

  импорт Yagmail

получатель = "ваш@gmail.com"
body = "Привет из Ягмаила"
имя_файла = "документ. pdf"

yag = yagmail.SMTP("мой@gmail.com")
яг.отправить(
    к = приемник,
    subject="Тест Yagmail с вложением",
    содержимое = тело,
    вложения = имя файла,
)
  

В этом примере кода электронное письмо с вложением в формате PDF отправляется в несколько строк, необходимых для нашего примера, с использованием электронной почты и smtplib .

При настройке Yagmail вы можете добавить проверки Gmail в связку ключей вашей ОС, как описано в документации. Если вы этого не сделаете, Yagmail предложит вам ввести пароль, когда это потребуется, и автоматически сохранит его в связке ключей.

Службы транзакционной электронной почты

Если вы планируете отправлять большое количество электронных писем, хотите просматривать статистику электронной почты и хотите обеспечить надежную доставку, возможно, вам стоит обратить внимание на службы транзакционной электронной почты. Хотя все следующие сервисы имеют платные планы для отправки больших объемов электронных писем, они также поставляются с бесплатным планом, чтобы вы могли их опробовать. Некоторые из этих бесплатных планов действуют бессрочно, и их может быть достаточно для ваших потребностей в электронной почте.

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

Вы можете запустить поиск в Google, чтобы узнать, какой поставщик лучше всего соответствует вашим потребностям, или просто попробовать несколько бесплатных планов, чтобы узнать, с каким API вам больше всего нравится работать.

Пример кода Sendgrid

Вот пример кода для отправки электронной почты с помощью Sendgrid, чтобы дать вам представление о том, как использовать службу транзакционной электронной почты с Python:

  импорт ОС
импортировать сетку отправки
из сендгрида.helpers.mail импорт контента, электронной почты, почты

sg = sendgrid.SendGridAPIClient(
    apikey=os.environ.get("SENDGRID_API_KEY")
)
from_email = Электронная почта ("мой@gmail. com")
to_email = Электронная почта ("ваш@gmail.com")
subject = "Тестовое письмо от Sendgrid"
контент = контент(
    "text/plain", "Вот тестовое письмо, отправленное через Python"
)
mail = Mail (от_электронной почты, тема, кому_электронная почта, содержание)
ответ = sg.client.mail.send.post(request_body=mail.get())

# Операторы ниже могут быть включены в целях отладки
распечатать(ответ.статус_код)
печать (ответ.тело)
печать (ответ. заголовки)
  

Чтобы запустить этот код, вы должны сначала:

• Зарегистрируйте (бесплатно) учетную запись Sendgrid
• Запрос ключа API для проверки пользователя
• Добавьте свой ключ API, введя setx SENDGRID_API_KEY "YOUR_API_KEY" в командной строке (для постоянного хранения этого ключа API) или установите SENDGRID_API_KEY YOUR_API_KEY , чтобы сохранить его только для текущего сеанса клиента

Дополнительную информацию о настройке Sendgrid для Mac и Windows можно найти в README репозитория на Github.

Заключение

Теперь вы можете установить безопасное SMTP-соединение и отправлять несколько персонализированных электронных писем людям из вашего списка контактов!

Вы узнали, как отправлять электронные письма в формате HTML с альтернативным текстом и прикреплять файлы к своим электронным письмам. Пакет Yagmail упрощает все эти задачи, если вы используете учетную запись Gmail. Если вы планируете отправлять большие объемы электронной почты, стоит обратить внимание на службы транзакционной электронной почты.

Наслаждайтесь отправкой электронных писем с помощью Python и помните: пожалуйста, никакого спама!

Смотреть сейчас Это руководство содержит связанный с ним видеокурс, созданный командой Real Python.Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Отправка электронных писем с помощью Python