Bagaimana cara python membaca data biner?

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

Table of Contents Show

Fungsi dan Pengecualian
Memformat String
Urutan Byte, Ukuran, dan Perataan
Memformat Karakter
Format Asli
Format Standar
Bagaimana cara membaca string biner dengan Python?
Bagaimana Anda membaca data biner?
Bagaimana cara Python menyimpan data dalam file biner?
Apa itu data biner di Python?

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. kesalahan

Pengecualian 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'

warga asli

>>> pack("@ccc", b'1', b'2', b'3')
b'123'
>>> pack("@3s", b'123')
b'123'

warga asli

standar

tidak ada

>>> pack("@ccc", b'1', b'2', b'3')
b'123'
>>> pack("@3s", b'123')
b'123'

little-endian

standar

tidak ada

>>> pack("@ccc", b'1', b'2', b'3')
b'123'
>>> pack("@3s", b'123')
b'123'

big-endian

standar

tidak ada

>>> pack("@ccc", b'1', b'2', b'3')
b'123'
>>> pack("@3s", b'123')
b'123'

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)

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

arang

byte dengan panjang 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

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

tidak ditandatangani char

bilangan bulat

(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

_Bool

bool

(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

pendek

bilangan bulat

(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

tidak ditandatangani pendek

bilangan bulat

(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

int

bilangan bulat

(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

tidak ditandatangani int

bilangan bulat

(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

panjang

bilangan bulat

(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

tidak bertanda tangan panjang

bilangan bulat

(2)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

panjang panjang

bilangan bulat

(2)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

tidak ditandatangani panjang panjang

bilangan bulat

(2)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

ukuran_t

bilangan bulat

(3)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

size_t

bilangan bulat

(3)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

(6)

mengambang

(4)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

mengambang

(4)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

dobel

mengambang

(4)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

karakter[]

byte

(9)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

karakter[]

byte

(8)

>>> pack('@llh0l', 1, 2, 3)
b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

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

Berubah di versi 3. 6. Menambahkan dukungan untuk format

>>> calcsize('@lhl')
24
>>> calcsize('@llh')
18

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

>>> 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

>>> 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

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

>>> calcsize('<qqh6x')
24
>>> calcsize('@llh0l')
12
>>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3)
False

>>> 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

Modul

Penyimpanan biner yang dikemas dari data homogen

Modul

Pembuat enkode dan dekoder JSON

Modul

Serialisasi 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

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'

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

format

String format yang digunakan untuk membuat objek Struct ini

Berubah di versi 3. 7. Jenis string format sekarang sebagai ganti.

ukuran

Ukuran struct yang dihitung (dan karenanya objek bytes yang dihasilkan oleh metode) sesuai dengan

Bagaimana cara membaca string biner dengan Python?

Metode #1. Data biner dibagi menjadi set 7 bit karena set biner ini sebagai input, mengembalikan nilai desimal yang sesuai yang merupakan kode ASCII dari karakter string. Kode ASCII ini kemudian diubah menjadi string menggunakan fungsi chr() .

Bagaimana Anda membaca data biner?

Untuk membaca dari file biner .

Gunakan metode ReadAllBytes, yang mengembalikan konten file sebagai larik byte. Contoh ini membaca dari file C. /Dokumen dan Pengaturan/potret diri. .

Untuk file biner yang besar, Anda dapat menggunakan metode Read dari objek FileStream untuk membaca dari file hanya dalam jumlah tertentu pada satu waktu

Bagaimana cara Python menyimpan data dalam file biner?

buang(). Metode yang digunakan untuk menulis data ke file biner adalah metode dump() . Dibutuhkan dua argumen 'file object' dan 'file' sebagai parameter. Ini mengembalikan representasi objek dalam mode byte. Metode dump() milik modul pickle.

Apa itu data biner di Python?

Variabel biner adalah variabel kategorikal yang hanya dapat mengambil salah satu dari dua nilai, biasanya direpresentasikan sebagai Boolean — Benar atau Salah — atau variabel bilangan bulat — 0 atau 1.