Lecture et écriture d'octets

Le type bytes : une séquence d'octets

En Python, le type `bytes` représente une séquence d'octets (des entiers entre 0 et 255). Un objet `bytes` est *immuable* (vous ne pouvez pas modifier ses éléments).

Les objets `bytes` sont utilisés pour représenter des données binaires, comme des images, des fichiers audio, des données compressées, ou des données provenant d'un réseau.

Vous pouvez créer un objet `bytes` de plusieurs manières :

• En utilisant la notation littérale `b"..."` : Les caractères ASCII peuvent être représentés directement, les autres octets sont représentés par leur code hexadécimal (par exemple, `\x48` pour l'octet 72, qui correspond au caractère 'H' en ASCII).
• En utilisant la fonction `bytes()` : Vous pouvez convertir une liste d'entiers (entre 0 et 255) en un objet `bytes`.
• En utilisant la méthode `encode()` d'une chaîne de caractères (pour convertir une chaîne en bytes en utilisant un encodage spécifique).

Exemples :

# Création d'objets bytes
octets1 = b"Hello"  # Utilisation de la notation littérale (caractères ASCII)
octets2 = b"\x48\x65\x6c\x6c\x6f"  # Même chose, mais en utilisant les codes hexadécimaux
octets3 = bytes([72, 101, 108, 108, 111])  # A partir d'une liste d'entiers
chaine = "Héllö"
octets4 = chaine.encode("utf-8")  # Encodage d'une chaîne en UTF-8

print(octets1)
print(octets2)
print(octets3)
print(octets4)

Vous pouvez accéder aux octets individuels d'un objet `bytes` en utilisant l'indexation (comme pour les listes), mais vous obtiendrez des entiers (entre 0 et 255), pas des bytes de longueur 1.

Ouvrir un fichier en mode binaire : le mode 'b'

Pour lire ou écrire des données binaires dans un fichier, vous devez ouvrir le fichier en mode binaire, en utilisant le mode `'b'` dans la fonction `open()` (par exemple, `'rb'` pour lecture binaire, `'wb'` pour écriture binaire).

Lorsque vous ouvrez un fichier en mode binaire :

• `read()` retourne un objet `bytes`.
• `write()` prend un objet `bytes` en argument.
• Aucune conversion d'encodage ou de fin de ligne n'est effectuée.

Exemple :

with open("mon_fichier.bin", "wb") as fichier:
    donnees = b"\x00\xff\x7f\x80"  # Quelques octets
    fichier.write(donnees)

with open("mon_fichier.bin", "rb") as fichier:
    contenu = fichier.read()
    print(contenu)  # Affiche b'\x00\xff\x7f\x80'

Il est *essentiel* d'utiliser le mode binaire lorsque vous travaillez avec des fichiers binaires. Si vous utilisez le mode texte (par défaut), vous risquez de corrompre les données, car Python pourrait essayer d'interpréter les octets comme des caractères et d'effectuer des conversions d'encodage et de fin de ligne.

Lire des octets avec read() en mode binaire

Lorsque vous ouvrez un fichier en mode binaire (`'rb'`), la méthode `read()` retourne un objet `bytes` contenant les données lues.

Si vous appelez `read()` sans argument, tout le contenu du fichier est lu.

Si vous spécifiez un argument entier à `read()`, au plus ce nombre d'octets seront lus.

Exemple :

with open("mon_fichier.bin", "rb") as fichier:
    donnees = fichier.read()  # Lit tout le contenu du fichier
    print(donnees)

    fichier.seek(0)  # Revient au début du fichier

    premier_octet = fichier.read(1)  # Lit le premier octet
    print(premier_octet)

    dix_octets_suivants = fichier.read(10)  # Lit les 10 octets suivants
    print(dix_octets_suivants)

Vous pouvez utiliser les méthodes habituelles des objets `bytes` pour manipuler les données lues (indexation, slicing, etc.).

Ecrire des octets avec write() en mode binaire

Lorsque vous ouvrez un fichier en mode binaire (`'wb'`, `'ab'`, `'xb'`), la méthode `write()` prend un objet `bytes` en argument et écrit ces octets dans le fichier.

Exemple :

with open("mon_fichier.bin", "wb") as fichier:
    octets = b"\x48\x65\x6c\x6c\x6f"  # "Hello" en ASCII
    fichier.write(octets)

    autre_donnees = bytes([10, 20, 30])  # Une liste d'entiers
    fichier.write(autre_donnees)

Assurez-vous que les données que vous écrivez sont bien de type `bytes`. Si vous essayez d'écrire une chaîne de caractères en mode binaire, vous obtiendrez une `TypeError`. Vous devez d'abord encoder la chaîne en bytes (par exemple, avec `.encode('utf-8')`).

Exemple : copier un fichier binaire

Voici un exemple complet de copie d'un fichier binaire (par exemple, une image) :

def copier_fichier_binaire(source, destination):
    """Copie un fichier binaire."""
    try:
        with open(source, "rb") as f_source:
            with open(destination, "wb") as f_destination:
                while True:
                    chunk = f_source.read(4096)  # Lit par blocs de 4096 octets
                    if not chunk:
                        break  # Fin du fichier
                    f_destination.write(chunk)
    except FileNotFoundError:
      print('Fichier non trouvé')
    except Exception as e:
      print(f'Une erreur est survenue : {e}')

#copier_fichier_binaire("image.jpg", "image_copie.jpg")

Dans cet exemple :

• Le fichier source est ouvert en mode lecture binaire (`'rb'`).
• Le fichier destination est ouvert en mode écriture binaire (`'wb'`).
• Le fichier est lu par blocs de 4096 octets (vous pouvez ajuster la taille du bloc). C'est plus efficace que de lire le fichier entier d'un coup, surtout pour les gros fichiers.
• Chaque bloc est écrit dans le fichier de destination.
• La boucle s'arrête lorsque `read()` retourne un objet `bytes` vide (ce qui signifie que la fin du fichier a été atteinte).
• Les exceptions possibles sont gérées. Notament, la `FileNotFoundError`.