# 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: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2023-02-04 16:46+0100\n"
"Last-Translator: Jules Lasne <jules.lasne@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 3.2.1\n"

#: tutorial/inputoutput.rst:5
msgid "Input and Output"
msgstr "Les entrées/sorties"

#: tutorial/inputoutput.rst:7
msgid ""
"There are several ways to present the output of a program; data can be "
"printed in a human-readable form, or written to a file for future use. This "
"chapter will discuss some of the possibilities."
msgstr ""
"Il existe bien des moyens de présenter les sorties d'un programme ; les "
"données peuvent être affichées sous une forme lisible par un être humain ou "
"sauvegardées dans un fichier pour une utilisation future. Ce chapitre "
"présente quelques possibilités."

#: tutorial/inputoutput.rst:15
msgid "Fancier Output Formatting"
msgstr "Formatage de données"

#: tutorial/inputoutput.rst:17
msgid ""
"So far we've encountered two ways of writing values: *expression statements* "
"and the :func:`print` function.  (A third way is using the :meth:`write` "
"method of file objects; the standard output file can be referenced as ``sys."
"stdout``. See the Library Reference for more information on this.)"
msgstr ""
"Jusqu'ici, nous avons rencontré deux moyens d'écrire des données : les "
"*déclarations d'expressions* et la fonction :func:`print`. Une troisième "
"méthode consiste à utiliser la méthode :meth:`write` des fichiers, avec le "
"fichier de sortie standard référencé en tant que ``sys.stdout``. Voyez le "
"Guide de Référence de la Bibliothèque Standard pour en savoir plus."

#: tutorial/inputoutput.rst:22
msgid ""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values. There are several ways to format "
"output."
msgstr ""
"Souvent vous voudrez plus de contrôle sur le formatage de vos sorties et "
"aller au delà d’un affichage de valeurs séparées par des espaces. Il y a "
"plusieurs moyens de les formater."

#: tutorial/inputoutput.rst:25
msgid ""
"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "
"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "
"Inside this string, you can write a Python expression between ``{`` and ``}"
"`` characters that can refer to variables or literal values."
msgstr ""
"Pour utiliser :ref:`les expressions formatées <tut-f-strings>`, commencez "
"une chaine de caractère avec ``f`` ou ``F`` avant d’ouvrir vos guillemets "
"doubles ou triples. Dans ces chaines de caractère, vous pouvez entrer des "
"expressions Python entre les caractères ``{`` et ``}`` qui peuvent contenir "
"des variables ou des valeurs littérales."

#: tutorial/inputoutput.rst:37
msgid ""
"The :meth:`str.format` method of strings requires more manual effort.  "
"You'll still use ``{`` and ``}`` to mark where a variable will be "
"substituted and can provide detailed formatting directives, but you'll also "
"need to provide the information to be formatted."
msgstr ""
"La méthode :meth:`str.format` sur les chaines de caractères exige un plus "
"grand effort manuel. Vous utiliserez toujours les caractères ``{`` et ``}`` "
"pour indiquer où une variable sera substituée et donner des détails sur son "
"formatage, mais vous devrez également fournir les informations à formater."

#: tutorial/inputoutput.rst:50
msgid ""
"Finally, you can do all the string handling yourself by using string slicing "
"and concatenation operations to create any layout you can imagine.  The "
"string type has some methods that perform useful operations for padding "
"strings to a given column width."
msgstr ""
"Enfin, vous pouvez construire des concaténations de tranches de chaînes vous-"
"même, et ainsi créer n'importe quel agencement. Le type des chaînes a des "
"méthodes utiles pour aligner des chaînes dans une largeur de taille fixe."

#: tutorial/inputoutput.rst:55
msgid ""
"When you don't need fancy output but just want a quick display of some "
"variables for debugging purposes, you can convert any value to a string with "
"the :func:`repr` or :func:`str` functions."
msgstr ""
"Lorsque qu'un affichage basique suffit, pour afficher simplement une "
"variable pour en inspecter le contenu, vous pouvez convertir n'importe "
"quelle valeur en chaîne de caractères en utilisant la fonction :func:`repr` "
"ou la fonction :func:`str`."

#: tutorial/inputoutput.rst:59
msgid ""
"The :func:`str` function is meant to return representations of values which "
"are fairly human-readable, while :func:`repr` is meant to generate "
"representations which can be read by the interpreter (or will force a :exc:"
"`SyntaxError` if there is no equivalent syntax).  For objects which don't "
"have a particular representation for human consumption, :func:`str` will "
"return the same value as :func:`repr`.  Many values, such as numbers or "
"structures like lists and dictionaries, have the same representation using "
"either function.  Strings, in particular, have two distinct representations."
msgstr ""
"La fonction :func:`str` est destinée à représenter les valeurs sous une "
"forme lisible par un être humain, alors que la fonction :func:`repr` est "
"destinée à générer des représentations qui puissent être lues par "
"l'interpréteur (ou qui lèvera une :exc:`SyntaxError` s'il n'existe aucune "
"syntaxe équivalente). Pour les objets qui n'ont pas de représentation "
"humaine spécifique, :func:`str` renvoie la même valeur que :func:`repr`. "
"Beaucoup de valeurs, comme les nombres ou les structures telles que les "
"listes ou les dictionnaires, ont la même représentation en utilisant les "
"deux fonctions. Les chaînes de caractères, en particulier, ont deux "
"représentations distinctes."

#: tutorial/inputoutput.rst:68
msgid "Some examples::"
msgstr "Quelques exemples ::"

#: tutorial/inputoutput.rst:91
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders "
"like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr ""
"Le module :mod:`string` contient une classe :class:`~string.Template` qui "
"permet aussi de remplacer des valeurs au sein de chaînes de caractères, en "
"utilisant des marqueurs comme ``$x``, et en les remplaçant par les valeurs "
"d'un dictionnaire, mais sa capacité à formater les chaînes est plus limitée."

#: tutorial/inputoutput.rst:100
msgid "Formatted String Literals"
msgstr "Les chaines de caractères formatées (*f-strings*)"

#: tutorial/inputoutput.rst:102
msgid ""
":ref:`Formatted string literals <f-strings>` (also called f-strings for "
"short) let you include the value of Python expressions inside a string by "
"prefixing the string with ``f`` or ``F`` and writing expressions as "
"``{expression}``."
msgstr ""
":ref:`Les chaines de caractères formatées <f-strings>` (aussi appelées f-"
"strings) vous permettent d’inclure la valeur d’expressions Python dans des "
"chaines de caractères en les préfixant avec ``f`` ou ``F`` et écrire des "
"expressions comme ``{expression}``."

#: tutorial/inputoutput.rst:107
msgid ""
"An optional format specifier can follow the expression. This allows greater "
"control over how the value is formatted. The following example rounds pi to "
"three places after the decimal::"
msgstr ""
"L'expression peut être suivie d'un spécificateur de format. Cela permet un "
"plus grand contrôle sur la façon dont la valeur est rendue. L'exemple "
"suivant arrondit pi à trois décimales après la virgule ::"

#: tutorial/inputoutput.rst:115
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making columns line up. ::"
msgstr ""
"Donner un entier après le ``':'`` indique la largeur minimale de ce champ en "
"nombre de caractères. C'est utile pour faire de jolis tableaux ::"

#: tutorial/inputoutput.rst:126
msgid ""
"Other modifiers can be used to convert the value before it is formatted. ``'!"
"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "
"applies :func:`repr`::"
msgstr ""
"D’autres modificateurs peuvent être utilisés pour convertir la valeur avant "
"son formatage. ``'!a'`` applique :func:`ascii`, ``'!s'`` applique :func:"
"`str`, et ``'!r'`` applique :func:`repr` ::"

#: tutorial/inputoutput.rst:136
msgid ""
"The ``=`` specifier can be used to expand an expression to the text of the "
"expression, an equal sign, then the representation of the evaluated "
"expression:"
msgstr ""
"Le spécificateur ``=`` peut être utilisé pour développer une expression en "
"« texte de l'expression, un signe égal, puis la représentation de "
"l'expression évaluée » :"

#: tutorial/inputoutput.rst:145
msgid ""
"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr ""
"Lisez :ref:`self-documenting expressions <bpo-36817-whatsnew>` pour "
"davantage d'information sur le spécificateur ``=``. Pour une référence sur "
"ces spécifications de formats, voir le guide de référence pour le :ref:"
"`formatspec`."

#: tutorial/inputoutput.rst:152
msgid "The String format() Method"
msgstr "La méthode de chaine de caractères ``format()``"

#: tutorial/inputoutput.rst:154
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr ""
"L'utilisation de base de la méthode :meth:`str.format` ressemble à ceci ::"

#: tutorial/inputoutput.rst:159
msgid ""
"The brackets and characters within them (called format fields) are replaced "
"with the objects passed into the :meth:`str.format` method.  A number in the "
"brackets can be used to refer to the position of the object passed into the :"
"meth:`str.format` method. ::"
msgstr ""
"Les accolades et les caractères à l'intérieur (appelés les champs de "
"formatage) sont remplacés par les objets passés en paramètres à la méthode :"
"meth:`str.format`. Un nombre entre accolades se réfère à la position de "
"l'objet passé à la méthode :meth:`str.format`. ::"

#: tutorial/inputoutput.rst:169
msgid ""
"If keyword arguments are used in the :meth:`str.format` method, their values "
"are referred to by using the name of the argument. ::"
msgstr ""
"Si des arguments nommés sont utilisés dans la méthode :meth:`str.format`, "
"leurs valeurs sont utilisées en se basant sur le nom des arguments ::"

#: tutorial/inputoutput.rst:176
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr ""
"Les arguments positionnés et nommés peuvent être combinés arbitrairement ::"

#: tutorial/inputoutput.rst:182
msgid ""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position.  This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys. ::"
msgstr ""
"Si vous avez une chaîne de formatage vraiment longue que vous ne voulez pas "
"découper, il est possible de référencer les variables à formater par leur "
"nom plutôt que par leur position. Utilisez simplement un dictionnaire et la "
"notation entre crochets ``'[]'`` pour accéder aux clés ::"

#: tutorial/inputoutput.rst:192
msgid ""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr ""
"Vous pouvez obtenir le même résultat en passant le dictionnaire ``table`` "
"comme des arguments nommés en utilisant la notation ``**`` ::"

#: tutorial/inputoutput.rst:199
msgid ""
"This is particularly useful in combination with the built-in function :func:"
"`vars`, which returns a dictionary containing all local variables."
msgstr ""
"C'est particulièrement utile en combinaison avec la fonction native :func:"
"`vars` qui renvoie un dictionnaire contenant toutes les variables locales."

#: tutorial/inputoutput.rst:202
msgid ""
"As an example, the following lines produce a tidily aligned set of columns "
"giving integers and their squares and cubes::"
msgstr ""
"À titre d’exemple, les lignes suivantes produisent un ensemble de colonnes "
"alignées de façon ordonnée donnant les entiers, leurs carrés et leurs "
"cubes ::"

#: tutorial/inputoutput.rst:219
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see :"
"ref:`formatstrings`."
msgstr ""
"Pour avoir une description complète du formatage des chaînes de caractères "
"avec la méthode :meth:`str.format`, lisez : :ref:`formatstrings`."

#: tutorial/inputoutput.rst:224
msgid "Manual String Formatting"
msgstr "Formatage de chaînes à la main"

#: tutorial/inputoutput.rst:226
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr "Voici le même tableau de carrés et de cubes, formaté à la main ::"

#: tutorial/inputoutput.rst:244
msgid ""
"(Note that the one space between each column was added by the way :func:"
"`print` works: it always adds spaces between its arguments.)"
msgstr ""
"(Remarquez que l'espace séparant les colonnes vient de la manière dont :func:"
"`print` fonctionne : il ajoute toujours des espaces entre ses arguments.)"

#: tutorial/inputoutput.rst:247
msgid ""
"The :meth:`str.rjust` method of string objects right-justifies a string in a "
"field of a given width by padding it with spaces on the left. There are "
"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "
"not write anything, they just return a new string. If the input string is "
"too long, they don't truncate it, but return it unchanged; this will mess up "
"your column lay-out but that's usually better than the alternative, which "
"would be lying about a value. (If you really want truncation you can always "
"add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr ""
"La méthode :meth:`str.rjust` des chaînes de caractères justifie à droite une "
"chaîne dans un champ d'une largeur donnée en ajoutant des espaces sur la "
"gauche. Il existe des méthodes similaires :meth:`str.ljust` et :meth:`str."
"center`. Ces méthodes n'écrivent rien, elles renvoient simplement une "
"nouvelle chaîne. Si la chaîne passée en paramètre est trop longue, elle "
"n'est pas tronquée mais renvoyée sans modification ; cela peut chambouler "
"votre mise en page mais c'est souvent préférable à l'alternative, qui "
"pourrait mentir sur une valeur (et si vous voulez vraiment tronquer vos "
"valeurs, vous pouvez toujours utiliser une tranche, comme dans ``x.ljust(n)[:"
"n]``)."

#: tutorial/inputoutput.rst:256
msgid ""
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
"the left with zeros.  It understands about plus and minus signs::"
msgstr ""
"Il existe une autre méthode, :meth:`str.zfill`, qui comble une chaîne "
"numérique à gauche avec des zéros. Elle comprend les signes plus et moins ::"

#: tutorial/inputoutput.rst:268
msgid "Old string formatting"
msgstr "Anciennes méthodes de formatage de chaînes"

#: tutorial/inputoutput.rst:270
msgid ""
"The % operator (modulo) can also be used for string formatting. Given "
"``'string' % values``, instances of ``%`` in ``string`` are replaced with "
"zero or more elements of ``values``. This operation is commonly known as "
"string interpolation. For example::"
msgstr ""
"L'opérateur % (modulo) peut également être utilisé pour le formatage des "
"chaînes de caractères. Pour ``'string' % values``, les instances de ``%`` "
"dans la chaine de caractères ``string`` sont remplacées par zéro ou "
"plusieurs d'éléments de ``values``. Cette opération est communément appelée "
"interpolation de chaîne de caractères. Par exemple ::"

#: tutorial/inputoutput.rst:279
msgid ""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr ""
"Vous trouvez plus d'informations dans la section :ref:`old-string-"
"formatting`."

#: tutorial/inputoutput.rst:285
msgid "Reading and Writing Files"
msgstr "Lecture et écriture de fichiers"

#: tutorial/inputoutput.rst:291
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two positional arguments and one keyword argument: ``open(filename, mode, "
"encoding=None)``"
msgstr ""
"La fonction :func:`open` renvoie un :term:`objet fichier` et est le plus "
"souvent utilisée avec deux arguments positionnels et un argument nommé : "
"``open(filename, mode, encoding=None)``"

#: tutorial/inputoutput.rst:304
msgid ""
"The first argument is a string containing the filename.  The second argument "
"is another string containing a few characters describing the way in which "
"the file will be used.  *mode* can be ``'r'`` when the file will only be "
"read, ``'w'`` for only writing (an existing file with the same name will be "
"erased), and ``'a'`` opens the file for appending; any data written to the "
"file is automatically added to the end.  ``'r+'`` opens the file for both "
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
"assumed if it's omitted."
msgstr ""
"Le premier argument est une chaîne contenant le nom du fichier. Le deuxième "
"argument est une autre chaîne contenant quelques caractères décrivant la "
"façon dont le fichier est utilisé. *mode* peut être ``'r'`` quand le fichier "
"n'est accédé qu'en lecture, ``'w'`` en écriture seulement (un fichier "
"existant portant le même nom sera alors écrasé) et ``'a'`` ouvre le fichier "
"en mode ajout (toute donnée écrite dans le fichier est automatiquement "
"ajoutée à la fin). ``'r+'`` ouvre le fichier en mode lecture/écriture. "
"L'argument *mode* est optionnel, sa valeur par défaut est ``'r'``."

#: tutorial/inputoutput.rst:313
msgid ""
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
"write strings from and to the file, which are encoded in a specific "
"*encoding*. If *encoding* is not specified, the default is platform "
"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "
"``encoding=\"utf-8\"`` is recommended unless you know that you need to use a "
"different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:"
"`binary mode`. Binary mode data is read and written as :class:`bytes` "
"objects. You can not specify *encoding* when opening file in binary mode."
msgstr ""
"Normalement, les fichiers sont ouverts en :dfn:`mode texte`, c'est-à-dire "
"que vous lisez et écrivez des chaînes de caractères depuis et dans ce "
"fichier, suivant un encodage donné via *encoding*. Si *encoding* n'est pas "
"spécifié, l'encodage par défaut dépend de la plateforme (voir :func:`open`). "
"UTF-8 étant le standard moderne de facto, ``encoding=\"utf-8\"`` est "
"recommandé à moins que vous ne sachiez que vous devez utiliser un autre "
"encodage. L’ajout d’un ``'b'`` au mode ouvre le fichier en :dfn:`mode "
"binaire`. Les données en mode binaire sont lues et écrites sous forme "
"d’objets :class:`bytes`. Vous ne pouvez pas spécifier *encoding* lorsque "
"vous ouvrez un fichier en mode binaire."

#: tutorial/inputoutput.rst:323
msgid ""
"In text mode, the default when reading is to convert platform-specific line "
"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``.  When "
"writing in text mode, the default is to convert occurrences of ``\\n`` back "
"to platform-specific line endings.  This behind-the-scenes modification to "
"file data is fine for text files, but will corrupt binary data like that in :"
"file:`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when "
"reading and writing such files."
msgstr ""
"En mode texte, le comportement par défaut, à la lecture, est de convertir "
"les fin de lignes spécifiques à la plateforme (``\\n`` sur Unix, ``\\r\\n`` "
"sur Windows, etc.) en simples ``\\n``. Lors de l'écriture, le comportement "
"par défaut est d'appliquer l'opération inverse : les ``\\n`` sont convertis "
"dans leur équivalent sur la plateforme courante. Ces modifications "
"effectuées automatiquement sont normales pour du texte mais détérioreraient "
"des données binaires contenues dans un fichier de type :file:`JPEG` ou :file:"
"`EXE`. Soyez particulièrement attentifs à ouvrir ces fichiers binaires en "
"mode binaire."

#: tutorial/inputoutput.rst:331
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  The advantage is that the file is properly closed after its "
"suite finishes, even if an exception is raised at some point.  Using :"
"keyword:`!with` is also much shorter than writing equivalent :keyword:"
"`try`\\ -\\ :keyword:`finally` blocks::"
msgstr ""
"C'est une bonne pratique d'utiliser le mot-clé :keyword:`with` lorsque vous "
"traitez des fichiers. Vous fermez ainsi toujours correctement le fichier, "
"même si une exception est levée. Utiliser :keyword:`!with` est aussi "
"beaucoup plus court que d'utiliser l'équivalent avec des blocs :keyword:"
"`try`\\ …\\ :keyword:`finally` ::"

#: tutorial/inputoutput.rst:344
msgid ""
"If you're not using the :keyword:`with` keyword, then you should call ``f."
"close()`` to close the file and immediately free up any system resources "
"used by it."
msgstr ""
"Si vous n'utilisez pas le mot clé :keyword:`with`, vous devez appeler ``f."
"close()`` pour fermer le fichier, et ainsi immédiatement libérer les "
"ressources qu'il utilise."

#: tutorial/inputoutput.rst:349
msgid ""
"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "
"``f.close()`` **might** result in the arguments of ``f.write()`` not being "
"completely written to the disk, even if the program exits successfully."
msgstr ""
"Appeler ``f.write()`` sans utiliser le mot clé :keyword:`!with` ni appeler "
"``f.close()`` **pourrait** mener à une situation où les arguments de ``f."
"write()`` ne seraient pas complètement écrits sur le disque, même si le "
"programme se termine avec succès."

#: tutorial/inputoutput.rst:357
msgid ""
"After a file object is closed, either by a :keyword:`with` statement or by "
"calling ``f.close()``, attempts to use the file object will automatically "
"fail. ::"
msgstr ""
"Après la fermeture du fichier, que ce soit *via* une instruction :keyword:"
"`with` ou en appelant ``f.close()``, toute tentative d'utilisation de "
"l'objet fichier échoue systématiquement. ::"

#: tutorial/inputoutput.rst:371
msgid "Methods of File Objects"
msgstr "Méthodes des objets fichiers"

#: tutorial/inputoutput.rst:373
msgid ""
"The rest of the examples in this section will assume that a file object "
"called ``f`` has already been created."
msgstr ""
"Les derniers exemples de cette section supposent qu'un objet fichier appelé "
"``f`` a déjà été créé."

#: tutorial/inputoutput.rst:376
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string (in text mode) or bytes object (in binary "
"mode). *size* is an optional numeric argument.  When *size* is omitted or "
"negative, the entire contents of the file will be read and returned; it's "
"your problem if the file is twice as large as your machine's memory. "
"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "
"binary mode) are read and returned. If the end of the file has been reached, "
"``f.read()`` will return an empty string (``''``).  ::"
msgstr ""
"Pour lire le contenu d'un fichier, appelez ``f.read(taille)``, cette "
"dernière lit une certaine quantité de données et la renvoie sous forme de "
"chaîne (en mode texte) ou d'objet *bytes* (en mode binaire). *taille* est un "
"argument numérique facultatif. Lorsque *taille* est omis ou négatif, la "
"totalité du contenu du fichier sera lue et renvoyée ; c'est votre problème "
"si le fichier est deux fois plus grand que la mémoire de votre machine. "
"Sinon, au maximum *taille* caractères (en mode texte) ou *taille* octets (en "
"mode binaire) sont lus et renvoyés. Si la fin du fichier est atteinte, ``f."
"read()`` renvoie une chaîne vide (``''``). ::"

#: tutorial/inputoutput.rst:390
msgid ""
"``f.readline()`` reads a single line from the file; a newline character "
"(``\\n``) is left at the end of the string, and is only omitted on the last "
"line of the file if the file doesn't end in a newline.  This makes the "
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
"end of the file has been reached, while a blank line is represented by "
"``'\\n'``, a string containing only a single newline.  ::"
msgstr ""
"``f.readline()`` lit une seule ligne du fichier ; un caractère de fin de "
"ligne (``\\n``) est laissé à la fin de la chaîne. Il n'est omis que sur la "
"dernière ligne du fichier si celui-ci ne se termine pas un caractère de fin "
"de ligne. Ceci permet de rendre la valeur de retour non ambigüe : si ``f."
"readline()`` renvoie une chaîne vide, c'est que la fin du fichier a été "
"atteinte, alors qu'une ligne vide est représentée par ``'\\n'`` (une chaîne "
"de caractères ne contenant qu'une fin de ligne). ::"

#: tutorial/inputoutput.rst:404
msgid ""
"For reading lines from a file, you can loop over the file object. This is "
"memory efficient, fast, and leads to simple code::"
msgstr ""
"Pour lire ligne à ligne, vous pouvez aussi boucler sur l'objet fichier. "
"C'est plus efficace en termes de gestion mémoire, plus rapide et donne un "
"code plus simple ::"

#: tutorial/inputoutput.rst:413
msgid ""
"If you want to read all the lines of a file in a list you can also use "
"``list(f)`` or ``f.readlines()``."
msgstr ""
"Pour construire une liste avec toutes les lignes d'un fichier, il est aussi "
"possible d'utiliser ``list(f)`` ou ``f.readlines()``."

#: tutorial/inputoutput.rst:416
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"the number of characters written. ::"
msgstr ""
"``f.write(chaine)`` écrit le contenu de *chaine* dans le fichier et renvoie "
"le nombre de caractères écrits. ::"

#: tutorial/inputoutput.rst:422
msgid ""
"Other types of objects need to be converted -- either to a string (in text "
"mode) or a bytes object (in binary mode) -- before writing them::"
msgstr ""
"Les autres types doivent être convertis, soit en une chaîne (en mode texte), "
"soit en objet *bytes* (en mode binaire) avant de les écrire ::"

#: tutorial/inputoutput.rst:430
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file represented as number of bytes from the beginning of the file when "
"in binary mode and an opaque number when in text mode."
msgstr ""
"``f.tell()`` renvoie un entier indiquant la position actuelle dans le "
"fichier, mesurée en octets à partir du début du fichier lorsque le fichier "
"est ouvert en mode binaire, ou un nombre obscur en mode texte."

#: tutorial/inputoutput.rst:434
msgid ""
"To change the file object's position, use ``f.seek(offset, whence)``.  The "
"position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *whence* argument.  A *whence* value of 0 "
"measures from the beginning of the file, 1 uses the current file position, "
"and 2 uses the end of the file as the reference point.  *whence* can be "
"omitted and defaults to 0, using the beginning of the file as the reference "
"point. ::"
msgstr ""
"Pour modifier la position dans le fichier, utilisez ``f.seek(décalage, "
"origine)``. La position est calculée en ajoutant *décalage* à un point de "
"référence ; ce point de référence est déterminé par l'argument *origine* : "
"la valeur 0 pour le début du fichier, 1 pour la position actuelle et 2 pour "
"la fin du fichier. *origine* peut être omis et sa valeur par défaut est 0 "
"(Python utilise le début du fichier comme point de référence). ::"

#: tutorial/inputoutput.rst:453
msgid ""
"In text files (those opened without a ``b`` in the mode string), only seeks "
"relative to the beginning of the file are allowed (the exception being "
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
"*offset* value produces undefined behaviour."
msgstr ""
"Sur un fichier en mode texte (ceux ouverts sans ``b`` dans le mode), seuls "
"les changements de position relatifs au début du fichier sont autorisés "
"(sauf une exception : se rendre à la fin du fichier avec ``seek(0, 2)``) et "
"les seules valeurs possibles pour le paramètre *décalage* sont les valeurs "
"renvoyées par ``f.tell()``, ou zéro. Toute autre valeur pour le paramètre "
"*décalage* produit un comportement indéfini."

#: tutorial/inputoutput.rst:459
msgid ""
"File objects have some additional methods, such as :meth:`~file.isatty` and :"
"meth:`~file.truncate` which are less frequently used; consult the Library "
"Reference for a complete guide to file objects."
msgstr ""
"Les fichiers disposent de méthodes supplémentaires, telles que :meth:`~file."
"isatty` et :meth:`~file.truncate` qui sont moins souvent utilisées ; "
"consultez la Référence de la Bibliothèque Standard pour avoir un guide "
"complet des objets fichiers."

#: tutorial/inputoutput.rst:467
msgid "Saving structured data with :mod:`json`"
msgstr "Sauvegarde de données structurées avec le module :mod:`json`"

#: tutorial/inputoutput.rst:471
msgid ""
"Strings can easily be written to and read from a file.  Numbers take a bit "
"more effort, since the :meth:`read` method only returns strings, which will "
"have to be passed to a function like :func:`int`, which takes a string like "
"``'123'`` and returns its numeric value 123.  When you want to save more "
"complex data types like nested lists and dictionaries, parsing and "
"serializing by hand becomes complicated."
msgstr ""
"Les chaînes de caractères peuvent facilement être écrites dans un fichier et "
"relues. Les nombres nécessitent un peu plus d'effort, car la méthode :meth:"
"`read` ne renvoie que des chaînes. Elles doivent donc être passées à une "
"fonction comme :func:`int`, qui prend une chaîne comme ``'123'`` en entrée "
"et renvoie sa valeur numérique 123. Mais dès que vous voulez enregistrer des "
"types de données plus complexes comme des listes, des dictionnaires ou des "
"instances de classes, le traitement lecture/écriture à la main devient vite "
"compliqué."

#: tutorial/inputoutput.rst:478
msgid ""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) <https://json."
"org>`_.  The standard module called :mod:`json` can take Python data "
"hierarchies, and convert them to string representations; this process is "
"called :dfn:`serializing`.  Reconstructing the data from the string "
"representation is called :dfn:`deserializing`.  Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr ""
"Plutôt que de passer son temps à écrire et déboguer du code permettant de "
"sauvegarder des types de données compliqués, Python permet d'utiliser `JSON "
"(*JavaScript Object Notation*) <https://json.org>`_, un format répandu de "
"représentation et d'échange de données. Le module standard appelé :mod:"
"`json` peut transformer des données hiérarchisées Python en une "
"représentation sous forme de chaîne de caractères. Ce processus est nommé :"
"dfn:`sérialiser`. Reconstruire les données à partir de leur représentation "
"sous forme de chaîne est appelé :dfn:`déserialiser`. Entre sa sérialisation "
"et sa dé-sérialisation, la chaîne représentant les données peut avoir été "
"stockée ou transmise à une autre machine."

#: tutorial/inputoutput.rst:489
msgid ""
"The JSON format is commonly used by modern applications to allow for data "
"exchange.  Many programmers are already familiar with it, which makes it a "
"good choice for interoperability."
msgstr ""
"Le format JSON est couramment utilisé dans les applications modernes pour "
"échanger des données. Beaucoup de développeurs le maîtrisent, ce qui en fait "
"un format de prédilection pour l'interopérabilité."

#: tutorial/inputoutput.rst:493
msgid ""
"If you have an object ``x``, you can view its JSON string representation "
"with a simple line of code::"
msgstr ""
"Si vous avez un objet ``x``, vous pouvez voir sa représentation JSON en "
"tapant simplement ::"

#: tutorial/inputoutput.rst:501
msgid ""
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
"dump`, simply serializes the object to a :term:`text file`.  So if ``f`` is "
"a :term:`text file` object opened for writing, we can do this::"
msgstr ""
"Une variante de la fonction :func:`~json.dumps`, nommée :func:`~json.dump`, "
"sérialise simplement l'objet donné vers un :term:`text file`. Donc si ``f`` "
"est un :term:`text file` ouvert en écriture, il est possible de faire ::"

#: tutorial/inputoutput.rst:507
msgid ""
"To decode the object again, if ``f`` is a :term:`binary file` or :term:`text "
"file` object which has been opened for reading::"
msgstr ""
"Pour reconstruire l'objet, si ``f`` est cette fois un :term:`binary file` ou "
"un :term:`text file` ouvert en lecture ::"

#: tutorial/inputoutput.rst:513
msgid ""
"JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening "
"JSON file as a :term:`text file` for both of reading and writing."
msgstr ""
"Les fichiers JSON doivent être encodés en UTF-8. Utilisez "
"``encoding=\"utf-8\"`` lorsque vous ouvrez un fichier JSON en tant que :term:"
"`fichier texte<text file>`, que ce soit en lecture ou en écriture."

#: tutorial/inputoutput.rst:516
msgid ""
"This simple serialization technique can handle lists and dictionaries, but "
"serializing arbitrary class instances in JSON requires a bit of extra "
"effort. The reference for the :mod:`json` module contains an explanation of "
"this."
msgstr ""
"Cette méthode de sérialisation peut sérialiser des listes et des "
"dictionnaires. Mais sérialiser d'autres types de données requiert un peu "
"plus de travail. La documentation du module :mod:`json` explique comment "
"faire."

#: tutorial/inputoutput.rst:522
msgid ":mod:`pickle` - the pickle module"
msgstr "Le module :mod:`pickle`"

#: tutorial/inputoutput.rst:524
msgid ""
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
"serialization of arbitrarily complex Python objects.  As such, it is "
"specific to Python and cannot be used to communicate with applications "
"written in other languages.  It is also insecure by default: deserializing "
"pickle data coming from an untrusted source can execute arbitrary code, if "
"the data was crafted by a skilled attacker."
msgstr ""
"Au contraire de :ref:`JSON <tut-json>`, *pickle* est un protocole permettant "
"la sérialisation d'objets Python arbitrairement complexes. Il est donc "
"spécifique à Python et ne peut pas être utilisé pour communiquer avec "
"d'autres langages. Il est aussi, par défaut, une source de vulnérabilité : "
"dé-sérialiser des données au format *pickle* provenant d'une source "
"malveillante et particulièrement habile peut mener à exécuter du code "
"arbitraire."

#~ msgid ""
#~ "If you're not using the :keyword:`with` keyword, then you should call ``f."
#~ "close()`` to close the file and immediately free up any system resources "
#~ "used by it. If you don't explicitly close a file, Python's garbage "
#~ "collector will eventually destroy the object and close the open file for "
#~ "you, but the file may stay open for a while.  Another risk is that "
#~ "different Python implementations will do this clean-up at different times."
#~ msgstr ""
#~ "Si vous n'utilisez pas le mot clef :keyword:`with`, vous devez appeler "
#~ "``f.close()`` pour fermer le fichier et immédiatement libérer les "
#~ "ressources système qu'il utilise. Si vous ne fermez pas explicitement le "
#~ "fichier, le ramasse-miette de Python finira par détruire l'objet et "
#~ "fermer le fichier pour vous, mais le fichier peut rester ouvert pendant "
#~ "un moment. Un autre risque est que différentes implémentations de Python "
#~ "risquent faire ce nettoyage à des moments différents."