通过 Gmail 和 Python 发送电子邮件

Question

使用 Gmail 和 Python 发送电子邮件的推荐方式是什么？

有很多 SO 线程，但大多数都是旧的，而且带有用户名和密码的 SMTP 也不再工作，或者用户必须降级其 Gmail 的安全性（例如，请参见此处）。

OAuth 是推荐的方式吗？

Answer 1

答案显示了如何使用 gmail API 和 python 发送电子邮件。 还更新了发送带有附件的电子邮件的答案。

Gmail API & OAuth -> 无需在脚本中保存用户名和密码。

脚本第一次打开浏览器以授权脚本并将在本地存储凭据（它不会存储用户名和密码）。 随后的运行不需要浏览器并且可以直接发送电子邮件。

使用此方法，您将不会收到以下 SMTPException 之类的错误，并且无需允许访问不太安全的应用程序：

raise SMTPException("SMTP AUTH extension not supported by server.")  
smtplib.SMTPException: SMTP AUTH extension not supported by server.

以下是使用 gmail API 发送电子邮件的步骤：

（向导链接在这里，更多信息在这里）

第 2 步：安装 Google 客户端库

pip install --upgrade google-api-python-client

第 3 步：使用以下脚本发送电子邮件（只需更改主函数中的变量）

import httplib2
import os
import oauth2client
from oauth2client import client, tools, file
import base64
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from apiclient import errors, discovery
import mimetypes
from email.mime.image import MIMEImage
from email.mime.audio import MIMEAudio
from email.mime.base import MIMEBase

SCOPES = 'https://www.googleapis.com/auth/gmail.send'
CLIENT_SECRET_FILE = 'client_secret.json'
APPLICATION_NAME = 'Gmail API Python Send Email'

def get_credentials():
    home_dir = os.path.expanduser('~')
    credential_dir = os.path.join(home_dir, '.credentials')
    if not os.path.exists(credential_dir):
        os.makedirs(credential_dir)
    credential_path = os.path.join(credential_dir,
                                   'gmail-python-email-send.json')
    store = oauth2client.file.Storage(credential_path)
    credentials = store.get()
    if not credentials or credentials.invalid:
        flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)
        flow.user_agent = APPLICATION_NAME
        credentials = tools.run_flow(flow, store)
        print('Storing credentials to ' + credential_path)
    return credentials

def SendMessage(sender, to, subject, msgHtml, msgPlain, attachmentFile=None):
    credentials = get_credentials()
    http = credentials.authorize(httplib2.Http())
    service = discovery.build('gmail', 'v1', http=http)
    if attachmentFile:
        message1 = createMessageWithAttachment(sender, to, subject, msgHtml, msgPlain, attachmentFile)
    else: 
        message1 = CreateMessageHtml(sender, to, subject, msgHtml, msgPlain)
    result = SendMessageInternal(service, "me", message1)
    return result

def SendMessageInternal(service, user_id, message):
    try:
        message = (service.users().messages().send(userId=user_id, body=message).execute())
        print('Message Id: %s' % message['id'])
        return message
    except errors.HttpError as error:
        print('An error occurred: %s' % error)
        return "Error"
    return "OK"

def CreateMessageHtml(sender, to, subject, msgHtml, msgPlain):
    msg = MIMEMultipart('alternative')
    msg['Subject'] = subject
    msg['From'] = sender
    msg['To'] = to
    msg.attach(MIMEText(msgPlain, 'plain'))
    msg.attach(MIMEText(msgHtml, 'html'))
    return {'raw': base64.urlsafe_b64encode(msg.as_bytes())}

def createMessageWithAttachment(
    sender, to, subject, msgHtml, msgPlain, attachmentFile):
    """Create a message for an email.

    Args:
      sender: Email address of the sender.
      to: Email address of the receiver.
      subject: The subject of the email message.
      msgHtml: Html message to be sent
      msgPlain: Alternative plain text message for older email clients          
      attachmentFile: The path to the file to be attached.

    Returns:
      An object containing a base64url encoded email object.
    """
    message = MIMEMultipart('mixed')
    message['to'] = to
    message['from'] = sender
    message['subject'] = subject

    messageA = MIMEMultipart('alternative')
    messageR = MIMEMultipart('related')

    messageR.attach(MIMEText(msgHtml, 'html'))
    messageA.attach(MIMEText(msgPlain, 'plain'))
    messageA.attach(messageR)

    message.attach(messageA)

    print("create_message_with_attachment: file: %s" % attachmentFile)
    content_type, encoding = mimetypes.guess_type(attachmentFile)

    if content_type is None or encoding is not None:
        content_type = 'application/octet-stream'
    main_type, sub_type = content_type.split('/', 1)
    if main_type == 'text':
        fp = open(attachmentFile, 'rb')
        msg = MIMEText(fp.read(), _subtype=sub_type)
        fp.close()
    elif main_type == 'image':
        fp = open(attachmentFile, 'rb')
        msg = MIMEImage(fp.read(), _subtype=sub_type)
        fp.close()
    elif main_type == 'audio':
        fp = open(attachmentFile, 'rb')
        msg = MIMEAudio(fp.read(), _subtype=sub_type)
        fp.close()
    else:
        fp = open(attachmentFile, 'rb')
        msg = MIMEBase(main_type, sub_type)
        msg.set_payload(fp.read())
        fp.close()
    filename = os.path.basename(attachmentFile)
    msg.add_header('Content-Disposition', 'attachment', filename=filename)
    message.attach(msg)

    return {'raw': base64.urlsafe_b64encode(message.as_string())}


def main():
    to = "to@address.com"
    sender = "from@address.com"
    subject = "subject"
    msgHtml = "Hi<br/>Html Email"
    msgPlain = "Hi\nPlain Email"
    SendMessage(sender, to, subject, msgHtml, msgPlain)
    # Send message with attachment: 
    SendMessage(sender, to, subject, msgHtml, msgPlain, '/path/to/file.pdf')

if __name__ == '__main__':
    main()

在没有浏览器的情况下在 linux 上运行此代码的提示：
如果您的 linux 环境没有浏览器来完成首次授权过程，您可以在笔记本电脑（mac 或 windows）上运行一次代码，然后将凭据复制到目标 linux 机器。 凭证通常存储在以下目的地：

~/.credentials/gmail-python-email-send.json

Answer 2

受Python Gmail API 'not JSON serializable' 的启发，我将其修改如下以使用 Python3

import httplib2
import os
import oauth2client
from oauth2client import client, tools
import base64
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from apiclient import errors, discovery

SCOPES = 'https://www.googleapis.com/auth/gmail.send'
CLIENT_SECRET_FILE = 'client_secret.json'
APPLICATION_NAME = 'Gmail API Python Send Email'

def get_credentials():
    home_dir = os.path.expanduser('~')
    credential_dir = os.path.join(home_dir, '.credentials')
    if not os.path.exists(credential_dir):
        os.makedirs(credential_dir)
    credential_path = os.path.join(credential_dir, 'gmail-python-email-send.json')
    store = oauth2client.file.Storage(credential_path)
    credentials = store.get()
    if not credentials or credentials.invalid:
        flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)
        flow.user_agent = APPLICATION_NAME
        credentials = tools.run_flow(flow, store)
        print('Storing credentials to ' + credential_path)
    return credentials

def SendMessage(sender, to, subject, msgHtml, msgPlain):
    credentials = get_credentials()
    http = credentials.authorize(httplib2.Http())
    service = discovery.build('gmail', 'v1', http=http)
    message1 = CreateMessage(sender, to, subject, msgHtml, msgPlain)
    SendMessageInternal(service, "me", message1)

def SendMessageInternal(service, user_id, message):
    try:
        message = (service.users().messages().send(userId=user_id, body=message).execute())
        print('Message Id: %s' % message['id'])
        return message
    except errors.HttpError as error:
        print('An error occurred: %s' % error)

def CreateMessage(sender, to, subject, msgHtml, msgPlain):
    msg = MIMEMultipart('alternative')
    msg['Subject'] = subject
    msg['From'] = sender
    msg['To'] = to
    msg.attach(MIMEText(msgPlain, 'plain'))
    msg.attach(MIMEText(msgHtml, 'html'))
    raw = base64.urlsafe_b64encode(msg.as_bytes())
    raw = raw.decode()
    body = {'raw': raw}
    return body

def main():
    to = "to@address.com"
    sender = "from@address.com"
    subject = "subject"
    msgHtml = "Hi<br/>Html Email"
    msgPlain = "Hi\nPlain Email"
    SendMessage(sender, to, subject, msgHtml, msgPlain)

if __name__ == '__main__':
    main()

Answer 3

这是发送不带（或带）附件的电子邮件所需的 Python 3.6 代码（和解释）。

（要发送带附件只需取消注释下面的 2 行## without attachment ，并评论下面的 2 行## with attachment ）

所有功劳（和投票）都归功于 apadana

import httplib2
import os
import oauth2client
from oauth2client import client, tools
import base64
from email import encoders

#needed for attachment
import smtplib  
import mimetypes
from email import encoders
from email.message import Message
from email.mime.audio import MIMEAudio
from email.mime.base import MIMEBase
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.application import MIMEApplication
#List of all mimetype per extension: http://help.dottoro.com/lapuadlp.php  or http://mime.ritey.com/

from apiclient import errors, discovery  #needed for gmail service




## About credentials
# There are 2 types of "credentials": 
#     the one created and downloaded from https://console.developers.google.com/apis/ (let's call it the client_id) 
#     the one that will be created from the downloaded client_id (let's call it credentials, it will be store in C:\Users\user\.credentials)


        #Getting the CLIENT_ID 
            # 1) enable the api you need on https://console.developers.google.com/apis/
            # 2) download the .json file (this is the CLIENT_ID)
            # 3) save the CLIENT_ID in same folder as your script.py 
            # 4) update the CLIENT_SECRET_FILE (in the code below) with the CLIENT_ID filename


        #Optional
        # If you don't change the permission ("scope"): 
            #the CLIENT_ID could be deleted after creating the credential (after the first run)

        # If you need to change the scope:
            # you will need the CLIENT_ID each time to create a new credential that contains the new scope.
            # Set a new credentials_path for the new credential (because it's another file)
def get_credentials():
    # If needed create folder for credential
    home_dir = os.path.expanduser('~') #>> C:\Users\Me
    credential_dir = os.path.join(home_dir, '.credentials') # >>C:\Users\Me\.credentials   (it's a folder)
    if not os.path.exists(credential_dir):
        os.makedirs(credential_dir)  #create folder if doesnt exist
    credential_path = os.path.join(credential_dir, 'cred send mail.json')

    #Store the credential
    store = oauth2client.file.Storage(credential_path)
    credentials = store.get()

    if not credentials or credentials.invalid:
        CLIENT_SECRET_FILE = 'client_id to send Gmail.json'
        APPLICATION_NAME = 'Gmail API Python Send Email'
        #The scope URL for read/write access to a user's calendar data  

        SCOPES = 'https://www.googleapis.com/auth/gmail.send'

        # Create a flow object. (it assists with OAuth 2.0 steps to get user authorization + credentials)
        flow = client.flow_from_clientsecrets(CLIENT_SECRET_FILE, SCOPES)
        flow.user_agent = APPLICATION_NAME

        credentials = tools.run_flow(flow, store)

    return credentials




## Get creds, prepare message and send it
def create_message_and_send(sender, to, subject,  message_text_plain, message_text_html, attached_file):
    credentials = get_credentials()

    # Create an httplib2.Http object to handle our HTTP requests, and authorize it using credentials.authorize()
    http = httplib2.Http()

    # http is the authorized httplib2.Http() 
    http = credentials.authorize(http)        #or: http = credentials.authorize(httplib2.Http())

    service = discovery.build('gmail', 'v1', http=http)

    ## without attachment
    message_without_attachment = create_message_without_attachment(sender, to, subject, message_text_html, message_text_plain)
    send_Message_without_attachment(service, "me", message_without_attachment, message_text_plain)


    ## with attachment
    # message_with_attachment = create_Message_with_attachment(sender, to, subject, message_text_plain, message_text_html, attached_file)
    # send_Message_with_attachment(service, "me", message_with_attachment, message_text_plain,attached_file)

def create_message_without_attachment (sender, to, subject, message_text_html, message_text_plain):
    #Create message container
    message = MIMEMultipart('alternative') # needed for both plain & HTML (the MIME type is multipart/alternative)
    message['Subject'] = subject
    message['From'] = sender
    message['To'] = to

    #Create the body of the message (a plain-text and an HTML version)
    message.attach(MIMEText(message_text_plain, 'plain'))
    message.attach(MIMEText(message_text_html, 'html'))

    raw_message_no_attachment = base64.urlsafe_b64encode(message.as_bytes())
    raw_message_no_attachment = raw_message_no_attachment.decode()
    body  = {'raw': raw_message_no_attachment}
    return body



def create_Message_with_attachment(sender, to, subject, message_text_plain, message_text_html, attached_file):
    """Create a message for an email.

    message_text: The text of the email message.
    attached_file: The path to the file to be attached.

    Returns:
    An object containing a base64url encoded email object.
    """

    ##An email is composed of 3 part :
        #part 1: create the message container using a dictionary { to, from, subject }
        #part 2: attach the message_text with .attach() (could be plain and/or html)
        #part 3(optional): an attachment added with .attach() 

    ## Part 1
    message = MIMEMultipart() #when alternative: no attach, but only plain_text
    message['to'] = to
    message['from'] = sender
    message['subject'] = subject

    ## Part 2   (the message_text)
    # The order count: the first (html) will be use for email, the second will be attached (unless you comment it)
    message.attach(MIMEText(message_text_html, 'html'))
    message.attach(MIMEText(message_text_plain, 'plain'))

    ## Part 3 (attachment) 
    # # to attach a text file you containing "test" you would do:
    # # message.attach(MIMEText("test", 'plain'))

    #-----About MimeTypes:
    # It tells gmail which application it should use to read the attachment (it acts like an extension for windows).
    # If you dont provide it, you just wont be able to read the attachment (eg. a text) within gmail. You'll have to download it to read it (windows will know how to read it with it's extension). 

    #-----3.1 get MimeType of attachment
        #option 1: if you want to attach the same file just specify it’s mime types

        #option 2: if you want to attach any file use mimetypes.guess_type(attached_file) 

    my_mimetype, encoding = mimetypes.guess_type(attached_file)

    # If the extension is not recognized it will return: (None, None)
    # If it's an .mp3, it will return: (audio/mp3, None) (None is for the encoding)
    #for unrecognized extension it set my_mimetypes to  'application/octet-stream' (so it won't return None again). 
    if my_mimetype is None or encoding is not None:
        my_mimetype = 'application/octet-stream' 


    main_type, sub_type = my_mimetype.split('/', 1)# split only at the first '/'
    # if my_mimetype is audio/mp3: main_type=audio sub_type=mp3

    #-----3.2  creating the attachment
        #you don't really "attach" the file but you attach a variable that contains the "binary content" of the file you want to attach

        #option 1: use MIMEBase for all my_mimetype (cf below)  - this is the easiest one to understand
        #option 2: use the specific MIME (ex for .mp3 = MIMEAudio)   - it's a shorcut version of MIMEBase

    #this part is used to tell how the file should be read and stored (r, or rb, etc.)
    if main_type == 'text':
        print("text")
        temp = open(attached_file, 'r')  # 'rb' will send this error: 'bytes' object has no attribute 'encode'
        attachment = MIMEText(temp.read(), _subtype=sub_type)
        temp.close()

    elif main_type == 'image':
        print("image")
        temp = open(attached_file, 'rb')
        attachment = MIMEImage(temp.read(), _subtype=sub_type)
        temp.close()

    elif main_type == 'audio':
        print("audio")
        temp = open(attached_file, 'rb')
        attachment = MIMEAudio(temp.read(), _subtype=sub_type)
        temp.close()            

    elif main_type == 'application' and sub_type == 'pdf':   
        temp = open(attached_file, 'rb')
        attachment = MIMEApplication(temp.read(), _subtype=sub_type)
        temp.close()

    else:                              
        attachment = MIMEBase(main_type, sub_type)
        temp = open(attached_file, 'rb')
        attachment.set_payload(temp.read())
        temp.close()

    #-----3.3 encode the attachment, add a header and attach it to the message
    # encoders.encode_base64(attachment)  #not needed (cf. randomfigure comment)
    #https://docs.python.org/3/library/email-examples.html

    filename = os.path.basename(attached_file)
    attachment.add_header('Content-Disposition', 'attachment', filename=filename) # name preview in email
    message.attach(attachment) 


    ## Part 4 encode the message (the message should be in bytes)
    message_as_bytes = message.as_bytes() # the message should converted from string to bytes.
    message_as_base64 = base64.urlsafe_b64encode(message_as_bytes) #encode in base64 (printable letters coding)
    raw = message_as_base64.decode()  # need to JSON serializable (no idea what does it means)
    return {'raw': raw} 



def send_Message_without_attachment(service, user_id, body, message_text_plain):
    try:
        message_sent = (service.users().messages().send(userId=user_id, body=body).execute())
        message_id = message_sent['id']
        # print(attached_file)
        print (f'Message sent (without attachment) \n\n Message Id: {message_id}\n\n Message:\n\n {message_text_plain}')
        # return body
    except errors.HttpError as error:
        print (f'An error occurred: {error}')




def send_Message_with_attachment(service, user_id, message_with_attachment, message_text_plain, attached_file):
    """Send an email message.

    Args:
    service: Authorized Gmail API service instance.
    user_id: User's email address. The special value "me" can be used to indicate the authenticated user.
    message: Message to be sent.

    Returns:
    Sent Message.
    """
    try:
        message_sent = (service.users().messages().send(userId=user_id, body=message_with_attachment).execute())
        message_id = message_sent['id']
        # print(attached_file)

        # return message_sent
    except errors.HttpError as error:
        print (f'An error occurred: {error}')


def main():
    to = "youremail@gmail.com"
    sender = "myemail@gmail.com"
    subject = "subject test1"
    message_text_html  = r'Hi<br/>Html <b>hello</b>'
    message_text_plain = "Hi\nPlain Email"
    attached_file = r'C:\Users\Me\Desktop\audio.m4a'
    create_message_and_send(sender, to, subject, message_text_plain, message_text_html, attached_file)


if __name__ == '__main__':
        main()

Answer 4

对于 jupyter-notebook 用户，在遵循 @apadana 的说明后，如果您收到神秘的错误消息，请确保将代码复制到它自己的 python 文件中并使用

%run [filename].py

（仍然不知道我是怎么想出来的）

当你完成这一步时，你现在几乎是清楚的。

进行最后一次更改： 代码示例中的 Gmail API 错误 - 需要类似字节的对象，而不是“str”

代替

return {'raw': base64.urlsafe_b64encode(message.as_string())}

和：

return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}

现在，它应该™ 工作。

---

最后注意事项：记住有两个 base64 编码的实例......

利用

return {'raw': base64.urlsafe_b64encode(msg.as_string().encode()).decode()}

在方法 CreateMessageHtml

和

return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}

在方法 createMessageWithAttachment

您必须这样做的原因是消息在 CreateMessageHtml 中具有变量名称“msg”，但在 createMessageWithAttachment 中名称为“message”。 因为原因。 这就是为什么。

Answer 5

因此，我发现上述所有内容都非常有用，但是开箱即用对我没有任何帮助。 具体来说，我的问题涉及找到用于发送阅读消息的适当范围（未在 Google 提供的快速入门指南中指定）。 可以在此处找到范围权限列表。

将其与快速入门指南结合使用，我们可以获得腌制凭证文件，如下所示：

import pickle
import os
from google_auth_oauthlib.flow import InstalledAppFlow


# Specify permissions to send and read/write messages
# Find more information at:
# https://developers.google.com/gmail/api/auth/scopes
SCOPES = ['https://www.googleapis.com/auth/gmail.send',
          'https://www.googleapis.com/auth/gmail.modify']


# Get the user's home directory
home_dir = os.path.expanduser('~')

# Recall that the credentials.json data is saved in our "Downloads" folder
json_path = os.path.join(home_dir, 'Downloads', 'credentials.json')

# Next we indicate to the API how we will be generating our credentials
flow = InstalledAppFlow.from_client_secrets_file(json_path, SCOPES)

# This step will generate the pickle file
# The file gmail.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
creds = flow.run_local_server(port=0)

# We are going to store the credentials in the user's home directory
pickle_path = os.path.join(home_dir, 'gmail.pickle')
with open(pickle_path, 'wb') as token:
    pickle.dump(creds, token)

然后，我们可以使用以下内容实际发送电子邮件：

import pickle
import os
import base64
import googleapiclient.discovery
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText


# Get the path to the pickle file
home_dir = os.path.expanduser('~')
pickle_path = os.path.join(home_dir, 'gmail.pickle')

# Load our pickled credentials
creds = pickle.load(open(pickle_path, 'rb'))

# Build the service
service = googleapiclient.discovery.build('gmail', 'v1', credentials=creds)

# Create a message
my_email = '<your_email_here>@gmail.com'
msg = MIMEMultipart('alternative')
msg['Subject'] = 'Hello World'
msg['From'] = f'{my_email}'
msg['To'] = f'{my_email}'
msgPlain = 'This is my first email!'
msgHtml = '<b>This is my first email!</b>'
msg.attach(MIMEText(msgPlain, 'plain'))
msg.attach(MIMEText(msgHtml, 'html'))
raw = base64.urlsafe_b64encode(msg.as_bytes())
raw = raw.decode()
body = {'raw': raw}

message1 = body
message = (
    service.users().messages().send(
        userId="me", body=message1).execute())
print('Message Id: %s' % message['id'])

来源： https ://scriptreference.com/sending-emails-via-gmail-with-python/

Answer 6

如果你想使用一个库，下面的代码就是你所需要的：

from yagmail import SMTP
conn = SMTP("my.email@gmail.com", oauth2_file="./credentials.json")
conn.send(subject="It works!")

第一次运行上面的代码时，如果您还没有，则必须提供通过执行下面的步骤 1-4 获得的客户端 ID 和客户端密码。

注意：第一次运行必须在您可以打开浏览器以完成 OAuth 授权流程的机器上完成（因此很可能不在您的服务器上！）。

代码怎么这么少？

这是一个不需要您将大块代码复制粘贴到项目中的解决方案，而是委托给名为yagmail （ GitHub 上的 2.3K⭐）的第三方库：

1. 实现 API 通信
2. 启动 OAuth 授权流程，如下面的第 5 步所示

据我所知，我在下面描述的所有步骤都是必需的，因此没有更简单的解决方案。 此处描述的过程于 2022 年 5 月进行了测试。

1. 在您的 Google 控制台中创建一个新项目

在您的谷歌云控制台中https://console.cloud.google.com/

2.启用GMail API

3. 配置 OAuth 同意屏幕

• 注意：您可能无法选择内部（我没有）。 据我所知，这意味着您稍后将有一个额外的步骤，您将在其中添加要用于发送到“测试人员”列表的电子邮件

3.b。 启用“发送邮件”OAuth 范围

选择“添加或删除范围”，然后启用 OAuth 范围“发送邮件”。

3.c。 添加您的测试用户

• 这是您要从中发送消息的邮件
• 如果您在步骤 3 中选择“外部”，则需要这样做； 如果您选择内部，则可能不需要

4. 创建一个新的 OAuth 客户端

OAuth 客户端是您的应用程序/脚本，它将代表您使用 GMail API 发送邮件。 选择“桌面应用程序”作为类型。

保存Client ID和Client secret - 它们向 Google 唯一标识您的客户端应用程序。 您将在下一步中需要它们。 您不必这样做，但您也可以下载包含它们的 .json 文件。

5. 授权客户端应用代您发送邮件

以下代码告诉 yagmail，您希望在使用 OAuth 进行身份验证时发送电子邮件：

import yagmail
yag = yagmail.SMTP("my.email@gmail.com", oauth2_file="./credentials.json")
yag.send(subject="It works!")

第一次运行此代码时，它不会找到credentials.json ，因此它将：

1. 从第 4 步询问您的客户端 ID 和客户端密码
2. 为您提供在浏览器中打开的链接以遵循 OAuth 授权流程。 在授权流程结束时，您将获得一个验证码，您将其粘贴回命令行

完成上述操作后，将创建credentials.json文件并将其保存在启动该过程的文件夹中。 该文件包含授权代表您发送电子邮件所需的 OAuth 令牌。

下次您运行代码时，会根据credentials.json中的信息立即发送一封电子邮件。

笔记：

• 这最后一步必须在您可以打开浏览器以完成 OAuth 授权流程的机器上完成（因此很可能不在您的服务器上！）
• 一旦你有了credentials.json ，你就可以将文件复制到你的服务器上

Answer 7

谢谢，@Guillame，@apadana。 @Guillaume 的回答在 Win/Python3.7 中对我很有用，但有一个变化。 对于所有 3 个打印语句，我必须删除“f”，如更改：

print (f'An error occurred: {error}')

至

print ('An error occurred: {error}')

另请查看@apandana 答案的第一部分以获取您的 client_secret.json 文件。 这对我来说更清楚。

Answer 8

前段时间我被同样的问题困住了。

在阅读代码之前 - 请转到 - https://developers.google.com/gmail/api/quickstart/python

此外，访问上述网站时，请启用 Gmail API，以便使用该代码。

我不得不谷歌很多并修改已经存在的谷歌Gmail API代码以找到它： -

from __future__ import print_function
import pickle
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from email.mime.text import MIMEText
import base64

subject = "Subject_Goes_Here"
msg = "Your_Message_Text_Goes_Here"
sender = "senders_email@email.com"
receiver = "recievers_email@email.com"

SCOPES = ['https://www.googleapis.com/auth/gmail.modify']
creds = None
if os.path.exists('token.pickle'):
    with open('token.pickle', 'rb') as token:
        creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
    if creds and creds.expired and creds.refresh_token:
        creds.refresh(Request())
    else:
        flow = InstalledAppFlow.from_client_secrets_file(
            'credentials.json', SCOPES)
        creds = flow.run_local_server(port=0)
    # Save the credentials for the next run
    with open('token.pickle', 'wb') as token:
        pickle.dump(creds, token)
service = build('gmail', 'v1', credentials=creds)
message = MIMEText(msg)
message['to'] = receiver
message['from'] = sender
message['subject'] = subject
raw = base64.urlsafe_b64encode(message.as_bytes())
raw = raw.decode()
body = {'raw' : raw}
message = (service.users().messages().send(userId='me', body=body).execute())

这段代码可能看起来很长，但您只需要更改变量中的值subject 、 message 、 sender和receiver 。

我已经根据我的需要修改了代码，它可能不适合你的。 然而，网上还有很多其他的例子。 例如，要制作带有附件的邮件，您可以去这里 - https://developers.google.com/gmail/api/guides/uploads

对于此示例，您必须通过启用安全性较低的应用程序访问您的 Gmail 帐户来降低安全性。 但由于这是一个 Google API，您不必担心。 此代码还会询问您的 Gmail 密码，但这仅作为一种安全措施，由 Google 服务器在本地控制和存储。

这段代码对我来说就像一个魅力，我希望它也对你有用。

谢谢，

Answer 9

这是您需要的简单明了的东西：

• 在您的 Google 帐户中设置应用程序密码
• 在您的代码中使用此应用程序密码

设置应用程序密码

• 设置两步验证（如果尚未）
• 生成应用密码：
  • 转到您的Google 帐户
  • 转到Security
  • 转到App passwords
  • 单击Select app ，然后单击Other (custom name)
  • 给一个名字，然后点击Generate
  • 复制/记住此应用密码

应用

然后您可以使用 smtplib 和电子邮件库发送电子邮件：

import smtplib
from email.message import EmailMessage

# Create an email
msg = EmailMessage()
msg['Subject'] = 'An Example Subject'
msg['From'] = "example@gmail.com"
msg['To'] = "receiver@example.com"
msg.set_content("Hi, this is an email.")

# Send the message
s = smtplib.SMTP('smtp.gmail.com', 587)
s.starttls()
s.login("example@gmail.com", "<APP PASSWORD>")
s.send_message(msg)
s.quit()

相应地填写<APP PASSWORD>和example@gmail.com 。

替代方案：红色邮件

我还制作了一个库来简化这一点（最大限度地减少样板文件并具有几个高级功能）。 安装它：

pip install redmail

然后简单地说：

from redmail import gmail

gmail.username = "example@gmail.com"
gmail.password = "<APP PASSWORD>"

gmail.send(
    subject='An Example Subject',
    receivers=['receiver@example.com'],
    text='Hi, this is an example email.'
)

Red Mail 支持文本、HTML、内联/嵌入的图像、附件，它集成了 Jinja 和日志处理程序。

• 文档： https ://red-mail.readthedocs.io/en/stable/index.html
• 源代码： https ://github.com/Miksus/red-mail
• 发布： https ://pypi.org/project/redmail/