Mengubah int menjadi byte dalam Python 3

Saya mencoba untuk membangun objek byte ini di Python 3:

b'3\r\n'

jadi saya mencoba yang jelas (untuk saya), dan menemukan perilaku aneh:

>>> bytes(3) + b'\r\n'
b'\x00\x00\x00\r\n'

Tampaknya:

>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

Saya tidak dapat melihat petunjuk tentang mengapa konversi byte bekerja dengan cara ini membaca dokumentasi. Namun, saya menemukan beberapa pesan kejutan dalam masalah Python ini tentang menambahkan formatke byte (lihat juga pemformatan Python 3 byte ):

http://bugs.python.org/issue3982

Ini berinteraksi lebih buruk lagi dengan keanehan seperti byte (int) mengembalikan nol sekarang

dan:

Akan jauh lebih nyaman bagi saya jika byte (int) mengembalikan ASCIIfication dari int itu; tetapi jujur, bahkan kesalahan akan lebih baik daripada perilaku ini. (Jika saya menginginkan perilaku ini - yang tidak pernah saya miliki - saya lebih suka itu menjadi metode kelas, dipanggil seperti "bytes.zeroes (n)".)

Dapatkah seseorang menjelaskan kepada saya dari mana perilaku ini berasal?

Begitulah cara itu dirancang - dan itu masuk akal karena biasanya, Anda akan memanggil bytesiterable daripada integer tunggal:

>>> bytes([3])
b'\x03'

The docs menyatakan ini , serta docstring untuk bytes:

 >>> help(bytes)
 ...
 bytes(int) -> bytes object of size given by the parameter initialized with null bytes

Dari python 3.2 bisa Anda lakukan

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'

https://docs.python.org/3/library/stdtypes.html#int.to_bytes

def int_to_bytes(x: int) -> bytes:
    return x.to_bytes((x.bit_length() + 7) // 8, 'big')

def int_from_bytes(xbytes: bytes) -> int:
    return int.from_bytes(xbytes, 'big')

Dengan demikian x == int_from_bytes(int_to_bytes(x)),. Perhatikan bahwa pengodean ini hanya berfungsi untuk bilangan bulat (non-negatif) yang tidak ditandatangani.

Anda dapat menggunakan paket struct :

In [11]: struct.pack(">I", 1)
Out[11]: '\x00\x00\x00\x01'

">" Adalah byte-order (big-endian) dan "I" adalah karakter format . Jadi Anda bisa spesifik jika Anda ingin melakukan sesuatu yang lain:

In [12]: struct.pack("<H", 1)
Out[12]: '\x01\x00'

In [13]: struct.pack("B", 1)
Out[13]: '\x01'

Ini berfungsi sama pada kedua python 2 dan python 3 .

Catatan: operasi terbalik (byte ke int) dapat dilakukan dengan membongkar .

Python 3.5+ memperkenalkan% -interpolasi (-style printfformat) untuk byte :

>>> b'%d\r\n' % 3
b'3\r\n'

Lihat PEP 0461 - Menambahkan format% ke byte dan bytearray .

Pada versi sebelumnya, Anda dapat menggunakan strdan .encode('ascii')hasilnya:

>>> s = '%d\r\n' % 3
>>> s.encode('ascii')
b'3\r\n'

Catatan: Ini berbeda dari apa yang int.to_bytesmenghasilkan :

>>> n = 3
>>> n.to_bytes((n.bit_length() + 7) // 8, 'big') or b'\0'
b'\x03'
>>> b'3' == b'\x33' != '\x03'
True

Dokumentasi mengatakan:

bytes(int) -> bytes object of size given by the parameter
              initialized with null bytes

Urutannya:

b'3\r\n'

Ini adalah karakter '3' (desimal 51) karakter '\ r' (13) dan '\ n' (10).

Oleh karena itu, cara akan memperlakukannya seperti itu, misalnya:

>>> bytes([51, 13, 10])
b'3\r\n'

>>> bytes('3', 'utf8') + b'\r\n'
b'3\r\n'

>>> n = 3
>>> bytes(str(n), 'ascii') + b'\r\n'
b'3\r\n'

Diuji pada IPython 1.1.0 & Python 3.2.3

ASCIIfikasi 3 "\x33"tidak "\x03"!

Itulah yang python lakukan untuk str(3)tetapi akan benar-benar salah untuk byte, karena mereka harus dianggap array data biner dan tidak disalahgunakan sebagai string.

Cara paling mudah untuk mencapai apa yang Anda inginkan adalah bytes((3,)), yang lebih baik daripada bytes([3])karena menginisialisasi daftar jauh lebih mahal, jadi jangan pernah menggunakan daftar ketika Anda bisa menggunakan tuple. Anda dapat mengonversi bilangan bulat yang lebih besar dengan menggunakan int.to_bytes(3, "little").

Menginisialisasi byte dengan panjang yang diberikan masuk akal dan merupakan yang paling berguna, karena mereka sering digunakan untuk membuat beberapa jenis buffer yang memerlukan memori yang dialokasikan untuk ukuran tertentu. Saya sering menggunakan ini ketika menginisialisasi array atau memperluas beberapa file dengan menulis nol padanya.

int(termasuk Python2 long) dapat dikonversi bytesmenggunakan fungsi berikut:

import codecs

def int2bytes(i):
    hex_value = '{0:x}'.format(i)
    # make length of hex_value a multiple of two
    hex_value = '0' * (len(hex_value) % 2) + hex_value
    return codecs.decode(hex_value, 'hex_codec')

Konversi terbalik dapat dilakukan oleh yang lain:

import codecs
import six  # should be installed via 'pip install six'

long = six.integer_types[-1]

def bytes2int(b):
    return long(codecs.encode(b, 'hex_codec'), 16)

Kedua fungsi bekerja pada Python2 dan Python3.

Saya ingin tahu tentang kinerja berbagai metode untuk satu int dalam kisaran [0, 255], jadi saya memutuskan untuk melakukan beberapa tes waktu.

Berdasarkan timing bawah, dan dari kecenderungan umum saya amati dari mencoba banyak nilai dan konfigurasi yang berbeda, struct.packtampaknya menjadi yang tercepat, diikuti oleh int.to_bytes, bytesdan dengan str.encode(mengejutkan) menjadi yang paling lambat. Perhatikan bahwa hasilnya menunjukkan lebih banyak variasi daripada yang diwakili, dan int.to_bytesdan byteskadang - kadang beralih peringkat kecepatan selama pengujian, tetapi struct.packjelas yang tercepat.

Hasil dalam CPython 3.7 di Windows:

Testing with 63:
bytes_: 100000 loops, best of 5: 3.3 usec per loop
to_bytes: 100000 loops, best of 5: 2.72 usec per loop
struct_pack: 100000 loops, best of 5: 2.32 usec per loop
chr_encode: 50000 loops, best of 5: 3.66 usec per loop

Modul uji (bernama int_to_byte.py):

"""Functions for converting a single int to a bytes object with that int's value."""

import random
import shlex
import struct
import timeit

def bytes_(i):
    """From Tim Pietzcker's answer:
    https://stackoverflow.com/a/21017834/8117067
    """
    return bytes([i])

def to_bytes(i):
    """From brunsgaard's answer:
    https://stackoverflow.com/a/30375198/8117067
    """
    return i.to_bytes(1, byteorder='big')

def struct_pack(i):
    """From Andy Hayden's answer:
    https://stackoverflow.com/a/26920966/8117067
    """
    return struct.pack('B', i)

# Originally, jfs's answer was considered for testing,
# but the result is not identical to the other methods
# https://stackoverflow.com/a/31761722/8117067

def chr_encode(i):
    """Another method, from Quuxplusone's answer here:
    https://codereview.stackexchange.com/a/210789/140921

    Similar to g10guang's answer:
    https://stackoverflow.com/a/51558790/8117067
    """
    return chr(i).encode('latin1')

converters = [bytes_, to_bytes, struct_pack, chr_encode]

def one_byte_equality_test():
    """Test that results are identical for ints in the range [0, 255]."""
    for i in range(256):
        results = [c(i) for c in converters]
        # Test that all results are equal
        start = results[0]
        if any(start != b for b in results):
            raise ValueError(results)

def timing_tests(value=None):
    """Test each of the functions with a random int."""
    if value is None:
        # random.randint takes more time than int to byte conversion
        # so it can't be a part of the timeit call
        value = random.randint(0, 255)
    print(f'Testing with {value}:')
    for c in converters:
        print(f'{c.__name__}: ', end='')
        # Uses technique borrowed from https://stackoverflow.com/q/19062202/8117067
        timeit.main(args=shlex.split(
            f"-s 'from int_to_byte import {c.__name__}; value = {value}' " +
            f"'{c.__name__}(value)'"
        ))

Meskipun jawaban sebelumnya oleh brunsgaard adalah pengkodean yang efisien, ia hanya berfungsi untuk bilangan bulat yang tidak ditandai. Yang ini dibangun untuk bekerja untuk bilangan bulat yang ditandatangani dan tidak ditandatangani.

def int_to_bytes(i: int, *, signed: bool = False) -> bytes:
    length = ((i + ((i * signed) < 0)).bit_length() + 7 + signed) // 8
    return i.to_bytes(length, byteorder='big', signed=signed)

def bytes_to_int(b: bytes, *, signed: bool = False) -> int:
    return int.from_bytes(b, byteorder='big', signed=signed)

# Test unsigned:
for i in range(1025):
    assert i == bytes_to_int(int_to_bytes(i))

# Test signed:
for i in range(-1024, 1025):
    assert i == bytes_to_int(int_to_bytes(i, signed=True), signed=True)

Untuk encoder, (i + ((i * signed) < 0)).bit_length()digunakan bukan hanya i.bit_length()karena yang terakhir mengarah pada pengkodean -128, -32768 yang tidak efisien, dll.

Kredit: CervEd untuk memperbaiki inefisiensi kecil.

Perilaku ini berasal dari fakta bahwa dalam Python sebelum versi 3 byteshanyalah alias untuk str. Dalam Python3.x bytesadalah versi abadi bytearray- tipe yang sama sekali baru, tidak kompatibel.

Dari byte dokumen :

Dengan demikian, argumen konstruktor ditafsirkan sebagai bytearray ().

Kemudian, dari bytearray docs :

Parameter sumber opsional dapat digunakan untuk menginisialisasi array dengan beberapa cara berbeda:

• Jika bilangan bulat, array akan memiliki ukuran itu dan akan diinisialisasi dengan byte nol.

Perhatikan, itu berbeda dari perilaku 2.x (di mana x> = 6), di mana byteshanya str:

>>> bytes is str
True

PEP 3112 :

2.6 str berbeda dari tipe byte 3.0 dalam berbagai cara; terutama, konstruktornya benar-benar berbeda.

Beberapa jawaban tidak bekerja dengan jumlah besar.

Konversikan integer ke representasi hex, lalu konversikan ke byte:

def int_to_bytes(number):
    hrepr = hex(number).replace('0x', '')
    if len(hrepr) % 2 == 1:
        hrepr = '0' + hrepr
    return bytes.fromhex(hrepr)

Hasil:

>>> int_to_bytes(2**256 - 1)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'

Jika pertanyaannya adalah bagaimana mengubah bilangan bulat itu sendiri (bukan string yang setara) menjadi byte, saya pikir jawabannya adalah:

>>> i = 5
>>> i.to_bytes(2, 'big')
b'\x00\x05'
>>> int.from_bytes(i.to_bytes(2, 'big'), byteorder='big')
5

Informasi lebih lanjut tentang metode ini di sini:

1. https://docs.python.org/3.8/library/stdtypes.html#int.to_bytes
2. https://docs.python.org/3.8/library/stdtypes.html#int.from_bytes