大致上一切网络皆socket(套接字)
socket是应用层与TCP/IP协议的封装，留给使用者一个编程接口(API借口)，用来实现网络上两个进程之间的数据交互,连接的一端称为一个socket。
服务端套接字函数：
s.bind（）绑定（主机，端口号）到套接字
s.listen（）开始TCP监听
s.accept（）被动接受TCP客户的连接（阻塞式）等待连接的到来
客户端套接字函数：
s.connect（）主动初始化TCP服务器连接
s.connect_ex（）connect（）函数的扩展版本，出错时返回出错码，而不是抛出异常
公共用途的套接字函数
s.recv( )接受TCP数据
s.send（）发送TCP数据（send在待发送数据量大于已端缓存区剩余空间是，数据丢失，不会发完）
s.sendall( ) 发送完整的TCP数据（本质就是循环调用send，sendall在待发送数据量大于已端缓存区剩余空间时，数据不丢失，循环调用send直到发完）
s.close（） 关闭套接字
其它功能:
参数一：地址簇 socket.AF_INET IPv4（默认） socket.AF_INET6 IPv6 socket.AF_UNIX 只能够用于单一的Unix系统进程间通信 参数二：类型 socket.SOCK_STREAM 流式socket , for TCP （默认） socket.SOCK_DGRAM 数据报式socket , for UDP socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。 socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。 socket.SOCK_SEQPACKET 可靠的连续数据包服务 参数三：协议 0 （默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议
service端: import socket sk = socket.socket()#创建对象 sk.bind(('127.0.0.1',9999,))#绑定地址,内部IP是元祖所以加括号,最好在后面加逗号(表示是元祖) sk.listen(5)#监听传入连接数最大为5,第6个直接断开 #接收客户端请求 while True: conn, address = sk.accept()#接收客户端请求(阻塞),等待连接. conn新的套接字对象接收发送数据,address连接客户端地址 conn.sendall(bytes("欢迎光临",encoding="utf-8"))#py3需要已字节的形式发送内容,用户连接过来时给他发一条信息 while True: print("正在等待Client输入内容......") ret_bytes = conn.recv(1024)#接收客户端发送过来的内容 ret_str = str(ret_bytes,encoding="utf-8")#转为字符串类型 print(ret_str)## 输出用户发送过来的内容 if ret_str == "q":#如果输入q退出 break inp = input("Service请输入要发送的内容>>>") conn.sendall(bytes(inp,encoding="utf-8"))#给客户端发送内容 print(address,conn)
client端: import socket obj = socket.socket() obj.connect(('127.0.0.1',9999,))#连接到address处的套接字 #recv阻塞等待用户发出去 ret_bytes = obj.recv(1024)#接收数据,因为服务端发送过来的是字节,所以需要把字节转换为字符串进行输出,最大接收1024字节(最大接收1024*8,就是8K),超过下次连接 ret_str = str(ret_bytes,encoding="utf-8") print(ret_str)# 输出内容 while True: inp = input("Client请输入要发送的内容>>> ")#当进入连接的时候,提示让用户输入内容 if inp == "q":#如果输入q则退出 obj.sendall(bytes(inp,encoding="utf-8"))# 把q发送给服务端 break#退出当前while else: obj.sendall(bytes(inp,encoding="utf-8"))#否则就把用户输入的内容发送给用户 print("正在等待Server输入内容......")#等待服务端回答 ret = str(obj.recv(1024),encoding="utf-8")#获取服务端发送过来的结果 print(ret) obj.close()#连接完成之后关闭链接
socket上传文件
server: import socket sk = socket.socket() sk.bind(("127.0.0.1",9999,)) sk.listen(5) while True: conn, address = sk.accept() conn.sendall(bytes("欢迎登陆老男孩FTP",encoding="utf-8")) file_size = str(conn.recv(1024),encoding="utf-8") print(file_size) total_size = int(file_size) has_recv = 0 f = open("new.jpg","wb")#上传的新文件 while True: if total_size == has_recv: break data = conn.recv(1024) f.write(data) has_recv += len(data) f.close() client: import socket, os obj = socket.socket() obj.connect(("127.0.0.1",9999,)) ret_bytes = obj.recv(1024) ret_str = str(ret_bytes,encoding="utf-8") print(ret_str) size = os.stat("f.jpg").st_size#获取图片的字节大小 obj.sendall(bytes(str(size), encoding="utf-8")) with open("f.jpg","rb") as f: for line in f : obj.sendall(line) obj.close()
粘包:
只有TCP有粘包现象，UDP永远不会粘包。
TCP（传输控制协议）是面向连接,提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket,发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，就会粘包
UDP(用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式.会丢数据，不可靠tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。两种情况下会发生粘包：
1.发送端需要等本机的缓冲区满了以后才发送出去，造成粘包（发送数据时间间隔很端，数据很小，会合在一个起，产生粘包）
2.接收端不及时接收缓冲区的包，造成多个包接受（客户端发送一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据 ，就产生粘包）
解决粘包方法:
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后依次send到对端，对端在接受时，先从缓存中取出定长的报头，然后再取真实数据。
使用struct模块
该模块可以把一个类型，如数字，转成固定长度的bytes字节
>>> res=struct.pack('i',1111111111111) #打包成固定长度的bytes
>>> struct.unpack(“I”,res) #解包
#服务端 import struct #导入模块 import socket #导入模块 import json #导入模块 import subprocess #导入模块 din=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于网络家族以流的方式创建一个链接路 ip=('127.0.0.1',8080) #设定服务端唯一的地址 din.bind(ip) #绑定地址 din.listen(5) #激活启动，设置链接池最大缓数量 while True: conn,addr=din.accept() #等待接受数据链接 print('------->>>') while True: try: #开始捕捉异常,在windows中使用 dr=conn.recv(1024) #接收内容并赋值给dr res=subprocess.Popen(dr.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) #设置一个管道，把对的内容一个对的管道中，把错误的放进一个错误的管道中。 dui=res.stdout.read() #读取标准输出的内容并赋值给dui cuo=res.stderr.read() #读取错误输出的内容并赋值给cuo data_lik=len(dui)+len(cuo) #计算标准输出和错误输出的总长度并赋值给data_lik head_dic={'data_lik':data_lik} #自己顶一个字典 并赋值给head_dic head_json=json.dumps(head_dic) #把自己定义的字典进行一个序列化 head_bytes=head_json.encode('utf-8') #把序列化后的内容进行转码 ，因为网络传输都是通过字节进行传输 head_len=len(head_bytes) #把转换成字节码的长度拿到 并赋值给head_len #发送报头长度 conn.send(struct.pack('i',head_len)) #发送自己定义的报头长度 # 发送报头 conn.send(head_bytes) #发送自己定义的报头 #发送真是数据 conn.send(dui) #发送真实的数据 conn.send(cuo) #发送真实的数据 except Exception: #结束捕捉异常 break #跳出 conn.close() #断开链接 din.close() #关闭连接 #客户端 import struct #导入模块 import socket #导入模块 import json #导入模块 din=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于网络家族和流的方式传输 创建连接 ip=('127.0.0.1',8080) #设置唯一的地址 din.connect(ip) #绑定地址 while True: run=input('请输入命令：') #用户交互界面 if not run:continue #判断如果run为空就跳出 din.send(bytes(run,encoding='utf-8')) #通过字节形式发送用户输入的的内容 data=din.recv(4) #接收内容长度为4，并赋值给data head_len=struct.unpack('i',data)[0] #解报头并索引出值赋值给head_len head_bytes=din.recv(head_len) #接收长度为head_len变量中的值，赋值给head_bytes head_json=head_bytes.decode('utf-8') #把刚刚接收的内容进行转换，转换成utf-8 head_dic=json.loads(head_json) #在把转换成utf-8的内容 反序列化成字典的形式 data_lik=head_dic['data_lik'] #在把字典的查找的值赋值给data_lik recv_size=0 #设定变量并赋值为0 recv_data=b'' #设定变量并创建一个空字节的 while recv_size < data_lik: #如果变量小于字典查找出来的值时，循环为真。 data=din.recv(1024) #接收内容赋值给data recv_size+=len(data) #把得到的内容长度加到变量recv_size中，这样就能实现如果没有取完内容就一直取得效果 recv_data+=data #把拿到的值加到新创建的字节中 print(recv_data.decode('gbk')) #打印以GBK转码的内容 din.close() #关闭连接
socket并发(支持多个客户端请求):
#server端 import socketserver class MyServer(socketserver.BaseRequestHandler):#定义类方法,必须定义这个类, 通讯作用 def handle(self):#类中必须定义一个handle方法 conn = self.request conn.sendall(bytes("欢迎来电",encoding="utf-8")) while True: ret_bytes = conn.recv(1024) ret_str = str(ret_bytes, encoding="utf-8") if ret_str == "q": break conn.sendall(bytes(ret_str + "好", encoding="utf-8")) if __name__ == "__main__": server = socketserver.ThreadingTCPServer(("127.0.0.1",9999),MyServer)#MyServer是上面的类名 server.serve_forever()#通讯循环 #客户端 import socket obj = socket.socket() obj.connect(('127.0.0.1',9999,)) ret_bytes = obj.recv(1024) ret_str = str(ret_bytes,encoding="utf-8") print(ret_str) while True: inp = input("Client请输入要发送的内容>>> ") if inp == "q": obj.sendall(bytes(inp,encoding="utf-8")) break else: obj.sendall(bytes(inp,encoding="utf-8")) print("正在等待Server输入内容......") ret = str(obj.recv(1024),encoding="utf-8") print(ret) obj.close()
基于tornado(web轻量型框架)简易聊天
基于socket,
浏览器输入127.0.0.1:8888, 返回hello world
import tornado.ioloop import tornado.web class MainHandler(tornado.web.RequestHandler): def get(self): self.write("Hello, world") def make_app(): return tornado.web.Application([ (r"/", MainHandler), ]) if __name__ == "__main__": app = make_app() app.listen(8888) tornado.ioloop.IOLoop.current().start()
通过sockserver模块进行多线程式(UDP)
#UDP多并发服务端 import socketserver ip=('127.0.0.1',8080) class UDPserver(socketserver.BaseRequestHandler): def handle(self): print(self) print(self.request) #相当于conn de=self.request[0] print(de.decode('utf-8')) # print(self.request[1]) cou=input('::::') self.request[1].sendto(cou.encode('utf-8'),self.client_address) if __name__ == '__main__': din=socketserver.ThreadingUDPServer(ip,UDPserver) din.serve_forever() #链接循环
#UDP多并发客户端 import socket din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) ip=('127.0.0.1',8080) while True: inp=input('>>') din.sendto(inp.encode('utf-8'),ip) data,addr=din.recvfrom(1024) print(data.decode('utf-8')) din.close()
基于UDP的套接字:
# UDP服务端 import socket din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) ip=('127.0.0.1',8080) din.bind(ip) while True: conn,addr=din.recvfrom(1024) print(conn.decode('utf-8')) print(addr) din.sendto(conn.upper(),addr) # UDP客户端 import socket din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) ip=('127.0.0.1',8080) while True: inp=input('>>>') din.sendto(inp.encode('utf-8'),ip) data,addr=din.recvfrom(1024) print(data.decode('utf-8'))