Comment convertir une chaîne de caractères en octets en Python

Les chaînes de caractères représentent du texte lisible par l'homme et constituent l'un des types de données les plus fondamentaux et les plus importants de la programmation informatique. Cependant, chaque caractère d'une chaîne de texte est représenté par un ou plusieurs octets de données binaires. Les applications telles que les opérations d'entrée et de sortie et la transmission de données exigent que les chaînes de caractères soient converties en octets à l'aide d'un codage spécifique.

Ce tutoriel explore les techniques de conversion de chaînes de caractères en octets en Python. Si l'opération inverse vous intéresse, consultez mon tutoriel sur pour savoir comment convertir des octets en chaînes de caractères en Python.

Avant d'entrer dans les détails, commençons par une réponse courte pour ceux d'entre vous qui sont pressés.

Réponse courte : Comment convertir une chaîne de caractères en octets en Python

Python permet de convertir facilement une chaîne de caractères en octets à l'aide de la méthode intégrée .encode():

my_string = "Hello, world!"
bytes_representation = my_string.encode(encoding="utf-8")  
# Optional: Specify the desired encoding (UTF-8 is the default)

print(bytes_representation)
# Output: b'Hello, world!'

La méthode .encode() renvoie un nouvel objet bytes représentant la version codée de la chaîne originale. Par défaut, il utilise le codage UTF-8, mais vous pouvez spécifier d'autres codages comme 'ascii' ou 'latin-1' si nécessaire.

Examinons ce processus de conversion plus en détail.

Comprendre les chaînes de caractères et les octets en Python

Deux des principaux types de données intégrés dans Python sont str et bytes. Ces types de données partagent des caractéristiques communes mais présentent des différences essentielles.

Tant str que bytes sont des séquences immuables, ​ce qui signifie que nous ne pouvons pas modifier leurs éléments après la création. Une chaîne est une séquence immuable de caractères, tandis qu'un objet bytes est une séquence immuable d'entiers compris entre 0 et 255. Cette gamme d'entiers peut être représentée par 8 bits, soit un octet. Par conséquent, un objet bytes est une séquence d'octets.

Codage des caractères ASCII

Considérons d'abord les caractères ASCII. L'ASCII (American Standard Code for Information Interchange) est un codage de caractères qui ne contient que 128 caractères. Par conséquent, tout caractère ASCII peut être représenté par sept bits, ce qui est inférieur à un octet.

Nous pouvons créer un objet bytes en ajoutant b devant les guillemets simples, doubles ou triples que nous utilisons normalement pour les chaînes de caractères :

word_as_bytes = b"Python"
print(word_as_bytes)
print(type(word_as_bytes))

b'Python'
<class 'bytes'>

Bien que le code affiche les caractères en épelant Python, chaque élément de l'objet bytes est un nombre entier compris entre 0 et 255 :

print(word_as_bytes[0])
print(list(word_as_bytes))

80
[80, 121, 116, 104, 111, 110]

Le premier élément de word_as_bytes est l'entier 80, qui est le code ASCII pour le P majuscule :

print(chr(80))

P

Lorsque l'on convertit word_as_bytes en liste, la liste contient les entiers représentant chaque octet. Les nombres entiers sont les codes ASCII des lettres du mot Python.

Cependant, le jeu de caractères ASCII est limité.

Codage des caractères UTF-8

Le codage de caractères le plus courant est UTF-8, qui est un codage Unicode sur 8 bits. Les 128 caractères ASCII sont représentés par les mêmes entiers dans l'UTF-8, mais d'autres caractères peuvent également être représentés en utilisant deux octets ou plus pour chaque caractère.

Créons un objet bytes en utilisant des caractères non ASCII. Nous devons utiliser le constructeur bytes():

word_as_bytes = bytes("café", "utf-8")
print(word_as_bytes)

b'caf\xc3\xa9'

L'objet bytes affiche directement les trois premières lettres de café. Cependant, le é accentué n'est pas un caractère ASCII, et il est représenté par deux octets, qui sont affichés comme \xc3 et \xa9. Ces octets représentent les nombres hexadécimaux c3 et a9, qui sont les nombres entiers 195 et 169. Ces deux octets combinés représentent é en UTF-8 :

print(len(word_as_bytes))
print(list(word_as_bytes))

5
[99, 97, 102, 195, 169]

Un objet bytes à cinq éléments représente la chaîne de quatre lettres.

Conversion des chaînes de caractères en octets : La méthode encode()

Plus tôt, nous avons utilisé le constructeur bytes() pour convertir une chaîne de texte en un objet bytes. Un moyen plus courant de convertir des chaînes Python en octets consiste à utiliser la méthode .encode() string, qui permet de contrôler le codage et la gestion des erreurs. Cette méthode renvoie un objet bytes qui représente la chaîne de caractères :

word_as_bytes = "Hello Python!".encode()
​print(word_as_bytes)
print(type(word_as_bytes))

b'Hello Python!'
<class 'bytes'>

La méthode .encode() utilise par défaut le codage UTF-8. UTF-8 est le format d'encodage le plus largement utilisé, et il prend en charge une gamme de caractères beaucoup plus large que l'ASCII. L'UTF-8 représente chaque caractère par une séquence d'unités d'un, deux, trois ou quatre octets.

Nous pouvons appeler .encode() avec un encodage alternatif comme argument :

word_as_bytes = "Hello Python!".encode("utf-16")
print(word_as_bytes)

b'\xff\xfeH\x00e\x00l\x00l\x00o\x00 \x00P\x00y\x00t\x00h\x00o\x00n\x00!\x00'

L'objet bytes est différent dans ce cas puisqu'il représente le codage UTF-16 de la même chaîne de texte.

Erreurs d'encodage

Comme tous les encodages ne comprennent pas tous les caractères, des erreurs peuvent se produire lors de l'encodage d'une chaîne dans un objet bytes.

Considérons la chaîne "Café • £2.20", qui contient trois caractères non ASCII. Nous pouvons l'encoder en utilisant l'encodage UTF-8 par défaut :

word_as_bytes = "Café • £2.20".encode()
print(word_as_bytes)

b'Caf\xc3\xa9 \xe2\x80\xa2 \xc2\xa32.20'

Les caractères non ASCII sont remplacés par leurs séquences d'échappement hexadécimales. Cependant, .encode() soulève une erreur si la même chaîne est encodée en ASCII car plusieurs caractères ne sont pas présents dans l'encodage ASCII :

word_as_bytes = "Café • £2.20".encode("ascii")
print(word_as_bytes)

Traceback (most recent call last):
...
word_as_bytes = "Café • £2.20".encode("ascii")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 3: ordinal not in range(128)

La méthode de la chaîne .encode() a un paramètre errors, dont la valeur par défaut est "strict". L'argument "strict" oblige .encode() à afficher UnicodeEncodeError lorsqu'un caractère ne peut pas être encodé.

Cependant, il existe d'autres options pour traiter les erreurs. Une option consiste à ignorer les erreurs en utilisant l'argument "ignore":

word_as_bytes = "Café • £2.20".encode("ascii", errors="ignore")
print(word_as_bytes)

b'Caf 2.20'

Cette option n'entraîne pas d'erreur. Au lieu de cela, .encode() renvoie un objet bytes, et le é accentué, le point et le dièse sont omis.

Une autre option consiste à remplacer les caractères qui ne peuvent pas être encodés par quelque chose d'autre. Il existe plusieurs options de remplacement. L'un d'entre eux est l'argument errors="replace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="replace")
print(word_as_bytes)

b'Caf? ? ?2.20'

Les trois caractères non ASCII, qui ne peuvent pas être encodés dans cet exemple, sont remplacés par un point d'interrogation. Par conséquent, chaque caractère manquant est remplacé par un autre caractère unique qui sert de substitut.

Nous pouvons également remplacer les caractères manquants par un texte plus informatif :

word_as_bytes = "Café • £2.20".encode("ascii", errors="backslashreplace")
print(word_as_bytes)

b'Caf\\xe9 \\u2022 \\xa32.20'

L'appel de .encode() avec errors="backslashreplace" remplace les caractères qui ne peuvent pas être encodés par leurs séquences d'échappement hexadécimales. Le nombre hexadécimal e9 représente le é accentué. Le point est le caractère Unicode u2022, et le nombre hexadécimal a3 représente le dièse.

Nous pouvons également utiliser "xmlcharrefreplace" pour remplacer les caractères manquants par leur code XML :

word_as_bytes = "Café • £2.20".encode("ascii", errors="xmlcharrefreplace")
print(word_as_bytes)

b'Café • £2.20'

Une autre option consiste à remplacer les caractères non valides par leur nom formel à l'aide de errors="namereplace":

word_as_bytes = "Café • £2.20".encode("ascii", errors="namereplace")
print(word_as_bytes)

b'Caf\\N{LATIN SMALL LETTER E WITH ACUTE} \\N{BULLET} \\N{POUND SIGN}2.20'

Différentes situations peuvent nécessiter une gestion des erreurs adaptée, et la méthode .encode() string offre plusieurs options pour traiter les caractères qui ne peuvent pas être encodés.

Applications de la conversion chaîne-octet en science des données

La conversion de chaînes de caractères en octets est une opération fondamentale qui trouve des applications dans divers domaines de la science des données :

• Traitement du langage naturel (NLP): Lorsque nous travaillons avec des données textuelles pour des tâches telles que l'analyse des sentiments, la modélisation des sujets ou la traduction automatique, nous traitons souvent le texte en le transformant en mots ou en sous-mots. Ce processus de tokenisation implique souvent la conversion de chaînes de caractères en séquences d'octets pour une représentation et une manipulation efficaces.
• Nettoyage et prétraitement des données : Les opérations au niveau de l'octet peuvent être utiles pour nettoyer les données textuelles, par exemple en supprimant les caractères non valides ou en normalisant le texte sur la base de modèles d'octets spécifiques.
• Ingénierie de fonctionnalité : Dans certains cas, des caractéristiques au niveau de l'octet (par exemple, des n-grammes d'octets) peuvent être extraites des données textuelles et utilisées comme caractéristiques d'entrée pour les modèles d'apprentissage automatique.
• Le scraping et l'extraction de données sur le web : Lorsque nous récupérons des données sur des sites web, nous recevons souvent du HTML ou d'autres contenus textuels qui doivent être analysés et traités au niveau de l'octet pour en extraire les informations pertinentes.
• Compression des données : Certains algorithmes de compression de données opèrent sur des séquences d'octets, de sorte que la conversion de chaînes de caractères en octets peut être une étape nécessaire avant d'appliquer des techniques de compression.

La compréhension de ces applications peut nous aider à identifier les situations dans lesquelles la conversion de chaînes en octets peut s'avérer utile.

Conclusion

Les chaînes de caractères sont des séquences de caractères lisibles par l'homme. Ces caractères sont codés sous forme d'octets de données binaires, qui peuvent être stockés dans un objet bytes. Un objet bytes est une séquence d'entiers, chaque entier représentant un octet.

Les applications exigent que les chaînes soient converties en objets bytes, que nous pouvons convertir à l'aide du constructeur bytes() ou de la méthode string .encode(). La maîtrise de la conversion entre chaînes de caractères et octets permet une manipulation plus souple des données.

Vous pouvez poursuivre votre apprentissage de Python avec les tutoriels et cours suivants :

• Cours d'introduction à Python
• Programmation en Python
• Principes de base de Python