Python（二十四） Python（二十四）

一基于UDP的套接字 udp服务端

1 ss = socket()#创建一个服务器的套接字 2 ss.bind()#绑定服务器套接字 3 inf_loop:#服务器无限循环 4cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送) 5 ss.close()# 关闭服务器套接字

udp客户端

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

udp套接字简单示例

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket ip_port=('127.0.0.1',9000) BUFSIZE=1024 udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)udp_server_client.bind(ip_port)while True: msg,addr=udp_server_client.recvfrom(BUFSIZE) print(msg,addr)udp_server_client.sendto(msg.upper(),addr)

文章图片
udp服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket ip_port=('127.0.0.1',9000) BUFSIZE=1024 udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)while True: msg=input('>>: ').strip() if not msg:continueudp_server_client.sendto(msg.encode('utf-8'),ip_port)back_msg,addr=udp_server_client.recvfrom(BUFSIZE) print(back_msg.decode('utf-8'),addr)

udp客户端 qq聊天(由于udp无连接，所以可以同时多个客户端去跟服务端通信)

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket ip_port=('127.0.0.1',8081) udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机 udp_server_sock.bind(ip_port)while True: qq_msg,addr=udp_server_sock.recvfrom(1024) print('来自[%s:%s]的一条消息:\033[1; 44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8'))) back_msg=input('回复消息: ').strip()udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

文章图片
udp服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)qq_name_dic={ '狗哥alex':('127.0.0.1',8081), '瞎驴':('127.0.0.1',8081), '一棵树':('127.0.0.1',8081), '武大郎':('127.0.0.1',8081), }while True: qq_name=input('请选择聊天对象: ').strip() while True: msg=input('请输入消息,回车发送: ').strip() if msg == 'quit':break if not msg or not qq_name or qq_name not in qq_name_dic:continue udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) print('来自[%s:%s]的一条消息:\033[1; 44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))udp_client_socket.close()

udp客户端1

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)qq_name_dic={ '狗哥alex':('127.0.0.1',8081), '瞎驴':('127.0.0.1',8081), '一棵树':('127.0.0.1',8081), '武大郎':('127.0.0.1',8081), }while True: qq_name=input('请选择聊天对象: ').strip() while True: msg=input('请输入消息,回车发送: ').strip() if msg == 'quit':break if not msg or not qq_name or qq_name not in qq_name_dic:continue udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])back_msg,addr=udp_client_socket.recvfrom(BUFSIZE) print('来自[%s:%s]的一条消息:\033[1; 44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))udp_client_socket.close()

udp客户端2 二 recv与recvfrom的区别
============part1：须知============
收发消息的原理须知晓--->请见十一的图：发消息，都是将数据发送到己端的发送缓冲中，收消息都是从己端的缓冲区中收
1. tcp：send发消息，recv收消息
2. udp：sendto发消息，recvfrom收消息

============part2：send与sendinto============
tcp是基于数据流的，而udp是基于数据报的：

send(bytes_data):发送数据流，数据流bytes_data若为空，自己这段的缓冲区也为空，操作系统不会控制tcp协议发空包
sendinto(bytes_data,ip_port)：发送数据报，bytes_data为空，还有ip_port,所有即便是发送空的bytes_data,数据报其实也不是空的，自己这端的缓冲区收到内容，操作系统就会控制udp协议发包。

============part3：recv与recvfrom============
1.tcp协议：
（1）如果收消息缓冲区里的数据为空，那么recv就会阻塞（阻塞很简单，就是一直在等着收）
（2）只不过tcp协议的客户端send一个空数据就是真的空数据，客户端即使有无穷个send空，也跟没有一个样。
（3）tcp基于链接通信

基于链接，则需要listen（backlog），指定半连接池的大小
基于链接，必须先运行的服务端，然后客户端发起链接请求
对于mac系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端在收消息后加上if判断，空消息就break掉通信循环)
对于windows/linux系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端通信循环内加异常处理，捕捉到异常后就break掉通讯循环)

客户端发送为空，测试结果--->验证:（1）
客户端直接终止程序，测试结果--->验证:（2）

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import subprocess from socket import *phone=socket(AF_INET,SOCK_STREAM) phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) phone.bind(('127.0.0.1',8080)) phone.listen(5)conn,addr=phone.accept()while True: data=https://www.it610.com/article/conn.recv(1024) print('from client msg is ',data) conn.send(data.upper())

文章图片
服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import subprocess from socket import *phone=socket(AF_INET,SOCK_STREAM) phone.connect(('127.0.0.1',8080))while True: msg=input('>>: ') phone.send(msg.encode('utf-8')) print('Client message has been sent')data=https://www.it610.com/article/phone.recv(1024) print('from server msg is ',data.decode('utf-8')) phone.close()

文章图片
客户端 2.udp协议
（1）如果如果收消息缓冲区里的数据为“空”，recvfrom也会阻塞
（2）只不过udp协议的客户端sendinto一个空数据并不是真的空数据（包含：空数据+地址信息，得到的报仍然不会为空），所以客户端只要有一个sendinto（不管是否发送空数据，都不是真的空数据），服务端就可以recvfrom到数据。
（3）udp无链接

无链接，因而无需listen（backlog），更加没有什么连接池之说了
无链接，udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息，只不过数据丢失
recvfrom收的数据小于sendinto发送的数据时，在mac和linux系统上数据直接丢失，在windows系统上发送的比接收的大直接报错
只有sendinto发送数据没有recvfrom收数据，数据丢失

客户端发送空，看服务端结果--->验证（1）

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import *ip_port=('127.0.0.1',9003) bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM) udp_server.bind(ip_port)while True: data1,addr=udp_server.recvfrom(bufsize) print(data1)

文章图片
服务端

文章图片

from socket import * ip_port=('127.0.0.1',9003) bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)while True: msg=input('>>: ') udp_client.sendto(msg.encode('utf-8'),ip_port) #发送空,发现服务端可以接收空

文章图片
客户端
分别运行服务端，客户端--->验证（2）

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import *ip_port=('127.0.0.1',9003) bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM) udp_server.bind(ip_port)data1,addr=udp_server.recvfrom(1) print('第一次收了 ',data1) data2,addr=udp_server.recvfrom(1) print('第二次收了 ',data2) data3,addr=udp_server.recvfrom(1) print('第三次收了 ',data3) print('--------结束----------')

服务端

文章图片

from socket import * ip_port=('127.0.0.1',9003) bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)udp_client.sendto(b'hello',ip_port) udp_client.sendto(b'world',ip_port) udp_client.sendto(b'egon',ip_port)

客户端
不运行服务端，单独运行客户端，一点问题没有，但是消息丢了--->验证（3）

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import *ip_port=('127.0.0.1',9003) bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM) udp_server.bind(ip_port)data1,addr=udp_server.recvfrom(bufsize) print('第一次收了 ',data1) data2,addr=udp_server.recvfrom(bufsize) print('第二次收了 ',data2) data3,addr=udp_server.recvfrom(bufsize) print('第三次收了 ',data3) print('--------结束----------')

文章图片
服务端

文章图片

from socket import * import time ip_port=('127.0.0.1',9003) bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)udp_client.sendto(b'hello',ip_port) udp_client.sendto(b'world',ip_port) udp_client.sendto(b'egon',ip_port)print('客户端发完消息啦') time.sleep(100)

文章图片
客户端
注意：
1.你单独运行上面的udp的客户端，你发现并不会报错，相反tcp却会报错，因为udp协议只负责把包发出去，对方收不收，我根本不管，而tcp是基于链接的，必须有一个服务端先运行着，客户端去跟服务端建立链接然后依托于链接才能传递消息，任何一方试图把链接摧毁都会导致对方程序的崩溃。
2.上面的udp程序，你注释任何一条客户端的sendinto，服务端都会卡住，为什么？因为服务端有几个recvfrom就要对应几个sendinto，哪怕是sendinto(b'')那也要有。
三粘包现象基于tcp先制作一个远程执行命令的程序（1：执行错误命令 2：执行ls 3：执行ifconfig）
【Python（二十四）】注意注意注意：
res=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码
且只能从管道里读一次结果
注意：命令ls -l ; lllllll ; pwd 的结果是既有正确stdout结果，又有错误stderr结果

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import * import subprocessip_port=('127.0.0.1',8080) BUFSIZE=1024tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5)while True: conn,addr=tcp_socket_server.accept() print('客户端',addr)while True: cmd=conn.recv(BUFSIZE) if len(cmd) == 0:breakres=subprocess.Popen(cmd.decode('utf-8'),shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)stderr=act_res.stderr.read() stdout=act_res.stdout.read() conn.send(stderr) conn.send(stdout)

文章图片
服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080)s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port)while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':breaks.send(msg.encode('utf-8')) act_res=s.recv(BUFSIZE)print(act_res.decode('utf-8'),end='')

文章图片
客户端上述程序是基于tcp的socket，在运行时会发生粘包

让我们再基于udp制作一个远程执行命令的程序

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng'#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import * import subprocessip_port=('127.0.0.1',9003) bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM) udp_server.bind(ip_port)while True: #收消息 cmd,addr=udp_server.recvfrom(bufsize) print('用户命令----->',cmd)#逻辑处理 res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE) stderr=res.stderr.read() stdout=res.stdout.read()#发消息 udp_server.sendto(stderr,addr) udp_server.sendto(stdout,addr) udp_server.close()

文章图片
服务端

文章图片

from socket import * ip_port=('127.0.0.1',9003) bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)while True: msg=input('>>: ').strip() udp_client.sendto(msg.encode('utf-8'),ip_port)data,addr=udp_client.recvfrom(bufsize) print(data.decode('utf-8'),end='')

文章图片
客户端上述程序是基于udp的socket，在运行时永远不会发生粘包
四什么是粘包须知：只有TCP有粘包现象，UDP永远不会粘包，为何，且听我娓娓道来
首先需要掌握一个socket收发消息的原理

文章图片

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

udp的recvfrom是阻塞的，一个recvfrom(x)必须对一个一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
两种情况下会发生粘包。
发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import * ip_port=('127.0.0.1',8080)tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5)conn,addr=tcp_socket_server.accept()data1=conn.recv(10) data2=conn.recv(10)print('----->',data1.decode('utf-8')) print('----->',data2.decode('utf-8'))conn.close()

服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080)s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port)s.send('hello'.encode('utf-8')) s.send('feng'.encode('utf-8'))

客户端接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' from socket import * ip_port=('127.0.0.1',8080)tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5)conn,addr=tcp_socket_server.accept()data1=conn.recv(2) #一次没有收完整 data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的print('----->',data1.decode('utf-8')) print('----->',data2.decode('utf-8'))conn.close()

文章图片
服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080)s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port)s.send('hello feng'.encode('utf-8'))

文章图片
客户端
拆包的发生情况
当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

五解决粘包的low比处理方法问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据
low版本的解决方法

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket,subprocess ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)s.bind(ip_port) s.listen(5)while True: conn,addr=s.accept() print('客户端',addr) while True: msg=conn.recv(1024) if not msg:break res=subprocess.Popen(msg.decode('utf-8'),shell=True,\ stdin=subprocess.PIPE,\ stderr=subprocess.PIPE,\ stdout=subprocess.PIPE) err=res.stderr.read() if err: ret=err else: ret=res.stdout.read() data_length=len(ret) conn.send(str(data_length).encode('utf-8')) data=https://www.it610.com/article/conn.recv(1024).decode('utf-8') if data =https://www.it610.com/article/='recv_ready': conn.sendall(ret) conn.close()

文章图片
服务端

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080))while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':breaks.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=https://www.it610.com/article/b'' while recv_size < length: data+=s.recv(1024) recv_size+=len(data)print(data.decode('utf-8'))

文章图片
客户端为何low：
程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗

文章图片

#_*_coding:utf-8_*_ __author__ = 'Linhaifeng' import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080))while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':breaks.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=https://www.it610.com/article/b'' while recv_size < length: data+=s.recv(1024) recv_size+=len(data)print(data.decode('utf-8'))

文章图片
转载于:https://www.cnblogs.com/guozhenle/p/7150177.html