`memoryview`, `struct`¶

Par Marc Schnaebele 1

`bytes`¶

Le type bytes fait partie des types dits de séquence. Il permet de traiter les chaines d’octets.

Instanciation¶

syntaxe

bytes([initializer[, encoding]])

exemple

"""Module d'exemple d'instanciation d'un bytes."""


msg = bytes('exemple', encoding='utf-8')
# On peut aussi affecter une chaine directement
# mais l'encodage par défaut sera utilisé.
msg = b"exemple$"

Affichage¶

Le b est affiché pour bien préciser que c’est une chaine de type bytes.

b'exemple'

Accès¶

Accède à la première valeur à la clé 0 donc b’e” dans l’exemple ci-dessus.

msg[0]

opérations¶

Cast bytes <–> str

"""Module d'exemple de cast entre un bytes et un string."""


# Cast string en bytes.
my_str = "exemple"
bytes = str.encode(my_str)

# Cast bytes en string.
my_decoded_str = str.decode(bytes)
type(my_decoded_str)  # vérifie que le type est string

Cast int <–> bytes

"""Module d'exemple de cast entre un bytes et un int."""


i = 16

# Crée 1 byte avec un int 16.
# Attention à utiliser le bon encodage (little ou big endian).
# vérifiez avec sys.byteorder.
single_byte = i.to_bytes(1, byteorder='big', signed=True)
print(single_byte)

# Crée un bytes avec une liste de int (0-255).
# sortie: b'\xff\xfe\xfd\xfc.
bytes_from_list = bytes([255, 254, 253, 252])

# Print out binary string (e.g. 0b010010).
print(bin(22))

# Bytes à Integer.
# Crée un int avec un bytes (non signé par défaut).
i = int.from_bytes('12', byteorder='big')

# Crée un int signé.
i = int.from_bytes(b'\x00\x0F', byteorder='big', signed=True)

# Utilise une liste d'entiers comme source pour le cast.
i = int.from_bytes([255, 0, 0, 0], byteorder='big')

Un tableau résumant les opérations standards sur les bytes se trouve sur la documentation officielle des Built-in Types.

`bytearray`¶

Le type bytearray est un tableau de bytes et contient donc un objet bytes dans chaque clé. Il n’y a donc pas de différence un bytarray est une collection de bytes.

Instanciation¶

bytearray([initializer[, encoding]])

exemple

"""Module d'exemple d'instanciation un bytearray."""


# Crée un bytearray à partir d'un objet bytes.
msg = bytearray(b"exemple")
# Crée un  bytearray à partir d'une chaine de caractères.
msg = bytearray("exemple", "utf-8")
# Crée un  bytearray à partir d'une liste d'entiers entre 0 et 255.
msg = bytearray([94, 91, 101, 125, 111, 35, 120, 101, 115, 101, 200])

# hexadécimal.
0xff  # sortie 255.
# binaire.
0b100  # sortie 4.

# autres possibilitées.
"{:x}".format(int.from_bytes("exemple".encode("utf-8"), byteorder="big"))
# sortie '6578656d706c65'.

# 65 est la lettre 'e' en hexadécimal.
f"{ord('e'):x}"  # sortie '65'.

Accès¶

Accède la première valeur à l’emplacement donc b'exemple' dans l’exemple ci-dessus.

msg[0]

Opérations¶

En plus des opérations, ci-dessous voir les opérations de bytes ci-dessus.

"""Module d'exemple de cast entre bytes et bytearray."""


# Cast bytes à bytearray.
mutable_bytes = bytearray(b'\x00\x0F')

# Cast bytearray à bytes.
immutable_bytes = bytes(mutable_bytes)

`memoryview`¶

Une memoryview est un objet permettant d’utiliser des buffers afin de pouvoir les manipuler comme tout autre objet Python.

Instanciation¶

"""Module d'exemple d'instanciation d'une memoryview."""


# Crée une memoryview à partir d'un objet byte.
mv = memoryview(b'exemple')

Opérations¶

"""Module d'exemple des opérations avec une memoryview."""


# retourne les données comme string de bytes.
# sortie: b'abc'.
mv = memoryview(b"abc")
mv.tobytes()

# retourne les données en hexadécimale.
# sortie: '616263'.
mv = memoryview(b"abc")
mv.hex()

# retourne les données en une lsite d'élements.
# sortie: [97, 98, 99].
memoryview(b'abc').tolist()

# relacher le buffer.
mv.release()

Plus d’opérations sur les memoryview dans la documentation des Built-in Types.

Exemple d’utilisation¶

"""Module d'exemple d'une memoryview."""


buf = bytearray(b'abcdefgh')
mv = memoryview(buf)
mv[4:6] = b'ZA'
buf
# sortie bytearray(b'abcdZAgh')

Avec bytearray:

"""Module d'exemple d'une memoryview avec un bytearray."""


# Avec bytearray.
buf = bytearray(b'abcdefgh')
mv = memoryview(buf)
mv[4:6] = b'ZA'
buf
bytearray(b'abcdZAgh')

`struct`¶

Un struct permet de convertir des structures C en valeurs Python représenté sous forme d’objets bytes. Ceux-ci sont utilisés pour manipuler des données binaire depuis des fichiers, le réseau ou d’autres sources.

Exemple d’utilisation¶

"""Module d'exemple struct."""


from collections import namedtuple
from struct import pack, unpack

# packing et unpacking de trois entiers.
pack('hhl', 1, 2, 3)
# sortie : '\x00\x01\x00\x02\x00\x00\x00\x03'
unpack('hhl', '\x00\x01\x00\x02\x00\x00\x00\x03')
# sortie : (1, 2, 3)

# On peut assigner des noms aux champs.
record = 'raymond   \x32\x12\x08\x01\x08'
name, serialnum, school, gradelevel = unpack('<10sHHb', record)

Student = namedtuple('Student', 'name serialnum school gradelevel')
Student._make(unpack('<10sHHb', record))
Student(name='raymond   ', serialnum=4658, school=264, gradelevel=8)