python接收/发送QQ邮箱(保姆级)

前言:

关于代码中:

sender_email = 'XXXX@qq.com'   #这个就是你的邮箱地址,不多说了
password = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX' #在QQ邮箱设置里拿到的码,自己去查.需要手机发信息过去,0.1/RMB一个;为期大概一个月!

1.发送邮箱:

1. import smtplib
2. from email.mime.text import MIMEText
3. from email.header import Header
5. # 邮件内容
6. subject = '邮件主题'
7. body = '邮件正文'
9. # 构建邮件
10. msg = MIMEText(body, 'plain', 'utf-8')
11. msg['Subject'] = Header(subject, 'utf-8')
12. msg['From'] = 'XXXX@qq.com'
13. msg['To'] = 'XXXX@qq.com'
15. # 发送邮件
16. smtp_server = 'smtp.qq.com'
17. smtp_port = 587
18. sender_email = 'XXXX@qq.com'
19. password = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX' #在QQ邮箱设置里拿到的码
21. try:
22. with smtplib.SMTP(smtp_server, smtp_port) as server:
23. server.starttls()
24. server.login(sender_email, password)
25. server.sendmail(sender_email, [msg['To']], msg.as_string())
26. print('邮件发送成功')
27. except smtplib.SMTPException as e:
28. print('邮件发送失败:', str(e))

2.接收邮箱---(打印发件人/主题,解决收件人乱码问题)

1. import base64
2. import poplib
3. from email.parser import BytesParser
4. import email.header as jiexi
5. import re
7. #这个代码会检查邮件发件人，如果发件人存在，才会进行解析和输出，否则将直接跳过邮件。并且我改变了邮件解析的方法，使用了email.header.decode_header函数来解析邮件的头部信息和主题。
9. # 连接到POP3服务器
10. pop_server = poplib.POP3_SSL('pop.qq.com', 995)
11. pop_server.user('xxxx@qq.com')
12. pop_server.pass_('xxxxxxxxxx')
14. # 获取邮箱中的邮件信息
15. num_emails = len(pop_server.list()[1])
17. # 遍历每封邮件
18. for i in range(num_emails):
19. # 获取邮件内容
20. response, lines, octets = pop_server.retr(i + 1)
21. email_content = b'\r\n'.join(lines)
23. # 解析邮件内容
24. email_parser = BytesParser()
25. email = email_parser.parsebytes(email_content)
27. # 解析邮件头部信息
28. email_from = email.get('From').strip()
29. email_from = str(jiexi.make_header(jiexi.decode_header(email_from)))
31. if email_from: # 只处理存在发件人的邮件
32. # 解析邮件主题
33. subject = email.get('Subject').strip()
34. decoded_subject = str(jiexi.make_header(jiexi.decode_header(subject))) if subject else None
36. print("------------------")
37. print("From:", email_from)
38. print("Subject:", decoded_subject)
39. else:
40. continue # 跳过缺失发件人的邮件
42. # 关闭连接
43. pop_server.quit()

3.接收邮箱v02---(打印出邮件的正文body部分)

1. import poplib
2. from email import policy
3. from email.parser import BytesParser
4. from email.header import decode_header, make_header
6. #在这段代码中，我定义了一个函数get_html_payload()来提取邮件的payload。
7. # 如果邮件的主题是多部分的（即包含多个部分，例如文本和HTML），那么我们会遍历每个部分，
8. # 找出HTML部分并返回。如果邮件主题只有一个部分且是HTML，则直接返回该部分。如果没有合适的部分，
9. # 那么函数将返回None。
10. def get_html_payload(email_message):
11. if email_message.is_multipart():
12. for part in email_message.iter_parts():
13. content_type = part.get_content_type()
14. if content_type == 'text/html':
15. return part.get_content()
16. else:
17. continue
18. elif email_message.get_content_type() == 'text/html':
19. return email_message.get_content()
21. # 连接到POP3服务器
22. pop_server = poplib.POP3_SSL('pop.qq.com', 995)
23. pop_server.user('xxxxxx@qq.com')
24. pop_server.pass_('xxxxxxx')
26. # 获取邮箱中的邮件信息
27. num_emails = len(pop_server.list()[1])
29. # 遍历每封邮件
30. for i in range(num_emails):
31. # 获取邮件内容
32. response, lines, octets = pop_server.retr(i + 1)
33. email_content = b'\r\n'.join(lines)
35. # 解析邮件内容
36. email_parser = BytesParser(policy=policy.default)
37. email = email_parser.parsebytes(email_content)
39. # 解析邮件头部信息
40. email_from = email.get('From').strip()
41. email_from = str(make_header(decode_header(email_from)))
42. if email_from: # 只处理存在发件人的邮件
43. # 解析邮件主题
44. subject = email.get('Subject').strip()
45. decoded_subject = str(make_header(decode_header(subject))) if subject else None
47. # 提取邮件正文
48. email_body = get_html_payload(email)
49. print("------------------")
50. print("From:", email_from)
51. print("Subject:", decoded_subject)
52. print("Body:", email_body)
53. else:
54. continue # 跳过缺失发件人的邮件
56. # 关闭连接
57. pop_server.quit()

4.接收邮箱v03---(打印出邮件的正文body部分,并分类存文件到目录,以html/图片/text分类)

1. import os
2. import base64
3. import poplib
4. from email import policy
5. from email.parser import BytesParser
6. from email.header import decode_header, make_header
9. def sanitize_folder_name(name):
10. #清理邮箱地址，移除或替换那些非法字符
11. invalid_characters = "<>:\"/\\|?*@"
12. for char in invalid_characters:
13. name = name.replace(char, "_")
14. return name
17. def get_payload(email_message):
18. #------------------解析正文-------------------
19. # 我在循环中使用了这个新的信息，根据正文的类型执行不同的操作。对于纯文本类型，它只打印正文；
20. # 对于html和image类型，它创建一个目录（如果还不存在），然后将正文写入一个文件。对于image，
21. # 我还添加了一个把数据从base64格式解码回二进制格式的步骤，这是因为图片通常会以base64格式存储在邮件中。
22. if email_message.is_multipart():
23. for part in email_message.iter_parts():
24. content_type = part.get_content_type()
25. if content_type == 'text/html':
26. return part.get_content(), 'html'
27. elif content_type == 'text/plain':
28. return part.get_content(), 'text'
29. elif content_type.startswith('image/'):
30. return part.get_content(), 'image', part.get_content_type().split('/')[-1]
31. else:
32. continue
33. elif email_message.get_content_type() == 'text/html':
34. return email_message.get_content(), 'html'
35. elif email_message.get_content_type() == 'text/plain':
36. return email_message.get_content(), 'text'
39. # 连接到POP3服务器
40. pop_server = poplib.POP3_SSL('pop.qq.com', 995)
41. pop_server.user('xxxx@qq.com')
42. pop_server.pass_('xxxxxx')
44. # 获取邮箱中的邮件信息
45. num_emails = len(pop_server.list()[1])
47. # 遍历每封邮件
48. for i in range(num_emails):
49. # 获取邮件内容
50. response, lines, octets = pop_server.retr(i + 1)
51. email_content = b'\r\n'.join(lines)
53. # 解析邮件内容
54. email_parser = BytesParser(policy=policy.default)
55. email = email_parser.parsebytes(email_content)
57. # 解析邮件头部信息
58. email_from = email.get('From').strip()
59. email_from = str(make_header(decode_header(email_from)))
60. if email_from: # 只处理存在发件人的邮件
61. # 解析邮件主题
62. subject = email.get('Subject').strip()
63. decoded_subject = str(make_header(decode_header(subject))) if subject else None
65. # 提取邮件正文
66. email_body, body_type, *extras = get_payload(email)
68. # 创建安全的文件夹名和文件名
69. safe_folder_name = sanitize_folder_name(email_from)
70. safe_subject = sanitize_folder_name(decoded_subject)
72. print("------------------")
73. print("From:", email_from)
74. print("Subject:", decoded_subject)
75. print("Body Type:", body_type)
77. # 根据正文类型处理
78. if body_type == 'text':
79. print("Body:", email_body)
80. elif body_type == 'html':
81. directory = safe_folder_name
82. if not os.path.exists(directory):
83. os.makedirs(directory)
84. with open(f'{directory}/{safe_subject}.html', 'w') as f:
85. f.write(email_body)
86. elif body_type == 'image':
87. directory = safe_folder_name
88. if not os.path.exists(directory):
89. os.makedirs(directory)
90. image_data = base64.b64decode(email_body)
91. image_extension = extras[0] # Get the image extension
92. with open(f'{directory}/{safe_subject}.{image_extension}', 'wb') as f:
93. f.write(image_data)
94. else:
95. continue # 跳过缺失发件人的邮件
97. # 关闭连接
98. pop_server.quit()

5.接收邮箱v04--(接收指定的邮箱,并把它封装好!完整版,可直接使用)

1. import os
2. import base64
3. import poplib
4. from email import policy
5. from email.parser import BytesParser
6. from email.header import decode_header, make_header
9. # 定义EmailClient类，用于连接到POP3服务器并从指定的邮件地址获取邮件
10. class EmailClient:
11. # 在初始化函数中，设置POP3服务器的来源、用户、密码和待查询的目标邮件地址
12. def __init__(self, host, user, password, target_email):
13. self.pop_server = poplib.POP3_SSL(host) # 使用POP3协议通过SSL安全连接到邮件服务器
14. self.pop_server.user(user) # 输入用户邮箱
15. self.pop_server.pass_(password) # 输入用户邮箱密码
16. self.target_email = target_email # 输入待查询的目标邮件地址
18. # 定义一个函数，用以清除文件名中的无效字符
19. def sanitize_folder_name(self, name):
20. invalid_characters = "<>:\"/\\|?*@"
21. for char in invalid_characters: # 遍历所有无效字符
22. name = name.replace(char, "_") # 将无效字符替换为下划线
23. return name # 返回清理后的名称
25. # 定义一个函数，用以提取邮件的payload（有效载荷，即邮件主体内容）
26. def get_payload(self, email_message):
27. if email_message.is_multipart(): # 判断邮件是否为多部分邮件
28. for part in email_message.iter_parts(): # 如果是，则遍历其中的每一部分
29. content_type = part.get_content_type() # 获取该部分的内容类型
30. if content_type == 'text/html': # 如果内容类型为HTML，则返回该部分内容
31. return part.get_content()
32. elif content_type == 'text/plain': # 如果内容类型为纯文本，则返回该部分内容
33. return part.get_content()
34. elif email_message.get_content_type() == 'text/html': # 如果邮件非多部分形式，且为HTML类型，则返回邮件内容
35. return email_message.get_content()
36. elif email_message.get_content_type() == 'text/plain': # 如果邮件非多部分形式，且为纯文本类型，则返回邮件内容
37. return email_message.get_content()
39. # 定义一个函数，用以获取邮件信息
40. def fetch_email(self):
41. num_emails = len(self.pop_server.list()[1]) # 获取邮箱内的邮件数量
43. # 遍历每一封邮件
44. for i in range(num_emails):
45. # 获取邮件内容
46. response, lines, octets = self.pop_server.retr(i + 1) # retr函数返回指定邮件的全部文本
47. email_content = b'\r\n'.join(lines) # 将所有行连接成一个bytes对象
49. # 解析邮件内容
50. email_parser = BytesParser(policy=policy.default) # 创建一个邮件解析器
51. email = email_parser.parsebytes(email_content) # 解析邮件内容，返回一个邮件对象
53. # 解析邮件头部信息并提取发件人信息
54. email_from = email.get('From').strip() # 获取发件人信息，并去除尾部的空格
55. email_from = str(make_header(decode_header(email_from))) # 解码发件人信息，并将其转换为字符串
56. if email_from == self.target_email: # 如果发件人地址与指定的目标邮件地址一致，对邮件进行处理
57. # 解析邮件时间
58. email_time = email.get('Date') # 获取邮件时间
60. # 提取邮件正文
61. email_body = self.get_payload(email) # 获取邮件正文
63. return email_body, email_time # 返回邮件正文和时间
65. print("No new emails from", self.target_email) # 如果没有从目标邮件地址收到新邮件，打印相应信息
66. return None, None # 返回None

-------封装他------------

1. from shou_self import EmailClient
2. client = EmailClient('pop.qq.com', '你的邮箱', '邮箱提取出的密码', '需要针对的目标邮箱')
3. body, time = client.fetch_email()
4. print("Time:", time)
5. print("Body:", body)