16 网络编程 - 《Python 核心编程》

	无论你使用哪一种地址家族。套接字的类型只有两种。一种是面向连接的套接字，即在通讯之
前一定要建立一条连接，就像跟朋友打电话时那样。这种通讯方式也被称为“虚电路”或“流套接
字”。面向连接的通讯方式提供了顺序的，可靠的，不会重复的数据传输，而且也不会被加上数据边
界。这也意味着，每一个要发送的信息，可能会被拆分成多份，每一份都会不多不少地正确到达目
的地。然后被重新按顺序拼装起来，传给正在等待的应用程序。
	实现这种连接的主要协议就是传输控制协议（即TCP）。要创建TCP 套接字就得在创建的时候，
指定套接字类型为SOCK_STREAM。TCP 套接字采用SOCK_STREAM 这个名字，表达了它做为流套接字的
特点。由于这些套接字使用Internet 协议（IP）来查找网络中的主机，这样形成的整个系统，一般
会由这两个协议（TCP 和IP）来提及，即TCP/IP。

	与虚电路完全相反的是数据报型的无连接套接字。这意味着，无需建立连接就可以进行通讯。
但这时，数据到达的顺序，可靠性及数据不重复性就无法保证了。数据报会保留数据边界，这就表
示，数据不会像面向连接的协议那样被拆分成小块。
	使用数据报来传输数据就像邮政服务一样。邮件和包裹不一定会按它们发送的顺序到达。事实
上，它们还有可能根本到不了！而且，由于网络的复杂性，数据还可能被重复传送。
既然数据报有这么多缺点，为什么还要使用它呢？（一定有什么方面能胜过流套接字的！）由于
	面向连接套接字要提供一些保证，以及要维持虚电路连接，这都是很重的额外负担。数据报没有这
些负担，所以它更“便宜”。通常能提供更好的性能，更适合某些应用场合。
	实现这种连接的主要协议就是用户数据报协议（即UDP）。要创建UDP 套接字就得在创建的时候，
指定套接字类型为SOCK_DGRAM。SOCK_DGRAM 这个名字，也许你已经猜到了，来自于单词“datagram”
（“数据报”）。由于这些套接字使用Internet 协议来查找网络中的主机，这样形成的整个系统，一
般会由这两个协议（UDP 和IP）来提及，即UDP/IP。

套接字对象的常用函数
	函数						描述
服务器端套接字函数
s.bind()			绑定地址（主机，端口号对）到套接字
s.listen()			开始 TCP 监听
s.accept()			被动接受 TCP 客户的连接，（阻塞式）等待连接的到来
客户端套接字函数
s.connect()			主动初始化 TCP 服务器连接
s.connect_ex()		　　　　　　 connect() 函数的扩展版本， 出错是返回错误码，而不是抛异常
公共用途的套接字函数
s.recv()			接收 TCP 数据
s.send()			发送 TCP 数据
s.sendall()			完整发送 TCP 数据
s.recvfrom()		　　　　　　 接收 UDP 数据
s.sendto()			发送 UDP 数据
s.getpeername()		连接到当前套接字的远端的地址
s.getsockname()		当前套接字的地址
s.getsockopt()		返回指定套接字的参数
s.setsockopt()		设置指定套接字的参数
s.close()		关闭套接字
面向阻塞的套接字方法 (Blocking-Oriented Scoket Methods)
s.setblocking()		设置套接字的阻塞或非阻塞的模式
s.settimeout()		设置阻塞套接字操作的超时时间
s.gettimeout()		得到阻塞套接字操作的超时时间
面向文件的套接字的函数
s.fileno()		套接字的文件描述符
s.makefile()		创建一个与该套接字关联的文件

核心提示：在运行网络应用程序是，最好在不同的电脑上执行服务器和客户端程序		  

ss = socket()		# 创建服务器套接字
ss.bind()		# 把地址绑定到套接字上
ss.listen()		# 监听连接
inf_loop:		# 服务器无限循环
cs = ss.accept()	# 接受客户连接
comm_loop:		# 通讯循环
cs.recv()/cs.send()	# 对话（接收与发送）
cs.close()		# 关闭客户套接字
ss.close()		# 关闭服务器套接字（可选）	

 1 #!/usr/bin/env python
 2 
 3 from socket import *
 4 from time import ctime
 5 
 6 HOST = ‘‘ # ‘‘ indicate bind() any effient available address
 7 PORT = 21569
 8 BUFSIZ = 1024 # 1K
 9 ADDR = (HOST, PORT)
10 
11 tcpSerSock = socket(AF_INET, SOCK_STREAM)
12 tcpSerSock.bind(ADDR)
13 tcpSerSock.listen(5) # max 5 connection concurrence
14 
15 while True:
16         print ‘waiting for connection...‘
17         tcpCliSock, addr = tcpSerSock.accept() # accept() block and wait
18         print ‘...connected from:‘, addr
19 
20         while True:
21                 data = tcpCliSock.recv(BUFSIZ)
22                 if not data:
23                         break
24                 tcpCliSock.send(‘[%s] %s‘ % (ctime(), data))
25 
26         tcpCliSock.close()
27 tcpSerSock.close() # don‘t forget to close

cc = socket()			# 创建客户套接字
cc.connect()			# 尝试连接服务器
comm_loop:			# 通讯循环
cs.send()/cs.recv()		# 对话（发送/接收）
cs.close()			# 关闭客户套接字

#!/usr/bin/env python

from socket import *

HOST = ‘localhost‘
PORT = 21569 # should correspond to the server socket
BUFSIZ = 1024 # 1K
ADDR = (HOST, PORT)

tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)

while True:
    data = raw_input(‘>‘)
    if not data:
        break
    tcpCliSock.send(data)
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print data

tcpCliSock.close()

ss = socket()		# 创建服务器套接字
ss.bind()			# 把地址绑定到套接字上
ss.listen()			# 监听连接
inf_loop:			# 服务器无限循环
cs.recvfrom()/cs.sendfrom()	# 对话（接收与发送）
ss.close()			# 关闭服务器套接字（可选）	

 1 #!/usr/bin/env python
 2 
 3 from socket import *
 4 from time import ctime
 5 
 6 HOST = ‘‘
 7 PORT = 21567
 8 BUFSIZ = 1024
 9 ADDR = (HOST, PORT)
10 
11 udpSerSock = socket(AF_INET, SOCK_DGRAM)
12 udpSerSock.bind(ADDR)
13 
14 while True:
15     print ‘waiting for message...‘
16     data, addr = udpSerSock.recvfrom(BUFSIZ)
17     udpSerSock.sendto(‘[%s] %s‘ % (18         ctime(), data), addr)
19 
20 udpSerSock.close()

cc = socket()			# 创建客户套接字
comm_loop:				# 通讯循环
cs.sendto()/cs.recvfrom()		# 对话（发送/接收）
cs.close()				# 关闭客户套接字

 1 #!/usr/bin/env python
 2 
 3 from socket import *
 4 
 5 HOST = ‘localhost‘
 6 PORT = 21567
 7 BUFSIZ = 1024
 8 ADDR = (HOST, PORT)
 9 
10 udpCliSock = socket(AF_INET, SOCK_DGRAM)
11 
12 while True:
13     data = raw_input(‘>‘)
14     if not data:
15         break
16     udpCliSock.sendto(data, ADDR)
17     data, ADDR = udpCliSock.recvfrom(BUFSIZ)
18     if not data:
19         break
20     print data, ADDR
21 udpCliSock.close()

	socket 模块属性
	属性名字				描述
数据属性
AF_UNIX, AF_INET, AF_INET6	Python 支持的套接字家族
SO_STREAM, SO_DGRAM		套接字类型（TCP = 流，UDP = 数据报）
has_ipv6			表示是否支持IPv6 的标志变量
异常
error					套接字相关错误
herror					主机和地址相关的错误
gaierror				地址相关的错误
timeout					超时
函数
socket()	用指定的地址家族，套接字类型和协议类型（可选）创建一个套接字对象
socketpair()	用指定的地址家族，套接字类型和协议类型（可选）创建一个套接字对象
fromfd		用一个已经打开的文件描述符创建一个套接字对象
数据属性
ssl()		在套接字初始化一个安全套接字层（SSL）。不做证书验证。
getaddrinfo()	得到地址信息
getfqdn()	返回完整的域的名字
gethostname()	得到当前主机名
gethostbyname()	由主机名得到对应的ip 地址
gethostname_ex()	gethostname()的扩展版本，返回主机名，主机所以的别名和IP 地址列表
gethostbyaddr()		由IP 地址得到DNS 信息，返回一个类型gethostbyname_ex()的3元组
getprotobyname()	由协议名（如‘TCP’）得到对应的号码
getservbyname()/getservbyport()		由服务名得到对应的端口号或相反
ntohl()/ntohs()	　　　　　　　　 把一个整数由网络字节序转为主机字节序
htonl()/htons()	　　　　　　　　 把一个整数由主机字节序转为网络字节序
inet_aton()/inet_ntoa()	　　把IP 地址转为32位整数，以及反向函数。（仅对IPv4地址有效）
inet_pton()/inet_ntop()	　　把IP 地址转为二进制格式以及反向函数。（仅对IPv4地址有效）
getdefaulttimeout()/setdefaulttimeout()	得到/设置默认的套接字超时时间，单位秒（浮点数）

	SocketServer 模块的类
	类						描述
BaseServer			包含服务器的核心功能与混合（mix-in）类的钩子功能。这个类用于
	派生，不要直接生成
TCPServer/UDPServer						基本的网络同步 TCP/UDP 服务器
UnixStreamServer/UnixDatagramServer		基本的基于文件同步的 TCP/UDP 服务器
ForkingMixIn/ThreadingMixIn		实现了核心的进程化或线程化的功能，用于
	与服务器类进行混合（mix-in），已提供一些异步特性。不要直接生成这个类的对象
ForkingTCPServer/ForkingUDPServer	ForkingMixIn 和 TCPServer/UDPServer 的组合
ThreadingTCPServer/ThreadingUDPServer	ThreadingMixIn 和 TCPServer/UDPServer 的组合
BaseRequestHandler		包含处理服务请求的核心功能。只用于派生新的类，不要直接
	生成这个类的对象，可以考虑使用 StreamRequestHandler 或 DatagramRequestHandler
StreamRequestHandler/DatagramRequestHandler	TCP/UDP 	服务器的请求处理类的一个实现

 1 #!/usr/bin/env python
 2 
 3 from SocketServer import (TCPServer as TCP, 4         StreamRequestHandler as SRH)
 5 from time import ctime
 6 
 7 HOST = ‘‘
 8 PORT = 21567
 9 ADDR = (HOST, PORT)
10 
11 class MyRequestHandler(SRH):
12     def handle(self):
13         print ‘...connected from:‘, self.client_address
14         self.wfile.write(‘[%s] %s‘ % (ctime(),15                 self.rfile.readline())
16 
17 tcpServ = TCP(ADDR, MyRequestHandler)
18 print ‘waiting for connection...‘
19 tcpServ.serve_forever()

 1 #!/usr/bin/env python
 2 
 3 from socket import *
 4 
 5 HOST = ‘localhost‘
 6 PORT = 21567
 7 BUFSIZ = 1024
 8 ADDR = (HOST, PORT)
 9 
10 tcpCliSock = socket(AF_INET, SOCK_STREAM)
11 tcpCliSock.connect(ADDR)
12 while True:
13     data = raw_input(‘>‘)
14     if not data:
15         break
16     tcpCliSock.send(‘%s\r\n‘ % data)
17     data = tcpCliSock.recv(BUFSIZ)
18     if not data:
19         break
20     print data.strip()
21 tcpCliSock.close()

网络/套接字编程相关模块
	模块				描述
socket				底层网络接口。
asyncore/asynchat	为能异步处理客户请求的网络应用程序提供底层功能。
select 				在单线程网路服务器中，管理多个套接字连接。
SocketServer		包含了网络应用服务器所需要的高级别模块。提供了完整的进程和线程的版本。