㈠ python电子邮件系列（三）之POP接收邮件
由上篇文章我们已经得知邮件从发送到接收的过程：
发件人->MUA->MTA->若干MTA->MDA->MUA->收件人
本节接收邮件主要就是编写一个 MUA 客户端，从 MDA 将邮件取回本地。
收取邮件最常用的是 POP协议 ，目前版本是第三版，也称 POP3 。python内置了 poplib 模块，支持POP3协议。
回想上一老烂庆节 SMTP ，我们对要发送的邮件内容进行了各种编码，包括添加MIME header，编码之后再进行发送。
因此，我们通过POP3协议接收的也不是原内容，而是经过一系列编码等处理的文本。
所以，要想把POP3收取的文本变为可阅读的邮件对象，就需要利用 email 模块对原始邮件进行解析。
所以，邮件收取的流程就是：
由上一篇 文章 最后总结部分可知。邮件由字符到发送到网络经历了如下的格式转化：
纯文本：
str->bytes->base64->str->bytes
二进制文件：
binary code->base64->str->bytes
我们解析邮件也是侍握按这个思路，逆序解析出内容。
这里的 decode('utf-8') 先把字节流转化为字符串，再将字符串转化为 message 结构的对象。这步与发送邮件的 as_string 函数相反。
先从上一节结构化的 msg 中取历芦出信件头，打印出来。
如果是 multipart 结构， get_payload 函数会返回一个包含不同part的list，然后对每一part递归调用 print_info ，打印子信件头和子信件内容。
不是 multipart 时，之后再依据 Content-Type 作不同处理:
如果是 text :
利用 get_payload(decode = Ture) 取出子信件的内容， decode 为True，则按照 Content-Transfer-Type 将 base64 或 QP 解码为 bytes 。
再 guess_charset 猜出编码方式，之后将其解码为字符显示。
如果不是 Text 对象，则为附件：
打印出附件的 Content-Type 。
㈡ 如何在python程序中发邮件
python中email模块使得处理邮件变得比较简单，今天着重学习了一下发送邮件的具体做法，这里写写自己的的心得,也请高手给些指点。
一、相关模块介绍
发送邮件主要用到了smtplib和email两个模块，这里首先就两个模块进行一下简单的介绍：
1、smtplib模块
smtplib.SMTP([host[, port[, local_hostname[, timeout]]]])
SMTP类构造函数，表示与SMTP服务器之间的连接，通过这个连接可以向smtp服务器发送指令，执行相关操作（如：登陆、发送邮件）。所有参数都是可选的。
host：smtp服务器主机名
port：smtp服务的端口，默认是25；如果在创建SMTP对象的时候提供了这两个参数，在初始化的时候会自动调用connect方法去连接服务器。
smtplib模块还提供了SMTP_SSL类和LMTP类，对它们的操作与SMTP基本一致。
smtplib.SMTP提供的方法：
SMTP.set_debuglevel(level)：设置是否为调试模式。默认为False，即非调试模式，表示不输出任何调试信息。
SMTP.connect([host[, port]])：连接到指定的smtp服务器。参数分别表示smpt主机和端口。注意: 也可以在host参数中指定端口号（如：smpt.yeah.net:25），这样就没必要给出port参数。
SMTP.docmd(cmd[, argstring])：向smtp服务器发送指令。可选参数argstring表示指令的参数。
SMTP.helo([hostname]) ：使用"helo"指令向服务器确认身份。相当于告诉smtp服务器“我是谁”。
SMTP.has_extn(name)：判断指定名称在服务器邮件列表中是否存在。出于安全考虑，smtp服务器往往屏蔽了该指令。
SMTP.verify(address) ：判断指定邮件地址是否在服务器中存在。出于安全考虑，smtp服务器往往屏蔽了该指令。
SMTP.login(user, password) ：登陆到smtp服务器。现在几乎所有的smtp服务器，都必须在验证用户信息合法之后才允许发送邮件。
SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]) ：发送邮件。这里要注意一下第三个参数，msg是字符串，表示邮件。我们知道邮件一般由标题，发信人，收件人，邮件内容，附件等构成，发送邮件的时候，要注意msg的格式。这个格式就是smtp协议中定义的格式。
SMTP.quit() ：断开与smtp服务器的连接，相当于发送"quit"指令。（很多程序中都用到了smtp.close()，具体与quit的区别google了一下，也没找到答案。）
2、email模块
emial模块用来处理邮件消息，包括MIME和其他基于RFC 2822 的消息文档。使用这些模块来定义邮件的内容，是非常简单的。其包括的类有：
class email.mime.base.MIMEBase(_maintype, _subtype, **_params)：这是MIME的一个基类。一般不需要在使用时创建实例。其中_maintype是内容类型，如text或者image。_subtype是内容的minor type 类型，如plain或者gif。 **_params是一个字典，直接传递给Message.add_header()。
class email.mime.multipart.MIMEMultipart([_subtype[, boundary[, _subparts[, _params]]]]：MIMEBase的一个子类，多个MIME对象的集合，_subtype默认值为mixed。boundary是MIMEMultipart的边界，默认边界是可数的。
class email.mime.application.MIMEApplication(_data[, _subtype[, _encoder[, **_params]]])：MIMEMultipart的一个子类。
class email.mime.audio. MIMEAudio(_audiodata[, _subtype[, _encoder[, **_params]]])： MIME音频对象
class email.mime.image.MIMEImage(_imagedata[, _subtype[, _encoder[, **_params]]])：MIME二进制文件对象。
class email.mime.message.MIMEMessage(_msg[, _subtype])：具体的一个message实例，使用方法如下：
msg=mail.Message.Message() #一个实例
msg['to']='[email protected]' #发送到哪里
msg['from']='[email protected]' #自己的邮件地址
msg['date']='2012-3-16' #时间日期
msg['subject']='hello world' #邮件主题
class email.mime.text.MIMEText(_text[, _subtype[, _charset]])：MIME文本对象，其中_text是邮件内容，_subtype邮件类型，可以是text/plain（普通文本邮件），html/plain(html邮件), _charset编码，可以是gb2312等等。
二、几种邮件的具体实现代码
1、普通文本邮件
普通文本邮件发送的实现，关键是要将MIMEText中_subtype设置为plain。首先导入smtplib和mimetext。创建smtplib.smtp实例，connect邮件smtp服务器，login后发送，具体代码如下：（python2.6下实现）
# -*- coding: UTF-8 -*-
import smtplib
from email.mime.text import MIMEText
mailto_list=[[email protected]]
mail_host="smtp.XXX.com" #设置服务器
mail_user="XXXX" #用户名
mail_pass="XXXXXX" #口令
mail_postfix="XXX.com" #发件箱的后缀
def send_mail(to_list,sub,content):
me="hello"+"<"+mail_user+"@"+mail_postfix+">"
msg = MIMEText(content,_subtype='plain',_charset='gb2312')
msg['Subject'] = sub
msg['From'] = me
msg['To'] = ";".join(to_list)
try:
server = smtplib.SMTP()
server.connect(mail_host)
server.login(mail_user,mail_pass)
server.sendmail(me, to_list, msg.as_string())
server.close()
return True
except Exception, e:
print str(e)
return False
if __name__ == '__main__':
if send_mail(mailto_list,"hello","hello world！"):
print "发送成功"
else:
print "发送失败"
2、html邮件的发送
与text邮件不同之处就是将将MIMEText中_subtype设置为html。具体代码如下：（python2.6下实现）
# -*- coding: utf-8 -*-
import smtplib
from email.mime.text import MIMEText
mailto_list=["[email protected]"]
mail_host="smtp.XXX.com" #设置服务器
mail_user="XXX" #用户名
mail_pass="XXXX" #口令
mail_postfix="XXX.com" #发件箱的后缀
def send_mail(to_list,sub,content): #to_list：收件人；sub：主题；content：邮件内容
me="hello"+"<"+mail_user+"@"+mail_postfix+">" #这里的hello可以任意设置，收到信后，将按照设置显示
msg = MIMEText(content,_subtype='html',_charset='gb2312') #创建一个实例，这里设置为html格式邮件
msg['Subject'] = sub #设置主题
msg['From'] = me
msg['To'] = ";".join(to_list)
try:
s = smtplib.SMTP()
s.connect(mail_host) #连接smtp服务器
s.login(mail_user,mail_pass) #登陆服务器
s.sendmail(me, to_list, msg.as_string()) #发送邮件
s.close()
return True
except Exception, e:
print str(e)
return False
if __name__ == '__main__':
if send_mail(mailto_list,"hello","<a href=''>小五义</a>"):
print "发送成功"
else:
print "发送失败"
3、发送带附件的邮件
发送带附件的邮件，首先要创建MIMEMultipart()实例，然后构造附件，如果有多个附件，可依次构造，最后利用smtplib.smtp发送。
# -*- coding: cp936 -*-
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import smtplib
#创建一个带附件的实例
msg = MIMEMultipart()
#构造附件1
att1 = MIMEText(open('d:\\123.rar', 'rb').read(), 'base64', 'gb2312')
att1["Content-Type"] = 'application/octet-stream'
att1["Content-Disposition"] = 'attachment; filename="123.doc"'#这里的filename可以任意写，写什么名字，邮件中显示什么名字
msg.attach(att1)
#构造附件2
att2 = MIMEText(open('d:\\123.txt', 'rb').read(), 'base64', 'gb2312')
att2["Content-Type"] = 'application/octet-stream'
att2["Content-Disposition"] = 'attachment; filename="123.txt"'
msg.attach(att2)
#加邮件头
msg['to'] = '[email protected]'
msg['from'] = '[email protected]'
msg['subject'] = 'hello world'
#发送邮件
try:
server = smtplib.SMTP()
server.connect('smtp.XXX.com')
server.login('XXX','XXXXX')#XXX为用户名，XXXXX为密码
server.sendmail(msg['from'], msg['to'],msg.as_string())
server.quit()
print '发送成功'
except Exception, e:
print str(e)
4、利用MIMEimage发送图片
# -*- coding: cp936 -*-
import smtplib
import mimetypes
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
def AutoSendMail():
msg = MIMEMultipart()
msg['From'] = "[email protected]"
msg['To'] = "[email protected]"
msg['Subject'] = "hello world"
txt = MIMEText("这是中文的邮件内容哦",'plain','gb2312')
msg.attach(txt)
file1 = "C:\\hello.jpg"
image = MIMEImage(open(file1,'rb').read())
image.add_header('Content-ID','<image1>')
msg.attach(image)
server = smtplib.SMTP()
server.connect('smtp.XXX.com')
server.login('XXX','XXXXXX')
server.sendmail(msg['From'],msg['To'],msg.as_string())
server.quit()
if __name__ == "__main__":
AutoSendMail()
利用MIMEimage发送图片，原本是想图片能够在正文中显示，可是代码运行后发现，依然是以附件形式发送的，希望有高手能够指点一下，如何可以发送在正文中显示的图片的邮件，就是图片是附件中存在，但同时能显示在正文中，具体形式如下图。
㈢ 如何用 python 搭建一个邮件服务器
有人说表示只学Python没有用，必须学会一个框架(比如Django和web.py)才能找到工作。
其实掌握一个类似于框架的高级工具是有用的，但是基础的东西可以让你永远不被淘汰，不要被工具限制了自己的发展。
今天不使用框架，也不使用Python标准库中的高级包，只使用标准库中的socket接口写一个Python服务器。
框架与底层
在当今Python服务器框架 (framework, 比如Django, Twisted, web.py等等) 横行的时代，从底层的socket开始写服务器似乎是一个出力不讨好的笨方法。
框架的意义在于掩盖底层的细节，提供一套对于开发人员更加友好的API，并处理诸如MVC的布局问题。
框架允许我们快速的构建一个成型而且成熟的Python服务器。然而，框架本身也是依赖于底层(比如socket)。对于底层socket的了解，不仅可以帮助我们更好的使用框架，更可以让我们明白框架是如何设计的。
更进一步，如果拥有良好的底层socket编程知识和其他系统编程知识，你完全可以设计并开发一款自己的框架。
如果你可以从底层socket开始，实现一个完整的Python服务器，支持用户层的协议，并处理好诸如MVC(Model-View-Control)、多线程(threading)等问题，并整理出一套清晰的函数或者类，作为接口(API)呈现给用户，你就相当于设计了一个框架。
socket接口是实际上是操作系统提供的系统调用。
socket的使用并不局限于Python语言，你可以用C或者Java来写出同样的socket服务器，而所有语言使用socket的方式都类似(Apache就是使用C实现的服务器)。
但是你不能跨语言的使用框架。
框架的好处在于帮你处理了一些细节，从而实现快速开发，但同时受到Python本身性能的限制。
我们已经看到，许多成功的网站都是利用动态语言(比如Python, Ruby或者PHP，比如twitter和facebook)快速开发，在网站成功之后，将代码转换成诸如C和JAVA这样一些效率比较高的语言，从而让服务器能更有效率的面对每天亿万次的请求。
在这种情况下，底层的重要性，就远远超过了框架。
TCP/IP和socket简介
回到我们的任务。
我们需要对网络传输，特别是TCP/IP协议和socket有一定的了解。
socket是进程间通信的一种方法，它是基于网络传输协议的上层接口。
socket有许多种类型，比如基于TCP协议或者UDP协议(两种网络传输协议)，其中又以TCP socket最为常用。
TCP socket与双向管道(plex PIPE)有些类似，一个进程向socket的一端写入或读取文本流，而另一个进程可以从socket的另一端读取或写入，比较特别是，这两个建立socket通信的进程可以分别属于两台不同的计算机。
TCP协议，就是规定了一些通信的守则，以便在网络环境下能够有效实现上述进程间通信过程。
双向管道(plex PIPE)存活于同一台电脑中，所以不必区分两个进程的所在计算机的地址，而socket必须包含有地址信息，以便实现网络通信。
一个socket包含四个地址信息: 两台计算机的IP地址和两个进程所使用的端口(port)。IP地址用于定位计算机，而port用于定位进程 (一台计算机上可以有多个进程分别使用不同的端口)。
TCP socket
在互联网上，让某台计算机作为服务器。
服务器开放自己的端口，被动等待其他计算机连接。
当其他计算机作为客户，主动使用socket连接到服务器的时候，服务器就开始为客户提供服务。
在Python中，我们使用标准库中的socket包来进行底层的socket编程。
首先是服务器端，我们使用bind()方法来赋予socket以固定的地址和端口，并使用listen()方法来被动的监听该端口。
当有客户尝试用connect()方法连接的时候，服务器使用accept()接受连接，从而建立一个连接的socket：
socket.socket()创建一个socket对象，并说明socket使用的是IPv4(AF_INET，IP version 4)和TCP协议(SOCK_STREAM)。
然后用另一台电脑作为客户，我们主动使用connect()方法来搜索服务器端的IP地址(在Linux中，你可以用$ifconfig来查询自己的IP地址)和端口，以便客户可以找到服务器，并建立连接:
在上面的例子中，我们对socket的两端都可以调用recv()方法来接收信息，调用sendall()方法来发送信息。
这样，我们就可以在分处于两台计算机的两个进程间进行通信了。
当通信结束的时候，我们使用close()方法来关闭socket连接。
(如果没有两台计算机做实验，也可以将客户端IP想要connect的IP改为"127.0.0.1"，这是个特殊的IP地址，用来连接当地主机。)
基于TCP socket的HTTP服务器
上面的例子中，我们已经可以使用TCP socket来为两台远程计算机建立连接。
然而，socket传输自由度太高，从而带来很多安全和兼容的问题。
我们往往利用一些应用层的协议(比如HTTP协议)来规定socket使用规则，以及所传输信息的格式。
HTTP协议利用请求-回应(request-response)的方式来使用TCP socket。
客户端向服务器发一段文本作为request，服务器端在接收到request之后，向客户端发送一段文本作为response。
在完成了这样一次request-response交易之后，TCP socket被废弃。
下次的request将建立新的socket。
request和response本质上说是两个文本，只是HTTP协议对这两个文本都有一定的格式要求。
Request <——> Response
现在，我们写出一个HTTP服务器端：
HTTP服务器程序的解释
如我们上面所看到的，服务器会根据request向客户传输的两条信息text_content和pic_content中的一条，作为response文本。
整个response分为起始行(start line), 头信息(head)和主体(body)三部分。起始行就是第一行:
它实际上又由空格分为三个片段，HTTP/1.x表示所使用的HTTP版本，200表示状态(status code)，200是HTTP协议规定的，表示服务器正常接收并处理请求，OK是供人来阅读的status code。
头信息跟随起始行，它和主体之间有一个空行。
这里的text_content或者pic_content都只有一行的头信息，text_content用来表示主体信息的类型为html文本：
而pic_content的头信息(Content-Type: image/jpg)说明主体的类型为jpg图片(image/jpg)。
主体信息为html或者jpg文件的内容。
(注意，对于jpg文件，我们使用"rb"模式打开，是为了与windows兼容。因为在windows下，jpg被认为是二进制(binary)文件，在UNIX系统下，则不需要区分文本文件和二进制文件。)
我们并没有写客户端程序，后面我们会用浏览器作为客户端。
request由客户端程序发给服务器。
尽管request也可以像response那样分为三部分，request的格式与response的格式并不相同。
request由客户发送给服务器，比如下面是一个request：
起始行可以分为三部分，第一部分为请求方法(request method)，第二部分是URL，第三部分为HTTP版本。
request method可以有GET， PUT， POST， DELETE， HEAD。最常用的为GET和POST。
GET是请求服务器发送资源给客户，POST是请求服务器接收客户送来的数据。
当我们打开一个网页时，我们通常是使用GET方法；当我们填写表格并提交时，我们通常使用POST方法。
第二部分为URL，它通常指向一个资源(服务器上的资源或者其它地方的资源)。像现在这样，就是指向当前服务器的当前目录的test.jpg。
按照HTTP协议的规定，服务器需要根据请求执行一定的操作。
正如我们在服务器程序中看到的，我们的Python程序先检查了request的方法，随后根据URL的不同，来生成不同的response(text_content或者pic_content)。
随后，这个response被发送回给客户端。
使用浏览器实验
为了配合上面的服务器程序，我已经在放置Python程序的文件夹里，保存了一个test.jpg图片文件。
我们在终端运行上面的Python程序，作为服务器端，再打开一个浏览器作为客户端。
(如果有时间，你也完全可以用Python写一个客户端。原理与上面的TCP socket的客户端程序相类似。)
在浏览器的地址栏输入:
(当然，你也可以用令一台电脑，并输入服务器的IP地址)
OK，我已经有了一个用Python实现的，并从socket写起的服务器了。
从终端，我们可以看到，浏览器实际上发出了两个请求。
第一个请求为 (关键信息在起始行，这一个请求的主体为空):
我们的Python程序根据这个请求，发送给服务器text_content的内容。
浏览器接收到text_content之后，发现正文的html文本中有<IMG src="text.jpg" />，知道需要获得text.jpg文件来补充为图片，立即发出了第二个请求:
我们的Python程序分析过起始行之后，发现/test.jpg符合if条件，所以将pic_content发送给客户。
最后，浏览器根据html语言的语法，将html文本和图画以适当的方式显示出来。
探索的方向
1) 在我们上面的服务器程序中，我们用while循环来让服务器一直工作下去。
实际上，我们还可以根据多线程的知识，将while循环中的内容改为多进程或者多线程工作。
2) 我们的服务器程序还不完善，我们还可以让我们的Python程序调用Python的其他功能，以实现更复杂的功能。比如说制作一个时间服务器，让服务器向客户返回日期和时间。你还可以使用Python自带的数据库，来实现一个完整的LAMP服务器。
3) socket包是比较底层的包。Python标准库中还有高层的包，比如SocketServer，SimpleHTTPServer，CGIHTTPServer，cgi。这些都包都是在帮助我们更容易的使用socket。如果你已经了解了socket，那么这些包就很容易明白了。利用这些高层的包，你可以写一个相当成熟的服务器。
4) 在经历了所有的辛苦和麻烦之后，你可能发现，框架是那么的方便，所以决定去使用框架。或者，你已经有了参与到框架开发的热情。
㈣ python 使用zmail收发电子邮件
1、发送邮件：
import zmail
server = zmail.server(' [email protected] ’, 'yourpassword')
server.send_mail(' [email protected] ',{'subject':'Hello!','content_text':'By zmail.'})
server.send_mail([' [email protected] ',' [email protected] '],{'subject':'Hello!','content_text':'By zmail.'})
2、接收最后一封邮件：
import zmail
server = zmail.server(' [email protected] ’, 'yourpassword')
latest_mail = server.get_latest()
zmail.show(latest_mail)
3、发送带附件的邮件：
import zmail
mail = {
'subject': 'Success!', # Anything you want.
'content_text': 'This message from zmail!', # Anything you want.
'attachments': ['/Users/zyh/Documents/example.zip','/root/1.jpg'], # Absolute path will be better.
}
server = zmail.server(' [email protected] ’, 'yourpassword')
server.send_mail(' [email protected] ', mail)
server.send_mail([' [email protected] ',' [email protected] '], mail)
4、发送html格式邮件：
with open('/Users/example.html','r') as f:
content_html = f.read()
mail = {
'subject': 'Success!', # Anything you want.
'content_html': content_html,
'attachments': '/Users/zyh/Documents/example.zip', # Absolute path will be better.
}
server.send_mail(' [email protected] ',mail)
5、使用抄送：
server.send_mail([' [email protected] ',' [email protected] '],mail,cc=[' [email protected] '])
6、自定义server
server = zmail.server('username','password',smtp_host='smtp.163.com',smtp_port=994,smtp_ssl=True,pop_host='pop.163.com',pop_port=995,pop_tls=True)
7、根据ID取回邮件：mail = server.get_mail(2)
根据日期、主题、发送人取回邮件：
mail = server.get_mails(subject='GitHub',after='2018-1-1',sender='github')
mail = server.get_mails(subject='GitHub',start_time='2018-1-1',sender='github',start_index=1,end_index=10)
8、查看邮箱统计
mailbox_info = server.stat() #结果为包含两个整型的元组: (邮件的数量, 邮箱的大小).
9、删除邮件：MailServer.delete(which)
10、保存附件：zmail.save_attachment(mail,target_path=None,overwrite=False)
11、保存邮件：zmail.save(mail,name=None,target_path=None,overwrite=False)
12、读取邮件：zmail.read(file_path,SEP=b'\r\n')
支持的列表：
㈤ 在Python的Flask框架下收发电子邮件
这篇文章主要介绍了在Python的Flask框架下收发电子邮件的教程,主要用到了Flask中的Flask-mail工具,需要的朋友可以参考下
在大多数此类教程中都会不遗余力的介绍如何使用数据库。今天我们对数据库暂且不表，而是来关注另一个在web应用中很重要的特性：如何推送邮件给用户。
在某个轻量级应用中我们可能会添加一个如下的邮件服务功能：当用户有了新的粉丝后，我们发送一封邮件通知用户。有很多方法可以实现这个特性，而我们希望提供出一种可复用的通用框架来处理。
Flask-Mail介绍
对于我们来说是幸运的，现在已经有很多外部插件来处理邮件，虽说不能百分百按照我们的想法去处理，但已经相当接近了。
在虚拟环境中安装 Flask-Mail是相当简单的。Windows以外的用户可以让手利用以下命令来安装：
?
1
flask/bin/pip install flask-mail
Windows用户的安装稍有不同，因为Flask-Mail所使用的一些模块不能再Windows系统上运行，你可以使用以下命令：
?
1
flaskScriptspip install --no-deps lamson chardet flask-mail
配置：
回想汪指一下前文中单元测试部分的案例，我们通过添加配置支持了一个这样的功能：当应用的某个版本测试出错时可以邮件通知我们。从这个例子就可以看出如何配置使用邮件支持。
再次提醒大家，我们需要设置两个方面的内容：
邮件服务器信息
用户邮箱地址
如下正是前文中所用到的配置
# email server
MAIL_SERVER =
MAIL_PORT = 25
MAIL_USE_TLS = False
MAIL_USE_SSL = False
MAIL_USERNAME = you
MAIL_PASSWORD = your-password
# administrator list
ADMINS = [[email protected]]
其中并没有设置切实可用的邮件服务器和邮箱。现在我们通过一个例子来看如何使用gmail邮箱账户来发送邮件：
# email server
MAIL_SERVER =
MAIL_PORT = 465
MAIL_USE_TLS = False
MAIL_USE_SSL = True
MAIL_USERNAME = your-gmail-username
MAIL_PASSWORD = your-gmail-password
# administrator list
ADMINS = [[email protected]]
另外我们也可以初始化一个Mail对象来连接SMTP邮件服务器，发送邮件：
?
1
2
from flask.ext.mail import Mail
mail = Mail(app)
发个邮件试试!
为了了解flask-mail如何工作的，我们可以从命令行发一封邮件看看。进入python shell并执行如下的脚本：
?
7
from flask.ext.mail import Message
from app import mail
from config import ADMINS
msg = Message(test subject, sender = ADMINS[0], recipients = ADMINS)
msg.body = text body
msg.html = bHTML/b body
mail.send(msg)
上面这段代码会根据inconfig.py中配置的邮箱地址列表，以首个邮箱作为发件人给所有邮箱发送一封邮件。邮件内容会以文本和html两种格式呈现，而你能看到哪种格式取决于你的邮件客户端。
多么简单小巧!你完全可以现在就把它集成到你的应用中。
邮件框架
我们现在可以编写一个帮助函数来发送邮件。困滑配这是以上测试中一个通用版的测试。我们把这个函数放进一个新的原文件中用作邮件支持(fileapp/emails.py):
?
7
8
from flask.ext.mail import Message
from app import mail
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender, recipients)
msg.body = text_body
msg.html = html_body
mail.send(msg)
Flask-Mail的邮件支持超出了我们目前的使用范围，像密件抄送和附件的功能并不会在此应用中得以使用。
Follower 提醒
现在，我们已经有了发邮件的基本框架，我们可以写发送follower提醒的函数了 (fileapp/emails.py):
11
from flask import render_template
from config import ADMINS
def follower_notification(followed, follower):
send_email([microblog] %s is now following you! % follower.nickname,
ADMINS[0],
[followed.email],
render_template(follower_email.txt,
user = followed, follower = follower),
render_template(follower_email.html,
user = followed, follower = follower))
你在这里找到任何惊喜了吗?我们的老朋友render_template函数有一次出现了。
如果你还记得,我们使用这个函数在views渲染模版. 就像在views里写html不好一样，使用邮件模版是理想的选择。我们要可能的将逻辑和表现分开，所以email模版也会和其它试图模版一起放到在模版文件夹里.
所以，我们需要为follower提醒邮件写纯文本和网页版的邮件模版，下面这个是纯文本的版本 (fileapp/templates/follower_email.txt):
?
7
8
9
Dear {{user.nickname}},
{{follower.nickname}} is now a follower. Click on the following link to visit {{follower.nickname}}s profile page:
{{url_for(user, nickname = follower.nickname, _external = True)}}
Regards,
The microblog admin
下面这个是网页版的邮件，效果会更好(fileapp/templates/follower_email.html):
11
12
13
pDear {{user.nickname}},/p
pa href={{url_for(user, nickname = follower.nickname, _external = True)}}{{follower.nickname}}/a is now a follower./p
table
tr valign=top
tdimg src={{follower.avatar(50)}}/td
td
a href={{url_for(user, nickname = follower.nickname, _external = True)}}{{follower.nickname}}/abr /
{{follower.about_me}}
/td
/tr
/table
pRegards,/p
pThe codemicroblog/code admin/p
注解：模版中的url_for函数的 _external = True 参数的意义.默认情况下，url_for 函数生成url是相对我们的域名的。例如，url_for(index)函数返回值是/index, 但是，发邮件是我们想要
最后一步是处理“follow”过程，即触发邮件提醒时的视图函数，(fileapp/views.py):
?
7
8
9
from emails import follower_notification
@app.route(/follow/nickname)
@login_required
def follow(nickname):
user = User.query.filter_by(nickname = nickname).first()
# ...
follower_notification(user, g.user)
return redirect(url_for(user, nickname = nickname))
现在你可以创建两个用户(如果还没有用户的话)尝试着用让一个用户follow另一个用户，理解邮件提醒是怎样工作的。
就是这样吗?我们做完了吗?
我们可能心底里很兴奋完成了这项工作并且把邮件提醒功能同未完成列表里删除。
但是，如果你现在测试下应用，你会发现当你单击follow链接的时候，页面会2到3秒才会响应，浏览器才会刷新，这在之前是没有的。
发生了什么?
问题是，Flask-Mail 使用同步模式发送电子邮件。 从电子邮件发送开始，直到电子邮件交付后，给浏览器发回其响应，在整个过程中，Web服务器会一直阻塞。如果我们试图发送电子邮件到一个服务器是缓慢的，甚至更糟糕的，暂时处于脱机状态，你能想象会发生什么吗?很不好。
这是一个可怕的限制，发送电子邮件应该是后台任务且不会干扰Web服务器，让我们看看我们如何能够解决这个问题。
Python中执行异步调用
我们想send_email 函数发完邮件后立即返回，需要让发邮件移动到后台进程来异步执行。
事实上python已经对异步任务提供了支持，但实际上，还可以用其他的方式，比如线程和多进程模块也可以实现异步任务。
每当我们需要发邮件的时候，启动一个线程来处理，比启动一个全新的进程节省资源。所以，让我们将mail.send(msg)调用放到另一个线程中。(fileapp/emails.py):
11
from threading import Thread
def send_async_email(msg):
mail.send(msg)
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender = sender, recipients = recipients)
msg.body = text_body
msg.html = html_body
thr = threading.Thread(target = send_async_email, args = [msg])
thr.start()
如果你测试‘follow‘函数，现在你会发现浏览器在发送邮件之前会刷新。
所以，我们已经实现了异步发送，但是，如果未来在别的需要异步功能的地方难道我们还需要在实现一遍吗?
过程都是一样的，这样就会在每一种情况下都有重复代码，这样非常不好。
我们可以通过 decorator改进代码。使用装饰器的代码是这样的：
11
from decorators import async
@async
def send_async_email(msg):
mail.send(msg)
def send_email(subject, sender, recipients, text_body, html_body):
msg = Message(subject, sender = sender, recipients = recipients)
msg.body = text_body
msg.html = html_body
send_async_email(msg)
更好了，对不对?
实现这种方式的代码实际上很简单，创建一个新源文件(fileapp/decorators.py):
?
7
from threading import Thread
def async(f):
def wrapper(*args, **kwargs):
thr = Thread(target = f, args = args, kwargs = kwargs)
thr.start()
return wrapper
现在我们对异步任务创建了个有用的框架(framework)， 我们可以说已经完成了!
仅仅作为一个练习，让我们思考一下为什么这个方法会看上去使用了进程而不是线程。我们并不想每当我们需要发送一封邮件时就有一个进程被启动，所以我们能够使用thePoolclass而不用themultiprocessingmole。这个类会创建指定数量的进程(这些都是主进程的子进程)，并且这些子进程会通过theapply_asyncmethod送到进程池，等待接受任务去工作。这可能对于一个繁忙的网站会是一个有趣的途径，但是我们目前仍将维持现在线程的方式。