Conteúdo
- 1. Usando o módulo de estruturação. Dados binários embalados
- 2. Os métodos básicos do módulo estruturante
- 2.1. Os métodos embalar() e desempacotar(). Embalagem e desempacotamento de dados
- 2.2. O método calcsize(). O tamanho do objecto embalado
- 3. cordas formatadas
- 3.1. Definir ordem de bytes, tamanho e alinhamento com base no carácter do formato
- 3.2. Exemplos de cordas formatadas para diferentes tipos de dados
- Tópicos relacionados
Procura outros websites:
br>>>>h5>1. Usando o módulo estrutural. Dados binários embalados
O módulo estrutural Python é utilizado para criar e puxar dados binários embalados a partir de cordas. No módulo estrutural, os bytes de dados são interpretados como dados binários embalados que podem ser representados por objectos do tipo bytes ou bytearray.
O módulo contém ferramentas de conversão entre valores Python e estruturas C, que são representados como objectos de bytes Python. Tais conversões são usadas no processamento de dados binários que são armazenados em ficheiros ou obtidos a partir de ligações de rede, etc.
Para fornecer uma descrição compacta das estruturas em C e conversão para valores (de valores) de Python, são usadas strings de formato.
⇑
2. Os métodos básicos do módulo estrutural
O módulo estrutural contém vários métodos básicos que podem ser usados para embalar e desempacotar dados.
2.1. Os métodos embalar() e desempacotar(). Embalar e desempacotar dados
Para embalar e desempacotar dados, são utilizados os métodos pack(), unpack(). O processo de embalagem/desembalagem é implementado de acordo com a cadeia de formatos.
De acordo com a documentação, a forma geral de usar o método pack() é a seguinte
obj = struct.pack(format, v1, v2, ...)
where
- formato – cadeia de formatos. Esta linha é formada de acordo com as regras estabelecidas nas tabelas (ver parágrafo 3);
- v1, v2, … – valores (objectos) a embalar;
- obj – objecto binário embalado.
A função desempacotar() executa a operação inversa da embalagem(). Permite obter o objecto de origem com base no objecto embalado. A forma geral de utilização da função é a seguinte:
obj = struct.unpack(format, buffer)
here
- buffer – um buffer no qual é escrito um objecto que foi anteriormente embalado pela função pack(). O tamanho deste objecto deve corresponder ao tamanho especificado no formato;
- formato – uma string de formato baseada na qual um objecto binário desempacotado é obtido;
- obj – o objecto resultante, que pode ser uma lista, um tuple, um conjunto, um dicionário, etc.
Ao chamar a função unpack(), a string de formato deve corresponder à mesma string que foi especificada pela função pack().
Exemplo. Para efeitos de demonstração, a embalagem/desembalagem da lista de números é efectuada.
# Module struct. Methods pack(), unpack()# Pack/unpack list of numbers# 1. Specified list of numbersLS = # 2. Include module structimport struct# 3. Pack list of numbers. Method pack()pack_obj = struct.pack('>4і', LS, LS, LS, LS)# 4. Display the object pack_objprint('pack_obj = ', pack_obj)# 5. Unpack list of numbers. Method unpack().# The result is a tuple T2T2 = struct.unpack('>4і', pack_obj) # T2 = (1, 3, 9, 12)# 6. Print the unpacked object T2print('T2 = ', T2)# 7. Convert tuple T2 to list LS2LS2 = list(T2) # LS2 = # 8. Display the list LS2print('LS2 = ', LS2)
o resultado do programa
pack_obj = b'\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\t\x00\x00\x00\x0c'T2 = (1, 3, 9, 12)LS2 =
⇑
2.2. Método calcsize(). O tamanho do objecto embalado
O método calcsize() devolve o tamanho do objecto criado pelo método pack().
Exemplo.
# Module struct.# Method calcsize(). Determine the size of the packed object# 1. Include module structimport struct# 2. Determine the size of a packed list of numbers# 2.1. Specified list of floating point numbersLS = # 2.2. Pack list LS. Method pack()pack_obj = struct.pack('>3f', LS, LS, LS)# 2.3. Display the packed object pack_objprint('pack_obj = ', pack_obj)# 2.4. Display the size of pack_objsize = struct.calcsize('>3f') # size = 12print('size = ', size)# 3. Determine the size of a packed tuple of strings# 3.1. The specified tuple of two stringsTS = ( 'Hello', 'abcd')# 3.2. Pack the tuple TSpack_obj = struct.pack('<5s4s', TS.encode(), TS.encode())# 3.3. Display the packed objectprint('pack_obj = ', pack_obj)# 3.4. Display the size of packed tuplesize = struct.calcsize('<5s4s') # size = 9print('size = ', size)
O resultado do programa
pack_obj = b'@8Q\xec@y\x99\x9a\xc1(\x00\x00'size = 12pack_obj = b'Helloabcd'size = 9
⇑
3. Cordas formatadas
3.1. Definir ordem de bytes, tamanho e alinhamento com base no carácter de formato
Em Python, a forma como uma cadeia de caracteres é embalada é determinada com base no primeiro carácter da cadeia de formato. Este símbolo define:
- a ordem dos bytes, que é formada utilizando os caracteres @, =, <>, ! Se este parâmetro não for especificado, o símbolo @ é aceite;
- o tamanho em bytes de dados embalados. Neste caso, os números que indicam o número são utilizados primeiro;
- alinhamento, que é definido pelo sistema.
De acordo com a documentação Python na cadeia de formato, a ordem dos bytes, tamanho e alinhamento são formados de acordo com o primeiro caractere do formato. Os possíveis primeiros caracteres do formato são mostrados na tabela seguinte.
Caracter | Por ordem de byte | Size | Alinhamento |
@ | nativo (dependente do hospedeiro) | Nativo | Nativo |
nativo | standard | none | |
< | little-endian | standard | none |
> | big-endian | none | |
! | network (= big-endian) | none |
Um valor de ordem de bytes pode ser um de 4:
- ordem nativa. Esta ordem pode ser ou little-endian ou big-endian. Esta ordem é determinada pelo sistema hospedeiro;
- ordem do tipo little-endian. Nesta ordem, o byte baixo é processado primeiro, e depois o byte alto;
- ordem do tipo big-endian. Neste caso, o byte alto é processado primeiro, e depois o byte baixo;
- ordem de rede, que não corresponde à ordem big-endiana.
O tamanho dos dados embalados pode ser uma de duas coisas:
- nativo – definido usando o tamanho das instruções do compilador C;
- padrão – é determinado com base no carácter do formato de acordo com a tabela abaixo.
Tabela. Definição do tamanho padrão dos dados embalados dependendo do carácter do formato
Format | C Tipo | Python Tipo | tamanho padrão |
x | pad byte | sem valor | |
c | char | bytes de comprimento 1 | 1 |
b | signed char | integer | 1 |
B | unsigned char | integer | 1 |
? | _Bool | bool | 1 | h | short | integer | 2 |
H | unsigned short | integer | 2 |
i | int | integer | 4 |
I | unigned int | integer | 4 |
l | long | integer | 4 |
L | longa não assinada | integer | 4 |
q | longo prazo | integer | 8 |
Q | longa não assinada | integer | 8 |
n | ssize_t | integer | |
N | size_t | integer | |
e | float (exponential format) | float | 2 |
f | float | float | 4 | d | double | float | 8 |
s | char | bytes | |
p | char | bytes | |
P | void* | integer |