python内置模块smtplib、email 发送电子邮件_python 邮件密送

一、简介

smtplib 是 Python 的标准库之一，用于发送电子邮件。它提供了一个简单的接口来连接到 SMTP（Simple Mail Transfer Protocol）服务器，并通过该服务器发送电子邮件。
email 是 Python 的标准库之一，用于处理电子邮件相关的操作。它提供了一组类和方法，用于创建、解析和操作电子邮件消息。

二、smtplib

1. smtplib.quoteaddr(address)：对邮件地址进行引用处理，返回引用后的地址字符串。
2. smtplib.quotedata(data)：对邮件数据进行引用处理，返回引用后的数据字符串。
3. smtplib.SMTP(host, port, local_hostname, timeout, source_address)：用于连接到 SMTP 服务器并发送邮件的类。它接受 SMTP 服务器的主机名、端口号、本地主机名、超时时间和源地址等参数。

   '''
   host：SMTP 服务器的主机名或 IP 地址。
   port：SMTP 服务器的端口号。默认为 25。
   local_hostname：可选参数，用于标识本地主机名。如果未指定，则默认使用计算机的主机名。
   timeout：可选参数，设置连接超时时间（以秒为单位）。默认为 None，表示没有超时限制。
   source_address：可选参数，指定源地址。如果计算机有多个网络接口，可以使用此参数指定要使用的特定接口。
   '''
   
   import smtplib
   
   # SMTP 服务器信息
   smtp_server = 'smtp.qq.com'
   smtp_port = 587
   smtp_user = 'shaofengma88@qq.com'
   smtp_password = 'eyzstypjjtwbbebd'
   
   
   try:
       # 连接到 SMTP 服务器
       with smtplib.SMTP(smtp_server, smtp_port) as smtp:
           print('smtp服务器连接成功')
   
           # 登录到 SMTP 服务器
           smtp.login(smtp_user, smtp_password)
   
           print('邮件发送成功')
   
   except Exception as e:
       print(e)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29

• smtp.timeout：设置与服务器建立连接或执行操作的超时时间。
• smtp.password：SMTP 服务器的密码。
• smtp.user：SMTP 服务器的用户名。
• smtp.file：与 SMTP 服务器建立的套接字文件。
• smtp.command_encoding：命令编码方式。
• smtp.debuglevel：调试级别，用于打印与服务器的交互信息。
• smtp.default_port：SMTP 服务器的默认端口。
• smtp.local_hostname：本地主机名。
• smtp.sock：与服务器建立的套接字。
• smtp.source_address：源地址。
• smtp.login(user, password, initial_response_ok=True)：登录到 SMTP 服务器。
• smtp.sendmail(from_addr, to_addrs, msg, mail_options=(), rcpt_options=())：发送邮件。
• smtp.quit()：关闭与服务器的连接。
• smtp.close()：关闭与服务器的连接。
• smtp.send(s)：发送字符串 s。
• smtp.data(msg)：发送邮件内容。
• smtp.connect(host=‘localhost’, port=0, source_address=None)：连接到 SMTP 服务器。
• smtp.auth(mechanism, authobject, initial_response_ok=True)：进行身份验证。
• smtp.auth_cram_md5(challenge=None)：使用 CRAM-MD5 进行身份验证。
• smtp.auth_login(challenge=None)：使用 LOGIN 进行身份验证。
• smtp.auth_plain(challenge=None)：使用 PLAIN 进行身份验证。
• smtp.getreply()：获取服务器的响应。
• smtp.has_extn(opt)：检查服务器是否支持特定扩展。
• smtp.rset(msg, from_addr=None, to_addrs=None, mail_options=(), rcpt_options=())：重置会话状态。
• smtp.send_message(msg, from_addr=None, to_addrs=None, mail_options=(), rcpt_options=())：发送 email.message.Message 对象。
• smtp.set_debuglevel(debuglevel)：设置调试级别。
• smtp.starttls(keyfile=None, certfile=None, context=None)：启动安全传输层。
• smtp.docmd(cmd, args=“”)：执行命令。
• smtp.putcmd(cmd, args=“”)：发送命令。
• smtp.helo(name=‘’)：发送 HELO 命令，HELO命令用于在客户端与服务器之间建立起SMTP会话时进行初始握手
• smtp.help(args=‘’)：发送 HELP 命令，EHLO命令也用于握手，但它提供了一些扩展能力，如支持TLS加密
• smtp.rcpt(recip, options=())：发送 RCPT 命令。
• smtp.noop()：发送 NOOP 命令。
• smtp.verify(address)：执行 VERIFY 命令
• smtp.ehlo(name=‘’)：发送 EHLO 命令
• smtp.mail(sender, options=())：发送 MAIL 命令。
• smtp.ehlo_or_helo_if_needed()：发送 EHLO 或 HELO 命令
• smtp.expn(address)：执行 EXPN 命令。
• smtp.ehlo_msg：EHLO 命令的消息。
• smtp.ehlo_resp：EHLO 命令的响应。
• smtp.helo_resp：HELO 命令的响应。
• smtp.does_esmtp：指示服务器是否支持 ESMTP。
• smtp.esmtp_features：ESMTP 的特性。

4. smtplib.LMTP(host, port, local_hostname, source_address, timeout)：用于连接到 LMTP（Local Mail Transfer Protocol，本地邮件传输协议）服务器并发送邮件的类。LMTP 是一种用于将邮件传输到本地邮件服务器的协议，继承SMTP

   host：LMTP 服务器的主机名或 IP 地址。
   port：LMTP 服务器的端口号。
   local_hostname：可选参数，用于指定本地主机名，用于在与服务器建立连接时进行标识。如果未指定，将使用默认的本地主机名。
   source_address：可选参数，用于指定客户端的源地址。如果未指定，将使用默认的源地址。
   timeout：可选参数，用于指定与服务器建立连接和发送/接收数据的超时时间。
   1
   2
   3
   4
   5

5. smtplib.SMTP_SSL(host, port, local_hostname, keyfile, certfile, timeout, source_address, context)：用于与使用 SSL/TLS 加密的 SMTP 服务器进行安全通信的类，继承SMTP

   host：SMTP 服务器的主机名或 IP 地址。
   port：SMTP 服务器的端口号。
   local_hostname：可选参数，用于指定本地主机名，用于在与服务器建立连接时进行标识。如果未指定，将使用默认的本地主机名。
   keyfile：可选参数，用于指定客户端的私钥文件路径。如果服务器要求客户端提供私钥进行身份验证，可以指定此参数。
   certfile：可选参数，用于指定客户端的证书文件路径。如果服务器要求客户端提供证书进行身份验证，可以指定此参数。
   timeout：可选参数，用于指定与服务器建立连接和发送/接收数据的超时时间。
   source_address：可选参数，用于指定客户端的源地址。如果未指定，将使用默认的源地址。
   context：可选参数，用于传递 SSL/TLS 相关的上下文对象。如果未指定，将使用默认的上下文。
   1
   2
   3
   4
   5
   6
   7
   8

三、email

1.import email

• email.message_from_file(fp, *args, **kws)：从文件对象 fp 中读取邮件内容，并返回一个 Message 对象。可以通过 *args 和 **kws 传递额外的参数给 Message 对象的构造函数。
• email.message_from_bytes(s, *args, **kws)：从字节串 s 中解析邮件内容，并返回一个 Message 对象。同样可以通过 *args 和 **kws 传递额外的参数给 Message 对象的构造函数。
• email.message_from_string(s, *args, **kws)：从字符串 s 中解析邮件内容，并返回一个 Message 对象。同样可以通过 *args 和 **kws 传递额外的参数给 Message 对象的构造函数。
• email.message_from_binary_file(fp, *args, **kws)：从二进制文件对象 fp 中读取邮件内容，并返回一个 Message 对象。同样可以通过 *args 和 **kws 传递额外的参数给 Message 对象的构造函数。

2. from email.message import Message,MIMEPart,EmailMessage：操作消息模块

• message = Message(policy=compat32)：用于表示邮件消息的基本类
• message[‘From’] = Header(sender)：设置发件人邮件
• message[‘To’] = Header(receiver)：设置接收人邮件
• message[‘Subject’] = Header(subject)：设置邮件主题
• message.policy：获取或设置邮件消息的策略对象。
• message.preamble：获取或设置邮件消息的前言部分。
• message.defects：获取邮件消息中的缺陷列表。
• message.epilogue：获取或设置邮件消息的尾言部分。
• message.as_string(unixfrom=False, maxheaderlen=0, policy=None)：将邮件消息转换为字符串形式。
• message.items()：返回邮件消息的头部信息以字典项形式的迭代器。
• message.get(name, failobj=None)：获取指定名称的头部字段的值。
• message.add_header(_name, _value, **_params)：添加一个头部字段。
• message.attach(payload)：将一个附件或其他邮件消息部分添加到当前消息中。
• message.get_param(param, failobj=None, header=‘content-type’, unquote=True)：获取指定参数的值。
• message.values()：返回邮件消息的头部信息的值的迭代器。
• message.keys()：返回邮件消息的头部信息的键的迭代器。
• message.as_bytes(unixfrom=False, policy=None)：将邮件消息转换为字节形式。
• message.del_param(param, header=‘content-type’, requote=True)：删除指定参数。
• message.get_all(name, failobj=None)：获取指定名称的所有头部字段的值。
• message.get_boundary(failobj=None)：获取邮件消息的边界值。
• message.get_charset()：获取邮件消息的字符集。
• message.get_charsets(failobj=None)：获取邮件消息中所有部分的字符集列表。
• message.get_content_charset(failobj=None)：获取邮件消息主体的字符集。
• message.get_content_disposition()：获取邮件消息主体的内容描述。
• message.get_content_maintype()：获取邮件消息主体的主类型。
• message.get_content_subtype()：获取邮件消息主体的子类型。
• message.get_content_type()：获取邮件消息主体的内容类型。
• message.get_default_type()：获取邮件消息的默认类型。
• message.get_filename(failobj=None)：获取邮件消息主体的文件名。
• message.get_params(failobj=None, header=‘content-type’, unquote=True)：获取指定头部字段的参数字典。
• message.get_payload(i=None, decode=False)：获取邮件消息的主体内容。
• message.get_unixfrom()：获取邮件消息的 Unix From 标志。
• message.is_multipart()：检查邮件消息是否为多部分消息。
• message.raw_items()：返回邮件消息的原始头部信息以字典项形式的迭代器。
• message.replace_header(_name, _value)：替换指定名称的头部字段的值。
• message.set_boundary(boundary)：设置邮件消息的边界值。
• message.set_charset(charset)：设置邮件消息的字符集。
• message.set_default_type(ctype)：设置邮件消息的默认类型。
• message.set_param(param, value, header=‘Content-Type’, requote=True, charset=None, language=‘’, replace=False)：设置指定参数的值。
• message.set_payload(payload, charset=None)：设置邮件消息的主体内容。
• message.set_raw(name, value)：设置指定名称的头部字段的原始值。
• message.set_type(type, header=‘Content-Type’, requote=True)：设置邮件消息的内容类型。
• message.set_unixfrom(unixfrom)：设置邮件消息的 Unix From 标志。
• mimePart = MIMEPart(policy=None)：创建和表示 MIME 邮件消息，继承Message
• mimePart.get_content(*args, content_manager=None, **kw)：获取部分的内容。可以传入参数来指定内容的编码、解码方式等。
• mimePart.as_string(unixfrom=False, maxheaderlen=None, policy=None)：将部分及其头部字段转换为字符串表示形式。
• mimePart.clear()：清除部分的内容和头部字段。
• mimePart.add_alternative(*args, **kw)：添加一个替代版本的部分。替代版本可以是不同格式或内容的部分，用于提供更好的兼容性。
• mimePart.add_attachment(*args, **kw)：添加一个附件部分。
• mimePart.add_related(*args, **kw)：添加一个相关部分，用于嵌入图片或其他资源。
• mimePart.clear_content()：清除部分的内容。
• mimePart.get_body(preferencelist=(‘related’, ‘html’, ‘plain’))：获取部分的主体内容。可以指定优先级列表，以确定返回哪种类型的主体内容。
• mimePart.is_attachment()：检查部分是否为附件。
• mimePart.iter_attachments()：迭代部分中的附件。
• mimePart.iter_parts()：迭代部分中的子部分。
• mimePart.make_alternative(boundary=None)：将部分转换为替代版本的部分。
• mimePart.make_mixed(boundary=None)：将部分转换为多部分混合的部分。
• mimePart.make_related(boundary=None)：将部分转换为相关部分。
• mimePart.set_content(*args, content_manager=None, **kw)：设置部分的内容。可以传入参数来指定内容的编码、解码方式等
• emailMessage = EmailMessage(*args, **kw)：创建和表示邮件消息，继承MIMEPart

3. from email.mime.base import MIMEBase：用于创建和表示 MIME 邮件消息中的基础部分的类，继承Mssage

   '''
   _maintype：部分的主类型，表示部分的一般类别，例如 "text"、"image"、"audio" 等。
   _subtype：部分的子类型，表示部分的具体类型，例如 "plain"、"html"、"jpeg"、"mp3" 等。
   policy：可选参数，用于指定部分的策略对象，用于处理部分的编码和字符集等信息。
   **_param：可选参数，用于指定部分的其他头部字段。可以使用关键字参数的形式传递，例如 charset="utf-8"、name="attachment.txt" 等。
               From：发件人的电子邮件地址。
               To：收件人的电子邮件地址。
               Cc：抄送的电子邮件地址。
               Bcc：密送的电子邮件地址。
               Subject：邮件主题。
               Date：邮件发送的日期和时间。
               Reply-To：指定回复邮件的地址。
               Message-ID：邮件的唯一标识符。
               In-Reply-To：指定邮件回复的原始邮件标识符。
               Content-Type：指定消息的内容类型。
               Content-Disposition：指定消息的内容处理方式。
               Content-Transfer-Encoding：指定消息的内容传输编码方式。
               Importance：指定邮件的重要性级别。
               X-Priority：指定邮件的优先级。
               X-Mailer：指定用于发送邮件的邮件客户端或程序的标识字符串 
               Name
               Charset
   '''
   
   MIMEBase(_maintype, _subtype, *, policy=None, **_param)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25

4. from email.mime.nonmultipart import MIMENonMultipart：用于创建和表示不包含多个部分的非多部分 MIME 邮件消息，如：音频、文件、图片等，继承MIMEBase
5. from email.mime.message import MIMEMessage：用于表示 MIME 邮件消息，继承MIMENonMultipart

   '''
   _text：邮件的文本内容。
   _subtype：可选参数，指定邮件的子类型，默认为 'plain'，表示纯文本。其他常见的子类型包括 'html'（HTML 格式）和 'xml'（XML 格式）等。
   _charset：可选参数，指定邮件的字符集，默认为 None，表示使用默认的字符集。
   policy：可选参数，指定邮件的策略对象，默认为 None，表示使用默认的策略
   '''
   
    MIMEText( _text, _subtype='plain', _charset=None, *, policy=None)
   1
   2
   3
   4
   5
   6
   7
   8

6. from email.mime.audio import MIMEAudio：用于表示MIME音频消息，继承MIMENonMultipart

   '''
   audiodata：音频数据的字节串。这是必需的参数，用于指定音频消息的内容。
   _subtype：可选参数，用于指定音频消息的子类型。默认值为 None，表示将根据文件名的扩展名来确定子类型。
   _encoder：可选参数，用于指定编码器函数，将音频数据编码为字符串。默认值为 encoders.encode_base64，表示使用 Base64 编码。
   policy：可选参数，用于指定策略对象，用于控制生成的 MIME 部分的行为。默认值为 None，表示使用默认策略。
   **_params：可选参数，用于指定其他 MIME 头部字段的参数。您可以通过关键字参数的形式传递这些参数
   '''
   
   MIMEAudio(_audiodata, _subtype=None,_encoder=encoders.encode_base64, *, policy=None, **_params)
   1
   2
   3
   4
   5
   6
   7
   8
   9

7. from email.mime.application import MIMEApplication：用于创建表示应用程序类型附件的 MIME 部分。可以使用它来创建并附加应用程序文件，例如二进制文件、文档、压缩文件等。继承MIMENonMultipart

   '''
   _data：要作为附件添加到 MIME 消息的数据。通常是一个字节字符串（bytes）。
   _subtype：附件的 MIME 子类型。默认为 'octet-stream'，表示通用的二进制数据流。您可以根据实际情况指定其他子类型，例如 'pdf'、'zip' 等。
   _encoder：用于编码附件数据的编码器。默认为 encoders.encode_base64，表示使用 Base64 编码。通常无需更改此参数。
   policy：可选参数，用于指定邮件策略。默认为 None，表示使用默认策略。
   **_params：可选参数，用于指定附件的其他参数。这些参数将作为附件的 MIME 头部字段添加到消息中，例如 filename、Content-Disposition 等。
   '''
   
   MIMEApplication(_data, _subtype='octet-stream', _encoder=encoders.encode_base64, *, policy=None, **_params)
   1
   2
   3
   4
   5
   6
   7
   8
   9

8. from email.mime.image import MIMEImage：创建表示图像类型附件的 MIME 部分。您以使用它来创建并附加图像文件，例如 JPEG、PNG 等，继承MIMENonMultipart

   '''
   _imagedata：要作为附件添加到 MIME 消息的图像数据。通常是一个字节字符串（bytes）。
   _subtype：附件的 MIME 子类型。默认为 None，表示根据 _imagedata 推断子类型。如果 _imagedata 是 JPEG 图像数据，则子类型将设置为 'jpeg'，如果是 PNG 图像数据，则子类型将设置为 'png'。您也可以手动指定子类型，例如 'jpeg'、'png' 等。
   _encoder：用于编码图像数据的编码器。默认为 encoders.encode_base64，表示使用 Base64 编码。通常无需更改此参数。
   policy：可选参数，用于指定邮件策略。默认为 None，表示使用默认策略。
   **_params：可选参数，用于指定附件的其他参数。这些参数将作为附件的 MIME 头部字段添加到消息中，例如 filename、Content-Disposition 等。
   '''
   
   MIMEImage(_imagedata, _subtype=None,_encoder=encoders.encode_base64, *, policy=None, **_params)
   1
   2
   3
   4
   5
   6
   7
   8
   9

9. from email.mime.multipart import MIMEMultipart：用于创建多部分 MIME 消息。多部分消息是由多个部分组成的邮件消息，每个部分可以包含不同类型的数据，例如文本、图像、附件等，继承MIMEBase

   '''
   _subtype：多部分消息的 MIME 子类型。默认为 'mixed'，表示混合类型的多部分消息。其他常见的子类型包括 'alternative'（用于包含多个表示相同内容的不同格式）和 'related'（用于嵌入图像或其他资源的多部分消息）。您可以根据需要设置适当的子类型。
   boundary：多部分消息的边界字符串。默认为 None，表示将自动生成一个边界字符串。通常无需手动设置边界字符串，除非您有特殊要求。
   _subparts：可选参数，用于指定消息的子部分。可以传入一个部分列表，将这些部分添加到多部分消息中。默认为 None，表示没有子部分。
   policy：可选参数，用于指定邮件策略。默认为 None，表示使用默认策略。
   **_params：可选参数，用于指定多部分消息的其他参数。这些参数将作为消息的 MIME 头部字段添加到消息中，例如 From、To、Subject 等
   '''
   
   MIMEMultipart(_subtype='mixed', boundary=None, _subparts=None,policy=None,**_params)
   1
   2
   3
   4
   5
   6
   7
   8
   9

10. from email.header import Header,make_header,decode_header

• header = Header(s=None, charset=None,maxlinelen=None, header_name=None,continuation_ws=’ ', errors=‘strict’)：用于处理电子邮件中的头部信息，特别是处理包含非 ASCII 字符的头部

  s：要编码或解码的字符串（默认为 None）。
  charset：字符集（编码方案）用于编码或解码字符串（默认为 None）。
  maxlinelen：生成的编码字符串的最大行长度（默认为 None）。
  header_name：头部字段的名称（默认为 None）。
  continuation_ws：用于多行头部字段的换行缩进空格（默认为 ' '）。
  errors：指定在编码或解码过程中遇到错误时的处理方式（默认为 'strict'）。
  1
  2
  3
  4
  5
  6

• header.append(s, charset=None, errors=‘strict’)：用于向现有的头部对象追加新的字符串
• header.encode(splitchars=‘;, \t’, maxlinelen=None, linesep=‘\n’)：用于将头部对象编码为字符串
• make_header(decoded_seq, maxlinelen=None, header_name=None, continuation_ws=’ ')：用于创建一个 Header 对象，将已解码的序列转换为编码后的头部字符串

  decoded_seq：一个已解码的序列，可以是字符串或元组的列表。
  maxlinelen：生成的编码字符串的最大行长度（默认为 None）。
  header_name：头部字段的名称（默认为 None）。
  continuation_ws：用于多行头部字段的换行缩进空格（默认为 ' '）。
  1
  2
  3
  4

• decode_header(header)：用于解码头部字符串

11. from email.policy import EmailPolicy：用于定义电子邮件的解析和生成策略

• emailPolicy = EmailPolicy(**kw)：创建策略对象
• emailPolicy.header_factory：用于创建头部对象的工厂函数。
• emailPolicy.mangle_from_：控制是否对 From 头部进行修剪和转义。
• emailPolicy.max_line_length：生成的邮件行的最大长度。
• emailPolicy.message_factory：用于创建消息对象的工厂函数。
• emailPolicy.raise_on_defect：确定是否在出现缺陷时引发异常。
• emailPolicy.refold_source：确定是否重新折叠已折叠的头部。
• emailPolicy.utf8：确定是否使用 UTF-8 编码。
• emailPolicy.linesep：生成邮件行时使用的换行符。
• emailPolicy.content_manager：用于管理邮件内容的对象。
• emailPolicy.cte_type：指定内容传输编码的类型。
• emailPolicy.clone(**kw)：创建当前策略的副本，并根据提供的关键字参数进行修改。
• emailPolicy.fold(name, value)：对给定的头部字段名称和值进行折叠。
• emailPolicy.fold_binary(name, value)：对给定的二进制头部字段名称和值进行折叠。
• emailPolicy.handle_defect(obj, defect)：处理消息对象中的缺陷。
• emailPolicy.header_fetch_parse(name, value)：解析头部字段的名称和值。
• emailPolicy.header_max_count(name)：返回指定头部字段的最大计数。
• emailPolicy.header_source_parse(sourcelines)：解析头部字段的原始行。
• emailPolicy.header_store_parse(name, value)：解析头部字段的名称和值。
• emailPolicy.register_defect(obj, defect)：注册消息对象中的缺陷。

12. import email.utils as email_util：用于处理电子邮件相关的实用函数

• email_util.parseaddr(address)：解析电子邮件地址字符串，返回一个包含用户名和地址的元组。
• email_util.formataddr(pair)：接受一个包含用户名和地址的元组，返回格式化后的电子邮件地址字符串。
• email_util.parsedate_to_datetime(date)：将日期字符串解析为 datetime 对象。
• email_util.format_datetime(dt)：将 datetime 对象格式化为 RFC 2822 格式的日期字符串。
• email_util.make_msgid(idstring=None, domain=None)：生成一个全局唯一的消息 ID。
• email_util.parseaddr_list(addresses)：解析多个电子邮件地址字符串，返回一个包含多个用户名和地址的元组列表。
• email_util.getaddresses(addresses)：解析多个电子邮件地址字符串，返回一个包含多个用户名和地址的列表。
• email_util.encode_rfc2231(value, charset=‘utf-8’, language=None)：将字符串编码为 RFC 2231 格式。
• email_util.decode_rfc2231(value)：解码 RFC 2231 格式的字符串。

13. import email.base64mime as email_baser64：用于处理电子邮件中的 Base64 编码

• email_baser64.decode(string)：对给定的字节串进行 Base64 编码。
• email_baser64.header_encode(header_bytes, charset=‘iso-8859-1’)：对给定的字节串进行 Base64 编码，并返回编码后的字符串，适用于邮件头部字段。
• email_baser64.header_length(bytearray)：返回给定字节数组的 Base64 编码后的长度，用于计算编码后的邮件头部字段长度。
• email_baser64.body_encode(s, maxlinelen=76, eol=NL)：对给定的字符串进行 Base64 编码，并返回编码后的字符串，适用于邮件正文。maxlinelen 参数指定每行的最大长度，eol 参数指定行结束符。

14. import email.encoders as email_encode：用于在电子邮件中对附件进行编码

• email_encode.encode_base64(msg)：对消息对象中的附件进行 Base64 编码。这个函数通常与 MIMEBase 类一起使用，例如 MIMEBase(‘application’, ‘octet-stream’)，然后使用 encode_base64 函数对附件进行编码。
• email_encode.encode_noop(msg)：这个函数不对消息对象进行任何编码操作，它只是一个空操作。可以在某些情况下使用，当您不需要对附件进行编码时，可以使用这个函数。
• email_encode.encode_7or8bit(msg)：对消息对象中的附件进行 7 位或 8 位编码。这个函数通常与 MIMEBase 类一起使用，例如 MIMEBase(‘application’, ‘octet-stream’)，然后使用 encode_7or8bit 函数对附件进行编码。
• email_encode.encode_quopri(msg)：对消息对象中的附件进行 Quoted-Printable 编码。这个函数通常与 MIMEBase 类一起使用，例如 MIMEBase(‘application’, ‘octet-stream’)，然后使用 encode_quopri 函数对附件进行编码。

15. import email.quoprimime as email_quoprimime：用于处理电子邮件中的 Quoted-Printable 编码

• email_quoprimime.header_encode(header_bytes, charset=‘iso-8859-1’)：对字节形式的邮件头部进行 Quoted-Printable 编码。header_bytes 参数是要编码的邮件头部字节串，charset 参数是字符集，默认为 ISO-8859-1。该函数返回编码后的字节串。
• email_quoprimime.decode(encoded, eol=NL)：对经过 Quoted-Printable 编码的文本进行解码。encoded 参数是要解码的文本，eol 参数是行结束符，默认为 NL（换行符）。该函数返回解码后的文本。
• email_quoprimime.unquote(s)：对 Quoted-Printable 编码的文本进行解码，将转义序列还原为原始字符。s 参数是要解码的文本。该函数返回解码后的文本。
• email_quoprimime.body_encode(body, maxlinelen=76, eol=NL)：对邮件正文进行 Quoted-Printable 编码。body 参数是要编码的邮件正文字符串，maxlinelen 参数是每行的最大长度，默认为 76，eol 参数是行结束符，默认为换行符 NL。该函数返回编码后的文本。
• email_quoprimime.header_length(bytearray)：计算字节数组形式的邮件头部的长度，用于 Quoted-Printable 编码。bytearray 参数是要计算长度的字节数组。
• email_quoprimime.body_check(octet)：检查单个字节是否需要进行 Quoted-Printable 编码。octet 参数是要检查的字节。
• email_quoprimime.body_length(bytearray)：计算字节数组形式的邮件正文的长度，用于 Quoted-Printable 编码。bytearray 参数是要计算长度的字节数组。
• email_quoprimime.header_check(octet)：检查单个字节是否需要进行 Quoted-Printable 编码。octet 参数是要检查的字节。
• email_quoprimime.quote©：对字符进行 Quoted-Printable 编码，将其转换为转义序列。c 参数是要编码的字符。
• email_quoprimime.header_decode(s)：对经过 Quoted-Printable 编码的邮件头部进行解码。s 参数是要解码的文本。该函数返回解码后的文本。

16. from email.parser import Parser,HeaderParser,BytesParser,BytesHeaderParser：邮件解析

• paser = Parser(_class=None, policy=compat32)：创建解析电子邮件对象
• paser.parse(fp, headersonly=False)：解析电子邮件附件，返回Message对象
• paser.parsestr(text, headersonly=False)：解析电子邮件文本，返回Message对象
• headerParser = HeaderParser()：解析电子邮件头部信息，继承Parser
• headerParser.parse(fp, headersonly=False)：解析电子邮件附件头部，返回Message对象
• headerParser.parsestr(text, headersonly=False)：解析电子邮件文本头部，返回Message对象
• bytesParser = BytesParser(_class=None, policy=compat32)：创建解析二进制数据形式的电子邮件对象
• bytesParser.parse(fp, headersonly=False)：解析二进制电子邮件附件，返回Message对象
• bytesParser.parsestr(text, headersonly=False)：解析二进制电子邮件文本，返回Message对象
• bytesHeaderParser = BytesHeaderParser()：解析二进制电子邮件头部信息，继承 BytesParser
• bytesHeaderParser.parse(fp, headersonly=False)：解析二进制电子邮件附件头部，返回Message对象
• bytesHeaderParser.parsestr(text, headersonly=False)：解析二进制电子邮件文本头部，返回Message对象

17. from email.generator import Generator,BytesGenerator,DecodedGenerator：把Message转换电子邮件文本，或者转换电子邮件头部

• generator = Generator(outfp, mangle_from_=None, maxheaderlen=None, policy=None)：创建生成电子邮件文本对象

  outfp：表示输出文件对象（file-like object），用于将生成的电子邮件文本写入文件。可以是文件对象、网络套接字等。如果要将电子邮件文本写入文件，可以使用 open() 函数创建一个文件对象，并将其传递给 Generator 的构造函数。
  mangle_from_：一个布尔值，用于控制是否对 "From" 头部进行修整（mangle）。默认情况下，Generator 类会根据需要对 "From" 头部进行修整，以确保邮件地址的正确格式。
  maxheaderlen：一个整数值，用于限制生成的每个头部的最大长度。如果头部的长度超过该值，将会进行折行处理。默认情况下，没有长度限制。
  policy：一个 email.policy.Policy 对象，用于控制生成的电子邮件文本的规则。如果不提供该参数，默认使用 email.policyEmailMessage.default 策略。
  1
  2
  3
  4

• generator.clone(fp)：创建并返回一个新的 Generator 对象，其输出文件对象（outfp）设置为与原始 Generator 对象相同。这个方法可以用于创建一个 Generator 对象的副本，以便在不同的地方使用相同的设置和输出目标。
• generator.write(s)：将字符串 s 写入输出文件对象（outfp）。这个方法可以用于将任意文本写入生成的电子邮件文本中，例如添加自定义的头部或内容。
• generator.flatten(msg, unixfrom=False, linesep=None)：将 Message 对象 msg 转换为电子邮件文本，并返回生成的文本字符串。

  msg：Message对象
  unixfrom 参数用于控制是否在生成的文本中包含 Unix From 行。
  linesep 参数用于指定行分隔符，如果未提供，则使用系统默认的行分隔符
  1
  2
  3

• bytesGenerator = BytesGenerator()：创建生成二进制电子邮件文本对象，继承Generator
• bytesGenerator.clone(fp)：创建并返回一个新的 Generator 对象，其输出文件对象（outfp）设置为与原始 Generator 对象相同。这个方法可以用于创建一个 Generator 对象的副本，以便在不同的地方使用相同的设置和输出目标。
• bytesGenerator.write(s)：将字符串 s 写入输出文件对象（outfp）。这个方法可以用于将任意文本写入生成的电子邮件文本中，例如添加自定义的头部或内容。
• bytesGenerator.flatten(msg, unixfrom=False, linesep=None)：将 Message 对象 msg 转换为电子邮件文本，并返回生成的文本字符串。
• decodedGenerator = DecodedGenerator(outfp, mangle_from_=None, maxheaderlen=None, fmt=None, policy=None)：将 Message 对象转换为电子邮件文本，并在必要时解码非ASCII字符
• decodedGenerator.clone(fp)：创建并返回一个新的 Generator 对象，其输出文件对象（outfp）设置为与原始 Generator 对象相同。这个方法可以用于创建一个 Generator 对象的副本，以便在不同的地方使用相同的设置和输出目标。
• decodedGenerator.write(s)：将字符串 s 写入输出文件对象（outfp）。这个方法可以用于将任意文本写入生成的电子邮件文本中，例如添加自定义的头部或内容。
• decodedGenerator.flatten(msg, unixfrom=False, linesep=None)：将 Message 对象 msg 转换为电子邮件文本，并返回生成的文本字符串。

  from email.message import EmailMessage
  from email.generator import Generator
  
  # 创建 EmailMessage 对象
  message = EmailMessage()
  message["Subject"] = "Hello"
  message["From"] = "sender@example.com"
  message["To"] = "recipient@example.com"
  message.set_content("This is the email content.")
  
  with open('email.txt','a+') as file:
  
      # 创建 Generator 对象，并将 Message 对象转换为字符串
      generator = Generator(file)
  
      # 使用 write() 方法将自定义文本写入生成的电子邮件文本
      generator.write("Custom header: X-Custom-Header\n")
  
      # 使用 flatten() 方法将 Message 对象转换为电子邮件文本
      generator.flatten(message)
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21

18. from email.charset import Charset,add_charset,add_alias,add_codec：处理电子邮件字符集

• charset = Charset(input_charset=DEFAULT_CHARSET)：创建字符集对象
• charset.header_encoding：表示用于编码邮件头部的编码名称。
• charset.input_codec：表示用于将输入字符转换为内部表示的编码名称。
• charset.output_codec：表示用于将内部表示的字符转换为输出字符的编码名称。
• charset.body_encoding：表示用于编码邮件正文的编码名称。
• charset.input_charset：表示字符集的名称。
• charset.output_charset：表示输出字符集的名称。
• charset.get_output_charset()：返回输出字符集的名称。
• charset.header_encode(string)：对给定的字符串进行邮件头部编码，并返回编码后的字符串。
• charset.body_encode(string)：对给定的字符串进行邮件正文编码，并返回编码后的字符串。
• charset.get_body_encoding()：返回用于编码邮件正文的编码名称。
• charset.header_encode_lines(string, maxlengths)：对给定的字符串进行邮件头部编码，并根据指定的行长度限制进行分行处理。
• add_codec(charset, codecname)：此方法用于向字符集编码表中添加新的编码

  charset 参数是字符集的名称。
  codecname 参数是编码的名称。
  1
  2

• add_charset(charset, header_enc=None, body_enc=None, output_charset=None)：此方法用于向字符集表中添加新的字符集。
  charset 参数是字符集的名称。

  header_enc 参数是用于编码邮件头部的编码名称。
  body_enc 参数是用于编码邮件正文的编码名称。
  output_charset 参数是输出字符集的名称。
  1
  2
  3

• add_alias(alias, canonical)：此方法用于向字符集别名表中添加字符集别名。

  alias 参数是别名。
  canonical 参数是对应的规范字符集名称。
  1
  2

19. from email.contentmanager import ContentManager：邮件内容管理

• contentManager = ContentManager()：创建邮件内容管理对象
• contentManager.get_content(msg, *args, **kw)：用于从邮件消息中获取内容

  msg 是邮件消息对象。
  *args 和 **kw 额外的参数或关键字参数，用于指定获取内容时的一些选项。
  1
  2

• contentManager.set_content(msg, obj, *args, **kw)：用于设置邮件消息的内容。

  msg 是邮件消息对象。
  obj 是要设置的内容。
  *args 和 **kw 额外的参数或关键字参数，用于指定设置内容时的一些选项。
  1
  2
  3

• contentManager.add_get_handler(key, handler)：用于注册一个获取内容的处理器。

  key 一个标识符，用于指定要处理的内容类型。
  handler 一个函数或者对象，用于处理相应类型的内容。
  1
  2

• contentManager.add_set_handler(typekey, handler)：用于注册一个设置内容的处理器。

  typekey 可能是一个标识符，用于指定要处理的内容类型。
  handler 可能是一个函数或者对象，用于处理相应类型的内容的设置。
  1
  2

20. from email.feedparser import FeedParser,BytesFeedParser：解析电子邮件消息的原始文本数据

• feedParser = FeedParser(_factory=None, policy=compat32)：创建电子邮件消息的原始文本数据对象
• feedParser.feed()：将原始邮件文本数据提供给解析器进行解析
• feedParser.close()：关闭解析器
• bytesFeedParser = BytesFeedParser()：创建二进制电子邮件消息的原始文本数据对象，继承FeedParser

四、smtp命令

1. HELO 命令：向服务器标识发送方的主机名或域名，HELO domain，如：HELO example.com

   '''状态码'''
   250：命令执行成功。
   500：命令语法错误，参数不正确。
   501：命令参数格式错误。
   504：命令参数格式错误，主机名或域名不正确。
   1
   2
   3
   4
   5

2. HELP 命令：请求服务器提供帮助信息。可选地，可以指定特定命令以获取有关该命令的帮助信息。HELP [command]

   '''状态码'''
   211：系统状态或帮助响应。
   214：帮助消息
   1
   2
   3

3. RCPT 命令：指定邮件的接收者地址。RCPT TO:
   ，如：RCPT TO: recipient@example.com

   '''状态码'''
   250：命令执行成功。
   251：用户非本地，将转发到其他邮件服务器。
   550：命令执行失败，无法找到接收者地址。
   1
   2
   3
   4

4. NOOP 命令：空操作命令，用于保持与服务器的活动连接，NOOP

   '''状态码'''
   250：命令执行成功。
   1
   2

5. VERIFY 命令：验证指定地址的有效性，VERIFY
   ，如：VERIFY recipient@example.com

   '''状态码'''
   250：命令执行成功，地址有效。
   251：用户非本地，将转发到其他邮件服务器。
   550：命令执行失败，地址无效。
   1
   2
   3
   4

6. EHLO 命令：扩展的 HELO 命令，向服务器标识发送方的主机名或域名，并请求服务器支持的扩展功能，EHLO domain，如：EHLO example.com

   '''状态码'''
   250：命令执行成功，服务器支持的扩展功能列表。
   500：命令语法错误，参数不正确。
   501：命令参数格式错误。
   504：命令参数格式错误，主机名或域名不正确
   1
   2
   3
   4
   5

7. MAIL 命令：指定邮件的发件人地址，MAIL FROM:
   ，如：MAIL FROM: recipient@example.com

   '''状态码'''
   250：命令执行成功。
   552：命令执行失败，邮件大小超过服务器限制。
   1
   2
   3

8. EXPN 命令：展开邮件列表的成员，EXPN

   '''状态码'''
   250：命令执行成功，返回列表成员。
   550：命令执行失败，无法展开列表
   1
   2
   3

五、QQ邮箱案例

import smtplib
from email.mime.text import MIMEText
from email.header import Header

# SMTP 服务器信息
smtp_server = 'smtp.qq.com'
smtp_port = 587
smtp_user = '5678987@qq.com'
smtp_password = 'eyzstypjjtwbbebd'

# 发件人邮箱和密码
sender = '5678987@qq.com'
# 收件人邮箱
receiver = '5678987@qq.com'

# 邮件内容
subject = 'python内置模块发送邮件'
content = '我是python email'

message = MIMEText(content, 'plain', 'utf-8')
message['From'] = Header(sender)
message['To'] = Header(receiver)
message['Subject'] = Header(subject)


try:
    # 连接到 SMTP 服务器
    with smtplib.SMTP(smtp_server, smtp_port) as smtp:
        print('smtp服务器连接成功')

        # 开启安全传输层（如果服务器支持）
        smtp.starttls()

        # 登录到 SMTP 服务器
        smtp.login(smtp_user, smtp_password)

        smtp.sendmail(sender, receiver, message.as_string())

        print('邮件发送成功')

except Exception as e:
    print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42