De strukturmodul i Python lar deg jobbe med binære data ved å tilby funksjonalitet for å konvertere mellom Python-verdier og C-stil binære data. Dette er spesielt nyttig når du arbeider med binære filformater eller nettverksprotokoller. Dens nøkkelfunksjoner inkluderer:

• Pakking konvertere Python-verdier til binære data (bytes).
• Pakker ut konvertere binære data tilbake til Python-verdier.
• Formater strenger definere hvordan data pakkes/pakkes ut ved hjelp av formatkoder (f.eks. i for heltall f for flyter).

Metoder i struct.pack()

1.Struct.pack(): Den konverterer Python-verdier til et pakket binært format. Formatstrengen (fmt) spesifiserer utformingen av de pakkede dataene og de påfølgende verdiene (v1 v2 ...) er pakket i henhold til dette formatet. Syntaks:

struct.pack(fmt v1 v2 ...)

• fmt : En formatstreng som spesifiserer hvordan dataene skal pakkes.
• v1 v2 ...: Verdiene som vil bli pakket i henhold til det angitte 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'  

Forklaring: 'hhl' betyr to korte heltall (h 2 byte hver) etterfulgt av et langt (l vanligvis 4 eller 8 byte avhengig av plattform). 'iii' pakker tre 4-byte heltall. Utgangen er i byte (b'') som representerer den binære kodingen av verdiene.

2.struct.unpack(): Den konverterer pakkede binære data tilbake til Python-verdier. Den tar en formatstreng (fmt) og en pakket binær streng og returnerer en tuppel med upakkede verdier. Syntaks:

struct.unpack(fmt-streng)

• fmt: En formatstreng som spesifiserer hvordan dataene skal pakkes ut.
• streng: De pakkede binære dataene som må pakkes ut.

   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)  

Forklaring: Dette eksemplet pakker først en boolsk (?) en kort (h) et heltall (i) og en lang (l) i byte. Deretter brukes struct.unpack() til å konvertere den tilbake til Python-verdier. Den andre delen pakker et langt langt heltall (q) og en float (f) og pakker dem deretter ut igjen. Legg merke til hvordan 2.3 blir 2.299999952... på grunn av flytpresisjon.

3. struct.calcsize(): Den returnerer størrelsen (i byte) til en struktur som tilsvarer formatstrengen. Det er nyttig for å bestemme hvor mye plass som kreves for å lagre pakket data. Syntaks:

struct.calcsize(fmt)

• fmt: En formatstreng som spesifiserer dataoppsettet.

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

16 12  

Forklaring: '?hil' krever 16 byte og 'qf' trenger 12 byte avhengig av justering og plattform.

4. struct.pack_into() og struct.unpack_from(): Disse metodene lar deg pakke og pakke ut data direkte inn i/fra en buffer som starter med en gitt offset. Disse er spesielt nyttige når du arbeider med forhåndstildelte minnebuffere eller når du arbeider med binære data lagret i minnet.

Syntaks for struct.pack_into():

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

• fmt: En formatstreng som spesifiserer dataoppsettet.
• buffer: En skrivbar buffer (f.eks. ctypes.create_string_buffer).
• offset: Startposisjonen i bufferen der pakkingen begynner.
• v1 v2 ...: Verdiene som skal pakkes inn i bufferen.

Syntaks for struct.unpack_from():

struct.unpack_from(fmt buffer offset=0)

• fmt: En formatstreng som spesifiserer dataoppsettet.
• buffer: Bufferen som inneholder de pakkede dataene.
• offset: Startposisjonen der utpakkingen begynner (valgfritt)

   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)  

Forklaring: Her lages en buffer ved hjelp av ctypes. struct.pack_into() setter inn verdiene i denne bufferen med spesifisert offset (0 i dette tilfellet). struct.unpack_from() leser deretter dataene tilbake fra bufferen.

Effekt av formatrekkefølge

Rekkefølgen på formattegn kan endre den pakkede utgangen på grunn av utfylling og justering. Dette påvirker både byteinnholdet og størrelsen 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  

Forklaring: 'bi' (byte int) kan inkludere utfylling etter byten mens 'ib' (int byte) trenger det ikke. Størrelsesforskjellen (8 vs 5) viser hvordan justering påvirker minneoppsettet.

Håndteringsfeil

Hvis feil datatype brukes med struct.pack() oppstår det en struct.error. Bruk prøve-unntatt for å håndtere slike saker trygt.

   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  }  '  )   

Produksjon

 Struct Error: required argument is not an integer   
 
    Forklaring:    Dette viser feilhåndtering ved bruk av struct. 'h' forventer et kort heltall, men en streng ('ugyldig') er gitt som forårsaker en struct.error. Prøv-unntatt-blokken fanger opp feilen og skriver ut en meningsfull melding.  
 
 Referanse    https://docs.python.org/2/library/struct.html    
         Lag quiz