python--网络编程
在python中,提供了两个级别访问网络,一是低级别的网络服务支持基本的 Socket,提供了标准的Sockets API,可以访问底层操作系统Socket接口;二是高级别的网络服务模块 SocketServer, 它提供了服务器中心类,可以简化网络服务器的开发
套接字socket
套接字socket是源IP地址和目的IP地址以及源端口号和目的端口号的组合,是支持TCP/IP的网络通信的基本操作单元,应用程序既可以通过socket来访问网络中的主机,又可以通过socket进程主机进程间的通讯
套接字socket相关函数函数
- socket.socket([family[, type[, proto]]])
用来创建一个套接字对象
参数:
-
- family:地址簇
- IPv4(socket.AF_INET)
- IPv6(socket.AF_INET6)
- socket.AF_UNIX 只能够用于单一的Unix系统进程间通信
- type:根据传输层的类型分为
SOCK_STREAM(TCP协议)
SOCK_DGRAM(UDP协议)
- proto:一般不填默认为0.
- family:地址簇
- s.bind(address)
绑定地址(host,port)到套接字, 在AF_INET下,以元组(host,port)的形式表示地址。
- s.listen([num])
TCP连接开始监听,监听个数为num
- s.accept()
等待客户端的连接,accept会阻塞
- s.connect(address)
连接TCP服务器,address以元祖(hostname,port)格式,如果连接出错,返回socket.error错误
- s.connect_ex()
connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
- s.recv(buffersize, flags=None)
接收TCP数据,bufsize指定要接收的最大数据量。flag提供有关消息的其他信息,通常可以忽略,该函数阻塞
- s.send()
发送TCP数据,返回值是要发送的字节数量,该数量可能小于string的字节大小。
- s.sendall()
完整发送TCP数据。成功返回None,失败则抛出异常。
- s.recvfrom()
接收UDP数据,与recv()类似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址(hostname,port)
- s.sendto()
发送UDP数据,将数据发送到套接字,address是形式为((hostname,port))的元组,指定远程地址。返回值是发送的字节数。
- s.close()
关闭套接字
- s.getpeername()
返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)
- s.getsockname()
返回套接字自己的地址。通常是一个元组(ipaddr,port)
- s.setsockopt(level,optname,value)
设置给定套接字选项的值。
- s.getsockopt(level,optname[.buflen])
返回套接字选项的值。
- s.settimeout(timeout)
设置套接字操作的超时期,timeout是一个浮点数,单位是秒。值为None表示没有超时期
- s.gettimeout()
返回当前超时期的值,单位是秒,如果没有设置超时期,则返回None。
- s.fileno()
返回套接字的文件描述符
- s.setblocking(flag)
如果flag为0,则将套接字设为非阻塞模式,否则将套接字设为阻塞模式(默认值)
- s.makefile()
创建一个与该套接字相关连的文件
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 3 #创建一个socket对象,协议为IPV4(AF_INET),TCP(SOCK_STREAM) 4 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0) 5 6 #绑定IP地址和端口号 7 addr=("127.0.0.1",9999) 8 sock.bind(addr) 9 10 #监听该socket, 11 sock.listen() 12 13 #等待客户端连接 14 while True: 15 #accept会阻塞 16 connSocket,address=sock.accept() 17 #向客户端发送数据,用于发送和接收用字节,所以需要转换一下 18 connSocket.sendall(bytes("welcome to my service~",encoding="utf-8")) 19 clientData=connSocket.recv(1024) 20 #将接收到的字节转化为字符串输出 21 clientData=str(clientData,encoding="utf-8") 22 print(clientData)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 3 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0) 4 addr=("127.0.0.1",9999) 5 #连接服务器 6 sock.connect(addr) 7 8 rec=sock.recv(1024) 9 10 #将接收到的字节转化为字符串输出 11 rec=str(rec,encoding="utf-8") 12 print(rec) 13 14 sock.sendall(bytes("你好,服务器,我来找你了~",encoding="utf-8")) 15 16 sock.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 3 #创建一个IPv4,UDP的套接字socket 4 sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0) 5 6 #绑定 7 addr=("127.0.0.1",9999) 8 sock.bind(addr) 9 10 while True: 11 #接受一个UDP数据,数据格式为(data,(IP,port)) 12 clientData=sock.recvfrom(1024) 13 #取出客户端反过来的数据 14 print(str(clientData[0],encoding="utf-8"),type(clientData)) 15 #取出客户端的IP和端口号 16 print("clientip[%s],clientPort[%s]" %(clientData[1][0],clientData[1][1])) 17 #根据客户端的IP和端口号向客户端发送数据 18 sock.sendto(bytes("你好,我是服务器~",encoding="utf-8"),clientData[1])
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 3 #创建一个IPv4,UDP的套接字socket 4 sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0) 5 addr=("127.0.0.1",9999) 6 #向UDP服务器为addr的发送数据 7 sock.sendto(bytes("服务器,我来了",encoding="utf-8"),addr) 8 #接受服务器的数据,数据格式为(data,(IP,port)) 9 serviceData=sock.recvfrom(1024) 10 #取出服务器发来的数据 11 print(str(serviceData[0],encoding="utf-8"),type(serviceData)) 12 #取出服务器的IP和端口 13 print("serviceIp[%s],servicePort[%s]"%(serviceData[1][0],serviceData[1][1]))
C++编写的TCP连接:http://www.cnblogs.com/chaguang/p/7115562.html
C++编写的UDP连接:http://www.cnblogs.com/chaguang/p/7118476.html
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 import os 3 #创建一个socket对象,协议为IPV4(AF_INET),TCP(SOCK_STREAM) 4 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0) 5 6 #绑定IP地址和端口号 7 addr=("127.0.0.1",9999) 8 sock.bind(addr) 9 10 #监听该socket, 11 sock.listen() 12 13 #等待客户端连接 14 while True: 15 #accept会阻塞 16 connSocket,address=sock.accept() 17 fileSize=str(connSocket.recv(1024),encoding="utf-8") 18 totalSize=int(fileSize) 19 startSzie=0 20 connSocket.sendall(bytes("已收到",encoding="utf-8")) 21 with open("recv1.jpg","wb") as file: 22 while startSzie<totalSize: 23 #接收文件的数据,并将它写入指定文件中 24 recvDate=connSocket.recv(1024) 25 file.write(recvDate) 26 startSzie+=len(recvDate)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 import os 3 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0) 4 addr=("127.0.0.1",9999) 5 #连接服务器 6 sock.connect(addr) 7 #上传文件 8 #获取文件的大小 9 fileSize=os.stat("windows编程模型.jpg").st_size 10 #先发送文件的大小 11 sock.send(bytes(str(fileSize),encoding="utf-8")) 12 sucess=sock.recv(1024) 13 #打开文件,准备上传 14 with open("windows编程模型.jpg",'rb') as file: 15 for line in file: 16 sock.sendall(line) 17 sock.close()
socketserver模块
socketserver是标准库中一个高级的模块,用来简化网络服务器的开发。内部使用 IO多路复用 以及 “多线程” 和 “多进程” ,从而实现并发处理多个客户端请求的Socket服务端。也就是在服务器中让一个线程作为代表去接受客户端的请求,当有客户端请求来了,就创建一个线程去处理该用户的请求,然后那个负责监听的线程继续回去监听客户的请求。
socketserver模块类
BaseServer | 包含核心服务器功能和mix-in类的钩子,仅用于推导,这样不会创建这个类的实例;可以用TCPServer或者UDPServer创建类的实例 |
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服务器的服务处理器 |
socketserver的实现
想要实现socketserver这个模块,必须定义一个继承基类BaseRequestHandle的一个类,在类中重写handle()方法,当有请求操作的话,就会调用handle方法,类中有几个实例变量包含有用的值:
- h.request:对TCP,h.request属性是套接字对象。对于UDP,它是包含收到数据的字节字符串。
- h.client_address:包含客户端地址
- h.server:包含调用处理程序的实例
常用方法和变量:
- s.socket::用于传入请求的套接字对象
- s.server_address:监听服务器地址
- s.RequestHandleClass:传递给服务器构造函数并由用户提供的请求处理程序类
- s.server_forever():处理请求
- s.shutdown():停止server_forever()循环
- s.fileno():返回服务器套接字的整数文件描述符
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socketserver 2 3 #必须继承socketserver.BaseRequestHandler,而且在类中实现handle方法 4 class MySocket(socketserver.BaseRequestHandler): 5 #用来处理客户端请求 6 def handle(self): 7 #self.request是与客户端连接的套接字对象 8 data=self.request.recv(1024) 9 print(str(data,encoding="utf-8")) 10 self.request.sendall(bytes("这里是socketserver,你好",encoding="utf-8")) 11 12 if __name__=="__main__": 13 #为每个client创建一个 线程,用来和客户端进行交互。 14 service=socketserver.ThreadingTCPServer(("127.0.0.1",6000),MySocket) 15 #开始处理请求 16 service.serve_forever()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import socket 5 6 7 ip_port = ('127.0.0.1',6000) 8 sk = socket.socket() 9 sk.connect(ip_port) 10 sk.sendall(bytes("hello",encoding="utf-8")) 11 data=sk.recv(1024) 12 print(str(data,encoding="utf-8")) 13 sk.close()
I/O多路复用
I/O多路复用是通过select,poll,epoll来监听多个对象,当对象有变化的时候就会去通知用户,然后用户就可以去处理这些变化了的对象。也就是通过一种机制一个进程能同时等待多个文件描述符,而这些文件描述符其中的任意一个进入读就绪状态,函数就可以返回。在windows和Mac中只提供了select,在linux中提供了select,poll,epoll
select函数
def select(rlist, wlist, xlist, timeout=None)
用法:
rList,wList,eList=select.select(句柄序列
, 句柄序列
, 句柄序列
, 超时时间
)
参数: 可接受四个参数(前三个必须)
返回值:三个列表
-
- 有状态变化的socket放到第一个返回值中,
- select的第二个参数放到第二个返回值中
- 当列表中socket出现错误的时候,将会放到第三个返回值中
- 最后一个参数为超时时间
- 当没有设置返回值的时候,select会一直阻塞,直到监听的句柄发生变化
当 超时时间 =n
时,如果监听的句柄均无任何变化,则select会阻塞n
秒,之后返回三个空列表,如果监听的句柄有变化,则直接执行。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import select 2 import socket 3 4 #用来保存监听列表 5 clientList=[] 6 7 #创建监听的socket对象 8 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0) 9 addr=("127.0.0.1",6000) 10 sock.bind(addr) 11 sock.listen() 12 #将负责监听的服务器socket加入到列表中 13 clientList.append(sock) 14 15 while True: 16 #监控clientList中的变量状态 17 #有状态变化的socket放到rList中,select的第二个参数放到wList中,当列表中socket 18 #出现错误的时候,将会放到eList中,最后一个参数为超时时间 19 rList,wList,eList=select.select(clientList,[],clientList,1) 20 for obj in rList: 21 if obj==sock: 22 #接受客户端的请求 23 clientSock,clientInfo=sock.accept() 24 print("accpet,ip[%s],port[%s]"%(clientInfo[0],clientInfo[1])) 25 #将客户端的socket添加到列表中,让select去监控变化 26 clientList.append(clientSock) 27 else: 28 Data=obj.recv(1024) 29 if Data: 30 sendData="%s好" % str(Data,encoding="utf-8") 31 obj.sendall(bytes(sendData,encoding="utf-8")) 32 print(str(Data,encoding="utf-8")) 33 else: 34 #将退出的客户端socket从监听列表中去除 35 print("exit,ip[%s],port[%s]" % (clientInfo[0], clientInfo[1])) 36 clientList.remove(obj)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import socket 2 import os 3 sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM,0) 4 addr=("127.0.0.1",6000) 5 #连接服务器 6 sock.connect(addr) 7 8 sock.sendall(bytes("你",encoding="utf-8")) 9 serviceData=sock.recv(1024) 10 print(str(serviceData,encoding="utf-8"))