# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2024-11-01 00:16+0100\n"

"PO-Revision-Date: 2023-03-26 17:48+0200\n"

"Last-Translator: Mathieu Dupuy\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 3.2.2\n"

#: howto/unicode.rst:5

msgid "Unicode HOWTO"

msgstr "Guide Unicode"

#: howto/unicode.rst:0

msgid "Release"

msgstr "Version"

#: howto/unicode.rst:7

msgid "1.12"

msgstr "1.12"

#: 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 guide 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."

#: howto/unicode.rst:15

msgid "Introduction to Unicode"

msgstr "Introduction à Unicode"

#: howto/unicode.rst:18

msgid "Definitions"

msgstr "Définitions"

#: 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."

#: 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."

#: 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."

#: 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, the `actual number assigned <https://www.unicode."

"org/versions/latest/#Summary>`_ is less than that). 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 possibles, le "

"`nombre de valeurs réellement assignées <https://www.unicode.org/versions/"

"latest/#Summary>`_ est inférieur à ce nombre). 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)."

#: howto/unicode.rst:50

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 :"

#: howto/unicode.rst:71

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."

#: howto/unicode.rst:78

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."

#: howto/unicode.rst:87

msgid "Encodings"

msgstr "Encodages"

#: howto/unicode.rst:89

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**."

#: howto/unicode.rst:97

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 :"

#: howto/unicode.rst:107

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."

#: howto/unicode.rst:110

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."

#: howto/unicode.rst:112

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."

#: howto/unicode.rst:120

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*)."

#: howto/unicode.rst:123

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."

#: howto/unicode.rst:126

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 :"

#: howto/unicode.rst:132

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."

#: howto/unicode.rst:133

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."

#: howto/unicode.rst:136

msgid "UTF-8 has several convenient properties:"

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

#: howto/unicode.rst:138

msgid "It can handle any Unicode code point."

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

#: howto/unicode.rst:139

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+0000). "

"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."

#: howto/unicode.rst:144

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."

#: howto/unicode.rst:145

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."

#: howto/unicode.rst:147

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."

#: howto/unicode.rst:150

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é octet. 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."

#: howto/unicode.rst:514 howto/unicode.rst:735

msgid "References"

msgstr "Références"

#: howto/unicode.rst:160

msgid ""

"The `Unicode Consortium site <https://www.unicode.org>`_ has character "

"charts, a glossary, and PDF versions of the Unicode specification. Be "

"prepared for some difficult reading. `A chronology <https://www.unicode.org/"

"history/>`_ of the origin and development of Unicode is also available on "

"the site."

msgstr ""

"Le site du `Consortium Unicode <https://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 <https://www.unicode.org/history/>`_ de l’origine et du "

"développement de l’Unicode est également disponible sur le site."

#: howto/unicode.rst:165

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 <https://www.youtube.com/watch?"

"v=MijmeoH9LT4>`_ (9 minutes et 36 secondes)."

#: howto/unicode.rst:169

msgid ""

"To help understand the standard, Jukka Korpela has written `an introductory "

"guide <https://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 <https://jkorpela.fi/unicode/guide.html>`_ à la lecture des "

"tables de caractères Unicode (ressource en anglais)."

#: howto/unicode.rst:173

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."

#: howto/unicode.rst:178

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."

#: howto/unicode.rst:184

msgid "Python's Unicode Support"

msgstr "Prise en charge Unicode de Python"

#: howto/unicode.rst:186

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."

#: howto/unicode.rst:190

msgid "The String Type"

msgstr "Le type *String*"

#: howto/unicode.rst:192

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."

#: howto/unicode.rst:196

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 ::"

#: howto/unicode.rst:206

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 ::"

#: howto/unicode.rst:212

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 "

"voyiez le glyphe réel du *delta majuscule* au lieu d'une séquence "

"d'échappement ``\\u...``) ::"

#: howto/unicode.rst:224

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*."

#: howto/unicode.rst:228

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 autorisées "

"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 ::"

#: howto/unicode.rst:248

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."

#: howto/unicode.rst:254

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 native :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 native :func:`ord` qui prend une chaîne "

"Unicode d'un caractère et renvoie la valeur du point de code ::"

#: howto/unicode.rst:266

msgid "Converting to Bytes"

msgstr "Conversion en octets"

#: howto/unicode.rst:268

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é."

#: howto/unicode.rst:272

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 encodable), 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{...}``)."

#: howto/unicode.rst:280

msgid "The following example shows the different results::"

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

#: howto/unicode.rst:301

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 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."

#: howto/unicode.rst:310

msgid "Unicode Literals in Python Source Code"

msgstr "Littéraux Unicode dans le code source Python"

#: howto/unicode.rst:312

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 ::"

#: howto/unicode.rst:324

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 native :func:`chr`, mais c'est encore plus fastidieux."

#: howto/unicode.rst:330

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."

#: howto/unicode.rst:335

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 ::"

#: howto/unicode.rst:345

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."

#: howto/unicode.rst:351

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."

#: howto/unicode.rst:356

msgid "Unicode Properties"

msgstr "Propriétés Unicode"

#: howto/unicode.rst:358

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."

#: howto/unicode.rst:366

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 ::"

#: howto/unicode.rst:380

msgid "When run, this prints:"

msgstr "Si vous l'exécutez, cela affiche :"

#: howto/unicode.rst:391

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 <https://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 <https://www."

"unicode.org/reports/tr44/#General_Category_Values>`_ (ressource en anglais) "

"pour une liste de codes de catégories."

#: howto/unicode.rst:402

msgid "Comparing Strings"

msgstr "Comparaison de chaînes de caractères"

#: howto/unicode.rst:404

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."

#: howto/unicode.rst:412

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* »."

#: howto/unicode.rst:425

#, fuzzy

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:`~unicodedata.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` 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 :"

#: howto/unicode.rst:448

msgid "When run, this outputs:"

msgstr "Si vous l'exécutez, cela affiche :"

#: howto/unicode.rst:457

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'``."

#: howto/unicode.rst:461

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 ::"

#: howto/unicode.rst:477

#, fuzzy

msgid ""

"This will print ``True``. (Why is :func:`!NFD` invoked twice? Because "

"there are a few characters that make :meth:`~str.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)."

#: howto/unicode.rst:484

msgid "Unicode Regular Expressions"

msgstr "Expressions régulières Unicode"

#: howto/unicode.rst:486

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'``."

#: howto/unicode.rst:493

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 ::"

#: howto/unicode.rst:503

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\"."

#: howto/unicode.rst:507

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]``."

#: howto/unicode.rst:518

msgid "Some good alternative discussions of Python's Unicode support are:"

msgstr ""

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

"sont :"

#: howto/unicode.rst:520

msgid ""

"`Processing Text Files in Python 3 <https://python-notes.curiousefficiency."

"org/en/latest/python3/text_file_processing.html>`_, by Nick Coghlan."

msgstr ""

"`Processing Text Files in Python 3 <https://python-notes.curiousefficiency."

"org/en/latest/python3/text_file_processing.html>`_, par Nick Coghlan."

#: howto/unicode.rst:521

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."

#: howto/unicode.rst:523

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`."

#: howto/unicode.rst:526

msgid "The documentation for the :mod:`unicodedata` module."

msgstr "La documentation du module :mod:`unicodedata`."

#: howto/unicode.rst:528

msgid "The documentation for the :mod:`codecs` module."

msgstr "La documentation du module :mod:`codecs`."

#: howto/unicode.rst:530

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 donné 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 les littéraux commencent par ``u``)."

#: howto/unicode.rst:538

msgid "Reading and Writing Unicode Data"

msgstr "Lecture et écriture de données Unicode"

#: howto/unicode.rst:540

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 ""

"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 ?"

#: howto/unicode.rst:544

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 ""

"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."

#: howto/unicode.rst:550

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 ""

"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."

#: howto/unicode.rst:555

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 ""

"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)."

#: howto/unicode.rst:565

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 ""

"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 :func:`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 :meth:`~io.TextIOBase.read` et :meth:`~io.TextIOBase."

"write`. Ceci fonctionne grâce aux paramètres *encoding* et *errors* de :func:"

"`open` qui sont interprétés comme ceux de :meth:`str.encode` et :meth:`bytes."

"decode`."

#: howto/unicode.rst:574

msgid "Reading Unicode from a file is therefore simple::"

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

#: howto/unicode.rst:580

msgid ""

"It's also possible to open files in update mode, allowing both reading and "

"writing::"

msgstr ""

"Il est également possible d'ouvrir des fichiers en mode « mise à jour », "

"permettant à la fois la lecture et l'écriture ::"

#: howto/unicode.rst:588

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 ""

"Le caractère Unicode ``U+FEFFF`` est utilisé comme marque pour indiquer le "