Modul ini mengonversi antara nilai Python dan struktur C yang direpresentasikan sebagai objek Python. Ringkas jelaskan konversi yang dimaksud ke/dari nilai Python. Fungsi dan objek modul dapat digunakan untuk dua aplikasi yang sangat berbeda, pertukaran data dengan sumber eksternal (file atau koneksi jaringan), atau transfer data antara aplikasi Python dan lapisan C
Catatan
Jika tidak ada karakter awalan yang diberikan, mode asli akan menjadi default. Itu mengemas atau membongkar data berdasarkan platform dan kompiler tempat juru bahasa Python dibangun. Hasil pengepakan struct C yang diberikan termasuk pad byte yang mempertahankan keselarasan yang tepat untuk tipe C yang terlibat; . Sebaliknya, saat mengkomunikasikan data antara sumber eksternal, pemrogram bertanggung jawab untuk menentukan urutan byte dan mengisi antar elemen. Lihat detailnya
Beberapa fungsi (dan metode ) menggunakan argumen buffer. Ini mengacu pada objek yang mengimplementasikan dan menyediakan buffer yang dapat dibaca atau dibaca-ditulis. Jenis yang paling umum digunakan untuk tujuan itu adalah and , tetapi banyak jenis lain yang dapat dilihat sebagai larik byte yang mengimplementasikan protokol buffer, sehingga dapat dibaca/diisi tanpa penyalinan tambahan dari objek
Fungsi dan Pengecualian
Modul ini mendefinisikan pengecualian dan fungsi berikut
pengecualian struct. kesalahanPengecualian diajukan pada berbagai kesempatan;
struktur. paket(format , v1 . , v2, ...)Mengembalikan objek byte yang berisi nilai v1, v2, … dikemas sesuai dengan format format string. Argumen harus sama persis dengan nilai yang diperlukan oleh format
struktur. pack_into(format , buffer . , offset, v1, v2, ...)Kemas nilai v1, v2, … sesuai dengan format format string dan tulis byte yang dikemas ke dalam buffer buffer yang dapat ditulis mulai dari offset posisi. Perhatikan bahwa offset adalah argumen yang diperlukan
struktur. bongkar(format , penyangga)Buka paket dari buffer buffer (mungkin dikemas oleh >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 7) sesuai dengan format format string. Hasilnya adalah sebuah tuple meskipun hanya berisi satu item. Ukuran buffer dalam byte harus sesuai dengan ukuran yang dibutuhkan oleh format, sebagaimana dicerminkan oleh
struktur. unpack_from(format , /, buffer, offset=0)Buka paket dari buffer mulai dari offset posisi, sesuai dengan format format string. Hasilnya adalah sebuah tuple meskipun hanya berisi satu item. Ukuran buffer dalam byte, mulai dari offset posisi, harus setidaknya ukuran yang dibutuhkan oleh format, seperti yang ditunjukkan oleh
struktur. iter_unpack(format , penyangga)Buka paket secara iteratif dari buffer buffer sesuai dengan format format string. Fungsi ini mengembalikan iterator yang akan membaca potongan berukuran sama dari buffer sampai semua isinya telah dikonsumsi. Ukuran buffer dalam byte harus merupakan kelipatan dari ukuran yang dibutuhkan oleh format, seperti yang ditunjukkan oleh
Setiap iterasi menghasilkan tuple seperti yang ditentukan oleh format string
Baru di versi 3. 4
struktur. menghitung(format)Kembalikan ukuran struct (dan karenanya objek byte yang dihasilkan oleh >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 7) sesuai dengan format format string
Memformat String
String format menjelaskan tata letak data saat mengemas dan membongkar data. Mereka dibangun dari , yang menentukan jenis data yang sedang dikemas/dibongkar. Selain itu, karakter khusus mengontrol. Setiap string format terdiri dari karakter awalan opsional yang mendeskripsikan properti keseluruhan data dan satu atau lebih karakter format yang mendeskripsikan nilai dan padding data aktual
Urutan Byte, Ukuran, dan Perataan
Secara default, tipe C direpresentasikan dalam format asli mesin dan urutan byte, dan diselaraskan dengan benar dengan melewatkan byte pad jika perlu (sesuai dengan aturan yang digunakan oleh kompiler C). Perilaku ini dipilih sehingga byte dari struct yang dikemas sesuai persis dengan tata letak memori dari struct C yang sesuai. Apakah akan menggunakan pengurutan dan pengisi byte asli atau format standar tergantung pada aplikasi
Alternatifnya, karakter pertama dari string format dapat digunakan untuk menunjukkan urutan byte, ukuran, dan perataan data yang dikemas, menurut tabel berikut
Karakter
Urutan byte
Ukuran
Penyelarasan
>>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 2
warga asli
warga asli
warga asli
>>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' _3
warga asli
standar
tidak ada
>>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' _4
little-endian
standar
tidak ada
>>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 5
big-endian
standar
tidak ada
>>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 6
jaringan (= big-endian)
standar
tidak ada
Jika karakter pertama bukan salah satu dari ini, >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 7 diasumsikan
Urutan byte asli adalah big-endian atau little-endian, tergantung pada sistem host. Misalnya, Intel x86, AMD64 (x86-64), dan Apple M1 adalah little-endian; . Gunakan untuk memeriksa endianness sistem Anda
Ukuran dan perataan asli ditentukan menggunakan ekspresi >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 9 compiler C. Ini selalu digabungkan dengan urutan byte asli
Ukuran standar hanya bergantung pada format karakter;
Perhatikan perbedaan antara >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 7 dan >>> record = b'raymond \x32\x12\x08\x01\x08' >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record) >>> from collections import namedtuple >>> Student = namedtuple('Student', 'name serialnum school gradelevel') >>> Student._make(unpack('<10sHHb', record)) Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8) 1. keduanya menggunakan urutan byte asli, tetapi ukuran dan perataan yang terakhir distandarisasi
Bentuk >>> record = b'raymond \x32\x12\x08\x01\x08' >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record) >>> from collections import namedtuple >>> Student = namedtuple('Student', 'name serialnum school gradelevel') >>> Student._make(unpack('<10sHHb', record)) Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8) _2 mewakili urutan byte jaringan yang selalu big-endian sebagaimana didefinisikan dalam IETF RFC 1700
Tidak ada cara untuk menunjukkan urutan byte non-native (memaksa byte-swapping);
Catatan
Padding hanya ditambahkan secara otomatis di antara anggota struktur yang berurutan. Tidak ada padding yang ditambahkan di awal atau akhir dari struct yang disandikan
No padding is added when using non-native size and alignment, e.g. with ‘’, ‘=’, and ‘!’.
Untuk menyelaraskan akhir struktur dengan persyaratan penyelarasan jenis tertentu, akhiri format dengan kode untuk jenis tersebut dengan jumlah pengulangan nol. Melihat
Memformat Karakter
Format karakter memiliki arti sebagai berikut; . Kolom 'Ukuran standar' mengacu pada ukuran nilai yang dikemas dalam byte saat menggunakan ukuran standar; . Saat menggunakan ukuran asli, ukuran nilai yang dikemas bergantung pada platform
Format
Tipe C
Jenis ular piton
Ukuran standar
Catatan
>>> record = b'raymond \x32\x12\x08\x01\x08' >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record) >>> from collections import namedtuple >>> Student = namedtuple('Student', 'name serialnum school gradelevel') >>> Student._make(unpack('<10sHHb', record)) Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8) _9
pad byte
Tidak bernilai
(7)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _0
arang
byte dengan panjang 1
1
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _1
ditandatangani char
bilangan bulat
1
(1), (2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _2
tidak ditandatangani char
bilangan bulat
1
(2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _3
_Bool
bool
1
(1)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _4
pendek
bilangan bulat
2
(2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _5
tidak ditandatangani pendek
bilangan bulat
2
(2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _6
int
bilangan bulat
4
(2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _7
tidak ditandatangani int
bilangan bulat
4
(2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _8
panjang
bilangan bulat
4
(2)
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5 _9
tidak bertanda tangan panjang
bilangan bulat
4
(2)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 0
panjang panjang
bilangan bulat
8
(2)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 1
tidak ditandatangani panjang panjang
bilangan bulat
8
(2)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 2
ukuran_t
bilangan bulat
(3)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 3
size_t
bilangan bulat
(3)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 4
(6)
mengambang
2
(4)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 5
mengambang
mengambang
4
(4)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 6
dobel
mengambang
8
(4)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 7
karakter[]
byte
(9)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' 8
karakter[]
byte
(8)
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00' _9
batal*
bilangan bulat
(5)
Berubah di versi 3. 3. Menambahkan dukungan untuk format >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 0 dan >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 1.
Berubah di versi 3. 6. Menambahkan dukungan untuk format >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 2.
Catatan
Kode konversi >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 _3 sesuai dengan jenis _Bool yang ditentukan oleh C99. Jika jenis ini tidak tersedia, maka disimulasikan menggunakan char . Dalam mode standar, selalu diwakili oleh satu byte.
Saat mencoba mengemas non-bilangan bulat menggunakan salah satu kode konversi bilangan bulat, jika non-bilangan bulat memiliki metode >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 4 maka metode itu dipanggil untuk mengonversi argumen menjadi bilangan bulat sebelum mengemas
Berubah di versi 3. 2. Penambahan penggunaan metode >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 4 untuk bukan bilangan bulat.
Kode konversi >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 0 dan >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 1 hanya tersedia untuk ukuran asli (dipilih sebagai default atau dengan karakter urutan >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 7 byte). Untuk ukuran standar, Anda dapat menggunakan format bilangan bulat mana saja yang sesuai dengan aplikasi Anda
Untuk kode konversi >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 9, >>> calcsize('@llh0l') 24 0 dan >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 2, representasi dikemas menggunakan format IEEE 754 binary32, binary64 atau binary16 (untuk >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 9, >>> calcsize('@llh0l') 24 0 atau >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 2), terlepas dari format floating-point yang digunakan oleh platform
Karakter format >>> calcsize('@llh0l') 24 5 hanya tersedia untuk pengurutan byte asli (dipilih sebagai default atau dengan karakter urutan >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 7 byte). Karakter urutan byte >>> record = b'raymond \x32\x12\x08\x01\x08' >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record) >>> from collections import namedtuple >>> Student = namedtuple('Student', 'name serialnum school gradelevel') >>> Student._make(unpack('<10sHHb', record)) Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8) _1 memilih untuk menggunakan urutan little- atau big-endian berdasarkan sistem host. Modul struct tidak mengartikan ini sebagai pemesanan asli, sehingga format >>> calcsize('@llh0l') 24 5 tidak tersedia
Jenis "setengah presisi" IEEE 754 binary16 diperkenalkan pada revisi 2008 standar IEEE 754. Ini memiliki bit tanda, eksponen 5-bit dan presisi 11-bit (dengan 10 bit disimpan secara eksplisit), dan dapat mewakili angka antara kira-kira >>> calcsize('@llh0l') 24 9 dan >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 0 dengan presisi penuh. Jenis ini tidak didukung secara luas oleh kompiler C. pada mesin biasa, unsigned short dapat digunakan untuk penyimpanan, tetapi tidak untuk operasi matematika. Lihat halaman Wikipedia pada format floating-point setengah presisi untuk informasi lebih lanjut
Saat mengemas, >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 1 menyisipkan satu byte NUL
Karakter format >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True _2 mengkodekan "string Pascal", yang berarti string pendek dengan panjang variabel yang disimpan dalam jumlah byte tetap, diberikan oleh hitungan. Byte pertama yang disimpan adalah panjang string, atau 255, mana yang lebih kecil. Byte dari string mengikuti. Jika string yang diteruskan ke terlalu panjang (lebih panjang dari hitungan minus 1), hanya >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 4 byte terdepan dari string yang disimpan. Jika string lebih pendek dari >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True _4, itu diisi dengan byte nol sehingga jumlah byte yang digunakan sama persis. Perhatikan bahwa untuk , karakter format >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 2 menggunakan >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 8 byte, tetapi string yang dikembalikan tidak akan pernah berisi lebih dari 255 byte
Untuk karakter format >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 9, hitungan ditafsirkan sebagai panjang byte, bukan hitungan berulang seperti karakter format lainnya; . g. , >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False _2) memetakan ke atau dari sepuluh objek byte Python yang berbeda. (Lihat untuk demonstrasi konkret tentang perbedaannya. ) Jika hitungan tidak diberikan, standarnya adalah 1. Untuk pengepakan, string dipotong atau diisi dengan byte nol yang sesuai untuk membuatnya pas. Untuk membongkar, objek byte yang dihasilkan selalu memiliki jumlah byte yang ditentukan. Sebagai kasus khusus, >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False _3 berarti satu string kosong (sementara >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False 4 berarti 0 karakter)
Karakter format dapat didahului dengan jumlah pengulangan integral. Misalnya, format string >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False _5 artinya persis sama dengan >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False 6
Karakter spasi antar format diabaikan;
Mengemas nilai >>> record = b'raymond \x32\x12\x08\x01\x08' >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record) >>> from collections import namedtuple >>> Student = namedtuple('Student', 'name serialnum school gradelevel') >>> Student._make(unpack('<10sHHb', record)) Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8) 9 Menggunakan salah satu format integer (>>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False 8, >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False 9, >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 00, >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 01, ______________0 ________0 ________0____0.0____3, ________0 ______0.
Berubah di versi 3. 1. Sebelumnya, beberapa format bilangan bulat membungkus nilai di luar rentang dan dimunculkan sebagai ganti.
Untuk karakter format >>> calcsize('@lhl') 24 >>> calcsize('@llh') 18 3, nilai kembaliannya adalah salah satu atau. Saat mengemas, nilai kebenaran objek argumen digunakan. Baik 0 atau 1 dalam representasi bool asli atau standar akan dikemas, dan nilai bukan nol apa pun akan menjadi >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 13 saat membongkar
Contoh
Catatan
Contoh urutan byte asli (ditunjuk oleh awalan format >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 7 atau tidak adanya karakter awalan apa pun) mungkin tidak cocok dengan apa yang dihasilkan mesin pembaca karena bergantung pada platform dan kompiler
Kemas dan buka kemasan bilangan bulat dari tiga ukuran berbeda, menggunakan pemesanan big endian
>>> from struct import * >>> pack(">bhl", 1, 2, 3) b'\x01\x00\x02\x00\x00\x00\x03' >>> unpack('>bhl', b'\x01\x00\x02\x00\x00\x00\x03' (1, 2, 3) >>> calcsize('>bhl') 7
Mencoba mengemas bilangan bulat yang terlalu besar untuk bidang yang ditentukan
>>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767
Peragakan perbedaan antara >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 9 dan >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 18 format karakter
>>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123'
Bidang yang belum dibuka dapat diberi nama dengan menugaskannya ke variabel atau dengan membungkus hasilnya dalam tupel bernama
>>> record = b'raymond \x32\x12\x08\x01\x08' >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record) >>> from collections import namedtuple >>> Student = namedtuple('Student', 'name serialnum school gradelevel') >>> Student._make(unpack('<10sHHb', record)) Student(name=b'raymond ', serialnum=4658, school=264, gradelevel=8)
Pengurutan karakter format mungkin berdampak pada ukuran dalam mode asli karena padding bersifat implisit. Dalam mode standar, pengguna bertanggung jawab untuk memasukkan padding yang diinginkan. Perhatikan dalam panggilan >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 _19 pertama di bawah bahwa tiga byte NUL ditambahkan setelah >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 20 yang dikemas untuk menyelaraskan bilangan bulat berikut pada batas empat byte. Dalam contoh ini, keluaran dihasilkan pada mesin little endian
>>> pack('@ci', b'#', 0x12131415) b'#\x00\x00\x00\x15\x14\x13\x12' >>> pack('@ic', 0x12131415, b'#') b'\x15\x14\x13\x12#' >>> calcsize('@ci') 8 >>> calcsize('@ic') 5
Format berikut >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 _21 menghasilkan dua pad byte yang ditambahkan di akhir, dengan asumsi panjang platform disejajarkan pada batas 4-byte
>>> pack('@llh0l', 1, 2, 3) b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'
Lihat juga
ModulPenyimpanan biner yang dikemas dari data homogen
ModulPembuat enkode dan dekoder JSON
ModulSerialisasi objek Python
Aplikasi
Ada dua aplikasi utama untuk modul ini, pertukaran data antara kode Python dan C dalam aplikasi atau aplikasi lain yang dikompilasi menggunakan kompiler yang sama (), dan pertukaran data antara aplikasi menggunakan tata letak data yang disepakati (). Secara umum, string format yang dibuat untuk kedua domain ini berbeda
Format Asli
Saat membuat string format yang meniru tata letak asli, kompiler dan arsitektur mesin menentukan pengurutan dan pengisian byte. Dalam kasus seperti itu, karakter format >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 2 harus digunakan untuk menentukan urutan byte asli dan ukuran data. Pad byte internal biasanya dimasukkan secara otomatis. Ada kemungkinan bahwa kode format pengulangan-nol akan diperlukan di akhir string format untuk membulatkan ke batas byte yang benar untuk penyelarasan potongan data yang tepat.
Pertimbangkan dua contoh sederhana ini (pada mesin 64-bit, little-endian)
>>> calcsize('@lhl') 24 >>> calcsize('@llh') 18
Data tidak diisi ke batas 8 byte di akhir string format kedua tanpa menggunakan bantalan tambahan. Kode format zero-repeat memecahkan masalah itu
>>> calcsize('@llh0l') 24
Kode format >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 1 dapat digunakan untuk menentukan perulangan, tetapi untuk format asli lebih baik menggunakan format perulangan nol seperti >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 28
Secara default, pengurutan dan penyelarasan byte asli digunakan, tetapi lebih baik eksplisit dan menggunakan karakter awalan >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 7
Format Standar
Saat bertukar data di luar proses Anda seperti jaringan atau penyimpanan, lakukan dengan tepat. Tentukan urutan, ukuran, dan perataan byte yang tepat. Jangan menganggap mereka cocok dengan urutan asli dari mesin tertentu. Misalnya, urutan byte jaringan adalah big-endian, sedangkan banyak CPU populer adalah little-endian. Dengan mendefinisikan ini secara eksplisit, pengguna tidak perlu peduli dengan spesifikasi platform tempat kode mereka dijalankan. Karakter pertama biasanya harus >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 4 atau >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 5 (atau >>> pack("@ccc", b'1', b'2', b'3') b'123' >>> pack("@3s", b'123') b'123' 6). Padding adalah tanggung jawab programmer. Karakter format pengulangan nol tidak akan berfungsi. Sebagai gantinya, pengguna harus secara eksplisit menambahkan >>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True 1 pad byte jika diperlukan. Meninjau kembali contoh-contoh dari bagian sebelumnya, kita punya
>>> calcsize('<qh6xq') 24 >>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3) True >>> calcsize('@llh') 18 >>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3) True >>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 24 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) True
Hasil di atas (dieksekusi pada mesin 64-bit) tidak dijamin cocok jika dijalankan pada mesin yang berbeda. Misalnya, contoh di bawah dijalankan pada mesin 32-bit
>>> calcsize('<qqh6x') 24 >>> calcsize('@llh0l') 12 >>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3) False
Kelas
Modul ini juga mendefinisikan tipe berikut
kelas struct. Struktur(format)Kembalikan objek Struct baru yang menulis dan membaca data biner sesuai dengan format format string. Membuat objek >>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 3 satu kali dan memanggil metodenya lebih efisien daripada memanggil fungsi tingkat modul dengan format yang sama karena string format hanya dikompilasi sekali
Catatan
Versi terkompilasi dari string format terbaru yang diteruskan ke dan fungsi tingkat modul di-cache, sehingga program yang hanya menggunakan beberapa string format tidak perlu khawatir tentang penggunaan kembali satu instans.
Objek Struct yang dikompilasi mendukung metode dan atribut berikut
paket(v1 , v2, ...)Identik dengan fungsinya, menggunakan format yang dikompilasi. (>>> pack(">h", 99999) Traceback (most recent call last): File "<stdin>", line 1, in <module> struct.error: 'h' format requires -32768 <= number <= 32767 39 akan sama. )
pack_into(buffer , offset, v1, v2, ...)Identik dengan fungsinya, menggunakan format yang dikompilasi
bongkar(penyangga)Identik dengan fungsinya, menggunakan format yang dikompilasi. Ukuran buffer dalam byte harus sama
unpack_from(buffer , offset=0)Identik dengan fungsinya, menggunakan format yang dikompilasi. Ukuran buffer dalam byte, mulai dari offset posisi, setidaknya harus
iter_unpack(penyangga)Identik dengan fungsinya, menggunakan format yang dikompilasi. Ukuran buffer dalam byte harus kelipatan
Baru di versi 3. 4
formatString format yang digunakan untuk membuat objek Struct ini
Berubah di versi 3. 7. Jenis string format sekarang sebagai ganti.
ukuranUkuran struct yang dihitung (dan karenanya objek bytes yang dihasilkan oleh metode) sesuai dengan