devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python接收/发送QQ邮箱(保姆级)_python 发邮件给指定qq

作者：人工智能uu | 2024-07-14 03:32:24

赞

踩

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
  4.  
  5. # 邮件内容
  6. subject = '邮件主题'
  7. body = '邮件正文'
  8.  
  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'
  14.  
  15. # 发送邮件
  16. smtp_server = 'smtp.qq.com'
  17. smtp_port = 587
  18. sender_email = 'XXXX@qq.com'
  19. password = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXX' #在QQ邮箱设置里拿到的码
  20.  
  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
  6.  
  7. #这个代码会检查邮件发件人，如果发件人存在，才会进行解析和输出，否则将直接跳过邮件。并且我改变了邮件解析的方法，使用了email.header.decode_header函数来解析邮件的头部信息和主题。
  8.  
  9. # 连接到POP3服务器
  10. pop_server = poplib.POP3_SSL('pop.qq.com', 995)
  11. pop_server.user('xxxx@qq.com')
  12. pop_server.pass_('xxxxxxxxxx')
  13.  
  14. # 获取邮箱中的邮件信息
  15. num_emails = len(pop_server.list()[1])
  16.  
  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)
  22.  
  23.     # 解析邮件内容
  24.     email_parser = BytesParser()
  25.     email = email_parser.parsebytes(email_content)
  26.  
  27.     # 解析邮件头部信息
  28.     email_from = email.get('From').strip()
  29.     email_from = str(jiexi.make_header(jiexi.decode_header(email_from)))
  30.  
  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
  35.  
  36.         print("------------------")
  37.         print("From:", email_from)
  38.         print("Subject:", decoded_subject)
  39.     else:
  40.         continue  # 跳过缺失发件人的邮件
  41.  
  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
  5.  
  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()
  20.  
  21. # 连接到POP3服务器
  22. pop_server = poplib.POP3_SSL('pop.qq.com', 995)
  23. pop_server.user('xxxxxx@qq.com')
  24. pop_server.pass_('xxxxxxx')
  25.  
  26. # 获取邮箱中的邮件信息
  27. num_emails = len(pop_server.list()[1])
  28.  
  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)
  34.  
  35.     # 解析邮件内容
  36.     email_parser = BytesParser(policy=policy.default)
  37.     email = email_parser.parsebytes(email_content)
  38.  
  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
  46.  
  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  # 跳过缺失发件人的邮件
  55.  
  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
  7.  
  8.  
  9. def sanitize_folder_name(name):
  10.     #清理邮箱地址，移除或替换那些非法字符
  11.     invalid_characters = "<>:\"/\\|?*@"
  12.     for char in invalid_characters:
  13.         name = name.replace(char, "_")
  14.     return name
  15.  
  16.  
  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'
  37.  
  38.  
  39. # 连接到POP3服务器
  40. pop_server = poplib.POP3_SSL('pop.qq.com', 995)
  41. pop_server.user('xxxx@qq.com')
  42. pop_server.pass_('xxxxxx')
  43.  
  44. # 获取邮箱中的邮件信息
  45. num_emails = len(pop_server.list()[1])
  46.  
  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)
  52.  
  53.     # 解析邮件内容
  54.     email_parser = BytesParser(policy=policy.default)
  55.     email = email_parser.parsebytes(email_content)
  56.  
  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
  64.  
  65.         # 提取邮件正文
  66.         email_body, body_type, *extras = get_payload(email)
  67.  
  68.         # 创建安全的文件夹名和文件名
  69.         safe_folder_name = sanitize_folder_name(email_from)
  70.         safe_subject = sanitize_folder_name(decoded_subject)
  71.  
  72.         print("------------------")
  73.         print("From:", email_from)
  74.         print("Subject:", decoded_subject)
  75.         print("Body Type:", body_type)
  76.  
  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  # 跳过缺失发件人的邮件
  96.  
  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
  7.  
  8.  
  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  # 输入待查询的目标邮件地址
  17.  
  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  # 返回清理后的名称
  24.  
  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()
  38.  
  39.     # 定义一个函数，用以获取邮件信息
  40.     def fetch_email(self):
  41.         num_emails = len(self.pop_server.list()[1])  # 获取邮箱内的邮件数量
  42.  
  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对象
  48.  
  49.             # 解析邮件内容
  50.             email_parser = BytesParser(policy=policy.default)  # 创建一个邮件解析器
  51.             email = email_parser.parsebytes(email_content)  # 解析邮件内容，返回一个邮件对象
  52.  
  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')  # 获取邮件时间
  59.  
  60.                 # 提取邮件正文
  61.                 email_body = self.get_payload(email)  # 获取邮件正文
  62.  
  63.                 return email_body, email_time  # 返回邮件正文和时间
  64.  
  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)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/822972
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号