HTTP

HTTP是超文本传输协议（Hyper-Text Transfer Proctol）的简称，维基百科上对HTTP的解释是：超文本传输协议是一种用于分布式、协作式和超媒体信息系统的应用层协议，它是万维网数据通信的基础，设计HTTP最初的目的是为了提供一种发布和接收HTML页面的方法，通过HTTP或者HTTPS（超文本传输安全协议）请求的资源由URI（统一资源标识符）来标识。关于HTTP的更多内容，我们推荐阅读阮一峰老师的《HTTP 协议入门》，简单的说，通过HTTP我们可以获取网络上的（基于字符的）资源，开发中经常会用到的网络API（有的地方也称之为网络数据接口）就是基于HTTP来实现数据传输的

requests库

requests是一个基于HTTP协议来使用网络的第三库，其官方网站有这样的一句介绍它的话：“Requests是唯一的一个非转基因的Python HTTP库，人类可以安全享用。”简单的说，使用requests库可以非常方便的使用HTTP，避免安全缺陷、冗余代码以及“重复发明轮子”（行业黑话，通常用在软件工程领域表示重新创造一个已有的或是早已被优化過的基本方法）。前面的文章中我们已经使用过这个库，下面我们还是通过requests来实现一个访问网络数据接口并从中获取美女图片下载链接然后下载美女图片到本地的例子程序，程序中使用了天行数据提供的网络API

  1. from threading import Thread
  2. import requests
  5. class DownloadHandler(Thread):
  7.     def __init__(self, url):
  8.         super().__init__()
  9.         self.url = url
  11.     def run(self):
  12.         filename = self.url[self.url.rfind('/') + 1:]
  13.         resp = requests.get(self.url)
  14.         with open('D:/pics/' + filename, 'wb') as f:
  15.             f.write(resp.content)
  18. def main():
  19.     # 要使用该数据接口需要在天行数据的网站上注册
  20.     # 然后用自己的Key替换掉下面代码的中APIKey即可
  21.     resp = requests.get('http://api.tianapi.com/meinv/?\
  22.                         key=6490668eb6c54d069b501854c2e598e1& num=10')
  23.     # 将服务器返回的JSON格式的数据解析为字典
  24.     data_model = resp.json()
  25.     for mm_dict in data_model['newslist']:
  26.         url = mm_dict['picUrl']
  27.         # 通过多线程的方式实现图片下载
  28.         DownloadHandler(url).start()
  31. if __name__ == "__main__":
  32.     main()

套接字

TCP套接字

在Python中可以通过创建socket对象并指定type属性为SOCK_STREAM来使用TCP套接字。由于一台主机可能拥有多个IP地址，而且很有可能会配置多个不同的服务，所以作为服务器端的程序，需要在创建套接字对象后将其绑定到指定的IP地址和端口上。这里的端口并不是物理设备而是对IP地址的扩展，用于区分不同的服务，例如我们通常将HTTP服务跟80端口绑定，而MySQL数据库服务默认绑定在3306端口，这样当服务器收到用户请求时就可以根据端口号来确定到底用户请求的是HTTP服务器还是数据库服务器提供的服务。端口的取值范围是0~65535，而1024以下的端口我们通常称之为“著名端口”（留给像FTP、HTTP、SMTP等“著名服务”使用的端口，有的地方也称之为“周知端口”），自定义的服务通常不使用这些端口，除非自定义的是HTTP或FTP这样的著名服务
下面的代码实现了一个提供时间日期的服务器

  1. from socket import socket, SOCK_STREAM, AF_INET
  2. from datetime import datetime
  5. def main():
  6.     # 1.创建套接字对象并指定使用哪种传输服务
  7.     # family=AF_INET - IPv4地址
  8.     # family=AF_INET6 - IPv6地址
  9.     # type=SOCK_STREAM - TCP套接字
  10.     # type=SOCK_DGRAM - UDP套接字
  11.     # type=SOCK_RAW - 原始套接字
  12.     server = socket(family=AF_INET, type=SOCK_STREAM)
  13.     # 2.绑定IP地址和端口(端口用于区分不同的服务)
  14.     # 同一时间在同一个端口上只能绑定一个服务否则报错
  15.     server.bind(('192.168.1.2', 6789))
  16.     # 3.开启监听 - 监听客户端连接到服务器
  17.     # 参数512可以理解为连接队列的大小
  18.     server.listen(512)
  19.     print('服务器启动开始监听...')
  20.     while True:
  21.         # 4.通过循环接收客户端的连接并作出相应的处理(提供服务)
  22.         # accept方法是一个阻塞方法如果没有客户端连接到服务器代码不会向下执行
  23.         # accept方法返回一个元组其中的第一个元素是客户端对象
  24.         # 第二个元素是连接到服务器的客户端的地址(由IP和端口两部分构成)
  25.         client, addr = server.accept()
  26.         print(str(addr) + '连接到了服务器.')
  27.         # 5.发送数据
  28.         client.send(str(datetime.now()).encode('utf-8'))
  29.         # 6.断开连接
  30.         client.close()
  33. if __name__ == '__main__':
  34.     main()

再写一个发送请求的客户端

  1. from socket import socket
  4. def main():
  5.     # 1.创建套接字对象默认使用IPv4和TCP协议
  6.     client = socket()
  7.     # 2.连接到服务器(需要指定IP地址和端口)
  8.     client.connect(('192.168.1.2', 6789))
  9.     # 3.从服务器接收数据
  10.     print(client.recv(1024).decode('utf-8'))
  11.     client.close()
  14. if __name__ == '__main__':
  15.     main()

需要注意的是，上面的服务器并没有使用多线程或者异步I/O的处理方式，这也就意味着当服务器与一个客户端处于通信状态时，其他的客户端只能排队等待。很显然，这样的服务器并不能满足我们的需求，我们需要的服务器是能够同时接纳和处理多个用户请求的。下面我们来设计一个使用多线程技术处理多个用户请求的服务器，该服务器会向连接到服务器的客户端发送一张图片
服务器端代码：

  1. from socket import socket, SOCK_STREAM, AF_INET
  2. from base64 import b64encode
  3. from json import dumps
  4. from threading import Thread
  7. def main():
  9.     # 自定义线程类
  10.     class FileTransferHandler(Thread):
  12.         def __init__(self, cclient):
  13.             super().__init__()
  14.             self.cclient = cclient
  16.         def run(self):
  17.             my_dict = {}
  18.             my_dict['filename'] = 'guido.jpg'
  19.             # JSON是纯文本不能携带二进制数据
  20.             # 所以图片的二进制数据要处理成base64编码
  21.             my_dict['filedata'] = data
  22.             # 通过dumps函数将字典处理成JSON字符串
  23.             json_str = dumps(my_dict)
  24.             # 发送JSON字符串
  25.             self.cclient.send(json_str.encode('utf-8'))
  26.             self.cclient.close()
  28.     # 1.创建套接字对象并指定使用哪种传输服务
  29.     server = socket()
  30.     # 2.绑定IP地址和端口(区分不同的服务)
  31.     server.bind(('192.168.1.2', 5566))
  32.     # 3.开启监听 - 监听客户端连接到服务器
  33.     server.listen(512)
  34.     print('服务器启动开始监听...')
  35.     with open('guido.jpg', 'rb') as f:
  36.         # 将二进制数据处理成base64再解码成字符串
  37.         data = b64encode(f.read()).decode('utf-8')
  38.     while True:
  39.         client, addr = server.accept()
  40.         # 启动一个线程来处理客户端的请求
  41.         FileTransferHandler(client).start()
  44. if __name__ == '__main__':
  45.     main()

客户端代码：

  1. from socket import socket
  2. from json import loads
  3. from base64 import b64decode
  6. def main():
  7.     client = socket()
  8.     client.connect(('192.168.1.2', 5566))
  9.     # 定义一个保存二进制数据的对象
  10.     in_data = bytes()
  11.     # 由于不知道服务器发送的数据有多大每次接收1024字节
  12.     data = client.recv(1024)
  13.     while data:
  14.         # 将收到的数据拼接起来
  15.         in_data += data
  16.         data = client.recv(1024)
  17.     # 将收到的二进制数据解码成JSON字符串并转换成字典
  18.     # loads函数的作用就是将JSON字符串转成字典对象
  19.     my_dict = loads(in_data.decode('utf-8'))
  20.     filename = my_dict['filename']
  21.     filedata = my_dict['filedata'].encode('utf-8')
  22.     with open('/Users/Hao/' + filename, 'wb') as f:
  23.         # 将base64格式的数据解码成二进制数据并写入文件
  24.         f.write(b64decode(filedata))
  25.     print('图片已保存.')
  28. if __name__ == '__main__':
  29.     main()

在这个案例中，我们使用了JSON作为数据传输的格式（通过JSON格式对传输的数据进行了序列化和反序列化的操作），但是JSON并不能携带二进制数据，因此对图片的二进制数据进行了Base64编码的处理。Base64是一种用64个字符表示所有二进制数据的编码方式，通过将二进制数据每6位一组的方式重新组织，刚好可以使用0~9的数字、大小写字母以及“+”和“/”总共64个字符表示从000000到111111的64种状态。维基百科上有关于Base64编码的详细讲解
上面的代码中， encode 是将字符串转换成编码，编码是Python中的 bytes 对象，所以 encode 是字符串的成员函数，返回 bytes 对象； decode 是将字符串转换成编码。另外类比原生字符串是在字符串前面加了一个“r”，而在字符串前面加一个“b”就成了一个bytes对象

UDP套接字

Python也可以通过socket套接字做UDP传输，具体自己研究研究

网络应用开发

发送电子邮件

就像我们可以用HTTP（超文本传输协议）来访问一个网站一样，发送邮件要使用SMTP（简单邮件传输协议），SMTP也是一个建立在TCP（传输控制协议）提供的可靠数据传输服务的基础上的应用级协议，它规定了邮件的发送者如何跟发送邮件的服务器进行通信的细节，而Python中的smtplib模块将这些操作简化成了几个简单的函数
下面的代码演示了如何在Python发送邮件

  1. from smtplib import SMTP
  2. from email.header import Header
  3. from email.mime.text import MIMEText
  6. def main():
  7.     # 请自行修改下面的邮件发送者和接收者
  8.     sender = 'asdffhaha@126.com'
  9.     receiver = 'aasdcx@qq.com'
  10.     message = MIMEText('用Python发送邮件的示例代码', 'plain', 'utf-8')
  11.     # 这里 to 和 from 一定要大概这么写，不然会被认为是垃圾邮件
  12.     message['From'] = 'asdffhaha<lcyxlihaotian@126.com>'
  13.     message['To'] = '' + '<aasdcx@qq.com>'
  14.     message['Subject'] = Header('示例代码邮件', 'utf-8')
  15.     smtper = SMTP('smtp.126.com')
  16.     # 自行修改密码
  17.     smtper.login(sender, 'password')
  18.     smtper.sendmail(sender, receiver, message.as_string())
  19.     print('sent successfully.')
  22. if __name__ == '__main__':
  23.     main()

如果要发送带有附件的邮件，那么可以按照下面的方式进行操作

  1. from smtplib import SMTP
  2. from email.header import Header
  3. from email.mime.text import MIMEText
  4. from email.mime.image import MIMEImage
  5. from email.mime.multipart import MIMEMultipart
  6. import urllib
  9. def main():
  10.     # 创建一个带附件的邮件消息对象
  11.     message = MIMEMultipart()
  13.     # 创建文本内容
  14.     text_content = MIMEText('附件中有本月数据请查收', 'plain', 'utf-8')
  15.     message['From'] = 'lihaotian<lcyxlihaotian@126.com>'
  16.     message['To'] = '' + '<292749786@qq.com>'
  17.     message['Subject'] = Header('本月数据', 'utf-8')
  18.     # 将文本内容添加到邮件消息对象中
  19.     message.attach(text_content)
  20.     # 读取文件并将文件作为附件添加到邮件消息对象中
  21.     with open('D:/word.txt', 'rb') as f:
  22.         txt = MIMEText(f.read(), 'base64', 'utf-8')
  23.         txt['Content-Type'] = 'text/plain'
  24.         txt['Content-Disposition'] = 'attachment; filename=word.txt'
  25.         message.attach(txt)
  26.     # 读取文件并将文件作为附件添加到邮件消息对象中
  27.     with open('d:/a.xlsx', 'rb') as f:
  28.         xls = MIMEText(f.read(), 'base64', 'utf-8')
  29.         xls['Content-Type'] = 'application/vnd.ms-excel'
  30.         xls['Content-Disposition'] = 'attachment; filename=a.xlsx'
  31.         message.attach(xls)
  32.     # 创建SMTP对象
  33.     smtper = SMTP('smtp.126.com')
  34.     # 开启安全连接
  35.     # smtper.starttls()
  36.     sender = 'lcyxlihaotian@126.com'
  37.     receiver = '292749786@qq.com'
  38.     # 登陆SMTP服务器
  39.     smtper = SMTP('smtp.126.com')
  40.     smtper.login(sender, 'lihaotian')
  41.     smtper.sendmail(sender, receiver, message.as_string())
  42.     # 断开连接
  43.     smtper.quit()
  44.     print('sent successfully.')
  47. if __name__ == '__main__':
  48.     main()

发送短信

在下面的代码中我们使用了互亿无线短信平台（该平台为注册用户提供了50条免费短信以及常用开发语言发送短信的demo，可以登录该网站并在用户自服务页面中对短信进行配置）提供的API接口实现了发送短信的服务，当然国内的短信平台很多，读者可以根据自己的需要进行选择（通常会考虑费用预算、短信达到率、使用的难易程度等指标），如果需要在商业项目中使用短信服务建议购买短信平台提供的套餐服务

  1. import urllib.parse
  2. import http.client
  3. import json
  6. def main():
  7.     host  = "106.ihuyi.com"
  8.     sms_send_uri = "/webservice/sms.php?method=Submit"
  9.     # 下面的参数需要填入自己注册的账号和对应的密码
  10.     params = urllib.parse.urlencode({'account': '你自己的账号', 'password' : '你自己的密码', 'content': '您的验证码是：147258。请不要把验证码泄露给其他人。', 'mobile': '接收者的手机号', 'format':'json' })
  11.     print(params)
  12.     headers = {'Content-type': 'application/x-www-form-urlencoded', 'Accept': 'text/plain'}
  13.     conn = http.client.HTTPConnection(host, port=80, timeout=30)
  14.     conn.request('POST', sms_send_uri, params, headers)
  15.     response = conn.getresponse()
  16.     response_str = response.read()
  17.     jsonstr = response_str.decode('utf-8')
  18.     print(json.loads(jsonstr))
  19.     conn.close()
  22. if __name__ == '__main__':
  23.     main()