Différences entre fichiers texte et binaires

Fichiers texte : du texte lisible par un humain

Un fichier texte est un fichier qui contient du texte lisible par un humain. Il est composé d'une séquence de caractères, organisés en lignes (généralement).

Les fichiers texte sont encodés à l'aide d'un encodage de caractères (comme UTF-8, ASCII, Latin-1, etc.) qui définit la correspondance entre les caractères et leur représentation binaire (une séquence d'octets).

Exemples de fichiers texte :

• Fichiers source Python (`.py`).
• Fichiers HTML (`.html`).
• Fichiers CSV (`.csv`).
• Fichiers de configuration (`.ini`, `.cfg`).
• Fichiers journaux (`.log`).
• Fichiers texte brut (`.txt`).

Vous pouvez ouvrir et lire des fichiers texte avec un simple éditeur de texte (comme Notepad, TextEdit, VS Code, etc.).

Fichiers binaires : des données non textuelles

Un fichier binaire est un fichier qui contient des données qui ne sont *pas* destinées à être directement interprétées comme du texte. Il peut contenir n'importe quelle séquence d'octets.

Les fichiers binaires sont utilisés pour stocker des données de manière plus compacte et plus efficace que les fichiers texte. Ils ne sont généralement pas lisibles directement par un humain (sauf avec un éditeur hexadécimal).

Exemples de fichiers binaires :

• Images (`.jpg`, `.png`, `.gif`, etc.).
• Fichiers audio (`.mp3`, `.wav`, etc.).
• Vidéos (`.mp4`, `.avi`, etc.).
• Fichiers exécutables (`.exe`, `.dll` sur Windows, pas d'extension particulière sur Linux/macOS).
• Fichiers compressés (`.zip`, `.gz`, etc.).
• Fichiers de données sérialisées (par exemple, avec `pickle`).
• Bases de données.

Si vous essayez d'ouvrir un fichier binaire avec un éditeur de texte, vous verrez probablement une suite de caractères incompréhensibles (ou des erreurs).

Différences fondamentales et implications

Les principales différences entre les fichiers texte et binaires sont :

• Contenu : Les fichiers texte contiennent du texte (une séquence de caractères), tandis que les fichiers binaires peuvent contenir n'importe quelle séquence d'octets.
• Lisibilité : Les fichiers texte sont lisibles par un humain (avec un éditeur de texte), tandis que les fichiers binaires ne le sont généralement pas.
• Encodage : Les fichiers texte utilisent un encodage de caractères (UTF-8, ASCII, etc.). Les fichiers binaires n'ont pas d'encodage de caractères (ce sont des données brutes).
• Fin de ligne : En mode texte, Python gère les conversions de fin de ligne (par exemple, `\n` sur Unix, `\r\n` sur Windows). En mode binaire, aucune conversion n'est effectuée.
• Structure : Les fichiers texte ont souvent une structure (lignes, colonnes, etc.), alors que les fichiers binaires peuvent avoir n'importe quelle structure (ou pas de structure du tout).

Ces différences ont des implications importantes sur la manière dont vous devez ouvrir et manipuler les fichiers en Python.

Les modes 't' et 'b' de la fonction open()

Lorsque vous ouvrez un fichier avec la fonction `open()`, vous devez spécifier le mode d'ouverture. Le mode d'ouverture indique à Python comment vous voulez interagir avec le fichier (lecture, écriture, etc.) et *s'il s'agit d'un fichier texte ou binaire*.

Les modes `'t'` (texte) et `'b'` (binaire) déterminent le type de données que vous allez lire ou écrire :

• `'t'` (texte) : C'est le mode par défaut. `open()` retourne un objet fichier qui travaille avec des *chaînes de caractères* (`str`). Python effectue des conversions d'encodage (si `encoding` est spécifié) et de fin de ligne.
• `'b'` (binaire) : `open()` retourne un objet fichier qui travaille avec des *bytes* (`bytes`). Aucune conversion d'encodage ou de fin de ligne n'est effectuée.

Exemple :

# Ouvrir un fichier texte en lecture (mode texte par défaut)
with open("mon_fichier.txt", "r", encoding="utf-8") as f:
    contenu = f.read()  # contenu est une chaîne de caractères (str)

# Ouvrir un fichier binaire en lecture (mode binaire)
with open("mon_image.jpg", "rb") as f:
    donnees = f.read()  # donnees est un objet bytes

Si vous essayez de lire un fichier binaire en mode texte (ou vice versa), vous obtiendrez probablement des erreurs ou des résultats incorrects.

Conséquences sur la lecture et l'écriture

Le mode d'ouverture (`'t'` ou `'b'`) affecte la manière dont vous lisez et écrivez les données :

• Mode texte (`'t'`) :
  • `read()` retourne une chaîne de caractères (`str`).
  • `write()` prend une chaîne de caractères en argument.
  • Les conversions d'encodage et de fin de ligne sont gérées automatiquement (si `encoding` est spécifié).
• Mode binaire (`'b'`) :
  • `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 (écriture) :

# Mode texte
with open("texte.txt", "w", encoding="utf-8") as f:
    f.write("Bonjour, monde !")  # Ecrit une chaîne de caractères

# Mode binaire
with open("binaire.bin", "wb") as f:
    f.write(b"\x48\x65\x6c\x6c\x6f")  # Ecrit des bytes (Hello en ASCII)

Exemple (lecture) :

# Mode texte
with open("texte.txt", "r", encoding="utf-8") as f:
    contenu = f.read()  # contenu est une chaîne de caractères
    print(contenu)

# Mode binaire
with open("binaire.bin", "rb") as f:
    donnees = f.read()  # donnees est un objet bytes
    print(donnees)

En résumé, utilisez le mode texte (`'t'`, par défaut) pour les fichiers texte, et le mode binaire (`'b'`) pour les fichiers binaires. Assurez-vous de toujours spécifier l'encodage lorsque vous travaillez avec des fichiers texte.