威尼斯人线上娱乐

Python中二进制数据处理模块struct使用,Python标准库笔记struct模块的选择

16 4月 , 2019  

该模块成效是成功Python数值和C语言结构体的Python字符串情势间的改动。那能够用来拍卖存款和储蓄在文书中或从互连网连接中贮存的二进制数据,以及其它数据源。

struct模块提供了用于在字节字符串和Python原生数据类型之间转换函数,比如数字和字符串。

Python版本: 2.x & 3.x

近日在攻读python互联网编制程序那壹块,在写轻易的socket通信代码时,遇到了struct那个模块的利用,当时不太知道那到底有和功用,后来查阅了有关资料大约精晓了,在那边做一下大致的下结论。

Python中从不二进制类型,但是能够利用string字符串类型来囤积二进制数据,然后采纳struct模块来对2进制数据开始展览拍卖。下边将详细描述如何选拔struct模块来拍卖二进制数据。

用途: 在Python基本数据类型和2进制数据里面开始展览转移

  该模块功用是形成Python数值和C语言结构体的Python字符串情势间的改动。
那足以用来拍卖存款和储蓄在文书中或从互连网连接中储存的二进制数据,以及别的数据源。

询问c语言的人,一定会精通struct结构体在c语言中的功能,它定义了1种结构,里面包括不相同体系的数量(int,char,bool等等),方便对某一构造对象进行拍卖。而在网络通讯当中,大多传递的数额是以二进制流(binary
data)存在的。当传递字符串时,不必担忧太多的难题,而当传递诸如int、char之类的主干数据的时候,就须要有壹种体制将或多或少特定的布局体类型打包成贰进制流的字符串然后再网络传输,而接收端也应当能够经过某种机制实行解包还原出原来的结构体数据。python中的struct模块就提供了如此的编写制定,该模块的显要功能正是对python基本类型值与用python字符串格式表示的C
struct类型间的倒车(This module performs conversions between Python
values and C structs represented as Python
strings.)。stuct模块提供了很简短的多少个函数,下边写多少个例子。

 

struct模块提供了用于在字节字符串和Python原生数据类型之间转移函数,比如数字和字符串。

一. 模块函数和Struct类

  它除了提供一个Struct类之外,还有不少模块级的函数用于拍卖结构化的值。那里有个格式符(Format
specifiers)的定义,是指从字符串格式调换为已编写翻译的代表方式,类似周丽娟则表达式的处理格局。日常实例化Struct类,调用类方法来形成更改,比向来调用模块函数有效的多。上面包车型地铁事例都以利用Struct类。

该模块成效是完成Python数值和C语言结构体的Python字符串方式间的调换。那足以用来拍卖存款和储蓄在文件中或从互联网连接中存储的2进制数据,以及任何数据源。

利用struct.pack把1个整数值打包成字符串,张开Python命令行,输入:

模块函数和Struct类

它除了提供一个Struct类之外,还有诸多模块级的函数用于拍卖结构化的值。那里有个格式符(Format
specifiers)的概念,是指从字符串格式调换为已编写翻译的意味方式,类似张永琛则表明式的处理格局。平常实例化Struct类,调用类方法来完结退换,比一向调用模块函数有效的多。上面包车型地铁例证都以选拔Struct类。

2. Packing(打包)和Unpacking(解包)

  Struct支撑将数据packing(打包)成字符串,并能从字符串中逆向unpacking(解压)出多少。

  在本例中,格式钦赐器(specifier)必要二个整型或长整型,二个多个字节的string,和一个浮点数。格式符中的空格用于分隔各类提示器(indicators),在编译格式时会被忽略。

import struct

import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
s = struct.Struct('I 2s f')
packed_data = s.pack(*values)

print('原始值:', values)
print('格式符:', s.format)
print('占用字节:', s.size)
print('打包结果:', binascii.hexlify(packed_data))

# output
原始值: (1, b'ab', 2.7)
格式符: b'I 2s f'
占用字节: 12
打包结果: b'0100000061620000cdcc2c40'

  那几个示例将包装的值转换为十6进制字节类别,用binascii.hexlify()方法打字与印刷出来。

  使用unpack()主意解包。

import struct
import binascii

packed_data = binascii.unhexlify(b'0100000061620000cdcc2c40')

s = struct.Struct('I 2s f')
unpacked_data = s.unpack(packed_data)
print('解包结果:', unpacked_data)

# output
解包结果: (1, b'ab', 2.700000047683716)

  将包装的值传给unpack(),基本上重返同样的值(浮点数会大相径庭)。

用途: 在Python基本数据类型和2进制数据里面举办调换

 

Packing(打包)和Unpacking(解包)

Struct帮忙将数据packing(打包)成字符串,并能从字符串中逆向unpacking(解压)出多少。

在本例中,格式内定器(specifier)须求3个整型或长整型,一个两个字节的string,和一个浮点数。格式符中的空格用于分隔各样提示器(indicators),在编写翻译格式时会被忽略。

import struct

import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
s = struct.Struct('I 2s f')
packed_data = s.pack(*values)

print('原始值:', values)
print('格式符:', s.format)
print('占用字节:', s.size)
print('打包结果:', binascii.hexlify(packed_data))

# output
原始值: (1, b'ab', 2.7)
格式符: b'I 2s f'
占用字节: 12
打包结果: b'0100000061620000cdcc2c40'

以此示例将包裹的值调换为十六进制字节类别,用binascii.hexlify()主意打字与印刷出来。

使用unpack()艺术解包。

import struct
import binascii

packed_data = binascii.unhexlify(b'0100000061620000cdcc2c40')

s = struct.Struct('I 2s f')
unpacked_data = s.unpack(packed_data)
print('解包结果:', unpacked_data)

# output
解包结果: (1, b'ab', 2.700000047683716)

将包裹的值传给unpack(),基本上重返一样的值(浮点数会有距离)。

叁. 字节相继/大小/对齐

  私下认可情形下,pack是采用本地C库的字节顺序来编码的。格式化字符串的第3个字符可以用来代表填充数据的字节顺序、大小和对齐方式,如下表所描述的:

Character Byte order Size Alignment
@ 本地 本地 本地
= 本地 standard none
< little-endian(小字节序) standard none
> big-endian(大字节序) standard none
! network (= big-endian) standard none

  假如格式符中未有安装这几个,那么暗许将动用 @

  本地字节顺序是指字节顺序是由方今主机系统调控。比如:AMDx捌六和速龙64(x8陆-6肆)使用小字节序; HTC 67000和 PowerPC
G伍应用大字节序。ACR-VM和速龙安腾扶助切换字节序。能够接纳sys.byteorder翻开当前系统的字节顺序。

  本地大小(Size)和对齐(Alignment)是由c编写翻译器的sizeof表明式明显的。它与地方字节顺序对应。

  标准尺寸由格式符明显,上边会讲各样格式的标准尺寸。

示例:

import struct
import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
print('原始值  : ', values)

endianness = [
    ('@', 'native, native'),
    ('=', 'native, standard'),
    ('<', 'little-endian'),
    ('>', 'big-endian'),
    ('!', 'network'),
]

for code, name in endianness:
    s = struct.Struct(code + ' I 2s f')
    packed_data = s.pack(*values)
    print()
    print('格式符  : ', s.format, 'for', name)
    print('占用字节: ', s.size)
    print('打包结果: ', binascii.hexlify(packed_data))
    print('解包结果: ', s.unpack(packed_data))

# output
原始值  :  (1, b'ab', 2.7)

格式符  :  b'@ I 2s f' for native, native
占用字节:  12
打包结果:  b'0100000061620000cdcc2c40'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'= I 2s f' for native, standard
占用字节:  10
打包结果:  b'010000006162cdcc2c40'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'< I 2s f' for little-endian
占用字节:  10
打包结果:  b'010000006162cdcc2c40'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'> I 2s f' for big-endian
占用字节:  10
打包结果:  b'000000016162402ccccd'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'! I 2s f' for network
占用字节:  10
打包结果:  b'000000016162402ccccd'
解包结果:  (1, b'ab', 2.700000047683716)

struct模块提供了用来在字节字符串和Python原生数据类型之间转换函数,比如数字和字符串。

>>>import struct

字节顺序/大小/对齐

暗中认可景况下,pack是使用本地C库的字节顺序来编码的。格式化字符串的第二个字符能够用来代表填充数据的字节顺序、大小和对齐格局,如下表所描述的:

Character Byte order Size Alignment
@ 本地 本地 本地
= 本地 standard none
< little-endian(小字节序) standard none
> big-endian(大字节序) standard none
! network (= big-endian) standard none

若果格式符中未有安装这么些,那么私下认可将采纳 @

本地字节顺序是指字节顺序是由方今主机系统调控。比如:英特尔x捌六和英特尔64(x捌六-6四)使用小字节序; 一加 68000和 PowerPC
G伍应用大字节序。AWranglerM和英特尔安腾帮助切换字节序。能够选拔sys.byteorder翻开当前系统的字节顺序。

本土大小(Size)和对齐(阿里gnment)是由c编写翻译器的sizeof表明式明确的。它与地面字节顺序对应。

专业尺寸由格式符分明,下边会讲各样格式的科班尺寸。

示例:

import struct
import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
print('原始值  : ', values)

endianness = [
    ('@', 'native, native'),
    ('=', 'native, standard'),
    ('<', 'little-endian'),
    ('>', 'big-endian'),
    ('!', 'network'),
]

for code, name in endianness:
    s = struct.Struct(code + ' I 2s f')
    packed_data = s.pack(*values)
    print()
    print('格式符  : ', s.format, 'for', name)
    print('占用字节: ', s.size)
    print('打包结果: ', binascii.hexlify(packed_data))
    print('解包结果: ', s.unpack(packed_data))

# output
原始值  :  (1, b'ab', 2.7)

格式符  :  b'@ I 2s f' for native, native
占用字节:  12
打包结果:  b'0100000061620000cdcc2c40'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'= I 2s f' for native, standard
占用字节:  10
打包结果:  b'010000006162cdcc2c40'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'< I 2s f' for little-endian
占用字节:  10
打包结果:  b'010000006162cdcc2c40'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'> I 2s f' for big-endian
占用字节:  10
打包结果:  b'000000016162402ccccd'
解包结果:  (1, b'ab', 2.700000047683716)

格式符  :  b'! I 2s f' for network
占用字节:  10
打包结果:  b'000000016162402ccccd'
解包结果:  (1, b'ab', 2.700000047683716)

4. 格式符

格式符对照表如下:

Format C Type Python type Standard size Notes
x pad byte no value
c char bytes of length 1 1
b signed char integer 1 (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)
n ssize_t integer (4)
N size_t integer (4)
f float float 4 (5)
d double float 8 (5)
s char[] bytes
p char[] bytes
P void * integer (6)

模块函数和Struct类

 

Python中二进制数据处理模块struct使用,Python标准库笔记struct模块的选择。格式符

格式符对照表如下:

Format C Type Python type Standard size Notes
x pad byte no value
c char bytes of length 1 1
b signed char integer 1 (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)
n ssize_t integer (4)
N size_t integer (4)
f float float 4 (5)
d double float 8 (5)
s char[] bytes
p char[] bytes
P void * integer (6)

5. 缓冲区

  将数据打包成贰进制平时是用在对质量供给极高的光景。
在那类场景中得以因此制止为种种打包结构分配新缓冲区的支付来优化。
pack_into()unpack_from()措施援助直接写入预先分配的缓冲区。

import array
import binascii
import ctypes
import struct

s = struct.Struct('I 2s f')
values = (1, 'ab'.encode('utf-8'), 2.7)
print('原始值:', values)

print()
print('使用ctypes模块string buffer')

b = ctypes.create_string_buffer(s.size)
print('原始buffer  :', binascii.hexlify(b.raw))
s.pack_into(b, 0, *values)
print('打包结果写入 :', binascii.hexlify(b.raw))
print('解包        :', s.unpack_from(b, 0))

print()
print('使用array模块')

a = array.array('b', b'\0' * s.size)
print('原始值   :', binascii.hexlify(a))
s.pack_into(a, 0, *values)
print('打包写入 :', binascii.hexlify(a))
print('解包     :', s.unpack_from(a, 0))

# output
原始值: (1, b'ab', 2.7)

使用ctypes模块string buffer
原始buffer  : b'000000000000000000000000'
打包结果写入 : b'0100000061620000cdcc2c40'
解包        : (1, b'ab', 2.700000047683716)

使用array模块
原始值   : b'000000000000000000000000'
打包写入 : b'0100000061620000cdcc2c40'
解包     : (1, b'ab', 2.700000047683716)

首发地址: Python标准库笔记(6) —
struct模块

它除了提供3个Struct类之外,还有诸多模块级的函数用于拍卖结构化的值。那里有个格式符(Format
specifiers)的定义,是指从字符串格式调换为已编写翻译的代表方式,类似李晓明则表达式的处理格局。常常实例化Struct类,调用类方法来变成改换,比一贯调用模块函数有效的多。上面包车型大巴事例都以使用Struct类。

>>> a =0x01020304

缓冲区

将数据打包成2进制平日是用在对质量须要异常高的光景。
在那类场景中可以透过防止为各样打包结构分配新缓冲区的开拓来优化。
pack_into()unpack_from()方式帮忙直接写入预先分配的缓冲区。

import array
import binascii
import ctypes
import struct

s = struct.Struct('I 2s f')
values = (1, 'ab'.encode('utf-8'), 2.7)
print('原始值:', values)

print()
print('使用ctypes模块string buffer')

b = ctypes.create_string_buffer(s.size)
print('原始buffer  :', binascii.hexlify(b.raw))
s.pack_into(b, 0, *values)
print('打包结果写入 :', binascii.hexlify(b.raw))
print('解包        :', s.unpack_from(b, 0))

print()
print('使用array模块')

a = array.array('b', b'\0' * s.size)
print('原始值   :', binascii.hexlify(a))
s.pack_into(a, 0, *values)
print('打包写入 :', binascii.hexlify(a))
print('解包     :', s.unpack_from(a, 0))

# output
原始值: (1, b'ab', 2.7)

使用ctypes模块string buffer
原始buffer  : b'000000000000000000000000'
打包结果写入 : b'0100000061620000cdcc2c40'
解包        : (1, b'ab', 2.700000047683716)

使用array模块
原始值   : b'000000000000000000000000'
打包写入 : b'0100000061620000cdcc2c40'
解包     : (1, b'ab', 2.700000047683716)

博客原著:

Packing(打包)和Unpacking(解包)

 

Struct援救将数据packing(打包)成字符串,并能从字符串中逆向unpacking(解压)出多少。

>>> str= struct.pack(“I”, a)

在本例中,格式钦定器(specifier)供给二个整型或长整型,一个四个字节的string,和1个浮点数。格式符中的空格用于分隔各样提醒器(indicators),在编写翻译格式时会被忽视。

 

import struct

import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
s = struct.Struct('I 2s f')
packed_data = s.pack(*values)

print('原始值:', values)
print('格式符:', s.format)
print('占用字节:', s.size)
print('打包结果:', binascii.hexlify(packed_data))

>>>repr(str)

# output
原始值: (1, b’ab’, 2.7)
格式符: b’I 2s f’
攻克字节: 1二
包装结果: b’0一千000616两千0cdcc二c40′

 

其1示例将包装的值转换为十陆进制字节体系,用binascii.hexlify()方法打字与印刷出来。

“‘\\x04\\x03\\x02\\x01′”

应用unpack()方法解包。

 

import struct
import binascii

packed_data = binascii.unhexlify(b'0100000061620000cdcc2c40')

s = struct.Struct('I 2s f')
unpacked_data = s.unpack(packed_data)
print('解包结果:', unpacked_data)

那时候,str为三个字符串,字符串中的内容与整数a的二进制存款和储蓄的内容壹律。

# output
解包结果: (壹, b’ab’, 贰.800000047683716)

 

将包裹的值传给unpack(),基本上重临同样的值(浮点数会有差异)。

 

字节顺序/大小/对齐

 

暗许情状下,pack是接纳本地C库的字节顺序来编码的。格式化字符串的第五个字符能够用来代表填充数据的字节顺序、大小和对齐格局,如下表所描述的:

接纳struct.unpack把字符串解包成整数类型,如下:

Character Byte order Size Alignment
@ 本地 本地 本地
= 本地 standard none
< little-endian(小字节序) standard none
> big-endian(大字节序) standard none
! network (= big-endian) standard none

 

假定格式符中未有安装这几个,那么默许将动用 @。

>>> b =struct.unpack(“I”, str)

地点字节顺序是指字节顺序是由如今主机系统调节。比如:英特尔x八陆和AMD6四(x86-64)使用小字节序; 魅族 6七千和 PowerPC
G5运用大字节序。A奇骏M和速龙安腾协理切换字节序。能够选拔sys.byteorder查看当前系统的字节顺序。

 

本土大小(Size)和对齐(Alignment)是由c编写翻译器的sizeof表明式明确的。它与地点字节顺序对应。

>>> b

正规尺寸由格式符鲜明,上边会讲各种格式的正儿八经尺寸。

 

示例:

(16909060,)

import struct
import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
print('原始值 : ', values)

endianness = [
 ('@', 'native, native'),
 ('=', 'native, standard'),
 ('<', 'little-endian'),
 ('>', 'big-endian'),
 ('!', 'network'),
]

for code, name in endianness:
 s = struct.Struct(code + ' I 2s f')
 packed_data = s.pack(*values)
 print()
 print('格式符 : ', s.format, 'for', name)
 print('占用字节: ', s.size)
 print('打包结果: ', binascii.hexlify(packed_data))
 print('解包结果: ', s.unpack(packed_data))

 

# output
原始值  :  (1, b’ab’, 2.7)

格式符  :  b’@ I 2s f’ for native, native
侵吞字节:  1贰
卷入结果:  b’0一千000616三千0cdcc二c40′
解包结果:  (一, b’ab’, 二.80000004768371六)

格式符  :  b’= I 2s f’ for native, standard
攻下字节:  十
包裹结果:  b’0一千000616二cdcc二c40′
解包结果:  (1, b’ab’, 二.70000004768371六)

格式符  :  b'< I 2s f’ for little-endian
攻克字节:  10
包装结果:  b’0一千000616贰cdcc二c40′
解包结果:  (一, b’ab’, 二.七千00047683716)

格式符  :  b’> I 2s f’ for big-endian
占用字节:  10
包裹结果:  b’000000016162402ccccd’
解包结果:  (壹, b’ab’, 贰.70000004768371陆)

格式符  :  b’! I 2s f’ for network
侵占字节:  拾
包装结果:  b’00000001616240二ccccd’
解包结果:  (1, b’ab’, 2.捌仟0004768371陆)

在解包之后,再次回到二个元组类型(tuple)的数目。

格式符

 

格式符对照表如下:

假使四个数据实行李包裹装,能够在格式中钦定打包的数据类型,然后数据通过参数字传送入:

Format C Type Python type Standard size Notes
x pad byte no value
c char bytes of length 1 1
b signed char integer 1 (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)
n ssize_t integer (4)
N size_t integer (4)
f float float 4 (5)
d double float 8 (5)
s char[] bytes
p char[] bytes
P void * integer (6)

 

缓冲区

>>> a =”hello”

将数据打包成贰进制经常是用在对品质供给非常高的风貌。

 

在那类场景中得以经过幸免为种种打包结构分配新缓冲区的费用来优化。

>>> b =”world!”

pack_into()和unpack_from()方法接济直接写入预先分配的缓冲区。

 

import array
import binascii
import ctypes
import struct

s = struct.Struct('I 2s f')
values = (1, 'ab'.encode('utf-8'), 2.7)
print('原始值:', values)

print()
print('使用ctypes模块string buffer')

b = ctypes.create_string_buffer(s.size)
print('原始buffer :', binascii.hexlify(b.raw))
s.pack_into(b, 0, *values)
print('打包结果写入 :', binascii.hexlify(b.raw))
print('解包  :', s.unpack_from(b, 0))

print()
print('使用array模块')

a = array.array('b', b'\0' * s.size)
print('原始值 :', binascii.hexlify(a))
s.pack_into(a, 0, *values)
print('打包写入 :', binascii.hexlify(a))
print('解包  :', s.unpack_from(a, 0))

>>> c =2

# output
原始值: (1, b’ab’, 2.7)

使用ctypes模块string buffer
原始buffer  : b’000000000000000000000000′
包裹结果写入 : b’0一千000616两千0cdcc二c40′
解包        : (1, b’ab’, 2.700000047683716)

使用array模块
原始值   : b’000000000000000000000000′
打包写入 : b’0一千00061630000cdcc二c40′
解包     : (1, b’ab’, 2.700000047683716)

 

以上正是本文的全体内容,希望对我们的读书抱有支持,也愿意我们多多援助脚本之家。

>>> d =45.123

你或然感兴趣的稿子:

  • Python中struct模块对字节流/二进制流的操作教程
  • 在Python的struct模块中展开数据格式调换的不二法门
  • 一言以蔽之介绍Python中的struct模块
  • Python struct模块解析

 

>>> str= struct.pack(“5s6sif”, a, b, c, d)

 

等价于: struct.pack_into(“5s6sif”,str,  0, a, b, c, d)

 

>>> str

 

‘helloworld!\x00\x02\x00\x00\x00\xf4}4B’

 

解包八个数据能够如此做:

 

>>>parts = struct.unpack(“5s6sif”, str)

 

等价于:  struct.unpack_from(“5s6sif”, str, 0)

 

>>>parts

 

(‘hello’,’world威尼斯人线上娱乐,!’, 2, 45.12300109863281)

 

从上得以见见浮点值在解包后与原来值不平等,那是因为浮点数的精度难题产生的。

 

struct模块中二进制格式化表示

 

格式

 C类型

 Python类型

 字节数

 

x

 填充字节

 无值

 1

 

c

 char

 长度为一的字符串

 1

 

b

 signed char

 整型

 1

 

B

 unsigned char

 整型

 1

 

?

 _bool

 bool

 1

 

h

 short

 整型

 2

 

H

 unsigned short

 整型

 2

 

i

 Int

 整型

 4

 

I

 Unsigned int

 整型

 4

 

l

 Long

 整型

 4

 

L

 Unsigned long

 整型

 4

 

q

 Long long 

 整型

 8

 

Q

 Unsigned long long 

 整型

 8

 

f

 float

 浮点数

 4

 

d

 double

 浮点数

 8

 

s

 Char[]

 字符串

 1

 

p

 Char[]

 字符串

 1

 

P

 Void *

 long

 4

 

 

最后三个方可用来代表指针类型,占四个字节(三十四人),8个字节(陆拾陆个人)。

 

为了在与不一致硬件结构之间沟通数据,供给怀恋字节序,如下:

 

字符

 字节序

 大小和对齐

 

@

 本机字节序

 本机,本机四字节对齐

 

=

 本机字节序

 标准,按原字节数对齐

 

 小尾字节序

 标准,按原字节数对齐

 

 大尾字节序

 标准,按原字节对齐

 

!

 互连网字节序(大尾)

 标准,按原字节对齐

 

 

注:缺省的景色下,使用本机字节序(同@),能够通过上面的字符修改字节序。

 

算算格式字符串的轻重函数:struct.calcsize(fmt)

 

>>>struct.calcsize(“ihi”)                      
缺省为4字节对齐时,长度为1贰

 

12

 

>>>struct.calcsize(“iih”)                          
 当h在最终的时(此时不四字节对齐),长度为十

 

10

 

>>>struct.calcsize(“@ihi”)

 

12

 

>>>struct.calcsize(“=ihi”)

 

10

 

>>>struct.calcsize(“>ihi”)

 

10

 

>>>struct.calcsize(“<ihi”)

 

10

 

>>>struct.calcsize(“!ihi”)

 

10

 

注:贰进制文件展开/读取的时候供给使用“rb”/“wb”情势以二进制格局打开/读取文件。

 

注:关于LE(little-endian)和BE(big-endian)区别:

 

LE—最适合人的构思的字节序,地址低位存款和储蓄值的低位,地址高位存款和储蓄值的要职。

 

BE—最直观的字节序,地址低位存款和储蓄值的高位,地址高位存款和储蓄值的低位。

 

例如:双字0X01020304在内存中存款和储蓄方式,LE=040叁 0二 01,BE=0一 0二 0叁 0肆。

 

 

 


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图