赵工的个人空间

Python是网络编程工具，有针对常见网络协议的库，如TCP、UDP、telnet、FTP、SMTP、SNMP等，还有各种爬虫软件包用于从网络获取数据，如scrapy、urllib。服务器端还有Web框架，如Django、web2py、Flask等。

1. 网络配置信息操作：

1）获取IP地址信息：
如果需要知道某个IP地址的详细信息，如国家、城市、经纬度等，可以使用pygeoip扩展库配合GeoLiteCity.dat来获取：
import pygeoip
gi=pygeoip.GeoIP('GeoLiteCity.dat')
gi.record_by_name('221.0.95.247')
其中使用的GeoLiteCity.dat需要下载。
2）查看本机IP地址与网卡物理地址：
可以使用dos shell命令ipconfig/all查看本机IP地址，也可以使用以下Python代码：
import socket
import uuid
ip=socket.gethostbyname(socket.gethostname())
node=uuid.getnode()
macHex=uuid.UUID(int=node).hex[-12:]
mac=[]
for i in range(len(macHex))[::2]:
    mac.append(macHex[i:i+2])
mac=':'.join(mac)
print('IP: ', ip)
print('MAC: ',mac)
发送数据时，如果目标IP地址中最后一组数字是255，表示是广播地址，局域网内所有主机都会收到信息。

2. Socket模块：

网络编程中，基本组件是套接字Socket，这是应用程序访问下层网络服务的接口，可以实现跨平台的数据传输。使用套接字，使用户在不同的主机之间进行通信，从而在网络中传送和接收数据，实现数据交换。
Socket模块中的socket()方法应用创建套接字：
socket(socket_family, socket_type, protocol=0)
其中，socket_family参数的值可以是AF_UNIX或AF_INET；socket_type的参数值可以为SOCK_ STRRAM或SOCK_DGRAM；protocol一般不赋值，默认为0。
套接字包括服务器套接字和客户端套接字，服务器套接字必须准备随时处理客户端的连接，同时还要处理多个连接；而客户端只是简单地连接、完成事务、断开连接。
一个套接字就是一个Socket模块中的Socket类的实例，实例化需要3个参数：
·地址簇：默认socket.AF_INET
·流或数据报：流默认为socket.SOCK_STREAM，数据报默认为socket.SOCK_DGRAM
·协议：默认0
不同的套接字类型有不同的套接字地址，AF_UNIX地址簇中使用一个简单的字符串；AF_INET地址簇使用host和port地址对，其中host为主机地址名、IP地址或者Internet上的URL，而port则是一个整数；AF_INET6地址簇中用(host,port,flowinfo,scopeid)元组来表示。
客户端应用程序在生成套接字对象后，可以调用bind()方法来绑定自己的请求套接字接口地址，然后调用connect()方法来连接服务器端进程。当连接建立后，可以使用send()和recv()方法来传输数据。最后使用close()方法将端口关闭。
服务器端套接字使用bind()方法绑定一个套接字端口地址，接着使用listen()方法监听客户端请求。当有客户端请求时，将通过accept()方法来生成一个连接对象，然后通过此连接对象发送和接收数据。数据传输完毕，可以调用close()方法将生成的连接关闭。
Python网络编程大部分都隐藏了Socket模块的细节，UDP和TCP是网络体系结构的传输层运行的两大重要协议。
1）UDP编程：
UDP是无连接的协议，不提供应答和重传机制，无法保证数据一定能够到达目的地，但传输效率高，额外开销小。UDP编程经常用到的socket模块方法有：
·socket([family[, proto]]])：创建一个socket对象，其中family为socket.AF_INET表示IPv4，socket.AF_INET6表示IPv6；type为SOCKET_STREAM表示使用TCP，SOCK_DGRAM表示使用UDP。
·sendto(string, address)：把string指定的内容发送给address指定的地址，其中address是一个包含接收方主机IP地址和应用进程端口号的元组，格式为(IP地址, 端口号)
·recvfrom(bufsize[, flags])：接收数据
示例：发送端发送一个字符串，接收端在本机5000端口进行监听，并显示接收的内容
接收端代码：
import socket
s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 使用IPv4，UDP传输
s.bind(('', 5000)) # 绑定端口号，空字符串表示本机任何可用IP地址
while True:
    data, addr=s.recvfrom(1024)
    print('received message:{0} from PORT {1} on {2}'.format(data.decode(), addr[1], addr[0]))
    if data.decode().lower()='bye':
        break
s.close()
发送端代码：
import socket
import sys
s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 使用IPv4，UDP传输
s.sendto(sys.argv[1].encode(), ('102.168.0.103', 5000)) # 设置接收端IP地址
s.close()
将上述代码分别保存为receiver.py和sender.py，然后运行接收端程序，再启动发送端程序。
2）TCP编程：
TCP一般用于要求可靠数据传输的场合，需要用到socket模块的方法有：
·connect(address)：连接远程计算机
·send(bytes[, flags])：发送数据
·recv(bufsize[, flags])：接收数据
·bind(address)：绑定地址
·listen(backlog)：开始监听，等待客户端连接
·accept()：响应客户端请求，接收一个连接
示例：简单的自动应答机
服务器端：
import socket
words={'how are you?':'Fine, thank you.', 'how old are you?':'38', ''what is your name?':'Tom', 'what's your name?':'Tom', 'where do you work?':'SZ', 'bye':'Bye'}
HOST=''
PORT=50007
s=socket.socket(socket.AF_INET, socket.SOCKET_STREAM)
s.bind((HOST, PORT)) # 绑定socket
s.listen(1) # 开始监听一个客户端连接
print('Listening at port: ', PORT)
conn,addr=s.accept()
print('Connected by', addr)
while True:
    data=conn.recv(1024)
    data=data.decode()
    if not data:
        break
    print('Received message: ', data)
    conn.sendall(words.get(data, 'Nothing').encode())
conn.close()
s.close()
客户端代码：
import socket, sys
HOST='127.0.0.1'
PORT=50007
s=socket.socket(socket.AF_INET, socket.SOCKET_STREAM)
try:
    s.connect((HOST, PORT)) # 连接服务器
except Exception as e:
    print('Server not found or not open')
    sys.exit()
while True:
    c=input('Input the content you want to send: ')
    s.sendall(c.encode()) # 发送数据
    data=s.recv(1024) # 从服务器接收数据
    data=data.decode()
    print('Received: ', data)
    if c.lower()=='bye':
        break
s.close()
将上述代码分别保存为server.py和client.py文件，然后启动服务器端程序，服务器开始监听，再启动客户端程序，在服务器端提示连接已建立后，在客户端输入要发送的信息，服务器端会根据提取建立的字典来自动回复。
socket模块还提供了获取本地主机名方法gethostname()、根据主机名获取IP地址的方法gethostbyname()、根据IP地址获取主机名的方法gethostbyaddr()、根据端口号获取对应服务名称的方法getservbyport()、根据服务名称获取对应端口号的方法getservbyname()等。
3）网络嗅探：
网络嗅探程序可以检测本机所在局域网内的网络流量和数据包收发情况。为了实现网络流量嗅探，需要将网卡设置为混杂模式，并且运行嗅探程序的用户需要有系统管理员权限。
import socket
import threading
import time
activeDegree=dict()
flag=1
def main():
    global activeDegree
    global flag
    HOST=socket.gethostbyname(socket.gethostname()) # 获取本机IP地址
    s.socket.socket(socket.AF_INET, socket.SOCK_RAM, socket.IPPROTO_IP)
    s.bind((HOST, 0))
    s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) # 设置数据包中含有IP包头
    s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON) # 启用混杂模式，捕捉数据包
    while flag: # 开始捕捉数据包
        c=s.recvfrom(65565)
        host=c[1][0]
        activeDegree[host]=activeDegree.get(host, 0)+1
        if c[1][0]!='10.2.1.8': # 假设本机IP地址10.2.1.8
            print(c)
    s.ioctl(socket.SIO_RECVALL, socket.RECVALL_OFF) # 关闭混杂模式
    s.close()
t=threading.Thread(target=main)
t.start()
time.sleep(60)
flag=0
t.join()
for item in activeDegree.items():
    print(item)
上述代码运行60s，然后输出本机所在局域网内非本机发出的数据包，并统计不同主机发出的数据包数量。对于Windows平台，使用s.socket.socket(socket.AF_INET, socket.SOCK_RAM, socket.IPPROTO_IP)，而对其他平台，要把socket.IPPROTO_IP替换为socket.IPPROTO_ICMP。
网络嗅探属于系统运维内容，sniffer pro是一款便携式网管和故障分析诊断软件。Python也有scapy程序包用于解码多种网络协议数据包，可以发送和捕获数据包，可以处理扫描、路由跟踪、探测、网络发现及攻击等任务。
4）多进程端口扫描：
xscan是经典的扫描软件，可以扫描远程服务类型、操作系统类型及版本、各种弱口令漏洞、后门、应用服务漏洞、网络设备漏洞、拒绝服务漏洞等。使用端口扫描可以探测指定主机是否开放了特定端口，判断是否运行某些网络服务，查找是否存在潜在安全漏洞。
import socket, sys
import multiprocessing
def ports(ports_service):
    for port in list(range(1,100))+[143,145,113,443,445,3389,8080]:
        try:
            ports_service[port]=socket.getservbyport(port)
        except socket.error:
            pass
def ports_scan(host, ports_service):
    ports_open=[]
    try:
        sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(0.01) # 超时时间的不同会影响扫描结果精确度
    except socker.error:
        print('socket creation error')
        sys.exit()
    for port in ports_service:
        try:
            sock.connect((host, port)) # 尝试连接指定端口
            ports_open.append(port) # 记录打开的端口
            sock.close()
        except socket.error:
            psss
    return ports_open
if __name__=='__main__':
    m=nultiprocessing.Manager()
    ports_service=dict()
    results=dict()
    ports(ports_service)
    pool=multiprocessing.Pool(processes=8) # 创建进程池，允许最多8进程
    net='10.2.1.'
    for host_number in map(str, range(8,10)):
        host=net+host_number
        results[host]=pool.apply_async(ports_scan, (host, ports_service)) # 同时记录
        print('starting '+host+'...')
pool.close() # 关闭进程池，close()必须在join()之前调用
pool.join() # 等待进程池中的进程全部执行结束
for host in results:
    print('='*30)
    print(host, '.'*10)
    for port in results[host].get():
        print(port, ':', ports_service[port])
代码使用TCP进行探测，速度很慢，如果改用UDP速度会提高很多。
netaddr库提供了大量可以处理网络地址的类和对象，如valid_ipv4(addr)用于判断addr是否合法的IPv4地址，IPNetwork('10.2.1.0/24')和IPRange('10.2.1.0','10.2.1.255')都可以用来生成包含介于10.2.1.0到10.2.1.255之间的IP地址的迭代对象。还有Nmap工具包，用于网络扫描。示例：
import socket
import nmap
nmScan=nmap.PortScanner() # 创建端口扫描对象
ip=socket.gethostbyname('www.microsirt.com') # 获取目标主机的IP地址
nmScan.scan(ip, '80') # 扫描指定端口
print(nmScan[ip]['tcp'][80]['state']) # 查看端口状态
5）代理服务器端口映射功能：
端口映射是网络地址转换技术的实现方法之一，也是代理服务器的必备功能之一，原理是在两个端口之间进行消息转发，用来实现内网和外网之间的通信，有效利用有限的IP地址，并且可以进行必要的过滤来保护内网安全。
代理服务器能够对客户端和服务器之间的通信内容进行记录，也能修改双方通信的内容。
6）FTP实现：
使用Python可以实现ftp功能，客户端代码为：
import socket
import sys
import re
import struct
import getpass
def main(sercerIP):
    sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((serverIP, 10600))
    userId=input('Please input username: ')
    userPwd=getpass.getpass('please input password: ')
    message=userId+','+userPwd
    sock.send(message.encode())
    login=sock.recv(100)
    if login==b'error': # 验证登录是否成功
        print('wrong userId or password')
        return
intSize=struct.calcsize('I') # 整数编码大小
while True:
    command=input('##>').lower().strip() # 接收客户端命令，'##>是提示符
    if not command: # 没有输入任何字符，提前进入下一循环，继续等待
        continue
    command=' '.join(command.split())
    sock.send(command.encode()) # 向服务器发送命令
    if command in ('quit', 'q'): # 退出
        break
    elif command in ('list', 'ls', 'dir'): # 查看文件列表
        loc_size=struct.unpack('I', sock.recv(intSize))[0] # 先接收字符串大小
        files=eval(sock.recv(loc_size).decode())
        for item in files:
            print(item)
    elif ' '.join(command.split())=='cd..': # 切换到上一级目录
        print(sock.recv(100).decode())
    elif command in ('cwd', 'cd'): # 查看当前工作目录
        print(sock.recv(1024).decode())
    elif command.startswith('cd'): # 切换至子文件夹
        print(sock.recv(100).decode())
    elif command.startswith('get'): # 从服务器下载文件
        ifFileExist=sock.recv(20)
        if isFileExist!=b'ok': # 如果文件不存在
            print('error')
        else: # 如果文件存在，开始下载
            print('downloading.', end='')
            fp=open(command.split()[1], 'wb')
            while True:
                print('.', end='') # 显示进度
                data=sock.recv(4096)
                if data==b'overxxxx':
                    break
                fp.write(data)
                sock.send(b'ok')
            fp.close()
            print('ok')
        else: # 无效内容
            print('无效命令')
    sock.close()
if __name__=='__main__':
    if len(sys.argv)!=2:
        print('Usage:{0} serverOPAddress'.format(sys.argv[0]))
        exit()
    serverIP=sys.argv[1]
    if re.match(r'^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}$', serverIP):
        main(serverIP)
    else:
        print('服务器地址不合法')
        exit()
ftplib模块提供了FTP客户端的主要功能，可用来实现ftp功能。

3. 网页内容读取与域名解析：

Python标准库urllib提供了request、response、parse和error四个模块，支持网页内容读取功能，如同这些文件存在于本地，但只能以只读方式访问。
1）读取并显示指定网页的内容：
urlopen(url, data=None, proxies=None)
示例：
import urllib.request
fp=urllib.request.urlopen(r'http://www.python.org')
print(fp.read(100))
print(fp.read(100).decode())
fp.close()
2）使用GET方法读取并显示指定url的内容：
import urllib.request
import urllib.parse
params=urllib.parse.urlencode({'spam':1, 'eggs':2, 'bacon':0})
url="http://www.musi-cal.com/cgi-bin/query?%s"%params
with urllib.request.urlopen(url) as f:
    print(f.read().decode('utf-8'))
3）使用POST方法提交参数读取指定页面：
import urllib.request
import urllib.parse
data=urllib.parse.urlencode({'spam':1, 'eggs':2, 'bacon':0})
data=data.encode('ascii')
with urllib.request.urlopen("http://requestb.in/xrbl82xr", data) as f:
    print(f.read().decode('utf-8'))
4）使用HTTP代理访问指定页面：
inport urllib.request
proxies={'http':'http://proxy.example.com:8080/'}
opener=urllib.request.FancyURLopener(proxies)
with opener.open("http://www.python.org") as f:
    f.read().decode('utf-8')
5）webbrowser库：
Python的webbrowser库支持使用已安装的浏览器直接打开网页，在命令提示符下执行命令：
python -m webbrowser -t "http://www.python.org"
也可以在IDEL或Python程序中使用下面的代码调用浏览器打开指定网页：
import webbrowser
webbrowser.open('http://www.python.org')
6）域名解析：支持url的拆分与合并，以及相对地址到绝对地址的转换
from urllib.parse import urlparse
o=urlparse('http://www.cwi.nl:80/%7Eguido/Python.html')
print(o.port)
print(o.hostname)
print(urlparse('www.cwi.nl:80/%Eguido/Python.html')
from urllib.parse import urljoin
url1=urljoin('http://www.cwi.nl/%7Eguido/Python.html', 'FAQ.html')
url2=urljoin('http://www.cwi.nl/%7Eguido/Python.html', '//www.python.org/%7Eguido')
from urllib.parse import urlsplit
url=r'https://docs.python.org/3/library/urllib.parse.html'
r1=urlsplit(url)
print(r1.hostname)
print(r1.geturl())
print(r1.netloc)
print(r1.scheme)

4. 网页爬虫：

网页爬虫常用来在互联网上爬取感兴趣的页面或文件，结合数据处理与分析，可以得到更深层次的信息。示例：
import sys
import multiprocessing
import re
import os
import urllib.request as lib
def craw_links(url, depth, keywords, processed):
    '''url: the url to craw
    depth: the current depth to craw
    keywords: the tuple of keywords to focus
    pool: process pool'''
    contents=[]
    if url.startswith(('http://', 'https://')):
        if url not in processed
            processed.append(url)
        else:
            return
        print('Crawing '+url+'...')
        fp=lib.urlopen(url)
        contents=fp.read()
        contents_decoded=contents.decode('UTF-8')
        fp.close()
        pattern='|'.join(keywords)
        flag=False
        if pattern:
            searched=re.search(pattern, contents_decoded)
        else:
            flag=True
        if flag or searched:
            with open('craw\\'+url.raplace(':','_').replace('/','_'), 'wb') as fp:
                fp.write(contents)
        links=re.findall('href="(.*?)"', contents_decoded)
        for link in links:
            if not link.startswith(('http://','https://')):
                try:
                    index=url.rindex('/')
                    link=url[0:index+1]+link
                except:
                    pass
            if depth>0 and link.endswith(('.htm','.html')):
                craw_links(link, depth-1, keywords, processed)
if __name__=='__main__':
    processed=[]
    keywords=('datetime', 'KeyWord2')
    if not os.path.exists('craw') or not os.path.isdir('craw'):
        os.mkdir('craw')
    craw_links(r'https://docs.python.org/3/library/index.html', 1, keywords, processed)

5. scrapy框架：

scrapy是网络爬虫框架，非常适合抓取Web站点的网页中提取结构化数据，并且支持自定义需求。使用pip3安装好scrapy后，在命令提示符下执行命令创建一个项目MyCraw：
scrapy startproject MyCraw
然后编写Python程序MyCraw\MyCraw\spiders\MySpider.py用于爬取指定页面内容：
import os
import urllib.request
import scrapy
class MySpider(scrapy.spiders.Spider):
    name='mySpider'
    allowed_domains=['www.sdibt.edu.cn']
    start_urls['http://www.sdibt.edu.cn/info/1026/11238.htm']
    def parse(self, response):
        self.downloadWebpage(response)
        self.downloadImages(response)
        hxs=scrapy.Selector(response)
        sites=hxs.xpath('//ul/li')
        for site in sites:
            link=site.xpath('a/@href').extract()[0]
            if link=='#':
                continue
            elif link.startswith('...'):
                next_url=os.path.dirname(response.url)
                next_url+='/'+link
            else:
                next_url=link
            yield scrapy.Request(url=next_url, callback=self.parse_item)
    def parse_item(self, response):
        self.downloadWebpage(response)
        self.downloadImage(response)
    def downloadImages(self, response):
        hxs=scrapy.Selector(response)
        images=hxs.xpath('//img/@src').extract()
        for image_url in images:
            imageFilename=image_url.split('/')[-1]
            if os.path.exists(iamgeFilename):
                continue
            if image_url.startswith('...'):
                image_url=os.path.dirname(response.url)+'/'+image_url
            fp=urllib.request.urlopen(image_url)
            with open(imageFilename,'wb') as f:
                f.write(fp.read())
            fp.close()
    def downloadWebpage(self, response):
        filename=response.url.split('/')[-1]
        with open(filename,'wb') as f:
            f.write(response.body)
最后，在命令提示符下执行命令启动爬虫程序开始爬取数据：
scrapy crawl mySpider

6. BeautifulSoup4：

BeautifulSoup是一个Python扩展库，可以用来从HTML或XML文件中提取数据，并且允许指定使用不同的解析器。使用pip3安装beautifulsoup4，然后导入，使用from bs4 import BeautifulSoup。详细资料见www.crummy.com/software/BeautifulSoup/bs4/doc/。示例：
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc, 'html.parse')
print(soup.prettify())
print(soup.title)
print(soup.title.name)
print(soup.title.text)
print(soup.title.string)
print(soup.title.parent)
print(soup.head)
print(soup.body)
print(soup.p)
print(soup.p['class'])
print(soup.p.get('class'))
print(soup.p.text)
print(soup.p.contents)
print(soup.a)
print(soup.a.attrs)
print(soup.a.string)
print(soup.find_all('a'))
print(soup.get_text())
print(soup.prettify())
for child in soup.body.children:
    print(child)
for string in soup.strings:
    print(string)

7. 在IIS运行Python CGI程序：

在Windows平台，为了使IIS能够运行Python程序，需要进行一些设置。
1）在控制面板--管理工具--Internet信息服务管理器图标。
如果没有这个图标，是还没有打开此项功能，需要在“程序和功能”下选择“打开或关闭Windows功能”，在打开的窗口中勾选Internet信息服务，并设置相关功能选项，注意要选择“万维网服务”项下的“应用程序开发功能”，至少选择CGI项。确认后系统会进行配置，然后就会出现Internet信息服务管理器图标了。
然后使用“新建网站”，在出现的窗口中填写网站基本信息，其中网站名称可以填写为Python，应用程序池也就自动设置为Python，物理路径选择一个路径，比如WebSite。完成网站配置后点击确认，在“网站”界面中会出现一个Python项。
点击左侧窗口的“网站”项下的Python图标，中间窗口会出现多个功能图标，双击“处理程序映射”，点击右侧的“添加脚本映射...”。在出现的窗口中，请求路径中填入“*.py”，可执行文件中填入Python安装路径并运行程序，如C:\Python36\python.exe %s %s，名称栏填入Python。
2）编写网站index.py：
网站启动时会自动运行一个默认脚本文件，这里设置为index.py，放入设置的网站路径的根目录下，如WebSite中。示例代码：
print('Status: 200 OK')
print('Content-type: text/html')
print(' ')
header='''<head runat='server'>
    <title></title>
    <script language='javascript' type='text/javascript'>
    //<![DATA[function Button2_onclick(){alert(Text1.value);}
    //]]>
    </scropt>
    </head>'''
print(header)
print('<h1>This is a header</h1>')
print('<input id="Text1" type="text"/>')
button='''<input id="Button2" type="button" value="button"
        onclick="return Button2_onclick()"/>'''
print(button)
print('<p>note: this is only a test.</p>')
3）点击设置的Python网站，在右侧窗口中点击“默认文档”，在其中添加index.py。
4）打开浏览器，在地址栏输入localhost。如果本机上有多个网站，会出现端口冲突问题，所以在设置网站时往往要设置使用另一个端口，如8080、8088等，这时也要加上此端口号。
如果以上设置正确，这时浏览器中就会显示出index.py中设置的网页。

8. Flask框架的使用：

Flask是比较流行的Python的Web框架之一，可以使用pip3安装。
1）使用Flask编写网站程序：
from flask import Flask
app=Flask(__name__)
@app.route("/")
def hello():
    return "Hello World!"
if __name__=='__main__':
    app.run()
将代码保存并运行。使用浏览器打开网址127.0.0.1:5000，会显示文本"Hello World!"。
2）发送带附件的电子邮件：
需要使用pip3安装flask-mail电子邮件扩展包。
import os.path
from flask import Flask
from flask.ext.mail import Mail,Message
app=Flask(__name__)
app.config['MAIL_SERVER']='smtp.126.com' # 以126免费邮箱为例
app.config['MAIL_PORT']=25
app.config['MAIL_USE_TLS']=True
app.config['MAIL_USERNAME']='abcd' # abcd@126.com
app.config['MAIL_PASSWORD']='XXXXXX'
def sendEmain(From, To, Subject, Body, Html, Attachments):
    '''To: must be a list'''
    msg=Message(Subject, sender=From, recipients=To)
    msg.body=Body
    msg.html=Html
    for f in Attachments:
        with app.open_response(f) as fp:
            msg.attach(filename=os.path.basename(f), data=fp.read(),
content_type='application/octet-stream')
    mail=Mail(app)
    with app.app_context():
        mail.send(msg)
if __name__=='__main__':
    From='<xxxx@123.com>'
    To=['<12345678@qq.com>']
    Subject='hello world'
    Body='Only a test.'
    Html='<h1>test a email program.</h1>'
    Attachments=['c:\\python36\\python.exe']
    sendMail(From, To, Subject, Body, Html, Attachments)

9. django框架应用：

django是成熟的Web框架，采用MVC模式，支持pip3安装。安装成功后，Python安装目录中的scripts文件夹中有个文件django-admin.py，这是用来创建和管理Web应用的重要程序。
1）创建django的Web应用：
在命令提示符下使用命令创建一个Web应用first_django：
python django-admin.py startproject first_django
如果执行成功，会在当前文件夹中创建子文件夹first_django。在first_django\first_django文件夹中创建一个Python程序view.py：
from django.http import HttpResponse
def hello(request):
    return HttpResponse('This is my first django application!')
def greeting(request):
    return HttpResponse('Hello everyone!')
然后打开文件first_django\first_django\urls.py，修改其中的代码：
from django.conf.urls import url
from first_django.view import hello, greeting # 其中view对应前面创建的view.py
urlpatterns=[ # 建立url和函数的对应关系
    url(r'^hello/', hello), # 第一个参数的正则表达式
    url(r'^greeting/', greeting), # 第二个参数是view.py中的函数
]
在命令提示符输入命令就可以启动这个网站：
python manage.py runserver 127.0.0.1:8000
命令中，127.0.0.1为本机IP地址，也可以改为用户计算机上配置的IP地址；8000表示这个网站使用的端口。启动成功，使用浏览器打开网址http://127.0.0.1:8000/greeting/和http://127.0.0.1:8000/hello/就能看到对应的页面。
2）使用网页模板：
使用网页模板可以避免重复设计网页布局带来的工作量，有效利用已有代码。首先创建网站django_template，然后创建文件夹django_template\templates，并创建网页模板文件django_template\templates\greeting.html，其中内容为：
<html>
    <body>
        <h1>Good{{morning_afternoon_evening}}, I am {{name}}.</h1>
    </body>
</html>
其中，两对大括号{{}}中的内容为变量，也就是运行时需要替换的内容。接下来创建Python程序django_template\templates\view.py。代码为：
from django.http import HttpResponse, Http404
import datetime
from django import template
from django.conf import settings
import os
import os.path
from random import choice
#settings.configure()
names=('Zhang san', 'Li si', 'Wang wu', 'Ma liu')
def greeting(request):
templateFile=os.path.join(os.path.split(os.path.dirname(__file__))[0],
             'templates')+'\\greeting.html'
    with open(templateFile) as fp: # 打开网页模板文件，创建模板
        t=template.Template(fp.read())
    current_name=choice(names) # 随机选择一个问候人
    h=datetime.datetime.now().hour # 当前时间
    if 0<=h<12: # 上午
        mae='Morning'
    elif 12<=h<18: # 下午
        mae='Afternoon'
    else:
        mae='Evening'
    con=template.Context({'name':current_name, 'morning_afternoon_evening':mae})
    html=t.render(con) # 渲染模板
    return HttpResponse(html)
最后，修改django_template\django_template\urls.py文件：
from django.conf.urls import include,url
from django.contrib import admin
from first_django.view import greeting # 其中view对应前面创建的view.py
urlpatterns=[ # 建立url和函数的对应关系
    url(r'^admin/', include(admin.site.urls)),
    url(r'^greeting/$', greeting), # 此参数是view.py中的函数
]
设计完成，启动网站，浏览器中使用地址http://127.0.0.1:8000/greeting/访问，会看到设置的网页，每次刷新都有不同的问候人变化。

10. 公共网关接口CGI：

CGI主要运行在服务器上，提供客户端HTML页面的接口，用于Web服务器处理来自浏览器的请求。常用的HTTP服务器为Apache、nginx等，而Python提供了CGI模块CGIHTTPServer，可用于学习和代码测试。使用方法：
python -m CGLHTTPServer 8888
在浏览器地址栏输入：http://localhost:8888/cgi-bin/cgitest.py可以显示一个界面。其中/cgi-bin/cgitest.py是用python设计的一个登录界面。
CGLHTTPServer默认的端口号是8000，但该端口会被占用，所以选用了8888。

11. WSGI：

Python定义了一个WSGI，提供了Web服务器和Web应用程序之间的简单通用接口，使Web开发框架都与Web服务器无关。WSGI比CGI简单，并具有扩展性。
WSGI服务器端提供了一个environ字典和一个start_response函数，environ字典需要提供一些WSGI定义。

12. 其他模块：

Python库还有其他一些与网络有关的模块：

服务器端和客户端的通信是构建网络通信的基础。