python-docs-fr/howto/unicode.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-23 16:48+0200\n"
"PO-Revision-Date: 2019-06-02 13:13+0200\n"
"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.2.1\n"

#: ../Doc/howto/unicode.rst:5
msgid "Unicode HOWTO"
msgstr "Guide Unicode"

#: ../Doc/howto/unicode.rst:0
msgid "Release"
msgstr "Version"

#: ../Doc/howto/unicode.rst:7
msgid "1.12"
msgstr "1.12"

#: ../Doc/howto/unicode.rst:9
msgid ""
"This HOWTO discusses Python's support for the Unicode specification for "
"representing textual data, and explains various problems that people "
"commonly encounter when trying to work with Unicode."
msgstr ""
"Ce HOWTO décrit la gestion de la spécification Unicode par Python pour les "
"données textuelles et explique les différents problèmes généralement "
"rencontrés par les utilisateurs qui travaillent avec Unicode."

#: ../Doc/howto/unicode.rst:15
msgid "Introduction to Unicode"
msgstr "Introduction à Unicode"

#: ../Doc/howto/unicode.rst:18
msgid "Definitions"
msgstr "Définitions"

#: ../Doc/howto/unicode.rst:20
msgid ""
"Today's programs need to be able to handle a wide variety of characters.  "
"Applications are often internationalized to display messages and output in a "
"variety of user-selectable languages; the same program might need to output "
"an error message in English, French, Japanese, Hebrew, or Russian.  Web "
"content can be written in any of these languages and can also include a "
"variety of emoji symbols. Python's string type uses the Unicode Standard for "
"representing characters, which lets Python programs work with all these "
"different possible characters."
msgstr ""
"Les programmes d'aujourd'hui doivent être capables de traiter une grande "
"variété de caractères. Les applications sont souvent internationalisées pour "
"afficher les messages et les résultats dans une variété de langues "
"sélectionnables par l'utilisateur ; le même programme peut avoir besoin "
"d'afficher un message d'erreur en anglais, français, japonais, hébreu ou "
"russe. Le contenu Web peut être écrit dans n'importe laquelle de ces langues "
"et peut également inclure une variété de symboles émoji. Le type de chaîne "
"de caractères de Python utilise le standard Unicode pour représenter les "
"caractères, ce qui permet aux programmes Python de travailler avec tous ces "
"différents caractères possibles."

#: ../Doc/howto/unicode.rst:30
msgid ""
"Unicode (https://www.unicode.org/) is a specification that aims to list "
"every character used by human languages and give each character its own "
"unique code.  The Unicode specifications are continually revised and updated "
"to add new languages and symbols."
msgstr ""
"Unicode (https://www.unicode.org/) est une spécification qui vise à lister "
"tous les caractères utilisés par les langues humaines et à donner à chaque "
"caractère son propre code unique. Les spécifications Unicode sont "
"continuellement révisées et mises à jour pour ajouter de nouvelles langues "
"et de nouveaux symboles."

#: ../Doc/howto/unicode.rst:35
msgid ""
"A **character** is the smallest possible component of a text.  'A', 'B', "
"'C', etc., are all different characters.  So are 'È' and 'Í'.  Characters "
"vary depending on the language or context you're talking about.  For "
"example, there's a character for \"Roman Numeral One\", 'Ⅰ', that's separate "
"from the uppercase letter 'I'.  They'll usually look the same, but these are "
"two different characters that have different meanings."
msgstr ""
"Un **caractère** est le plus petit composant possible d'un texte. « A », "
"« B », « C », etc. sont tous des caractères différents. Il en va de même "
"pour « È » et « Í ». Les caractères varient selon la langue ou le contexte "
"dont vous parlez. Par exemple, il y a un caractère pour « Chiffre Romain "
"Un » (*Roman Numeral One*) , « Ⅰ », qui est séparé de la lettre majuscule "
"« I ». Ils se ressemblent généralement, mais ce sont deux caractères "
"différents qui ont des significations différentes."

#: ../Doc/howto/unicode.rst:42
msgid ""
"The Unicode standard describes how characters are represented by **code "
"points**.  A code point value is an integer in the range 0 to 0x10FFFF "
"(about 1.1 million values, with some 110 thousand assigned so far).  In the "
"standard and in this document, a code point is written using the notation ``U"
"+265E`` to mean the character with value ``0x265e`` (9,822 in decimal)."
msgstr ""
"Le standard Unicode décrit comment les caractères sont représentés par les "
"**points de code**. Une valeur de point de code est un nombre entier compris "
"entre ``0`` et ``0x10FFFF`` (environ 1,1 million de valeurs, avec environ "
"110 000 valeurs attribuées à ce jour). Dans le standard et dans le présent "
"document, un point de code est écrit en utilisant la notation ``U+265E`` "
"pour désigner le caractère avec la valeur ``0x265e`` (9 822 en décimal)."

#: ../Doc/howto/unicode.rst:49
msgid ""
"The Unicode standard contains a lot of tables listing characters and their "
"corresponding code points:"
msgstr ""
"La standard Unicode contient de nombreux tableaux contenant la liste des "
"caractères et des points de code correspondants :"

#: ../Doc/howto/unicode.rst:70
msgid ""
"Strictly, these definitions imply that it's meaningless to say 'this is "
"character ``U+265E``'.  ``U+265E`` is a code point, which represents some "
"particular character; in this case, it represents the character 'BLACK CHESS "
"KNIGHT', '♞'.  In informal contexts, this distinction between code points "
"and characters will sometimes be forgotten."
msgstr ""
"À proprement parler, ces définitions laissent entendre qu'il est inutile de "
"dire « c'est le caractère ``U+265E`` ». ``U+265E`` est un point de code, qui "
"représente un caractère particulier ; dans ce cas, il représente le "
"caractère « BLACK CHESS KNIGHT », « ♞ ». Dans des contextes informels, cette "
"distinction entre les points de code et les caractères sera parfois oubliée."

#: ../Doc/howto/unicode.rst:77
msgid ""
"A character is represented on a screen or on paper by a set of graphical "
"elements that's called a **glyph**.  The glyph for an uppercase A, for "
"example, is two diagonal strokes and a horizontal stroke, though the exact "
"details will depend on the font being used.  Most Python code doesn't need "
"to worry about glyphs; figuring out the correct glyph to display is "
"generally the job of a GUI toolkit or a terminal's font renderer."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:86
msgid "Encodings"
msgstr "Encodages"

#: ../Doc/howto/unicode.rst:88
msgid ""
"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 of code points needs to be represented in memory as a set of "
"**code units**, and **code units** are then mapped to 8-bit bytes.  The "
"rules for translating a Unicode string into a sequence of bytes are called a "
"**character encoding**, or just an **encoding**."
msgstr ""
"Pour résumer la section précédente : une chaîne Unicode est une séquence de "
"points de code, qui sont des nombres de ``0`` à ``0x10FFFF`` (1 114 111 en "
"décimal). Cette séquence de points de code doit être stockée en mémoire sous "
"la forme d'un ensemble de **unités de code**, et les **unités de code** sont "
"ensuite transposées en octets de 8 bits. Les règles de traduction d'une "
"chaîne Unicode en une séquence d'octets sont appelées un **encodage de "
"caractères** ou simplement un **encodage**."

#: ../Doc/howto/unicode.rst:96
msgid ""
"The first encoding you might think of is using 32-bit integers as the code "
"unit, and then using the CPU's representation of 32-bit integers. In this "
"representation, the string \"Python\" might look like this:"
msgstr ""
"Le premier encodage auquel vous pouvez penser est l'utilisation d'entiers 32 "
"bits comme unité de code, puis l'utilisation de la représentation des "
"entiers 32 bits par le CPU. Dans cette représentation, la chaîne \"Python\" "
"ressemblerait à ceci :"

#: ../Doc/howto/unicode.rst:106
msgid ""
"This representation is straightforward but using it presents a number of "
"problems."
msgstr ""
"Cette représentation est simple mais son utilisation pose un certain nombre "
"de problèmes."

#: ../Doc/howto/unicode.rst:109
msgid "It's not portable; different processors order the bytes differently."
msgstr ""
"Elle n’est pas portable ; des processeurs différents ordonnent les octets "
"différemment."

#: ../Doc/howto/unicode.rst:111
msgid ""
"It's very wasteful of space.  In most texts, the majority of the code points "
"are less than 127, or less than 255, so a lot of space is occupied by "
"``0x00`` bytes.  The above string takes 24 bytes compared to the 6 bytes "
"needed for an ASCII representation.  Increased RAM usage doesn't matter too "
"much (desktop computers have gigabytes of RAM, and strings aren't usually "
"that large), but expanding our usage of disk and network bandwidth by a "
"factor of 4 is intolerable."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:119
msgid ""
"It's not compatible with existing C functions such as ``strlen()``, so a new "
"family of wide string functions would need to be used."
msgstr ""
"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*)."

#: ../Doc/howto/unicode.rst:122
msgid ""
"Therefore this encoding isn't used very much, and people instead choose "
"other encodings that are more efficient and convenient, such as UTF-8."
msgstr ""
"Par conséquent, cet encodage n'est pas très utilisé et d'autres encodages, "
"plus efficaces et pratiques comme UTF-8, sont plutôt choisis."

#: ../Doc/howto/unicode.rst:125
msgid ""
"UTF-8 is one of the most commonly used encodings, and Python often defaults "
"to using it.  UTF stands for \"Unicode Transformation Format\", and the '8' "
"means that 8-bit values are used in the encoding.  (There are also UTF-16 "
"and UTF-32 encodings, but they are less frequently used than UTF-8.)  UTF-8 "
"uses the following rules:"
msgstr ""
"UTF-8 est l’un des encodages les plus couramment utilisés et Python "
"l’utilise souvent par défaut. UTF signifie « Unicode Transformation "
"Format » (format de transformation Unicode) et « 8 » signifie que des "
"nombres à 8 bits sont utilisés dans l'encodage (il existe également des "
"codages UTF-16 et UTF-32, mais ils sont moins souvent utilisés que UTF-8). "
"UTF-8 utilise les règles suivantes :"

#: ../Doc/howto/unicode.rst:131
msgid ""
"If the code point is < 128, it's represented by the corresponding byte value."
msgstr ""
"Si le point de code est < 128, il est représenté par la valeur de l'octet "
"correspondant."

#: ../Doc/howto/unicode.rst:132
msgid ""
"If the code point is >= 128, it's turned into a sequence of two, three, or "
"four bytes, where each byte of the sequence is between 128 and 255."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:135
msgid "UTF-8 has several convenient properties:"
msgstr "UTF-8 a plusieurs propriétés intéressantes :"

#: ../Doc/howto/unicode.rst:137
msgid "It can handle any Unicode code point."
msgstr "Il peut gérer n'importe quel point de code Unicode."

#: ../Doc/howto/unicode.rst:138
msgid ""
"A Unicode string is turned into a sequence of bytes that contains embedded "
"zero bytes only where they represent the null character (U+0000). This means "
"that UTF-8 strings can be processed by C functions such as ``strcpy()`` and "
"sent through protocols that can't handle zero bytes for anything other than "
"end-of-string markers."
msgstr ""
"Une chaîne Unicode est transformée en une séquence d’octets qui contient des "
"octets zéro uniquement lorsqu’ils représentent le caractère nul (U+000000). "
"Cela signifie que les chaînes UTF-8 peuvent être traitées par des fonctions "
"C telles que ``strcpy()`` et envoyées par des protocoles pour qui les octets "
"zéro signifient forcément la fin de chaîne."

#: ../Doc/howto/unicode.rst:143
msgid "A string of ASCII text is also valid UTF-8 text."
msgstr "Une chaîne de texte ASCII est également un texte UTF-8 valide."

#: ../Doc/howto/unicode.rst:144
msgid ""
"UTF-8 is fairly compact; the majority of commonly used characters can be "
"represented with one or two bytes."
msgstr ""
"UTF-8 est assez compact. La majorité des caractères couramment utilisés "
"peuvent être représentés avec un ou deux octets."

#: ../Doc/howto/unicode.rst:146
msgid ""
"If bytes are corrupted or lost, it's possible to determine the start of the "
"next UTF-8-encoded code point and resynchronize.  It's also unlikely that "
"random 8-bit data will look like valid UTF-8."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:149
msgid ""
"UTF-8 is a byte oriented encoding. The encoding specifies that each "
"character is represented by a specific sequence of one or more bytes. This "
"avoids the byte-ordering issues that can occur with integer and word "
"oriented encodings, like UTF-16 and UTF-32, where the sequence of bytes "
"varies depending on the hardware on which the string was encoded."
msgstr ""
"UTF-8 est un encodage orienté octets. L'encodage spécifie que chaque "
"caractère est représenté par une séquence spécifique d'un ou plusieurs "
"octets. Ceci permet d'éviter les problèmes d'ordre des octets qui peuvent "
"survenir avec les encodages orientés entiers (*integer*) ou orientés mots "
"processeurs (*words*), comme UTF-16 et UTF-32, où la séquence des octets "
"varie en fonction du matériel sur lequel la chaîne a été encodée."

#: ../Doc/howto/unicode.rst:157 ../Doc/howto/unicode.rst:513
#: ../Doc/howto/unicode.rst:734
msgid "References"
msgstr "Références"

#: ../Doc/howto/unicode.rst:159
msgid ""
"The `Unicode Consortium site <http://www.unicode.org>`_ has character "
"charts, a glossary, and PDF versions of the Unicode specification.  Be "
"prepared for some difficult reading.  `A chronology <http://www.unicode.org/"
"history/>`_ of the origin and development of Unicode is also available on "
"the site."
msgstr ""
"Le site du `Consortium Unicode <http://www.unicode.org>`_, 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 <http://www.unicode.org/history/>`_ de l’origine et du "
"développement de l’Unicode est également disponible sur le site."

#: ../Doc/howto/unicode.rst:164
msgid ""
"On the Computerphile Youtube channel, Tom Scott briefly `discusses the "
"history of Unicode and UTF-8 <https://www.youtube.com/watch?v=MijmeoH9LT4>` "
"(9 minutes 36 seconds)."
msgstr ""
"Sur la chaîne Youtube *Computerphile*, Tom Scott parle brièvement de "
"l'histoire d'Unicode et d'UTF-8, en anglais : `Characters, Symbols and the "
"Unicode Miracle <https://www.youtube.com/watch?v=MijmeoH9LT4>` (9 minutes et "
"36 secondes)."

#: ../Doc/howto/unicode.rst:168
msgid ""
"To help understand the standard, Jukka Korpela has written `an introductory "
"guide <http://jkorpela.fi/unicode/guide.html>`_ to reading the Unicode "
"character tables."
msgstr ""
"Pour aider à comprendre le standard, Jukka Korpela a écrit `un guide "
"d’introduction <http://jkorpela.fi/unicode/guide.html>`_ à la lecture des "
"tables de caractères Unicode (ressource en anglais)."

#: ../Doc/howto/unicode.rst:172
msgid ""
"Another `good introductory article <https://www.joelonsoftware."
"com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-"
"positively-must-know-about-unicode-and-character-sets-no-excuses/>`_ was "
"written by Joel Spolsky. If this introduction didn't make things clear to "
"you, you should try reading this alternate article before continuing."
msgstr ""
"Un autre `bon article d'introduction <https://www.joelonsoftware."
"com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-"
"positively-must-know-about-unicode-and-character-sets-no-excuses/>`_ a été "
"écrit par Joel Spolsky. Si cette présente introduction ne vous a pas "
"clarifié les choses, vous devriez essayer de lire cet article là avant de "
"continuer."

#: ../Doc/howto/unicode.rst:177
msgid ""
"Wikipedia entries are often helpful; see the entries for \"`character "
"encoding <https://en.wikipedia.org/wiki/Character_encoding>`_\" and `UTF-8 "
"<https://en.wikipedia.org/wiki/UTF-8>`_, for example."
msgstr ""
"Les pages Wikipédia sont souvent utiles ; voir les pages pour \"`Codage des "
"caractères <https://fr.wikipedia.org/wiki/Codage_des_caract%C3%A8res>`_\" et "
"`UTF-8 <https://fr.wikipedia.org/wiki/UTF-8>`_, par exemple."

#: ../Doc/howto/unicode.rst:183
msgid "Python's Unicode Support"
msgstr "Prise en charge Unicode de Python"

#: ../Doc/howto/unicode.rst:185
msgid ""
"Now that you've learned the rudiments of Unicode, we can look at Python's "
"Unicode features."
msgstr ""
"Maintenant que vous avez appris les rudiments de l'Unicode, nous pouvons "
"regarder les fonctionnalités Unicode de Python."

#: ../Doc/howto/unicode.rst:189
msgid "The String Type"
msgstr "Le Type *String*"

#: ../Doc/howto/unicode.rst:191
msgid ""
"Since Python 3.0, the language's :class:`str` type contains Unicode "
"characters, meaning any string created using ``\"unicode rocks!\"``, "
"``'unicode rocks!'``, or the triple-quoted string syntax is stored as "
"Unicode."
msgstr ""
"\"Depuis Python 3.0, le type :class:`str` du langage contient des caractères "
"Unicode, c'est-à-dire n'importe quelle chaîne créée à l'aide de ``\"unicode "
"déchire !\"``, ``'unicode déchire !'`` ou la syntaxe à triples guillemets "
"est enregistrée comme Unicode."

#: ../Doc/howto/unicode.rst:195
msgid ""
"The default encoding for Python source code is UTF-8, so you can simply "
"include a Unicode character in a string literal::"
msgstr ""
"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 : ::"

#: ../Doc/howto/unicode.rst:205
msgid ""
"Side note: Python 3 also supports using Unicode characters in identifiers::"
msgstr ""
"Note : Python 3 sait gérer les caractères Unicode dans les identifiants : ::"

#: ../Doc/howto/unicode.rst:211
msgid ""
"If you can't enter a particular character in your editor or want to keep the "
"source code ASCII-only for some reason, you can also use escape sequences in "
"string literals. (Depending on your system, you may see the actual capital-"
"delta glyph instead of a \\u escape.) ::"
msgstr ""
"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 "
"voyez le glyphe réel du *delta majuscule* au lieu d'une séquence "
"d'échappement ``\\u...``) : ::"

#: ../Doc/howto/unicode.rst:223
msgid ""
"In addition, one can create a string using the :func:`~bytes.decode` method "
"of :class:`bytes`.  This method takes an *encoding* argument, such as "
"``UTF-8``, and optionally an *errors* argument."
msgstr ""
"De plus, une chaîne de caractères peut être créée en utilisant la méthode :"
"func:`~bytes.decode` de la classe :class:`bytes`.  Cette méthode prend un "
"argument *encoding*, ``UTF-8`` par exemple, et optionnellement un argument "
"*errors*."

#: ../Doc/howto/unicode.rst:227
msgid ""
"The *errors* argument specifies the response when the input string can't be "
"converted according to the encoding's rules.  Legal values for this argument "
"are ``'strict'`` (raise a :exc:`UnicodeDecodeError` exception), "
"``'replace'`` (use ``U+FFFD``, ``REPLACEMENT CHARACTER``), ``'ignore'`` "
"(just leave the character out of the Unicode result), or "
"``'backslashreplace'`` (inserts a ``\\xNN`` escape sequence). The following "
"examples show the differences::"
msgstr ""
"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 légales pour "
"cet argument sont ``'strict'`` (\"strict\" : lève une exception :exc:"
"`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 : ::"

#: ../Doc/howto/unicode.rst:247
msgid ""
"Encodings are specified as strings containing the encoding's name.  Python "
"comes with roughly 100 different encodings; see the Python Library Reference "
"at :ref:`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."
msgstr ""
"Les encodages sont spécifiés sous forme de chaînes de caractères contenant "
"le nom de l'encodage. Python est livré avec une centaine d'encodages "
"différents ; voir la référence de la bibliothèque Python sur les :ref:"
"`encodages standards <standard-encodings>` pour une liste. Certains "
"encodages ont plusieurs noms ; par exemple, ``'latin-1'``, ``'iso_8859_1'`` "
"et ``'8859'`` sont tous synonymes du même encodage."

#: ../Doc/howto/unicode.rst:253
msgid ""
"One-character Unicode strings can also be created with the :func:`chr` built-"
"in function, which takes integers and returns a Unicode string of length 1 "
"that contains the corresponding code point.  The reverse operation is the "
"built-in :func:`ord` function that takes a one-character Unicode string and "
"returns the code point value::"
msgstr ""
"Des chaînes Unicode à un caractère peuvent également être créées avec la "
"fonction intégrée :func:`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 intégrée :func:`ord` qui prend une "
"chaîne Unicode d'un caractère et renvoie la valeur du point de code : ::"

#: ../Doc/howto/unicode.rst:265
msgid "Converting to Bytes"
msgstr "Conversion en octets"

#: ../Doc/howto/unicode.rst:267
msgid ""
"The opposite method of :meth:`bytes.decode` is :meth:`str.encode`, which "
"returns a :class:`bytes` representation of the Unicode string, encoded in "
"the requested *encoding*."
msgstr ""
"La méthode inverse de :meth:`bytes.decode` est :meth:`str.encode`, qui "
"renvoie une représentation :class:`bytes` de la chaîne Unicode, codée dans "
"l’encodage *encoding* demandé."

#: ../Doc/howto/unicode.rst:271
msgid ""
"The *errors* parameter is the same as the parameter of the :meth:`~bytes."
"decode` method but supports a few more possible handlers. As well as "
"``'strict'``, ``'ignore'``, and ``'replace'`` (which in this case inserts a "
"question mark instead of the unencodable character), there is also "
"``'xmlcharrefreplace'`` (inserts an XML character reference), "
"``backslashreplace`` (inserts a ``\\uNNNN`` escape sequence) and "
"``namereplace`` (inserts a ``\\N{...}`` escape sequence)."
msgstr ""
"Le paramètre *errors* est le même que le paramètre de la méthode :meth:"
"`~bytes.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{...}``)."

#: ../Doc/howto/unicode.rst:279
msgid "The following example shows the different results::"
msgstr "L'exemple suivant montre les différents résultats : ::"

#: ../Doc/howto/unicode.rst:300
msgid ""
"The low-level routines for registering and accessing the available encodings "
"are found in the :mod:`codecs` module.  Implementing new encodings also "
"requires understanding the :mod:`codecs` module. However, the encoding and "
"decoding functions returned by this module are usually more low-level than "
"is comfortable, and writing new encodings is a specialized task, so the "
"module won't be covered in this HOWTO."
msgstr ""
"Les routines de bas niveau pour enregistrer et accéder aux encodages "
"disponibles se trouvent dans le module :mod:`codecs`. L'implémentation de "
"nouveaux encodages nécessite également de comprendre le module :mod:"
"`codecs`. Cependant, les fonctions d'encodage et de décodage renvoyées par "
"ce module sont généralement de trop bas-niveau pour être confortables  et "
"l'écriture de nouveaux encodages est une tâche très spécialisée, donc le "
"module ne sera pas couvert dans ce HOWTO."

#: ../Doc/howto/unicode.rst:309
msgid "Unicode Literals in Python Source Code"
msgstr "Littéraux Unicode dans le code source Python"

#: ../Doc/howto/unicode.rst:311
msgid ""
"In Python source code, specific Unicode code points can be written using the "
"``\\u`` escape sequence, which is followed by four hex digits giving the "
"code point.  The ``\\U`` escape sequence is similar, but expects eight hex "
"digits, not four::"
msgstr ""
"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 ::"

#: ../Doc/howto/unicode.rst:323
msgid ""
"Using escape sequences for code points greater than 127 is fine in small "
"doses, but becomes an annoyance if you're using many accented characters, as "
"you would in a program with messages in French or some other accent-using "
"language.  You can also assemble strings using the :func:`chr` built-in "
"function, but this is even more tedious."
msgstr ""
"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 intégrée :func:`chr`, mais c'est encore plus "
"fastidieux."

#: ../Doc/howto/unicode.rst:329
msgid ""
"Ideally, you'd want to be able to write literals in your language's natural "
"encoding.  You could then edit Python source code with your favorite editor "
"which would display the accented characters naturally, and have the right "
"characters used at runtime."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:334
msgid ""
"Python supports writing source code in UTF-8 by default, but you can use "
"almost any encoding if you declare the encoding being used.  This is done by "
"including a special comment as either the first or second line of the source "
"file::"
msgstr ""
"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 ::"

#: ../Doc/howto/unicode.rst:344
msgid ""
"The syntax is inspired by Emacs's notation for specifying variables local to "
"a file.  Emacs supports many different variables, but Python only supports "
"'coding'.  The ``-*-`` symbols indicate to Emacs that the comment is "
"special; they have no significance to Python but are a convention.  Python "
"looks for ``coding: name`` or ``coding=name`` in the comment."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:350
msgid ""
"If you don't include such a comment, the default encoding used will be UTF-8 "
"as already mentioned.  See also :pep:`263` for more information."
msgstr ""
"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."

#: ../Doc/howto/unicode.rst:355
msgid "Unicode Properties"
msgstr "Propriétés Unicode"

#: ../Doc/howto/unicode.rst:357
msgid ""
"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 (for "
"characters representing numeric concepts such as the Roman numerals, "
"fractions such as one-third and four-fifths, etc.).  There are also display-"
"related properties, such as how to use the code point in bidirectional text."
msgstr ""
"La spécification Unicode inclut une base de données d'informations sur les "
"points de code. Pour chaque point de code défini, l'information comprend le "
"nom du caractère, sa catégorie, la valeur numérique s'il y a lieu (pour les "
"caractères représentant des concepts numériques tels que les chiffres "
"romains, les fractions telles qu'un tiers et quatre cinquièmes, etc.). Il "
"existe également des propriétés liées à l'affichage, telles que "
"l'utilisation du point de code dans un texte bidirectionnel."

#: ../Doc/howto/unicode.rst:365
msgid ""
"The following program displays some information about several characters, "
"and prints the numeric value of one particular character::"
msgstr ""
"Le programme suivant affiche des informations sur plusieurs caractères et "
"affiche la valeur numérique d'un caractère particulier ::"

#: ../Doc/howto/unicode.rst:379
msgid "When run, this prints:"
msgstr "Si vous l'exécutez, cela affiche :"

#: ../Doc/howto/unicode.rst:390
msgid ""
"The category codes are abbreviations describing the nature of the character. "
"These are grouped into categories such as \"Letter\", \"Number\", "
"\"Punctuation\", or \"Symbol\", which in turn are broken up into "
"subcategories.  To take the codes from the above output, ``'Ll'`` means "
"'Letter, lowercase', ``'No'`` means \"Number, other\", ``'Mn'`` is \"Mark, "
"nonspacing\", and ``'So'`` is \"Symbol, other\".  See `the General Category "
"Values section of the Unicode Character Database documentation <http://www."
"unicode.org/reports/tr44/#General_Category_Values>`_ for a list of category "
"codes."
msgstr ""
"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 <http://www."
"unicode.org/reports/tr44/#General_Category_Values>`_ (ressource en anglais) "
"pour une liste de codes de catégories."

#: ../Doc/howto/unicode.rst:401
msgid "Comparing Strings"
msgstr "Comparaison de chaînes de caractères"

#: ../Doc/howto/unicode.rst:403
msgid ""
"Unicode adds some complication to comparing strings, because the same set of "
"characters can be represented by different sequences of code points.  For "
"example, a letter like 'ê' can be represented as a single code point U+00EA, "
"or as U+0065 U+0302, which is the code point for 'e' followed by a code "
"point for 'COMBINING CIRCUMFLEX ACCENT'.  These will produce the same output "
"when printed, but one is a string of length 1 and the other is of length 2."
msgstr ""
"Unicode ajoute une certaine complication à la comparaison des chaînes de "
"caractères, car le même jeu de caractères peut être représenté par "
"différentes séquences de points de code.  Par exemple, une lettre comme "
"« ê » peut être représentée comme un point de code unique ``U+00EA``, ou "
"comme ``U+0065 U+0302``, qui est le point de code pour « e » suivi d'un "
"point de code pour ``COMBINING CIRCUMFLEX ACCENT``.  Celles-ci produisent le "
"même résultat lorsqu'elles sont affichées, mais l'une est une chaîne de "
"caractères de longueur 1 et l'autre de longueur 2."

#: ../Doc/howto/unicode.rst:411
msgid ""
"One tool for a case-insensitive comparison is the :meth:`~str.casefold` "
"string method that converts a string to a case-insensitive form following an "
"algorithm described by the Unicode Standard.  This algorithm has special "
"handling for characters such as the German letter 'ß' (code point U+00DF), "
"which becomes the pair of lowercase letters 'ss'."
msgstr ""
"Un outil pour une comparaison insensible à la casse est la méthode :meth:"
"`~str.casefold` qui convertit une chaîne en une forme insensible à la casse "
"suivant un algorithme décrit par le standard Unicode.  Cet algorithme a un "
"traitement spécial pour les caractères tels que la lettre allemande "
"« *ß* » (point de code ``U+00DF``), qui devient la paire de lettres "
"minuscules « *ss* »."

#: ../Doc/howto/unicode.rst:424
msgid ""
"A second tool is the :mod:`unicodedata` module's :func:`~unicodedata."
"normalize` function that converts strings to one of several normal forms, "
"where letters followed by a combining character are replaced with single "
"characters.  :func:`normalize` can be used to perform string comparisons "
"that won't falsely report inequality if two strings use combining characters "
"differently:"
msgstr ""
"Un deuxième outil est la fonction :mod:`unicodedata` du module :func:"
"`~unicodedata.normalize` du module qui convertit les chaînes de caractères "
"en l'une de plusieurs formes normales, où les lettres suivies d'un caractère "
"de combinaison sont remplacées par des caractères simples. :func:`normalize` "
"peut être utilisée pour effectuer des comparaisons qui ne rapportent pas "
"faussement les inégalités si deux chaînes utilisent différents caractères de "
"combinaison :"

#: ../Doc/howto/unicode.rst:447
msgid "When run, this outputs:"
msgstr "Si vous l'exécutez, cela affiche :"

#: ../Doc/howto/unicode.rst:456
msgid ""
"The first argument to the :func:`~unicodedata.normalize` function is a "
"string giving the desired normalization form, which can be one of 'NFC', "
"'NFKC', 'NFD', and 'NFKD'."
msgstr ""
"Le premier argument de la fonction :func:`~unicodedata.normalize` est une "
"chaîne de caractères donnant la forme de normalisation désirée, qui peut "
"être une de celles-ci : ``'NFC'``, ``'NFKC'``, ``'NFD'`` et ``'NFKD'``."

#: ../Doc/howto/unicode.rst:460
msgid "The Unicode Standard also specifies how to do caseless comparisons::"
msgstr ""
"La norme Unicode spécifie également comment faire des comparaisons "
"insensibles à la casse ::"

#: ../Doc/howto/unicode.rst:476
msgid ""
"This will print ``True``.  (Why is :func:`NFD` invoked twice?  Because there "
"are a few characters that make :meth:`casefold` return a non-normalized "
"string, so the result needs to be normalized again. See section 3.13 of the "
"Unicode Standard for a discussion and an example.)"
msgstr ""
"Ceci affiche ``True``.  (Pourquoi :func:`NFD` est-il invoqué deux fois ?  "
"Parce qu'il y a quelques caractères qui font que :meth:`casefold` renvoie "
"une chaîne non normalisée, donc le résultat doit être normalisé à nouveau. "
"Voir la section 3.13 du standard Unicode pour une discussion et un exemple)."

#: ../Doc/howto/unicode.rst:483
msgid "Unicode Regular Expressions"
msgstr "Expressions régulières Unicode"

#: ../Doc/howto/unicode.rst:485
msgid ""
"The regular expressions supported by the :mod:`re` module can be provided "
"either as bytes or strings.  Some of the special character sequences such as "
"``\\d`` and ``\\w`` have different meanings depending on whether the pattern "
"is supplied as bytes or a string.  For example, ``\\d`` will match the "
"characters ``[0-9]`` in bytes but in strings will match any character that's "
"in the ``'Nd'`` category."
msgstr ""
"Les expressions régulières gérées par le module :mod:`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'``."

#: ../Doc/howto/unicode.rst:492
msgid ""
"The string in this example has the number 57 written in both Thai and Arabic "
"numerals::"
msgstr ""
"Dans cet exemple, la chaîne contient le nombre 57 écrit en chiffres arabes "
"et thaïlandais ::"

#: ../Doc/howto/unicode.rst:502
msgid ""
"When executed, ``\\d+`` will match the Thai numerals and print them out.  If "
"you supply the :const:`re.ASCII` flag to :func:`~re.compile`, ``\\d+`` will "
"match the substring \"57\" instead."
msgstr ""
"Une fois exécuté, ``\\d+`` correspond aux chiffres thaïlandais et les "
"affiche.  Si vous fournissez le drapeau :const:`re.ASCII` à :func:`~re."
"compile`, ``\\d+`` correspond cette fois à la chaîne \"57\"."

#: ../Doc/howto/unicode.rst:506
msgid ""
"Similarly, ``\\w`` matches a wide variety of Unicode characters but only "
"``[a-zA-Z0-9_]`` in bytes or if :const:`re.ASCII` is supplied, and ``\\s`` "
"will match either Unicode whitespace characters or ``[ \\t\\n\\r\\f\\v]``."
msgstr ""
"De même, ``\\w`` correspond à une grande variété de caractères Unicode mais "
"seulement ``[a-zA-Z0-9_]`` en octets (ou si :const:`re.ASCII` est fourni) et "
"``\\s`` correspond soit aux caractères blancs Unicode soit aux caractères "
"``[ \\t\\n\\r\\f\\v]``."

#: ../Doc/howto/unicode.rst:517
msgid "Some good alternative discussions of Python's Unicode support are:"
msgstr ""
"Quelques bonnes discussions alternatives sur la gestion d'Unicode par Python "
"sont :"

#: ../Doc/howto/unicode.rst:519
msgid ""
"`Processing Text Files in Python 3 <http://python-notes.curiousefficiency."
"org/en/latest/python3/text_file_processing.html>`_, by Nick Coghlan."
msgstr ""
"`Processing Text Files in Python 3 <http://python-notes.curiousefficiency."
"org/en/latest/python3/text_file_processing.html>`_, par Nick Coghlan."

#: ../Doc/howto/unicode.rst:520
msgid ""
"`Pragmatic Unicode <https://nedbatchelder.com/text/unipain.html>`_, a PyCon "
"2012 presentation by Ned Batchelder."
msgstr ""
"`Pragmatic Unicode <https://nedbatchelder.com/text/unipain.html>`_, une "
"présentation PyCon 2012 par Ned Batchelder."

#: ../Doc/howto/unicode.rst:522
msgid ""
"The :class:`str` type is described in the Python library reference at :ref:"
"`textseq`."
msgstr ""
"Le type :class:`str` est décrit dans la référence de la bibliothèque Python "
"à :ref:`textseq`."

#: ../Doc/howto/unicode.rst:525
msgid "The documentation for the :mod:`unicodedata` module."
msgstr "La documentation du module :mod:`unicodedata`."

#: ../Doc/howto/unicode.rst:527
msgid "The documentation for the :mod:`codecs` module."
msgstr "La documentation du module :mod:`codecs`."

#: ../Doc/howto/unicode.rst:529
msgid ""
"Marc-André Lemburg gave `a presentation titled \"Python and Unicode\" (PDF "
"slides) <https://downloads.egenix.com/python/Unicode-EPC2002-Talk.pdf>`_ at "
"EuroPython 2002.  The slides are an excellent overview of the design of "
"Python 2's Unicode features (where the Unicode string type is called "
"``unicode`` and literals start with ``u``)."
msgstr ""
"Marc-André Lemburg a fait une présentation intitulée `« Python et "
"Unicode » (diapositives PDF) <https://downloads.egenix.com/python/Unicode-"
"EPC2002-Talk.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 commence littéralement par "
"``u``)."

#: ../Doc/howto/unicode.rst:537
msgid "Reading and Writing Unicode Data"
msgstr ""

#: ../Doc/howto/unicode.rst:539
msgid ""
"Once you've written some code that works with Unicode data, the next problem "
"is input/output.  How do you get Unicode strings into your program, and how "
"do you convert Unicode into a form suitable for storage or transmission?"
msgstr ""

#: ../Doc/howto/unicode.rst:543
msgid ""
"It's possible that you may not need to do anything depending on your input "
"sources and output destinations; you should check whether the libraries used "
"in your application support Unicode natively.  XML parsers often return "
"Unicode data, for example.  Many relational databases also support Unicode-"
"valued columns and can return Unicode values from an SQL query."
msgstr ""

#: ../Doc/howto/unicode.rst:549
msgid ""
"Unicode data is usually converted to a particular encoding before it gets "
"written to disk or sent over a socket.  It's possible to do all the work "
"yourself: open a file, read an 8-bit bytes object from it, and convert the "
"bytes with ``bytes.decode(encoding)``.  However, the manual approach is not "
"recommended."
msgstr ""

#: ../Doc/howto/unicode.rst:554
msgid ""
"One problem is the multi-byte nature of encodings; one Unicode character can "
"be represented by several bytes.  If you want to read the file in arbitrary-"
"sized chunks (say, 1024 or 4096 bytes), you need to write error-handling "
"code to catch the case where only part of the bytes encoding a single "
"Unicode character are read at the end of a chunk.  One solution would be to "
"read the entire file into memory and then perform the decoding, but that "
"prevents you from working with files that are extremely large; if you need "
"to read a 2 GiB file, you need 2 GiB of RAM. (More, really, since for at "
"least a moment you'd need to have both the encoded string and its Unicode "
"version in memory.)"
msgstr ""

#: ../Doc/howto/unicode.rst:564
msgid ""
"The solution would be to use the low-level decoding interface to catch the "
"case of partial coding sequences.  The work of implementing this has already "
"been done for you: the built-in :func:`open` function can return a file-like "
"object that assumes the file's contents are in a specified encoding and "
"accepts Unicode parameters for methods such as :meth:`~io.TextIOBase.read` "
"and :meth:`~io.TextIOBase.write`.  This works through :func:`open`\\'s "
"*encoding* and *errors* parameters which are interpreted just like those in :"
"meth:`str.encode` and :meth:`bytes.decode`."
msgstr ""

#: ../Doc/howto/unicode.rst:573
msgid "Reading Unicode from a file is therefore simple::"
msgstr ""

#: ../Doc/howto/unicode.rst:579
msgid ""
"It's also possible to open files in update mode, allowing both reading and "
"writing::"
msgstr ""

#: ../Doc/howto/unicode.rst:587
msgid ""
"The Unicode character ``U+FEFF`` is used as a byte-order mark (BOM), and is "
"often written as the first character of a file in order to assist with "
"autodetection of the file's byte ordering.  Some encodings, such as UTF-16, "
"expect a BOM to be present at the start of a file; when such an encoding is "
"used, the BOM will be automatically written as the first character and will "
"be silently dropped when the file is read.  There are variants of these "
"encodings, such as 'utf-16-le' and 'utf-16-be' for little-endian and big-"
"endian encodings, that specify one particular byte ordering and don't skip "
"the BOM."
msgstr ""

#: ../Doc/howto/unicode.rst:596
msgid ""
"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.  For "
"reading such files, use the 'utf-8-sig' codec to automatically skip the mark "
"if present."
msgstr ""

#: ../Doc/howto/unicode.rst:603
msgid "Unicode filenames"
msgstr ""

#: ../Doc/howto/unicode.rst:605
msgid ""
"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.  Today Python is converging on using UTF-8: Python on MacOS has "
"used UTF-8 for several versions, and Python 3.6 switched to using UTF-8 on "
"Windows as well.  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 again UTF-8."
msgstr ""

#: ../Doc/howto/unicode.rst:615
msgid ""
"The :func:`sys.getfilesystemencoding` function returns the encoding to use "
"on your current system, in case you want to do the encoding manually, but "
"there's not much reason to bother.  When opening a file for reading or "
"writing, you can usually just provide the Unicode string as the filename, "
"and it will be automatically converted to the right encoding for you::"
msgstr ""

#: ../Doc/howto/unicode.rst:625
msgid ""
"Functions in the :mod:`os` module such as :func:`os.stat` will also accept "
"Unicode filenames."
msgstr ""

#: ../Doc/howto/unicode.rst:628
msgid ""
"The :func:`os.listdir` function returns filenames, which raises an issue: "
"should it return the Unicode version of filenames, or should it return bytes "
"containing the encoded versions?  :func:`os.listdir` can 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::"
msgstr ""

#: ../Doc/howto/unicode.rst:646
msgid "will produce the following output:"
msgstr ""

#: ../Doc/howto/unicode.rst:654
msgid ""
"The first list contains UTF-8-encoded filenames, and the second list "
"contains the Unicode versions."
msgstr ""

#: ../Doc/howto/unicode.rst:657
msgid ""
"Note that on most occasions, you should can just stick with using Unicode "
"with these APIs.  The bytes APIs should only be used on systems where "
"undecodable file names can be present; that's pretty much only Unix systems "
"now."
msgstr ""

#: ../Doc/howto/unicode.rst:664
msgid "Tips for Writing Unicode-aware Programs"
msgstr ""

#: ../Doc/howto/unicode.rst:666
msgid ""
"This section provides some suggestions on writing software that deals with "
"Unicode."
msgstr ""

#: ../Doc/howto/unicode.rst:669
msgid "The most important tip is:"
msgstr ""

#: ../Doc/howto/unicode.rst:671
msgid ""
"Software should only work with Unicode strings internally, decoding the "
"input data as soon as possible and encoding the output only at the end."
msgstr ""

#: ../Doc/howto/unicode.rst:674
msgid ""
"If you attempt to write processing functions that accept both Unicode and "
"byte strings, you will find your program vulnerable to bugs wherever you "
"combine the two different kinds of strings.  There is no automatic encoding "
"or decoding: if you do e.g. ``str + bytes``, a :exc:`TypeError` will be "
"raised."
msgstr ""

#: ../Doc/howto/unicode.rst:679
msgid ""
"When using data coming from a web browser or some other untrusted source, a "
"common technique is to check for illegal characters in a string before using "
"the string in a generated command line or storing it in a database.  If "
"you're doing this, be careful to check the decoded string, not the encoded "
"bytes data; some encodings may have interesting properties, such as not "
"being bijective or not being fully ASCII-compatible.  This is especially "
"true if the input data also specifies the encoding, since the attacker can "
"then choose a clever way to hide malicious text in the encoded bytestream."
msgstr ""

#: ../Doc/howto/unicode.rst:690
msgid "Converting Between File Encodings"
msgstr ""

#: ../Doc/howto/unicode.rst:692
msgid ""
"The :class:`~codecs.StreamRecoder` class can transparently convert between "
"encodings, taking a stream that returns data in encoding #1 and behaving "
"like a stream returning data in encoding #2."
msgstr ""

#: ../Doc/howto/unicode.rst:696
msgid ""
"For example, if you have an input file *f* that's in Latin-1, you can wrap "
"it with a :class:`~codecs.StreamRecoder` to return bytes encoded in UTF-8::"
msgstr ""

#: ../Doc/howto/unicode.rst:710
msgid "Files in an Unknown Encoding"
msgstr ""

#: ../Doc/howto/unicode.rst:712
msgid ""
"What can you do if you need to make a change to a file, but don't know the "
"file's encoding?  If you know the encoding is ASCII-compatible and only want "
"to examine or modify the ASCII parts, you can open the file with the "
"``surrogateescape`` error handler::"
msgstr ""

#: ../Doc/howto/unicode.rst:726
msgid ""
"The ``surrogateescape`` error handler will decode any non-ASCII bytes as "
"code points in a special range running from U+DC80 to U+DCFF.  These code "
"points will then turn back into the same bytes when the ``surrogateescape`` "
"error handler is used to encode the data and write it back out."
msgstr ""

#: ../Doc/howto/unicode.rst:736
msgid ""
"One section of `Mastering Python 3 Input/Output <http://pyvideo.org/"
"video/289/pycon-2010--mastering-python-3-i-o>`_, a PyCon 2010 talk by David "
"Beazley, discusses text processing and binary data handling."
msgstr ""

#: ../Doc/howto/unicode.rst:740
msgid ""
"The `PDF slides for Marc-André Lemburg's presentation \"Writing Unicode-"
"aware Applications in Python\" <https://downloads.egenix.com/python/LSM2005-"
"Developing-Unicode-aware-applications-in-Python.pdf>`_ discuss questions of "
"character encodings as well as how to internationalize and localize an "
"application.  These slides cover Python 2.x only."
msgstr ""

#: ../Doc/howto/unicode.rst:746
msgid ""
"`The Guts of Unicode in Python <http://pyvideo.org/video/1768/the-guts-of-"
"unicode-in-python>`_ is a PyCon 2013 talk by Benjamin Peterson that "
"discusses the internal Unicode representation in Python 3.3."
msgstr ""

#: ../Doc/howto/unicode.rst:753
msgid "Acknowledgements"
msgstr "Remerciements"

#: ../Doc/howto/unicode.rst:755
msgid ""
"The initial draft of this document was written by Andrew Kuchling. It has "
"since been revised further by Alexander Belopolsky, Georg Brandl, Andrew "
"Kuchling, and Ezio Melotti."
msgstr ""

#: ../Doc/howto/unicode.rst:759
msgid ""
"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, Serhiy Storchaka, Eryk Sun, Chad Whitacre, Graham Wideman."
msgstr ""

#~ msgid "History of Character Codes"
#~ msgstr "Histoire des codes de caractères"

#~ msgid ""
#~ "In 1968, the American Standard Code for Information Interchange, better "
#~ "known by its acronym ASCII, was standardized.  ASCII defined numeric "
#~ "codes for various characters, with the numeric values running from 0 to "
#~ "127.  For example, the lowercase letter 'a' is assigned 97 as its code "
#~ "value."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "ASCII was an American-developed standard, so it only defined unaccented "
#~ "characters.  There was an 'e', but no 'é' or 'Í'.  This meant that "
#~ "languages which required accented characters couldn't be faithfully "
#~ "represented in ASCII. (Actually the missing accents matter for English, "
#~ "too, which contains words such as 'naïve' and 'café', and some "
#~ "publications have house styles which require spellings such as "
#~ "'coöperate'.)"
#~ msgstr ""
#~ "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* ».)"

#~ msgid ""
#~ "For a while people just wrote programs that didn't display accents. In "
#~ "the mid-1980s an Apple II BASIC program written by a French speaker might "
#~ "have lines like these:"
#~ msgstr ""
#~ "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 : ::"

#~ msgid ""
#~ "Those messages should contain accents (terminée, paramètre, enregistrés) "
#~ "and they just look wrong to someone who can read French."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "In the 1980s, almost all personal computers were 8-bit, meaning that "
#~ "bytes could hold values ranging from 0 to 255.  ASCII codes only went up "
#~ "to 127, so some machines assigned values between 128 and 255 to accented "
#~ "characters.  Different machines had different codes, however, which led "
#~ "to problems exchanging files. Eventually various commonly used sets of "
#~ "values for the 128--255 range emerged. Some were true standards, defined "
#~ "by the International Organization for Standardization, and some were *de "
#~ "facto* conventions that were invented by one company or another and "
#~ "managed to catch on."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "255 characters aren't very many.  For example, you can't fit both the "
#~ "accented characters used in Western Europe and the Cyrillic alphabet used "
#~ "for Russian into the 128--255 range because there are more than 128 such "
#~ "characters."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "You could write files using different codes (all your Russian files in a "
#~ "coding system called KOI8, all your French files in a different coding "
#~ "system called Latin1), but what if you wanted to write a French document "
#~ "that quotes some Russian text?  In the 1980s people began to want to "
#~ "solve this problem, and the Unicode standardization effort began."
#~ msgstr ""
#~ "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é."

#~ msgid ""
#~ "Unicode started out using 16-bit characters instead of 8-bit characters.  "
#~ "16 bits means you have 2^16 = 65,536 distinct values available, making it "
#~ "possible to represent many different characters from many different "
#~ "alphabets; an initial goal was to have Unicode contain the alphabets for "
#~ "every single human language. It turns out that even 16 bits isn't enough "
#~ "to meet that goal, and the modern Unicode specification uses a wider "
#~ "range of codes, 0 through 1,114,111 ( ``0x10FFFF`` in base 16)."
#~ msgstr ""
#~ "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)."

#~ msgid ""
#~ "There's a related ISO standard, ISO 10646.  Unicode and ISO 10646 were "
#~ "originally separate efforts, but the specifications were merged with the "
#~ "1.1 revision of Unicode."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "(This discussion of Unicode's history is highly simplified.  The precise "
#~ "historical details aren't necessary for understanding how to use Unicode "
#~ "effectively, but if you're curious, consult the Unicode consortium site "
#~ "listed in the References or the `Wikipedia entry for Unicode <https://en."
#~ "wikipedia.org/wiki/Unicode#History>`_ for more information.)"
#~ msgstr ""
#~ "(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 <https://en.wikipedia.org/wiki/"
#~ "Unicode#History>`_ (page en anglais) pour plus d’informations.)"

#~ msgid ""
#~ "Many Internet standards are defined in terms of textual data, and can't "
#~ "handle content with embedded zero bytes."
#~ msgstr ""
#~ "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*."

#~ msgid ""
#~ "Generally people don't use this encoding, instead choosing other "
#~ "encodings that are more efficient and convenient.  UTF-8 is probably the "
#~ "most commonly supported encoding; it will be discussed below."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "Encodings don't have to handle every possible Unicode character, and most "
#~ "encodings don't.  The rules for converting a Unicode string into the "
#~ "ASCII encoding, for example, are simple; for each code point:"
#~ msgstr ""
#~ "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 :"

#~ msgid ""
#~ "If the code point is < 128, each byte is the same as the value of the "
#~ "code point."
#~ msgstr ""
#~ "Si le point de code est < 128, chaque octet est identique à la valeur du "
#~ "point de code."

#~ msgid ""
#~ "If the code point is 128 or greater, the Unicode string can't be "
#~ "represented in this encoding.  (Python raises a :exc:`UnicodeEncodeError` "
#~ "exception in this case.)"
#~ msgstr ""
#~ "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 :exc:"
#~ "`UnicodeEncodeError` dans ce cas)."

#~ msgid ""
#~ "Latin-1, also known as ISO-8859-1, is a similar encoding.  Unicode code "
#~ "points 0--255 are identical to the Latin-1 values, so converting to this "
#~ "encoding simply requires converting code points to byte values; if a code "
#~ "point larger than 255 is encountered, the string can't be encoded into "
#~ "Latin-1."
#~ msgstr ""
#~ "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."

#~ msgid ""
#~ "Encodings don't have to be simple one-to-one mappings like Latin-1.  "
#~ "Consider IBM's EBCDIC, which was used on IBM mainframes.  Letter values "
#~ "weren't in one block: 'a' through 'i' had values from 129 to 137, but 'j' "
#~ "through 'r' were 145 through 153.  If you wanted to use EBCDIC as an "
#~ "encoding, you'd probably use some sort of lookup table to perform the "
#~ "conversion, but this is largely an internal detail."
#~ msgstr ""
#~ "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."