python中struct模块之字节型数据的处理方法 以及tcp粘包现象的解决

基本的信息存储单位

位(Bit) :度量数据的最小单位
字节(Byte):最常用的基本单位，一个字节有8位
K字节 1k=1024 byte
M(兆)字节 1M=1024K
G(吉)字节 1G=1024M
T(太)字节 1T=1024G

字节顺序

一个数据有多个字节表示的时候，字节的顺序不同也就决定了值，在struct中有以下几种字节顺序：

对于字节顺序，只有大端和小端两种方式，只是比如你用@和=代表你用本机的字节顺序，！代表你使用网络的字节顺序。你不指定字节顺序则默认的是@。

本地字节顺序是大端或小端，取决于主机系统。例如，Intel x86和AMD64（x86-64）是小端的; 摩托罗拉68000和PowerPC G5是大端; ARM和Intel Itanium具有可切换的字节序（双字节序）。使用sys.byteorder来检查你的系统的字节顺序。

数据格式

struct支持的打包解包的数据格式如下，我们需要指定格式才能对应处理，其中对应尺寸已列出（以字节为单位）：

struct简单的打包解包模式

import struct
vaa = struct.pack('>I', 1255)         #打包时：根据字符的字节大小来确认使用上图中的哪种类型字符来表示
vab = struct.pack('>II', 1255, 23) 
vaaa = struct.unpack('>I', vaa) # vaaa: <class 'tuple'>: (1255, )     #用相同的类型来解包 返回结果集的元祖
vaba = struct.unpack('>II', vab) # vaba: <class 'tuple'>: (1255, 23)

进阶使用
pack_into(fmt, buffer, offset, *args)
fmt：定义的类型
buffer：可写的缓存区
offset：是写入位置的偏移量
*args：是需要写入的数据
这个有什么用呢，我们想想这样两个情况

1. 我们有两个类型已经打包好，我们想在这两个已经打包好的数据后面再添加一个数据打包
2. 或者我们要打包的数据很多，我们不可能在pack中把所有需要打包的数据都通过参数传递给pack，可能在后续添加数据的顺序不同

要使用它必须要一个可以写入的缓存区，我们可以导入一个字符缓存区包，然后创建一个固定大小的缓存区（以字节为单位）：

import struct
from ctypes import create_string_buffer
 
# 创建一个9字节大小的缓存区，初始化默认全部为\x00 
buf = create_string_buffer(9)        # buf.raw: '\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 
# 从缓存区buf的第0个字节开始打包 两个4字节无符号整型数据1和2
struct.pack_into(">II", buf, 0, 1, 2)      # buf.raw: '\x00\x00\x00\x01\x00\x00\x00\x02\x00'
# 然后我们想再打包一个布尔型数据到buf中就可以改变以下偏移量
struct.pack_into(">?", buf, 8, True) # buf.raw: '\x00\x00\x00\x01\x00\x00\x00\x02\x01'

#解包================
# 记录取值的位置
pos = 0
# 从buf缓存区中以大端方式从偏移位置pos处解包两个无符号整型数据返回，注意
#返回值如果只写一个则返回一个元组，否则你解包几个数据就要写几个返回值。
val = struct.unpack_from('>II', buf, pos)                 # val: <class 'tuple'>: (1, 2)
val_a, val_b = struct.unpack_from('>II', buf, pos)        # val_a: 1 val_b: 2
 
# 重置解包位置
pos += struct.calcsize('>II')               # pos: 8     
val_c, = struct.unpack_from('>?', buf, pos) # val_c: True    在正确的位置继续解包

这个示例是基于mnist手写数字识别的，我们刚开始有60000张手写数字的图片（.bmp格式的），我们通过下述代码将60000张图片转换成字节型数据，bytes.py代码如下：

import struct
import os
import numpy as np
from ctypes import create_string_buffer
import cv2
 
# 创建一个60000 * 784 * 1 + 3 * 4字节大小的缓存区，初始化默认全部为\x00
buffer = create_string_buffer(60000 * 784 * 1 + 3 * 4)
def writeBytesData():
 index = 0
 BMP_NUM = 0
 BMP_WIDTH = 28
 BMP_HEIGHT = 28
 
 # 先保留三个无符号整型的缓存区
 index += struct.calcsize('>III')
 path = 'data/bmp'
 if not os.path.exists(path):
  print('No this dir!')
  return
 list = os.listdir(path)
 for line_bmp in list:
  bmp_path = os.path.join(path, line_bmp)
  if os.path.isdir(bmp_path):
   print('This is not a .bmp')
  else:
   BMP_NUM += 1
   print(BMP_NUM)
   buf = cv2.imread(bmp_path, cv2.IMREAD_GRAYSCALE)
   buf = np.reshape(buf, [784])
   for pos in range(buf.__len__()):
    struct.pack_into('>B', buffer, index, buf[pos])
    index += struct.calcsize('>B')
 
 # 将保留缓存区的内容填上
 struct.pack_into('>III', buffer, 0, BMP_NUM, BMP_WIDTH, BMP_HEIGHT)
 with open('data/bytes/bytes.bytes', 'wb') as fp:
  fp.write(buffer)
 
def readFromBytes():
 index = 0
 images = []
 with open('data/bytes/bytes.bytes', 'rb') as fp:
  buffer = fp.read()
  # 解包前三个无符号整型
  bmp_num, bmp_width, bmp_height = struct.unpack_from('>III', buffer, index)
 
  # 重定位偏移量
  index += struct.calcsize('>III')
  for pos in range(bmp_num):
   img = struct.unpack_from('>784B', buffer, index)
   index += struct.calcsize('>784B')
   # 修改为原来的图片形状
   img = np.array(img, dtype=np.uint8)
   img = np.reshape(img, [bmp_height, bmp_width])
   # 显示图片
   cv2.imshow('bmp', img)
   # 按任意键继续
   cv2.waitKey(0)
   images.append(img)
 return images
 
writeBytesData()
readFromBytes()

黏包现象只发生在tcp协议中：
1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

import json,struct
#假设通过客户端上传1M:的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1024*1024,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

通过socket 传输struct模式并接收的一些详细方法

https://www.cnblogs.com/gbq-dog/p/10315557.html