Guide Unicode
*************

Version:
   1.12

This HOWTO discusses Python support for Unicode, and explains various
problems that people commonly encounter when trying to work with
Unicode.


Introduction à Unicode
======================


Histoire des codes de caractères
--------------------------------

En 1968, l'*American Standard Code for Information Interchange*, mieux
connu sous son acronyme *ASCII*, a été normalisé.  L'ASCII définissait
des codes numériques  pour différents caractères, les valeurs
numériques s'étendant de 0 à 127.  Par exemple, la lettre minuscule «
a » est assignée à 97 comme valeur de code.

ASCII était une norme développée par les États-Unis, elle ne
définissait donc que des caractères non accentués.  Il y avait « e »,
mais pas « é » ou « Í ».  Cela signifiait que les langues qui
nécessitaient des caractères accentués ne pouvaient pas être
fidèlement représentées en ASCII. (En fait, les accents manquants
importaient pour l'anglais aussi, qui contient des mots tels que «
naïve » et « café », et certaines publications ont des styles propres
qui exigent des orthographes tels que « *coöperate* ».)

Pendant un certain temps, les gens ont juste écrit des programmes qui
n'affichaient pas d'accents. Au milieu des années 1980, un programme
Apple II BASIC écrit par un français pouvait avoir des lignes comme
celles-ci :

   PRINT "MISE A JOUR TERMINEE"
   PRINT "PARAMETRES ENREGISTRES"

Ces messages devraient contenir des accents (terminée, paramètre,
enregistrés) et ils ont juste l'air anormaux à quelqu'un lisant le
français.

Dans les années 1980, presque tous les ordinateurs personnels étaient
à 8 bits, ce qui signifie que les octets pouvaient contenir des
valeurs allant de 0 à 255.  Les codes ASCII allaient seulement jusqu'à
127, alors certaines machines ont assigné les valeurs entre 128 et 255
à des caractères accentués.  Différentes machines avaient des codes
différents, cependant, ce qui a conduit à des problèmes d'échange de
fichiers. Finalement, divers ensembles de valeurs couramment utilisés
pour la gamme 128--255 ont émergé. Certains étaient de véritables
normes, définies par l'Organisation internationale de normalisation,
et certaines étaient des conventions *de facto* qui ont été inventées
par une entreprise ou une autre et qui ont fini par se répandre.

255 caractères, ça n'est pas beaucoup.  Par exemple, vous ne pouvez
pas contenir à la fois les caractères accentués utilisés en Europe
occidentale et l'alphabet cyrillique utilisé pour le russe dans la
gamme 128--255, car il y a plus de 128 de tous ces caractères.

Vous pouviez écrire les fichiers avec des codes différents (tous vos
fichiers russes dans un système de codage appelé *KOI8*, tous vos
fichiers français dans un système de codage différent appelé
*Latin1*), mais que faire si vous souhaitiez écrire un document
français citant du texte russe ? Dans les années 80, les gens ont
commencé à vouloir résoudre ce problème, et les efforts de
standardisation Unicode ont commencé.

Unicode a commencé par utiliser des caractères 16 bits au lieu de 8
bits. 16 bits signifie que vous avez 2^16 = 65 536 valeurs distinctes
disponibles, ce qui permet de représenter de nombreux caractères
différents à partir de nombreux alphabets différents. Un des objectifs
initiaux était de faire en sorte que Unicode contienne les alphabets
de chaque langue humaine. Il s’avère que même 16 bits ne suffisent pas
pour atteindre cet objectif, et la spécification Unicode moderne
utilise une gamme de codes plus étendue, allant de 0 à 1 114 111
("0x10FFFF" en base 16).

Il existe une norme ISO connexe, ISO 10646. Unicode et ISO 10646
étaient à l’origine des efforts séparés, mais les spécifications ont
été fusionnées avec la révision 1.1 d’Unicode.

(Cette discussion sur l’historique d’Unicode est extrêmement
simplifiée. Les détails historiques précis ne sont pas nécessaires
pour comprendre comment utiliser efficacement Unicode, mais si vous
êtes curieux, consultez le site du consortium Unicode indiqué dans les
références ou la page Wikipédia pour Unicode (page en anglais) pour
plus d’informations.)


Définitions
-----------

A **character** is the smallest possible component of a text.  'A',
'B', 'C', etc., are all different characters.  So are 'È' and 'Í'.
Characters are abstractions, and vary depending on the language or
context you're talking about.  For example, the symbol for ohms (Ω) is
usually drawn much like the capital letter omega (Ω) in the Greek
alphabet (they may even be the same in some fonts), but these are two
different characters that have different meanings.

The Unicode standard describes how characters are represented by
**code points**.  A code point is an integer value, usually denoted in
base 16.  In the standard, a code point is written using the notation
"U+12CA" to mean the character with value "0x12ca" (4,810 decimal).
The Unicode standard contains a lot of tables listing characters and
their corresponding code points:

   0061    'a'; LATIN SMALL LETTER A
   0062    'b'; LATIN SMALL LETTER B
   0063    'c'; LATIN SMALL LETTER C
   ...
   007B    '{'; LEFT CURLY BRACKET

Strictly, these definitions imply that it's meaningless to say 'this
is character "U+12CA"'.  "U+12CA" is a code point, which represents
some particular character; in this case, it represents the character
'ETHIOPIC SYLLABLE WI'.  In informal contexts, this distinction
between code points and characters will sometimes be forgotten.

Un caractère est représenté sur un écran ou sur papier par un ensemble
d’éléments graphiques appelé **glyphe**. Le glyphe d’un A majuscule,
par exemple, est deux traits diagonaux et un trait horizontal, bien
que les détails exacts dépendent de la police utilisée. La plupart du
code Python n’a pas besoin de s’inquiéter des glyphes ; trouver le bon
glyphe à afficher est généralement le travail d’une boîte à outils GUI
ou du moteur de rendu des polices d’un terminal.


Encodages
---------

To summarize the previous section: a Unicode string is a sequence of
code points, which are numbers from 0 through "0x10FFFF" (1,114,111
decimal).  This sequence needs to be represented as a set of bytes
(meaning, values from 0 through 255) in memory.  The rules for
translating a Unicode string into a sequence of bytes are called an
**encoding**.

The first encoding you might think of is an array of 32-bit integers.
In this representation, the string "Python" would look like this:

      P           y           t           h           o           n
   0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
      0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Cette représentation est simple mais son utilisation pose un certain
nombre de problèmes.

1. Elle n’est pas portable ; des processeurs différents ordonnent les
   octets différemment.

2. Elle gâche beaucoup d'espace. Dans la plupart des textes, la
   majorité des points de code sont inférieurs à 127, ou à 255, donc
   beaucoup d'espace est occupé par des octets "0x00". La chaîne ci-
   dessus occupe 24 octets, à comparer aux 6 octets nécessaires pour
   une représentation en ASCII. L'utilisation supplémentaire de RAM
   n'a pas trop d'importance (les ordinateurs de bureau ont des
   gigaoctets de RAM et les chaînes ne sont généralement pas si
   grandes que ça), mais l'accroissement de notre utilisation du
   disque et de la bande passante réseau par un facteur de 4 est
   intolérable.

3. Elle n’est pas compatible avec les fonctions C existantes telles
   que "strlen()", il faudrait donc utiliser une nouvelle famille de
   fonctions, celle des chaînes larges (*wide strings*).

4. De nombreuses normes Internet sont définies en termes de données
   textuelles et ne peuvent pas gérer le contenu incorporant des
   octets *zéro*.

Généralement, les gens n’utilisent pas cet encodage, mais optent pour
d’autres encodages plus efficaces et pratiques. UTF-8 est probablement
l’encodage le plus couramment pris en charge ; celui-ci sera abordé
ci-dessous.

Les encodages n'ont pas à gérer tous les caractères Unicode possibles,
et les plupart ne le font pas. Les règles pour convertir une chaîne
Unicode en codage ASCII, par exemple, sont simples. pour chaque point
de code :

1. Si le point de code est < 128, chaque octet est identique à la
   valeur du point de code.

2. Si le point de code est égal à 128 ou plus, la chaîne Unicode ne
   peut pas être représentée dans ce codage (Python déclenche une
   exception "UnicodeEncodeError" dans ce cas).

Latin-1, également connu sous le nom de ISO-8859-1, est un encodage
similaire. Les points de code Unicode 0–255 étant identiques aux
valeurs de Latin-1, la conversion en cet encodage nécessite simplement
la conversion des points de code en octets de même valeur ; si un
point de code supérieur à 255 est rencontré, la chaîne ne peut pas
être codée en latin-1.

Les encodages ne doivent pas nécessairement être de simples mappages
un à un, comme Latin-1. Prenons l’exemple du code EBCDIC d’IBM,
utilisé sur les ordinateurs centraux IBM. Les valeurs de lettre ne
faisaient pas partie d’un bloc: les lettres « a » à « i » étaient
comprises entre 129 et 137, mais les lettres « j » à « r » étaient
comprises entre 145 et 153. Si vous vouliez utiliser EBCDIC comme
encodage, vous auriez probablement utilisé une sorte de table de
correspondance pour effectuer la conversion, mais il s’agit en surtout
d’un détail d'implémentation.

UTF-8 is one of the most commonly used encodings.  UTF stands for
"Unicode Transformation Format", and the '8' means that 8-bit numbers
are used in the encoding.  (There are also a UTF-16 and UTF-32
encodings, but they are less frequently used than UTF-8.)  UTF-8 uses
the following rules:

1. Si le point de code est < 128, il est représenté par la valeur de
   l'octet correspondant.

2. Si le point de code est ≥ 128, il est transformé en une séquence de
   deux, trois ou quatre octets, où chaque octet de la séquence est
   compris entre 128 et 255.

UTF-8 a plusieurs propriétés intéressantes :

1. Il peut gérer n'importe quel point de code Unicode.

2. A Unicode string is turned into a sequence of bytes containing no
   embedded zero bytes.  This avoids byte-ordering issues, and means
   UTF-8 strings can be processed by C functions such as "strcpy()"
   and sent through protocols that can't handle zero bytes.

3. Une chaîne de texte ASCII est également un texte UTF-8 valide.

4. UTF-8 est assez compact. La majorité des caractères couramment
   utilisés peuvent être représentés avec un ou deux octets.

5. Si des octets sont corrompus ou perdus, il est possible de
   déterminer le début du prochain point de code encodé en UTF-8 et de
   se resynchroniser. Il est également improbable que des données
   8-bits aléatoires ressemblent à du UTF-8 valide.


Références
----------

Le site du Consortium Unicode, en anglais, a des diagrammes de
caractères, un glossaire et des versions PDF de la spécification
Unicode. Préparez-vous à une lecture difficile. Une chronologie de
l’origine et du développement de l’Unicode est également disponible
sur le site.

To help understand the standard, Jukka Korpela has written an
introductory guide to reading the Unicode character tables.

Another good introductory article was written by Joel Spolsky. If this
introduction didn't make things clear to you, you should try reading
this alternate article before continuing.

Les pages Wikipédia sont souvent utiles ; voir les pages pour « Codage
des caractères » et UTF-8, par exemple.


Prise en charge Unicode de Python
=================================

Maintenant que vous avez appris les rudiments de l'Unicode, nous
pouvons regarder les fonctionnalités Unicode de Python.


Le type *String*
----------------

Since Python 3.0, the language features a "str" type that contain
Unicode characters, meaning any string created using ""unicode
rocks!"", "'unicode rocks!'", or the triple-quoted string syntax is
stored as Unicode.

L'encodage par défaut pour le code source Python est UTF-8, il est
donc facile d'inclure des caractères Unicode dans une chaîne littérale
:

   try:
       with open('/tmp/input.txt', 'r') as f:
           ...
   except OSError:
       # 'File not found' error message.
       print("Fichier non trouvé")

You can use a different encoding from UTF-8 by putting a specially-
formatted comment as the first or second line of the source code:

   # -*- coding: <encoding name> -*-

Note : Python 3 sait gérer les caractères Unicode dans les
identifiants :

   répertoire = "/tmp/records.log"
   with open(répertoire, "w") as f:
       f.write("test\n")

Si vous ne pouvez pas entrer un caractère particulier dans votre
éditeur ou si vous voulez garder le code source uniquement en ASCII
pour une raison quelconque, vous pouvez également utiliser des
séquences d'échappement dans les littéraux de chaîne (en fonction de
votre système, il se peut que vous voyiez le glyphe réel du *delta
majuscule* au lieu d'une séquence d'échappement "\u...")

   >>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
   '\u0394'
   >>> "\u0394"                          # Using a 16-bit hex value
   '\u0394'
   >>> "\U00000394"                      # Using a 32-bit hex value
   '\u0394'

De plus, une chaîne de caractères peut être créée en utilisant la
méthode "decode()" de la classe "bytes". Cette méthode prend un
argument *encoding*, "UTF-8" par exemple, et optionnellement un
argument *errors*.

L'argument *errors* détermine la réponse lorsque la chaîne en entrée
ne peut pas être convertie selon les règles de l'encodage. Les valeurs
autorisées pour cet argument sont "'strict'" (« strict » : lève une
exception "UnicodeDecodeError"), "'replace'" (« remplacer » : utilise
"U+FFFD", "REPLACEMENT CARACTER"), "'ignore'" (« ignorer » : n'inclut
pas le caractère dans le résultat Unicode) ou "'backslashreplace'" («
remplacer avec antislash » : insère une séquence d’échappement
"\xNN"). Les exemples suivants illustrent les différences :

   >>> b'\x80abc'.decode("utf-8", "strict")  
   Traceback (most recent call last):
       ...
   UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:
     invalid start byte
   >>> b'\x80abc'.decode("utf-8", "replace")
   '\ufffdabc'
   >>> b'\x80abc'.decode("utf-8", "backslashreplace")
   '\\x80abc'
   >>> b'\x80abc'.decode("utf-8", "ignore")
   'abc'

Encodings are specified as strings containing the encoding's name.
Python 3.2 comes with roughly 100 different encodings; see the Python
Library Reference at Standard Encodings for a list.  Some encodings
have multiple names; for example, "'latin-1'", "'iso_8859_1'" and
"'8859"' are all synonyms for the same encoding.

Des chaînes Unicode à un caractère peuvent également être créées avec
la fonction native "chr()", qui prend des entiers et renvoie une
chaîne Unicode de longueur 1 qui contient le point de code
correspondant. L'opération inverse est la fonction native "ord()" qui
prend une chaîne Unicode d'un caractère et renvoie la valeur du point
de code :

   >>> chr(57344)
   '\ue000'
   >>> ord('\ue000')
   57344


Conversion en octets
--------------------

La méthode inverse de "bytes.decode()" est "str.encode()", qui renvoie
une représentation "bytes" de la chaîne Unicode, codée dans l’encodage
*encoding* demandé.

Le paramètre *errors* est le même que le paramètre de la méthode
"decode()" mais possède quelques gestionnaires supplémentaires. En
plus de "'strict'", "'ignore'" et "'remplace'" (qui dans ce cas insère
un point d'interrogation au lieu du caractère non codable), il y a
aussi "'xmlcharrefreplace'" (insère une référence XML),
"backslashreplace" (insère une séquence "\uNNNN") et "namereplace"
(insère une séquence "\N{...}").

L'exemple suivant montre les différents résultats :

   >>> u = chr(40960) + 'abcd' + chr(1972)
   >>> u.encode('utf-8')
   b'\xea\x80\x80abcd\xde\xb4'
   >>> u.encode('ascii')  
   Traceback (most recent call last):
       ...
   UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
     position 0: ordinal not in range(128)
   >>> u.encode('ascii', 'ignore')
   b'abcd'
   >>> u.encode('ascii', 'replace')
   b'?abcd?'
   >>> u.encode('ascii', 'xmlcharrefreplace')
   b'&#40960;abcd&#1972;'
   >>> u.encode('ascii', 'backslashreplace')
   b'\\ua000abcd\\u07b4'
   >>> u.encode('ascii', 'namereplace')
   b'\\N{YI SYLLABLE IT}abcd\\u07b4'

Les routines de bas niveau pour enregistrer et accéder aux encodages
disponibles se trouvent dans le module "codecs". L'implémentation de
nouveaux encodages nécessite également de comprendre le module
"codecs". Cependant, les fonctions d'encodage et de décodage renvoyées
par ce module sont généralement de bas-niveau pour être facilement
utilisées et l'écriture de nouveaux encodages est une tâche très
spécialisée, donc le module ne sera pas couvert dans ce guide.


Littéraux Unicode dans le code source Python
--------------------------------------------

Dans le code source Python, des points de code Unicode spécifiques
peuvent être écrits en utilisant la séquence d'échappement "\u",
suivie de quatre chiffres hexadécimaux donnant le point de code. La
séquence d'échappement "\U" est similaire, mais attend huit chiffres
hexadécimaux, pas quatre :

   >>> s = "a\xac\u1234\u20ac\U00008000"
   ... #     ^^^^ two-digit hex escape
   ... #         ^^^^^^ four-digit Unicode escape
   ... #                     ^^^^^^^^^^ eight-digit Unicode escape
   >>> [ord(c) for c in s]
   [97, 172, 4660, 8364, 32768]

L'utilisation de séquences d'échappement pour des points de code
supérieurs à 127 est acceptable à faible dose, mais devient gênante si
vous utilisez beaucoup de caractères accentués, comme c'est le cas
dans un programme avec des messages en français ou dans une autre
langue utilisant des lettres accentuées. Vous pouvez également
assembler des chaînes de caractères à l'aide de la fonction native
"chr()", mais c'est encore plus fastidieux.

Idéalement, vous devriez être capable d'écrire des littéraux dans
l'encodage naturel de votre langue. Vous pourriez alors éditer le code
source de Python avec votre éditeur favori qui affiche les caractères
accentués naturellement, et a les bons caractères utilisés au moment
de l'exécution.

Python considère que le code source est écrit en UTF-8 par défaut,
mais vous pouvez utiliser presque n'importe quel encodage si vous
déclarez l'encodage utilisé. Cela se fait en incluant un commentaire
spécial sur la première ou la deuxième ligne du fichier source :

   #!/usr/bin/env python
   # -*- coding: latin-1 -*-

   u = 'abcdé'
   print(ord(u[-1]))

La syntaxe s'inspire de la notation d'*Emacs* pour spécifier les
variables locales à un fichier. *Emacs* supporte de nombreuses
variables différentes, mais Python ne gère que *coding*. Les symboles
"-*-" indiquent à *Emacs* que le commentaire est spécial ; ils n'ont
aucune signification pour Python mais sont une convention. Python
cherche "coding: name" ou "coding=name" dans le commentaire.

Si vous n'incluez pas un tel commentaire, l'encodage par défaut est
UTF-8 comme déjà mentionné. Voir aussi la **PEP 263** pour plus
d'informations.


Propriétés Unicode
------------------

The Unicode specification includes a database of information about
code points. For each defined code point, the information includes the
character's name, its category, the numeric value if applicable
(Unicode has characters representing the Roman numerals and fractions
such as one-third and four-fifths).  There are also properties related
to the code point's use in bidirectional text and other display-
related properties.

Le programme suivant affiche des informations sur plusieurs caractères
et affiche la valeur numérique d'un caractère particulier :

   import unicodedata

   u = chr(233) + chr(0x0bf2) + chr(3972) + chr(6000) + chr(13231)

   for i, c in enumerate(u):
       print(i, '%04x' % ord(c), unicodedata.category(c), end=" ")
       print(unicodedata.name(c))

   # Get numeric value of second character
   print(unicodedata.numeric(u[1]))

Si vous l'exécutez, cela affiche :

   0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE
   1 0bf2 No TAMIL NUMBER ONE THOUSAND
   2 0f84 Mn TIBETAN MARK HALANTA
   3 1770 Lo TAGBANWA LETTER SA
   4 33af So SQUARE RAD OVER S SQUARED
   1000.0

Les codes de catégorie sont des abréviations décrivant la nature du
caractère. Celles-ci sont regroupées en catégories telles que « Lettre
», « Nombre », « Ponctuation » ou « Symbole », qui sont à leur tour
divisées en sous-catégories. Pour prendre par exemple les codes de la
sortie ci-dessus, "'Ll'" signifie « Lettre, minuscules », "'No'"
signifie « Nombre, autre », "'Mn'" est « Marque, non-espaçant », et
"'So'" est « Symbole, autre ». Voir la section Valeurs générales des
catégories de la documentation de la base de données de caractères
Unicode (ressource en anglais) pour une liste de codes de catégories.


Expressions régulières Unicode
------------------------------

Les expressions régulières gérées par le module "re" peuvent être
fournies sous forme de chaîne d'octets ou de texte. Certaines
séquences de caractères spéciaux telles que "\d" et "\w" ont des
significations différentes selon que le motif est fourni en octets ou
en texte. Par exemple, "\d" correspond aux caractères "[0-9]" en
octets mais dans les chaînes de caractères correspond à tout caractère
de la catégorie "'Nd'".

Dans cet exemple, la chaîne contient le nombre 57 écrit en chiffres
arabes et thaïlandais :

   import re
   p = re.compile(r'\d+')

   s = "Over \u0e55\u0e57 57 flavours"
   m = p.search(s)
   print(repr(m.group()))

Une fois exécuté, "\d+" correspond aux chiffres thaïlandais et les
affiche. Si vous fournissez le drapeau "re.ASCII" à "compile()", "\d+"
correspond cette fois à la chaîne "57".

De même, "\w" correspond à une grande variété de caractères Unicode
mais seulement "[a-zA-Z0-9_]" en octets (ou si "re.ASCII" est fourni)
et "\s" correspond soit aux caractères blancs Unicode soit aux
caractères "[ \t\n\r\f\v]".


Références
----------

Quelques bonnes discussions alternatives sur la gestion d'Unicode par
Python sont :

* Processing Text Files in Python 3, par Nick Coghlan.

* Pragmatic Unicode, a PyCon 2012 presentation by Ned Batchelder.

Le type "str" est décrit dans la référence de la bibliothèque Python à
Type Séquence de Texte — str.

La documentation du module "unicodedata".

La documentation du module "codecs".

Marc-André Lemburg a donné une présentation intitulée « Python et
Unicode » (diapositives PDF) à *EuroPython* 2002. Les diapositives
sont un excellent aperçu de la conception des fonctionnalités Unicode
de Python 2 (où le type de chaîne Unicode est appelé "unicode" et les
littéraux commencent par "u").


Lecture et écriture de données Unicode
======================================

Une fois que vous avez écrit du code qui fonctionne avec des données
Unicode, le problème suivant concerne les entrées/sorties. Comment
obtenir des chaînes Unicode dans votre programme et comment convertir
les chaînes Unicode dans une forme appropriée pour le stockage ou la
transmission ?

Il est possible que vous n'ayez rien à faire en fonction de vos
sources d'entrée et des destinations de vos données de sortie ; il
convient de vérifier si les bibliothèques utilisées dans votre
application gèrent l'Unicode nativement. Par exemple, les analyseurs
XML renvoient souvent des données Unicode. De nombreuses bases de
données relationnelles prennent également en charge les colonnes
encodées en Unicode et peuvent renvoyer des valeurs Unicode à partir
d'une requête SQL.

Les données Unicode sont généralement converties en un encodage
particulier avant d'être écrites sur le disque ou envoyées sur un
connecteur réseau. Il est possible de faire tout le travail vous-même
: ouvrir un fichier, lire un élément 8-bits, puis convertir les octets
avec "bytes.decode(encoding)". Cependant, l'approche manuelle n'est
pas recommandée.

La nature multi-octets des encodages pose problème ; un caractère
Unicode peut être représenté par plusieurs octets. Si vous voulez lire
le fichier par morceaux de taille arbitraire (disons 1024 ou 4096
octets), vous devez écrire un code de gestion des erreurs pour
détecter le cas où une partie seulement des octets codant un seul
caractère Unicode est lue à la fin d'un morceau. Une solution serait
de lire le fichier entier en mémoire et d'effectuer le décodage, mais
cela vous empêche de travailler avec des fichiers extrêmement
volumineux ; si vous avez besoin de lire un fichier de 2 Gio, vous
avez besoin de 2 Gio de RAM (plus que ça, en fait, puisque pendant un
moment, vous aurez besoin d'avoir à la fois la chaîne encodée et sa
version Unicode en mémoire).

La solution serait d'utiliser l'interface de décodage de bas-niveau
pour intercepter le cas des séquences d'encodage incomplètes. Ce
travail d'implémentation a déjà été fait pour vous : la fonction
native "open()" peut renvoyer un objet de type fichier qui suppose que
le contenu du fichier est dans un encodage spécifié et accepte les
paramètres Unicode pour des méthodes telles que "read()" et "write()".
Ceci fonctionne grâce aux paramètres *encoding* et *errors* de
"open()" qui sont interprétés comme ceux de "str.encode()" et
"bytes.decode()".

Lire de l'Unicode à partir d'un fichier est donc simple :

   with open('unicode.txt', encoding='utf-8') as f:
       for line in f:
           print(repr(line))

Il est également possible d'ouvrir des fichiers en mode « mise à jour
», permettant à la fois la lecture et l'écriture :

   with open('test', encoding='utf-8', mode='w+') as f:
       f.write('\u4500 blah blah blah\n')
       f.seek(0)
       print(repr(f.readline()[:1]))

Le caractère Unicode "U+FEFFF" est utilisé comme marque pour indiquer
le boutisme (c'est-à-dire l'ordre dans lequel les octets sont placés
pour indiquer une valeur sur plusieurs octets, *byte-order mark* en
anglais ou *BOM*), et est souvent écrit en tête (premier caractère)
d'un fichier afin d'aider à l'auto-détection du boutisme du fichier.
Certains encodages, comme UTF-16, s'attendent à ce qu'une *BOM* soit
présente au début d'un fichier ; lorsqu'un tel encodage est utilisé,
la *BOM* sera automatiquement écrite comme premier caractère et sera
silencieusement retirée lorsque le fichier sera lu. Il existe des
variantes de ces encodages, comme "utf-16-le" et "utf-16-be" pour les
encodages petit-boutiste et gros-boutiste, qui spécifient un ordre
d'octets donné et ne sautent pas la *BOM*.

In some areas, it is also convention to use a "BOM" at the start of
UTF-8 encoded files; the name is misleading since UTF-8 is not byte-
order dependent. The mark simply announces that the file is encoded in
UTF-8.  Use the 'utf-8-sig' codec to automatically skip the mark if
present for reading such files.


Noms de fichiers Unicode
------------------------

Most of the operating systems in common use today support filenames
that contain arbitrary Unicode characters.  Usually this is
implemented by converting the Unicode string into some encoding that
varies depending on the system.  For example, Mac OS X uses UTF-8
while Windows uses a configurable encoding; on Windows, Python uses
the name "mbcs" to refer to whatever the currently configured encoding
is.  On Unix systems, there will only be a filesystem encoding if
you've set the "LANG" or "LC_CTYPE" environment variables; if you
haven't, the default encoding is UTF-8.

La fonction "sys.getfilesystemencoding()" renvoie l'encodage à
utiliser sur votre système actuel, au cas où vous voudriez faire
l'encodage manuellement, mais il n'y a pas vraiment de raisons de
s'embêter avec ça. Lors de l'ouverture d'un fichier pour la lecture ou
l'écriture, vous pouvez généralement simplement fournir la chaîne
Unicode comme nom de fichier et elle est automatiquement convertie à
l'encodage qui convient :

   filename = 'filename\u4500abc'
   with open(filename, 'w') as f:
       f.write('blah\n')

Les fonctions du module "os" telles que "os.stat()" acceptent
également les noms de fichiers Unicode.

The "os.listdir()" function returns filenames and raises an issue:
should it return the Unicode version of filenames, or should it return
bytes containing the encoded versions?  "os.listdir()" will do both,
depending on whether you provided the directory path as bytes or a
Unicode string.  If you pass a Unicode string as the path, filenames
will be decoded using the filesystem's encoding and a list of Unicode
strings will be returned, while passing a byte path will return the
filenames as bytes.  For example, assuming the default filesystem
encoding is UTF-8, running the following program:

   fn = 'filename\u4500abc'
   f = open(fn, 'w')
   f.close()

   import os
   print(os.listdir(b'.'))
   print(os.listdir('.'))

produit la sortie suivante :

   amk:~$ python t.py
   [b'filename\xe4\x94\x80abc', ...]
   ['filename\u4500abc', ...]

La première liste contient les noms de fichiers encodés en UTF-8 et la
seconde contient les versions Unicode.

Note that on most occasions, the Unicode APIs should be used.  The
bytes APIs should only be used on systems where undecodable file names
can be present, i.e. Unix systems.


Conseils pour écrire des programmes compatibles Unicode
-------------------------------------------------------

Cette section fournit quelques suggestions sur l'écriture de logiciels
qui traitent de l'Unicode.

Le conseil le plus important est :

   Il convient que le logiciel ne traite que des chaînes Unicode en
   interne, décodant les données d'entrée dès que possible et encodant
   la sortie uniquement à la fin.

Si vous essayez d'écrire des fonctions de traitement qui acceptent à
la fois les chaînes Unicode et les chaînes d'octets, les possibilités
d'occurrences de bogues dans votre programme augmentent partout où
vous combinez les deux différents types de chaînes. Il n'y a pas
d'encodage ou de décodage automatique : si vous faites par exemple
"str + octets", une "TypeError" est levée.

Lors de l'utilisation de données provenant d'un navigateur Web ou
d'une autre source non fiable, une technique courante consiste à
vérifier la présence de caractères illégaux dans une chaîne de
caractères avant de l'utiliser pour générer une ligne de commande ou
de la stocker dans une base de données. Si vous le faites, vérifiez
bien la chaîne décodée, pas les données d'octets codés ; certains
encodages peuvent avoir des propriétés intéressantes, comme ne pas
être bijectifs ou ne pas être entièrement compatibles avec l'ASCII.
C'est particulièrement vrai si l'encodage est spécifié explicitement
dans vos données d'entrée, car l'attaquant peut alors choisir un moyen
intelligent de cacher du texte malveillant dans le flux de données
encodé.


Conversion entre les encodages de fichiers
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

La classe "StreamRecoder" peut convertir de manière transparente entre
les encodages : prenant un flux qui renvoie des données dans
l'encodage #1, elle se comporte comme un flux qui renvoie des données
dans l'encodage #2.

Par exemple, si vous avez un fichier d'entrée *f* qui est en Latin-1,
vous pouvez l'encapsuler dans un "StreamRecoder" pour qu'il renvoie
des octets encodés en UTF-8 :

   new_f = codecs.StreamRecoder(f,
       # en/decoder: used by read() to encode its results and
       # by write() to decode its input.
       codecs.getencoder('utf-8'), codecs.getdecoder('utf-8'),

       # reader/writer: used to read and write to the stream.
       codecs.getreader('latin-1'), codecs.getwriter('latin-1') )


Fichiers dans un encodage inconnu
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Vous avez besoin de modifier un fichier, mais vous ne connaissez pas
son encodage ? Si vous savez que l'encodage est compatible ASCII et
que vous voulez seulement examiner ou modifier les parties ASCII, vous
pouvez ouvrir le fichier avec le gestionnaire d'erreurs
"surrogateescape" :

   with open(fname, 'r', encoding="ascii", errors="surrogateescape") as f:
       data = f.read()

   # make changes to the string 'data'

   with open(fname + '.new', 'w',
             encoding="ascii", errors="surrogateescape") as f:
       f.write(data)

The "surrogateescape" error handler will decode any non-ASCII bytes as
code points in the Unicode Private Use Area ranging from U+DC80 to
U+DCFF.  These private code points will then be turned back into the
same bytes when the "surrogateescape" error handler is used when
encoding the data and writing it back out.


Références
----------

Une partie de la conférence Mastering Python 3 Input/Output (ressource
en anglais), donnée lors de *PyCon* 2010 de David Beazley, parle du
traitement de texte et du traitement des données binaires.

Le PDF du diaporama de la présentation de Marc-André Lemburg "Writing
Unicodeaware Applications in Python" (ressource en anglais) traite des
questions d'encodage de caractères ainsi que de l'internationalisation
et de la localisation d'une application. Ces diapositives ne couvrent
que Python 2.x.

The Guts of Unicode in Python (ressource en anglais) est une
conférence *PyCon* 2013 donnée par Benjamin Peterson qui traite de la
représentation interne Unicode en Python 3.3.


Remerciements
=============

La première ébauche de ce document a été rédigée par Andrew Kuchling.
Il a depuis été révisé par Alexander Belopolsky, Georg Brandl, Andrew
Kuchling et Ezio Melotti.

Thanks to the following people who have noted errors or offered
suggestions on this article: Éric Araujo, Nicholas Bastin, Nick
Coghlan, Marius Gedminas, Kent Johnson, Ken Krugler, Marc-André
Lemburg, Martin von Löwis, Terry J. Reedy, Chad Whitacre.
