Manejo de bytes y encoding

Bytes, encoding y representación de bajo nivel: ASCII/Unicode, los objetos bytes y bytearray, lectura por chunks y conversión de enteros con big/little endian.

Creado por

SebastianZ28

Valoración0 votos

-.-

memory

Bytes y encoding

Un computador solo almacena ceros y unos. La unidad básica es el byte: una secuencia de 8 bits, que puede representar $2^{8} = 256$ valores distintos, es decir, los enteros del 0 al 255.

¿Cómo se vuelven caracteres?

Un encoding (codificación) es la regla que interpreta cada número como un carácter. Por ejemplo, ASCII (de 1963) asigna A→65, a→97, 0→48, etc. Unicode es la codificación moderna que cubre prácticamente todos los idiomas y símbolos.

Las funciones chr y ord traducen entre código y carácter:

python

print(ord('B'))   # 66  -> de caracter a codigo
print(chr(105))   # i   -> de codigo a caracter
print(ord('pi'[0]))
print(chr(960))   # se puede ir mas alla de ASCII (Unicode)

Los bytes suelen escribirse en hexadecimal (dígitos 0-9 y A-F), donde dos dígitos representan un byte. Las funciones hex y bin muestran esas representaciones:

python

for i in [0, 15, 16, 42, 255]:
    print(i, hex(i), bin(i))
# 255 0xff 0b11111111

Cargando Quiz...

data_object

El objeto bytes

En Python los bytes se representan con el tipo bytes, una secuencia inmutable (como los str). Se declaran con una b al inicio, y \xNN indica un byte en hexadecimal.

python

# Cada \xNN es un byte en hexadecimal
caracteres = b'\x63\x6c\x69\x63\x68\xe9'
print(caracteres)        # b'clich\xe9'
print(type(caracteres))  # <class 'bytes'>

encode y decode

Para pasar de str a bytes usamos str.encode(encoding); para volver, bytes.decode(encoding). Un mismo byte produce caracteres distintos según el encoding que uses para interpretarlo.

python

code

bytearray: bytes mutables

Un bytearray es un arreglo de bytes mutable: se comporta como una lista de bytes. Permite slicing, append y extend.

append(int): agrega un byte dado como entero (0-255).
extend(bytes): agrega varios bytes.
Indexar (ba[0]) devuelve un int, no un byte.

python

ba = bytearray(b'hola')
ba.append(33)           # agrega el byte 33 (!)
ba.extend(b' mundo')
print(ba)               # bytearray(b'hola! mundo')
 
print(ba[0])            # 104  -> un int, no un byte
print(ba[0:4])          # bytearray(b'hola')

Indexar un bytearray (o bytes) devuelve el entero del byte; hacer slicing devuelve otra secuencia de bytes. Por eso ba[0] da 104 pero ba[0:1] da bytearray(b'h').

Cuidado

schema

Leer por chunks

Un chunk es un grupo de bytes. Al manejar muchos datos no conviene leerlos todos de golpe (no caben en memoria) ni uno por uno (muy lento): el punto medio es leer en chunks de tamaño fijo.

python

muchos = bytearray(b'Una gran cantidad de bytes a leer de a poco')
TAM = 8
for i in range(0, len(muchos), TAM):
    chunk = muchos[i:i+TAM]
    print(chunk)

También se leen archivos por chunks pasando un número a file.read(n). El operador walrus := asigna y evalúa a la vez: el bucle termina cuando read devuelve bytes vacíos.

python

tune

Enteros ↔ bytes y endianness

Un número mayor a 255 no cabe en un solo byte, así que se reparte en varios. El orden de esos bytes se llama byteorder:

big endian: el byte más significativo va primero. El 256 es \x01\x00.
little endian: el byte más significativo va al final. El 256 es \x00\x01.

Decimal	big endian	little endian
256	`\x01\x00`	`\x00\x01`
269	`\x01\x0d`	`\x0d\x01`

to_bytes y from_bytes

int.to_bytes(length, byteorder): convierte un entero a un arreglo de bytes del largo dado.
int.from_bytes(bytes, byteorder): reconstruye el entero.

python

print((256).to_bytes(2, 'big'))     # b'\x01\x00'
print((256).to_bytes(2, 'little'))  # b'\x00\x01'
 
print(int.from_bytes(b'\x01\x00', 'big'))     # 256
print(int.from_bytes(b'\x01\x00', 'little'))  # 1