De strukturmodul i Python giver dig mulighed for at arbejde med binære data ved at tilbyde funktionalitet til at konvertere mellem Python-værdier og binære data i C-stil. Dette er især nyttigt, når du har at gøre med binære filformater eller netværksprotokoller. Dets nøglefunktioner inkluderer:

• Pakning konverter Python-værdier til binære data (bytes).
• Udpakning konverter binære data tilbage til Python-værdier.
• Formater strenge definere, hvordan data pakkes/udpakkes ved hjælp af formatkoder (f.eks. i for heltal f for flydende).

Metoder i struct.pack()

1.Struct.pack(): Det konverterer Python-værdier til et pakket binært format. Formatstrengen (fmt) angiver layoutet af de pakkede data, og de efterfølgende værdier (v1 v2 ...) pakkes i henhold til dette format. Syntaks:

struct.pack(fmt v1 v2 ...)

• fmt : En formatstreng, der specificerer, hvordan dataene vil blive pakket.
• v1 v2...: Værdierne, der vil blive pakket i henhold til det angivne format.

   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' betyder to korte heltal (h 2 bytes hver) efterfulgt af et langt (l normalt 4 eller 8 bytes afhængig af platform). 'iii' pakker tre 4-byte heltal. Outputtet er i bytes (b''), der repræsenterer den binære kodning af værdierne.

2.struct.unpack(): Det konverterer pakkede binære data tilbage til Python-værdier. Det tager en formatstreng (fmt) og en pakket binær streng og returnerer en tuple af upakkede værdier. Syntaks:

struct.unpack(fmt-streng)

• fmt: En formatstreng, der angiver, hvordan dataene skal pakkes ud.
• snor: De pakkede binære data, der skal pakkes ud.

   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 eksempel pakker først en boolesk (?) en kort (h) et heltal (i) og en lang (l) i bytes. Derefter bruges struct.unpack() til at konvertere det tilbage til Python-værdier. Den anden del pakker et langt langt heltal (q) og en float (f) og pakker dem derefter ud. Bemærk hvordan 2.3 bliver til 2.299999952... på grund af flydepræcision.

3. struct.calcsize(): Det returnerer størrelsen (i bytes) af en struktur svarende til formatstrengen. Det er nyttigt til at bestemme, hvor meget plads der kræves for at gemme pakket data. Syntaks:

struct.calcsize(fmt)

• fmt: En formatstreng, der specificerer datalayoutet.

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

16 12  

Forklaring: '?hil' kræver 16 bytes og 'qf' har brug for 12 bytes afhængig af justering og platform.

4. struct.pack_into() og struct.unpack_from(): Disse metoder giver dig mulighed for direkte at pakke og udpakke data ind i/fra en buffer, der starter med en given offset. Disse er især nyttige, når du har at gøre med præ-allokerede hukommelsesbuffere, eller når du arbejder med binære data, der er gemt i hukommelsen.

Syntaks for struct.pack_into():

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

• fmt: En formatstreng, der angiver datalayoutet.
• buffer: En skrivbar buffer (f.eks. ctypes.create_string_buffer).
• offset: Startpositionen i bufferen, hvor pakningen begynder.
• v1 v2 ...: Værdierne, der skal pakkes i bufferen.

Syntaks for struct.unpack_from():

struct.unpack_from(fmt buffer offset=0)

• fmt: En formatstreng, der angiver datalayoutet.
• buffer: Bufferen, der indeholder de pakkede data.
• offset: Udgangspositionen, hvorfra udpakningen begynder (valgfrit)

   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 oprettes en buffer ved hjælp af ctypes. struct.pack_into() indsætter værdierne i denne buffer ved den angivne offset (0 i dette tilfælde). struct.unpack_from() læser derefter data tilbage fra bufferen.

Effekt af formatrækkefølge

Rækkefølgen af ​​formattegn kan ændre det pakkede output på grund af polstring og justering. Dette påvirker både byteindholdet og størrelsen af ​​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 omfatte polstring efter byten, mens 'ib' (int byte) har ikke brug for det. Størrelsesforskellen (8 vs 5) viser, hvordan justering påvirker hukommelseslayoutet.

Håndteringsfejl

Hvis den forkerte datatype bruges med struct.pack(), opstår der en struct.error. Brug try-undtagen for at håndtere sådanne sager sikkert.

   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   
 
    Forklaring:    Dette viser fejlhåndtering ved brug af struct. 'h' forventer et kort heltal, men en streng ('ugyldig') er givet, hvilket forårsager en struct.error. Prøv-undtagen-blokken fanger fejlen og udskriver en meningsfuld meddelelse.  
 
 Reference    https://docs.python.org/2/library/struct.html    
         Opret quiz