Pack, unpack of the Python:struct module

Source: Internet
Author: User
Tags function prototype unpack knowledge base

mport struct

Pack, unpack, Pack_into, Unpack_from

 1 # ref:http://blog.csdn<a href= "http://lib.csdn.net/base/dotnet" class= ' Replace_word ' title= ". NET Knowledge Base "target= ' _blank ' style= ' color: #df3434; Font-weight:bold; ' >.net</a>/jgood/archive/2009/06/22/4290158.aspx 2 3 Import struct 4 5 #pack-unpack 6 Print 7 Prin T ' ===== pack-unpack ===== ' 8 9 str = struct.pack ("II", +--) print ' str: ', str-print ' Len (str): ', Len (s   TR) # len (str): 8 a1, a2 = Struct.unpack ("II", str) print "A1:", A1 # A1:20 print "A2:", A2 # a2:400 print ' struct.calcsize: ', Struct.calcsize ("II") # Struct.calcsize:8 #unpack print ' ===== Unpack ===== ' (string = ' Test astring ') format = ' 5s 4x 3s ' Print struct.unpack (format, String) # (' t  Est ', ' ing '), string = ' He is not very happy ', format = ' 2s 1x 2s 5x 4s 1x 5s ' Print struct.unpack (format, String) # (' He ', ' is ', ' very ', ' happy ') #pack the print ' ===== pack ===== ' 36  PNS a = [+] b = [8] str = struct.pack ("II", A, b) print ' Length: ', Len (str) #length: 43 Print str Print repr (str) # '/x14/x00/x00/x00/x90/x01/x00/x00 ' in #pack_into-unpack_from print ' ===== PAC K_into-unpack_from ===== ' from ctypes import create_string_buffer (buf = create_string_buffer) Print Repr (Buf.raw) Struct.pack_into ("III", BUF, 0, 1, 2,-1) Print repr (Buf.raw)   ("III", BUF, 0)

Operation Result:

[Email protected] python]$ Python struct_pack.py

===== Pack-unpack =====
Str:?
Len (str): 8
A1:20
a2:400
Struct.calcsize:8

===== Unpack =====
(' test ', ' ing ')
(' He ', ' is ', ' very ', ' happy ')

===== Pack =====
Length:8
?
'/x14/x00/x00/x00/x90/x01/x00/x00 '

===== Pack_into-unpack_from =====
'/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00/x00 '
'/x01/x00/x00/x00/x02/x00/x00/x00/xff/xff/xff/xff '
(1, 2,-1)

Python is a very concise language, and for data type representations, many types are not predefined like in other languages (e.g., in C #, there are 8 types of optical integers defined)

It only defines six basic types: string, integer, floating point, tuple (set), List (array), dictionary (Key/value)

With these six data types, we can do most of the work. But when Python needs to interact with other platforms over the network, it must take into account the conversion of these data types to the types of other platforms or languages. For example: the C + + write client sends an INT (4 bytes) variable data to a Python-written server, and Python receives 4 bytes of data representing the integer, how to parse it into a python-recognized integer? Python's standard module struct is used to solve this problem.

The content of the struct module is not too much, it is not too difficult, the following is the most commonly used methods are described:

1, Struct.pack
Struct.pack is used to convert Python values from a format character to a string (because there is no byte type in Python , you can interpret the string here as a byte stream, or an array of bytes). The function prototypes are: Struct.pack (FMT, V1, v2, ...), the parameter FMT is a format string, and the relevant information about the format string is described below. V1, v2, ... Represents the Python value to convert. The following example converts two integers to a string (byte stream):

1 #!/usr/bin/env python   2 #encoding: UTF8   3    4 Import sys   5 reload (SYS)   6 sys.setdefaultencoding (" Utf-8 ")   7    8 import struct   9   a = ten  B =   str = struct.pack (" II ", A, b)  print ' Length: ', Len (str)          # Length:  8  print str                           # garbled:   print repr (str)                     # ' \x14\x00\x00\x00 \x90\x01\x00\x00 '  

The format character "I" represents the conversion to int, ' II ' means there are two int variables.

The result of the conversion is 8 bytes long (the int type takes 4 bytes and two int is 8 bytes)

You can see that the result of the output is garbled, because the result is binary data, so it is displayed as garbled.

You can use Python's built-in function repr to get a recognizable string, where 16 binary 0x00000014, 0x00001009 20 and 400, respectively.

2, Struct.unpack
Struct.unpack does work just as opposed to struct.pack, which is used to convert byte streams into Python data types. The function prototype is: Struct.unpack (FMT, String), which returns a tuple.

The following is a simple example:

1 #!/usr/bin/env python   2 #encoding: UTF8   3    4 Import sys   5 reload (SYS)   6 sys.setdefaultencoding (" Utf-8 ")   7    8 import struct   9   a = ten  B = +  /-pack + str = struct.pack (" II " , A, b)  print ' Length: ', Len (str)          # Length:  8  print str                           # garbled:   print repr (str) 
   
    # ' \x14\x00\x00\x00\x90\x01\x00\x00 '   # unpack  str2 = Struct.unpack ("II", str)  print ' Length: ', Len (str2)          # Length:  2  print str2                           # (+, +)  print repr (str2)                     # (20, 400)  
   

3, Struct.calcsize
The struct.calcsize is used to calculate the length of the result of the format string, such as: Struct.calcsize (' II '), which returns 8. Because two int types occupy a length of 8 bytes.

1 import struct  2 print "Len:", struct.calcsize (' I ')       # len:  4  3 print "Len:", Struct.calcsize (' II ') 
   
    # Len:  8  4 print "Len:", Struct.calcsize (' F ')       # len:  4  5 print "Len:", struct.calcsize (' FF ')      # len:  8  6 print "Len:", Struct.calcsize (' s ')       # len:  1  7 print "Len:", Struct.calcsize ( ' SS ')      # len:  2  8 print "Len:", Struct.calcsize (' d ')       # len:  8  9 print "Len:", Struct.calcsize (' DD ')      # len:  
   

4, Struct.pack_into, Struct.unpack_from
These two functions are described in the Python manual, but there are no examples of how to use them. In fact, they do not use much in practical applications. Google for a long time, only to find an example, paste out to share a bit:

1 #!/usr/bin/env python   2 #encoding: UTF8   3    4 Import sys   5 reload (SYS)   6 sys.setdefaultencoding (" Utf-8 ")   7    8 import struct   9 from ctypes import create_string_buffer   buf = create_string_ Buffer (14)  print repr (buf.raw)     # ' \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 '   Struct.pack_into ("III", BUF, 0, 1, 2,-1)  print repr (buf.raw)     # ' \x01\x00\x00\x00\x02\x00\x00\x00\xff\xff \xff\xff '   print Struct.unpack_from ("III", BUF, 0)     

struct Type table

Standard
Format C Type Python Typesize Notes
X Pad byte No value
C Char string of length 1 1
B Signed Char Integer 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)
F Float Float 4 (4)
D Double Float 8 (4)
S Char[] String 1
P Char[] String
P void * Integer (5), (3)

Pack, unpack of the Python:struct module

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.