Fonctions Python encoder () et décoder ()

| | | | | | | | | | | | | | | | | |

Les méthodes Python encode et decode sont utilisées pour encoder et décoder une chaîne d`entrée à l`aide d`un encodage donné. Examinons de plus près ces deux fonctions.

encoder la chaîne donnée

Nous utilisons la méthode encode () sur la chaîne d`entrée que chaque objet de chaîne a.

Format :



 input_string.encode (encodage, erreurs) 

C`est l`encodage t input_string en utilisant encoding , où errors définit le comportement à suivre si par hasard la chaîne n`est pas encodée.

encode () donnera la séquence bytes .

 inp_string = `Bonjour` bytes_encoded = inp_string.encode () print (type (bytes_encoded)) 

Comme prévu, l`objet résultant est "classe `octets` >  :

 "classe `octets` > 

Le type d`encodage à suivre est indiqué par le paramètre encoding . Il existe différents types de schémas d`encodage de caractères, dont Python est par défaut UTF-8.

Prenons un exemple d`encodage.

 a = `Ceci est une phrase simple.` print (` Chaîne originale : `, a) # Décode en utf-8 par défaut a_utf = a.encode () print (` Chaîne encodée : `, a_utf) 

Sortie

 Chaîne d`origine : il s`agit d`une phrase simple. Chaîne codée : b`Ceci est une phrase simple.` 

Comme vous pouvez le voir, nous avons encodé la chaîne d`entrée au format UTF-8. Bien qu`il n`y ait pas beaucoup de différence, vous remarquerez peut-être que la chaîne est préfixée par b . Cela signifie que la chaîne est convertie en un flux d`octets.

Ceci n`est en fait présenté que comme la chaîne d`origine pour la lisibilité, préfixé par b pour indiquer qu`il ne s`agit pas d`une chaîne mais une séquence d`octets.

Gestion des erreurs

Il existe différents types d`erreurs , dont certaines sont répertoriées ci-dessous :




Type d`erreur Comportement
strict Comportement par défaut qui déclenche UnicodeDecodeError sur échec.
ignore Ignore l`Unicode non codé du résultat.
replace Remplace tous les caractères Unicode non codés par un point d`interrogation (?)
backslashreplace < /td> Insère des tirets de séquence d`échappement antislash (uNNNN) au lieu de caractères Unicode non codés.

Regardons les concepts ci-dessus avec un exemple simple. Nous considérerons une chaîne d`entrée qui n`encode pas tous les caractères (par exemple, √∂ ),

 a = `C`est un peu m√∂re c√∂phrase complexe.` print(`Chaîne d`origine :`, a) print(`Encoding with errors = ignore:`, a.encode (encoding = `ascii`, errors =`ignore`)) print(`Encoding with errors = replace: `, a .encode (encoding =` ascii`, errors = `replace`)) 

Sortie

 Chaîne d`origine : il s`agit am√∂re c√∂phrase complexe. Encodage avec erreurs = ignorer : b`Ceci est une phrase un peu plus complexe.` Encodage avec erreurs = remplacer : b`C`est un peu m ? Re c? Phrase complexe.` 

Décodage d`un flux d`octets

Semblable à l`encodage d`une chaîne, nous pouvons décoder un flux d`octets en un objet chaîne à l`aide de la fonction decode () .

Format :

 encodé = input_string.encode () # Utilisation de decode () decodé = encodé.decode (décodage, erreurs) 

Parce que encode () convertit la chaîne en octets, decode () fait exactement le contraire.

 byte_seq = b`Hello` decoded_string = byte_seq .decode () print (type (decoded_string)) print (decoded_string) 

Sortie

 "classe `str` > Bonjour 

Cela indique que decode () convertit les octets en une chaîne Python.

Similaire aux options encode () , decoding définit le type d`encodage à partir duquel la séquence d`octets est décodée. Le paramètre errors spécifie le comportement en cas d`échec du décodage, qui a les mêmes valeurs ‚Äã‚Äãas encode () .

Importance de l`encodage

Étant donné que l`encodage et le décodage de la chaîne d`entrée dépendent du format, nous devons être prudents avec ces opérations. Si nous utilisons le mauvais format, cela entraînera une sortie incorrecte et peut provoquer des erreurs.

Le premier décodage est erroné car il tente de décoder la chaîne d`entrée codée au format UTF-8. La seconde est correcte car les formats d`encodage et de décodage sont les mêmes.

 a = `C`est un peu m√∂re c√∂mplex phrase.` print (` Original string: ` , a) # Encodage en UTF-8 encoded_bytes = a.encode (`utf-8`,` replace`) # Tentative de décodage via ASCII, qui est incorrect decoded_incorrect = encoded_bytes.decode (`ascii `,` remplacer`) decoded_correct = encoded_bytes.decode (`utf-8`,` remplacer`) print (`Chaîne décodée incorrectement :`, décodé_incorrect) print (`Chaîne correctement décodée :`, décodé_correct) 

Sortie

 Chaîne originale : c`est une phrase un peu m√∂re c√∂mplex. Chaîne décodée de manière incorrecte : il s`agit d`une phrase complexe bit m re c. Chaîne correctement décodée : il s`agit d`une phrase un peu m√∂re c√∂mplex.