subproess模块

  1. import subprocess
  2. while True:
  3. cmd = input('cmd>>>: ')
  4. if cmd == 'q':
  5. break
  6. data = subprocess.Popen(
  7. cmd,
  8. shell=True,
  9. stdout=subprocess.PIPE, # 返回标准输出结果
  10. stderr=subprocess.PIPE # 返回标准错误结果
  11. )
  12. res = data.stdout.read() + data.stderr.read()
  13. print(res.decode('gbk'))

TCP粘包问题

服务端第一次发送的数据,客户端无法精确一次性接收完毕,下一次发送的数据与上一次数据黏在一起了。

  1. 无法预测对方需要接收的数据大小长度
  2. TCP流式协议,会将多次连续发送数据量小、并且时间间隔短的数据一次性打包发送。

基于TCP的套接字客户端往服务端上传文件,发送时文件内容是按照一段一段的字节流发送的,在接收方看了,根本不知道该文件的字节流从何处开始何处结束。

粘包两种情况

  1. 服务端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包)
  1. # server.py
  2. import socket
  3. server = socket.socket()
  4. server.bind(
  5. ('127.0.0.1', 9527)
  6. )
  7. server.listen(5)
  8. conn, addr = server.accept()
  9. data1 = conn.recv(1024)
  10. data2 = conn.recv(1024)
  11. data3 = conn.recv(1024)
  12. print(data1)
  13. print(data2)
  14. print(data3)
  15. # client.py
  16. import socket
  17. client = socket.socket()
  18. client.connect(
  19. ('127.0.0.1', 9527)
  20. )
  21. client.send(b'hello')
  22. client.send(b'hello')
  23. client.send(b'hello')
  24. client.close()
  25. '''
  26. b'hellohellohello'
  27. b''
  28. b''
  29. '''
  1. 客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据
  1. # 服务端
  2. import socket
  3. server = socket.socket()
  4. server.bind(
  5. ('127.0.0.1', 9527)
  6. )
  7. server.listen(5)
  8. conn, addr = server.accept()
  9. data1 = conn.recv(2)
  10. data2 = conn.recv(20)
  11. print(data1)
  12. print(data2)
  13. # 客户端
  14. import socket
  15. client = socket.socket()
  16. client.connect(
  17. ('127.0.0.1', 9527)
  18. )
  19. client.send(b'hello world and shcaondskasd nknasksfn km')
  20. client.close()
  21. '''
  22. b'he'
  23. b'llo world and shcaon
  24. '''

解决粘包问题

使用struct模块

struct模块是一个可以将很长的数据的长度,压缩成固定的长度的一个标记(数据报头)。

必须先定义报头,发送报头,再发送真实数据

struct模块的使用

  1. import struct
  2. str1 = '123a56'
  3. # 打包
  4. # i模式会将数据长度压缩成4个bytes
  5. headers = struct.pack('i', len(str1))
  6. print(headers)
  7. print(len(headers))
  8. # 解包
  9. data_len = struct.unpack('i', headers)
  10. print(data_len[0]) # 真实数据长度为len(str1)

使用struct模块解决粘包

服务端:

  1. import struct
  2. import socket
  3. import subprocess
  4. server = socket.socket()
  5. server.bind(
  6. ('127.0.0.1', 8888)
  7. )
  8. server.listen(5)
  9. while True:
  10. conn, addr = server.accept()
  11. print(addr)
  12. while True:
  13. try:
  14. cmd = conn.recv(1024).decode('utf-8')
  15. if len(cmd) == 0:
  16. continue
  17. if cmd == 'q':
  18. break
  19. res = subprocess.Popen(
  20. cmd,
  21. shell=True,
  22. stdout=subprocess.PIPE,
  23. stderr=subprocess.PIPE)
  24. data = res.stdout.read() + res.stderr.read()
  25. # 打包压缩
  26. headers = struct.pack('i', len(data))
  27. # 先发送头部
  28. conn.send(headers)
  29. # 再发送真实数据
  30. conn.send(data)
  31. except Exception:
  32. break
  33. conn.close()

客户端:

  1. import struct
  2. import socket
  3. client = socket.socket()
  4. client.connect(
  5. ('127.0.0.1', 8888)
  6. )
  7. while True:
  8. cmd = input('cmd>>>:')
  9. client.send(cmd.encode('utf-8'))
  10. if cmd == 'q':
  11. break
  12. # 先获取数据报头
  13. headers = client.recv(4)
  14. # 再解包获取真实数据
  15. data_len = struct.unpack('i', headers)[0]
  16. # 接收真实数据长度
  17. data = client.recv(data_len)
  18. print(data.decode('gbk'))
  19. client.close()

优化解决粘包问题

把数据真实长度和数据的描述信息一同发送过去

服务端:

  1. import socket
  2. import struct
  3. import json
  4. server = socket.socket()
  5. server.bind(('127.0.0.1', 9999))
  6. server.listen(5)
  7. while True:
  8. conn, addr = server.accept()
  9. print(addr)
  10. while True:
  11. try:
  12. # 接收数据报头
  13. headers = conn.recv(4)
  14. # 解包获取真实数据长度
  15. data_len = struct.unpack('i', headers)[0]
  16. bytes_data = conn.recv(data_len)
  17. back_dic = json.loads(bytes_data.decode('utf-8'))
  18. print(back_dic)
  19. except Exception:
  20. break
  21. conn.close()

客户端:

  1. import socket
  2. import struct
  3. import json
  4. client = socket.socket()
  5. client.connect(('127.0.0.1', 9999))
  6. while True:
  7. dic = {
  8. 'file_name': 'shoot on me',
  9. 'file_size': 10000000
  10. }
  11. # json序列化
  12. json_data = json.dumps(dic)
  13. json_bytes = json_data.encode('utf-8')
  14. # 压缩
  15. headers = struct.pack('i', len(json_bytes))
  16. client.send(headers)
  17. client.send(json_bytes)

上传大文件

服务端

  1. import socket
  2. import struct
  3. import json
  4. server = socket.socket()
  5. server.bind(('127.0.0.1', 9999))
  6. server.listen(5)
  7. conn, addr = server.accept()
  8. print(addr)
  9. while True:
  10. try:
  11. headers = conn.recv(4)
  12. data_len = struct.unpack('i', headers)[0]
  13. bytes_data = conn.recv(data_len)
  14. back_dic = json.loads(bytes_data.decode('utf-8'))
  15. print(back_dic)
  16. file_name = back_dic.get('file_name')
  17. file_size = back_dic.get('file_size')
  18. init_data = 0
  19. # 写入文件视频
  20. with open(file_name, 'wb') as f:
  21. while init_data < file_size:
  22. data = conn.recv(1024)
  23. f.write(data)
  24. init_data += len(data)
  25. print(f'{file_name}接收完毕! ')
  26. except Exception as e:
  27. print(e)
  28. break
  29. conn.close()

客户端

  1. import socket
  2. import struct
  3. import json
  4. client = socket.socket()
  5. client.connect(('127.0.0.1', 9999))
  6. # 1.打开视频文件,获取视频数据
  7. with open(r'D:\pycharm_project\忌日快乐2.mkv', 'rb') as f:
  8. movie_bytes = f.read()
  9. # 2.为视频组织一个字典
  10. send_dic = {
  11. 'file_name': '忌日快乐2.mkv',
  12. 'file_size': len(movie_bytes)
  13. }
  14. # 3.先打包字典,发送headers,再发字典真实数据
  15. json_data = json.dumps(send_dic)
  16. bytes_data = json_data.encode('utf-8')
  17. headers = struct.pack('i', len(bytes_data))
  18. client.send(headers)
  19. client.send(bytes_data)
  20. # 再发真实视频数据
  21. init_data = 0
  22. num = 1
  23. with open(r'D:\pycharm_project\忌日快乐2.mkv', 'rb') as f:
  24. while init_data < len(movie_bytes):
  25. send_data = f.read(1024)
  26. print(send_data, num)
  27. num += 1
  28. client.send(send_data)
  29. init_data += len(send_data)

UDP协议

UDP是一种传输协议

  1. 不需要建立双向通道
  2. 不会粘包
  3. 客户端给服务端发送数据,不需要等待服务返回接收成功

upd套接字

  1. # server.py
  2. import socket
  3. server = socket.socket(type=socket.SOCK_DGRAM)
  4. server.bind(
  5. ('127.0.0.1', 8888)
  6. )
  7. msg, addr = server.recvfrom(1024)
  8. msg1, addr1 = server.recvfrom(1024)
  9. msg2, addr2 = server.recvfrom(1024)
  10. msg3, addr3= server.recvfrom(1024)
  11. print(msg)
  12. print(msg1)
  13. print(msg2)
  14. print(msg3)
  15. # client.py
  16. import socket
  17. client = socket.socket(type=socket.SOCK_DGRAM)
  18. client.sendto(b'hello', ('127.0.0.1', 8888))
  19. client.sendto(b'hello', ('127.0.0.1', 8888))
  20. client.sendto(b'hello', ('127.0.0.1', 8888))
  21. client.sendto(b'hello', ('127.0.0.1', 8888))
  22. '''
  23. b'hello'
  24. b'hello'
  25. b'hello'
  26. b'hello'
  27. '''

基于upd实现qq聊天室

  1. # server.py
  2. import socket
  3. server = socket.socket(type=socket.SOCK_DGRAM)
  4. server.bind(('127.0.0.1', 8888))
  5. while True:
  6. msg, addr = server.recvfrom(1024)
  7. print(addr)
  8. print(msg.decode('utf-8'))
  9. send_msg = input('服务端发送消息:').encode('utf-8')
  10. server.sendto(send_msg, addr)
  11. # client.py
  12. import socket
  13. client = socket.socket(type=socket.SOCK_DGRAM)
  14. server_ip_port = ('127.0.0.1', 8888)
  15. while True:
  16. send_msg = input('客户端1:').encode('utf-8')
  17. client.sendto(send_msg, server_ip_port)
  18. msg, addr = client.recvfrom(1024)
  19. print(msg.decode('utf-8'))

socketserver

python内置模块,可以简化socket套接字服务端的代码,必须要创建一个类

  1. # server.py
  2. import socketserver
  3. class MyTCPServer(socketserver.BaseRequestHandler):
  4. # 必须要重写父类的handler
  5. def handle(self):
  6. print(self.client_address)
  7. while True:
  8. try:
  9. data = self.request.recv(1024).decode('utf-8')
  10. send_msg = data.upper()
  11. self.request.send(send_msg.encode('utf-8'))
  12. except Exception:
  13. break
  14. if __name__ == '__main__':
  15. server = socketserver.ThreadingTCPServer (
  16. ('127.0.0.1', 8888), MyTCPServer
  17. )
  18. server.serve_forever()
  19. # client.py
  20. import socket
  21. client = socket.socket()
  22. client.connect(
  23. ('127.0.0.1', 8888)
  24. )
  25. while True:
  26. send_msg = input('客户端:')
  27. if send_msg == 'q':
  28. break
  29. client.send(send_msg.encode('utf-8'))
  30. data = client.recv(1024).decode('utf-8')
  31. print(data)
  32. client.close()

tcp粘包、解决粘包问题的更多相关文章

  1. Python进阶----粘包,解决粘包(旗舰版)

    Python进阶----粘包,解决粘包(旗舰版) 一丶粘包 只有TCP有粘包现象,UDP永远不会粘包 什么是粘包     存在于客户端接收数据时,不能一次性收取全部缓冲区中的数据.当下一次再有数据来时 ...

  2. tcp套接字粘包解决办法

    粘包只会出现在tcp,udp传输不会产生粘包现象.解决粘包的原理就是服务器预先向客户端发送客户端即将获取文件的大小. 第一版解决方案: 服务器: # Author : Kelvin # Date : ...

  3. socket编程 TCP 粘包和半包 的问题及解决办法

    一般在socket处理大数据量传输的时候会产生粘包和半包问题,有的时候tcp为了提高效率会缓冲N个包后再一起发出去,这个与缓存和网络有关系. 粘包 为x.5个包 半包 为0.5个包 由于网络原因 一次 ...

  4. 8-2udp和tcp网络编程以及粘包和解决粘包的方法

    一  tcp网络编程 server 端 import socket sk=socket.socket() #实例化一个对象 sk.setsockopt(socket.SOL_SOCKET,socket ...

  5. TCP粘包问题的解决方案02——利用readline函数解决粘包问题

      主要内容: 1.read,write 与 recv,send函数. recv函数只能用于套接口IO ssize_t recv(int sockfd,void * buff,size_t len,i ...

  6. 《连载 | 物联网框架ServerSuperIO教程》- 9. 协议过滤器,解决一包多发、粘包、冗余数据

    1.C#跨平台物联网通讯框架ServerSuperIO(SSIO)介绍 <连载 | 物联网框架ServerSuperIO教程>1.4种通讯模式机制. <连载 | 物联网框架Serve ...

  7. c# socket 解决粘包,半包

    处理原理: 半包:即一条消息底层分几次发送,先有个头包读取整条消息的长度,当不满足长度时,将消息临时缓存起来,直到满足长度再解码 粘包:两条完整/不完整消息粘在一起,一般是解码完上一条消息,然后再判断 ...

  8. 关于TCP封包、粘包、半包

    关于Tcp封包 很多朋友已经对此作了不少研究,也花费不少心血编写了实现代码和blog文档.当然也充斥着一些各式的评论,自己看了一下,总结一些心得. 首先我们学习一下这些朋友的心得,他们是: http: ...

  9. python3全栈开发-什么是粘包、粘包现象、如何解决粘包

    一.粘包现象 让我们基于tcp先制作一个远程执行命令的程序(1:执行错误命令 2:执行ls 3:执行ifconfig) 注意注意注意: res=subprocess.Popen(cmd.decode( ...

随机推荐

  1. iOS中点击按钮跳转到外部浏览器和内部打开

    如图所示,需要实现点击一个按钮,跳转到指定网页: -(void)pushBtnCellClickDeleate{ NSLog(@"跳转"); //在APP内部打开指定网页 UIWe ...

  2. Django2.1.1与xadmin0.6.0遇到的坑(一)

    (1)django2.0把from django.core.urlresolvers修改成了django.urls 异常信息: ModuleNotFoundError: No module named ...

  3. property用法,使Python中的get方法和set方法使用更简单

    方法一: class a: def __init__(self): self.__num = 1              #定义一个私有变量(以双下划线开头的是私有变量) def getNum(se ...

  4. Educational Codeforces Round 71 (Rated for Div. 2)

    传送门 A.There Are Two Types Of Burgers 签到. B.Square Filling 签到 C.Gas Pipeline 每个位置只有"高.低"两种状 ...

  5. requests乱码问题

    有三种方法解决请求后乱码问题. 一:获取二进制数据,再利用str进行编码转换 url='http://music.baidu.com' r = requests.get(url) html=r.con ...

  6. 阿里Nacos初体验

    Nacos 从开源到现在已经18个releases了,更新很快,社区也很活跃,光钉钉群的人数那也是好多,每次点个查看全部成员的按钮,我的钉钉就要卡死,也有可能我没更新最新的版本. 前面写了一段时间的S ...

  7. Mybatis框架模糊查询+多条件查询

    一.ISmbmsUserDao层 //根据姓名模糊查询 public List<Smbms> getUser(); //多条件查询 public List<Smbms> get ...

  8. 用python读写和处理csv文件

    import requestsfrom bs4 import BeautifulSoupimport csv date = open('test.csv', 'w')writer = csv.writ ...

  9. laravel中使用FormRequest进行表单验证,验证异常返回JSON

    通常在项目中,我们会对大量的前端提交过来的表单进行验证,如果不通过,则返回错误信息. 前端为了更好的体验,都使用ajax进行表单提交,虽然 validate() 方法能够根据前端的不同请求方式,返回不 ...

  10. 【BZOJ4823】[CQOI2017]老C的方块(网络流)

    [BZOJ4823][CQOI2017]老C的方块(网络流) 题面 BZOJ 题解 首先还是给棋盘进行黑白染色,然后对于特殊边左右两侧的格子单独拎出来考虑. 为了和其他格子区分,我们把两侧的这两个格子 ...