De strukturmodul i Python låter dig arbeta med binär data genom att tillhandahålla funktionalitet för att konvertera mellan Python-värden och binär data i C-stil. Detta är särskilt användbart när du hanterar binära filformat eller nätverksprotokoll. Dess nyckelfunktioner inkluderar:

• Förpackning konvertera Python-värden till binära data (byte).
• Uppackning konvertera binära data tillbaka till Python-värden.
• Formatera strängar definiera hur data packas/packas upp med hjälp av formatkoder (t.ex. i för heltal f för flytande).

Metoder i struct.pack()

1.Struct.pack(): Den konverterar Python-värden till ett packat binärt format. Formatsträngen (fmt) anger layouten för packad data och de efterföljande värdena (v1 v2 ...) packas enligt detta format. Syntax:

struct.pack(fmt v1 v2 ...)

• fmt : En formatsträng som anger hur data ska packas.
• v1 v2...: Värdena som kommer att packas enligt det angivna formatet.

import struct # pack values into binary var = struct.pack('hhl' 1 2 3) print(var) var = struct.pack('iii' 1 2 3) print(var) 

b'x01x00x02x00x00x00x00x00x03x00x00x00x00x00x00x00' b'x01x00x00x00x02x00x00x00x03x00x00x00' 

Förklaring: 'hhl' betyder två korta heltal (h 2 byte vardera) följt av ett långt (l vanligtvis 4 eller 8 byte beroende på plattform). 'iii' packar tre 4-byte heltal. Utdata är i byte (b'') som representerar den binära kodningen av värdena.

2.struct.unpack(): Det konverterar packad binär data tillbaka till Python-värden. Det tar en formatsträng (fmt) och en packad binär sträng och returnerar en tuppel av uppackade värden. Syntax:

struct.unpack(fmt sträng)

• fmt: En formatsträng som anger hur data ska packas upp.
• sträng: Den packade binära data som måste packas upp.

import struct var = struct.pack('?hil' True 2 5 445) print(var) tup = struct.unpack('?hil' var) print(tup) var = struct.pack('qf' 5 2.3) print(var) tup = struct.unpack('qf' var) print(tup) 

b'x01x00x02x00x05x00x00x00xbdx01x00x00x00x00x00x00' (True 2 5 445) b'x05x00x00x00x00x00x00x0033x13@' (5 2.299999952316284) 

Förklaring: Detta exempel packar först ett booleskt (?) ett kort (h) ett heltal (i) och ett långt (l) i byte. Sedan används struct.unpack() för att konvertera tillbaka det till Python-värden. Den andra delen packar ett långt långt heltal (q) och en float (f) packar sedan upp dem tillbaka. Notera hur 2.3 blir 2.299999952... på grund av flytprecision.

3. struct.calcsize(): Den returnerar storleken (i byte) på en struktur som motsvarar formatsträngen. Det är användbart för att avgöra hur mycket utrymme som krävs för att lagra packad data. Syntax:

struct.calcsize(fmt)

• fmt: En formatsträng som anger datalayouten.

import struct print(struct.calcsize('?hil')) print(struct.calcsize('qf')) 

16 12 

Förklaring: '?hil' kräver 16 byte och 'qf' behöver 12 byte beroende på justering och plattform.

4. struct.pack_into() och struct.unpack_from(): Dessa metoder låter dig packa och packa upp data direkt in i/från en buffert med början vid en given offset. Dessa är särskilt användbara när man hanterar förallokerade minnesbuffertar eller när man arbetar med binära data lagrade i minnet.

Syntax för struct.pack_into():

struct.pack_into(fmt buffer offset v1 v2 ...)

• fmt: En formatsträng som anger datalayouten.
• buffert: En skrivbar buffert (t.ex. ctypes.create_string_buffer).
• offset: Startpositionen i bufferten där packningen börjar.
• v1 v2 ...: Värdena som ska packas i bufferten.

Syntax för struct.unpack_from():

struct.unpack_from(fmt buffer offset=0)

• fmt: En formatsträng som anger datalayouten.
• buffert: Bufferten som innehåller den packade datan.
• offset: Startpositionen där uppackningen börjar (valfritt)

import struct import ctypes # Allocate buffer size = struct.calcsize('hhl') buff = ctypes.create_string_buffer(size) # Pack into buffer struct.pack_into('hhl' buff 0 2 2 3) # Unpack from buffer res = struct.unpack_from('hhl' buff 0) print(res) 

(2 2 3) 

Förklaring: Här skapas en buffert med hjälp av ctypes. struct.pack_into() infogar värdena i denna buffert med angiven offset (0 i detta fall). struct.unpack_from() läser sedan tillbaka data från bufferten.

Effekt av formatordning

Ordningen på formattecken kan ändra den packade utdatan på grund av utfyllnad och justering. Detta påverkar både byteinnehållet och storleken på resultatet.

import struct var = struct.pack('bi' 56 0x12131415) print(var) print(struct.calcsize('bi')) var = struct.pack('ib' 0x12131415 56) print(var) print(struct.calcsize('ib')) 

b'8x00x00x00x15x14x13x12' 8 b'x15x14x13x128' 5 

Förklaring: 'bi' (byte int) kan inkludera utfyllnad efter byten medan 'ib' (int byte) behöver det inte. Storleksskillnaden (8 vs 5) visar hur justeringen påverkar minneslayouten.

Hanteringsfel

Om fel datatyp används med struct.pack() uppstår en struct.error. Använd försök-utom för att hantera sådana fall säkert.

import struct try: struct.pack('h' 'invalid') # Wrong type 'invalid' is a string but 'h' expects an integer except struct.error as e: print(f'Struct Error: {e}') 

Produktion

Struct Error: required argument is not an integer  

Förklaring: Detta visar felhantering vid användning av struct. 'h' förväntar sig ett kort heltal men en sträng ('ogiltig') ges som orsakar en struct.error. Prova-utom-blocket fångar felet och skriver ut ett meningsfullt meddelande.

Hänvisning https://docs.python.org/2/library/struct.html