structpython

① python中的struct模块中pack参数个数限制

struct.pack 函数后面的可变长参数没有参数长度的限制。

另外，如果你已经将所需的参数放入一个叫args 的 tuple中，那么可以用下面的方法传给 pack 函数：

args=("H","elloworld",5)
struct.pack("c12si",*args)
#等价于
struct.pack("c12si","H","elloworld",5)

② Python中如何使用C的结构体struct求解

閟truct就可以使用结构体了：
import struct
生成一个结构体实例：
data = struct.pack( 'format_string', struct_menber_1, struct_menber_2, ... )
其中的format_string用来指定结构体的格式（指明该结构体在C中的定义），由两部分组成：
首先是一个可选的特殊字符，用来指明字节序、数据类型大小和对齐方式：
@: native order, size & alignment (default)
=: native order, std. size & alignment
<: little-endian, std. size & alignment
>: big-endian, std. size & alignment
!: same as >
然后是指明结构体定义的部分：
The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
h:short; H:unsigned short; i:int; I:unsigned int;
l:long; L:unsigned long; f:float; d:double.
Special cases (preceding decimal count indicates length):
s:string (array of char); p: pascal string (with count byte).
Special case (only available in native format):
P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
q:long long; Q:unsigned long long
Whitespace between formats is ignored.
如果struct模块的函数出错，将产生struct.error异常。

③ python3 利用struct.pack 动态组建字节流

a = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
fmt = str(len(a)) + 'H' # 默认小端模式
struct.pack(fmt, *a) # 列表a前面加*，表示将a解压后单个传入参数
推理：a如果是动态变化的list，或者动态截取a其中一段来转换成字节流都是可以的

④ python struct模块使用问题

when you pack a struct, you need to give it the format you need:

Check it here : http://www.python.org/doc//current/library/struct.html

In your case, you should

pack('BBHHHLL', a,b,c,d,e,f,g) # assuming all are unsigned.

⑤ python中的struct模块怎么使用

• Python为各种数据类型（如整型等）提供与“C”不同的抽象层次，它们也以不同的方式存储它们。当然，存储在二进制文件中的数据或通过网络发送和接收的数据是连续的字节。在Python中，列表中的数据可能不会被存储为连续的字节块。

  

• 2

  为了处理它们，将python值转换为“C”结构很重要，即将它们打包成连续的数据字节，或者将一个连续的字节块分解成Python对象。模块“struct”提供了将python对象打包为连续的字节块的功能，或者将一大块字节拆分成python结构。

⑥ python struct 格式符b 为什么是两个字节

整个代码是把data每两个字符变成一个字节，比如"7F"变成一个值127的byte。struct.pack()参数B指按Byte转换。输出的byte_dat是一个字节串，类似b"\xEF"。
+号的含义因该是拼接，把后转换的一个字节拼接在之前积累的数据后面。b""前缀是字节串，不是字符串。

⑦ 关于python代码中struct模块的定义

这个你得好好看看struct模块的pack函数的文档了，fmt就是format，pack的第一个参数代表了格式的信息，这个格式的格式，有专门的定义

⑧ python struct pack怎么弄成二进制

有的时候需要用python处理二进制数据，比如，存取文件，socket操作时.这时候，可以使用python的struct模块来完成.可以用 struct来处理c语言中的结构体.
struct模块中最重要的三个函数是pack(), unpack(), calcsize()
8

# 按照给定的格式(fmt)，把数据封装成字符串(实际上是类似于c结构体的字节流)pack(fmt, v1, v2, ...) # 按照给定的格式(fmt)解析字节流string，返回解析出来的tupleunpack(fmt, string) # 计算给定的格式(fmt)占用多少字节的内存calcsize(fmt)

上述fmt中，支持的格式为：

FORMAT
C TYPE
PYTHON TYPE
STANDARD SIZE
NOTES

x pad byte no value
c char string of length 1 1
b signed char integer 1 (3)
B unsigned char integer 1 (3)
? _Bool bool 1 (1)
h short integer 2 (3)
H unsigned short integer 2 (3)
i int integer 4 (3)
I unsigned int integer 4 (3)
l long integer 4 (3)
L unsigned long integer 4 (3)
q long long integer 8 (2), (3)
Q unsigned long long integer 8 (2), (3)
f float float 4 (4)
d double float 8 (4)
s char[] string
p char[] string
P void * integer (5), (3)
注1.q和Q只在机器支持64位操作时有意思
注2.每个格式前可以有一个数字，表示个数
注3.s格式表示一定长度的字符串，4s表示长度为4的字符串，但是p表示的是pascal字符串
注4.P用来转换一个指针，其长度和机器字长相关
注5.最后一个可以用来表示指针类型的，占4个字节
为了同c中的结构体交换数据，还要考虑有的c或c++编译器使用了字节对齐，通常是以4个字节为单位的32位系统，故而struct根据本地机器字节顺序转换.可以用格式中的第一个字符来改变对齐方式.定义如下：

CHARACTER
BYTE ORDER
SIZE
ALIGNMENT

@ native native native
= native standard none
< little-endian standard none
> big-endian standard none
! network (= big-endian) standard none
使用方法是放在fmt的第一个位置，就像’@5s6sif’
例子1：
结构体如下：

structHeader{ unsigned shortid; char[4] tag; unsigned intversion; unsigned intcount;}

通过socket.recv接收到了一个上面的结构体数据，存在字符串s中，现在需要把它解析出来，可以使用unpack()函数：

importstructid, tag, version, count =struct.unpack("!H4s2I", s)

上面的格式字符串中，!表示我们要使用网络字节顺序解析，因为我们的数据是从网络中接收到的，在网络上传送的时候它是网络字节顺序的.后面的H表示 一个unsigned short的id,4s表示4字节长的字符串，2I表示有两个unsigned int类型的数据.
就通过一个unpack，现在id, tag, version, count里已经保存好我们的信息了.
同样，也可以很方便的把本地数据再pack成struct格式：

ss =struct.pack("!H4s2I", id, tag, version, count);

pack函数就把id, tag, version, count按照指定的格式转换成了结构体Header，ss现在是一个字符串(实际上是类似于c结构体的字节流)，可以通过 socket.send(ss)把这个字符串发送出去。
例子2：

importstruct a=12.34 # 将a变为二进制bytes=struct.pack('i',a)

此时bytes就是一个string字符串，字符串按字节同a的二进制存储内容相同。
再进行反操作，现有二进制数据bytes，（其实就是字符串），将它反过来转换成python的数据类型：

# 注意，unpack返回的是tuple !!a,=struct.unpack('i',bytes)

如果是由多个数据构成的，可以这样：

a='hello'b='world!'c=2d=45.123 bytes=struct.pack('5s6sif',a,b,c,d)

此时的bytes就是二进制形式的数据了，可以直接写入文件比如 binfile.write(bytes)
然后，当我们需要时可以再读出来，bytes=binfile.read()
再通过struct.unpack()解码成python变量：

a,b,c,d=struct.unpack('5s6sif',bytes)

’5s6sif’这个叫做fmt，就是格式化字符串，由数字加字符构成，5s表示占5个字符的字符串，2i，表示2个整数等等，下面是可用的字符及类型，ctype表示可以与python中的类型一一对应。
注意：二进制文件处理时会碰到的问题
我们使用处理二进制文件时，需要用如下方法：

binfile=open(filepath,'rb') #读二进制文件 binfile=open(filepath,'wb') #写二进制文件

那么和binfile=open(filepath,’r')的结果到底有何不同呢？
不同之处有两个地方：
第一，使用’r'的时候如果碰到’0x1A’，就会视为文件结束，这就是EOF。使用’rb’则不存在这个问题。即，如果你用二进制写入再用文本读出的话，如果其中存在’0X1A’，就只会读出文件的一部分。使用’rb’的时候会一直读到文件末尾。
第二，对于字符串x=’abc\ndef’，我们可用len(x)得到它的长度为7，\n我们称之为换行符，实际上是’0X0A’。当我们用’w'即文本方式写的时候，在windows平台上会自动将’0X0A’变成两个字符’0X0D’，’0X0A’，即文件长度实际上变成8.。当用’r'文本方式读取时，又自动的转换成原来的换行符。如果换成’wb’二进制方式来写的话，则会保持一个字符不变，读取时也是原样读取。所以如果用文本方式写入，用二进制方式读取的话，就要考虑这多出的一个字节了。’0X0D’又称回车符。linux下不会变。因为linux只使用’0X0A’来表示换行。

⑨ Python中struct.pack的一个疑问

的确很奇怪。我试验了10几分钟，你按下面的方法来做就可以正确。

importstruct
zzz=("{Type:2}").encode("utf-8")
length=len(zzz)
a=struct.pack("%ds"%length,zzz)
print(a)

简单的说s其实只是一个字符，所以前面要加一个数字，比如8s，就可以存贮一个长度为8的字符串。你只写一个s当然只存贮一个。

python帮助的原文如下

For the 's' format
character, the count is interpreted as the size of the string, not a repeat
count like for the other format characters; for example, '10s' means a single
10-byte string, while '10c' means 10 characters. If a count is not given, it
defaults to 1. For packing, the string is truncated or padded with null bytes as
appropriate to make it fit. For unpacking, the resulting string always has
exactly the specified number of bytes. As a special case, '0s' means a single, empty
string (while '0c'
means 0 characters).