python-docs-fr/tutorial/inputoutput.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:40+0100\n"
"PO-Revision-Date: 2016-11-19 16:27+0100\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

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

#: ../Doc/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 programmes ; les "
"données peuvent être imprimées sous une forme lisible par un être humain, ou "
"sauvegardées dans un fichier pour une utilisation future. Ce chapitre "
"présentera donc diverses possibilités."

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

#: ../Doc/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 ""
"Jusque là, 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, le "
"fichier de sortie standard peut être référence en tant que ``sys.stdout``. "
"Voyez le Guide de Référence de la Bibliothèque Standard pour en savoir plus.)"

#: ../Doc/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 two ways to format your "
"output; the first way is to do all the string handling yourself; using "
"string slicing and concatenation operations you can create any layout you "
"can imagine.  The string type has some methods that perform useful "
"operations for padding strings to a given column width; these will be "
"discussed shortly.  The second way is to use :ref:`formatted string literals "
"<f-strings>`, or the :meth:`str.format` method."
msgstr ""
"Souvent, vous voudrez plus de contrôle sur le formattage de votre sortie que "
"simplement afficher des valeurs séparées par des espaces. Il y a deux façons "
"de formatter votre sortie. La première est de le faire vous-même, en "
"utilisant des opérations slicing et de concaténation vous pouvez créer "
"toutes les dispositions que vous imaginez ; le type ``string`` a des "
"méthodes qui effectuent des opérations utiles pour aligner des chaines à une "
"certaine largeur de colonne, qui seront discutées sous peu. La seconde est "
"d'utiliser des :ref:`littéraux de chaine formattés <f-strings>` ou la "
"méthode :meth:`str.format`."

#: ../Doc/tutorial/inputoutput.rst:31
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class which "
"offers yet another way to substitute values into strings."
msgstr ""
"Le module :mod:`string` contient une classe :class:`~string.Template` qui "
"offre encore une autre façon de remplacer des valeurs au sein de chaînes de "
"caractères."

#: ../Doc/tutorial/inputoutput.rst:34
msgid ""
"One question remains, of course: how do you convert values to strings? "
"Luckily, Python has ways to convert any value to a string: pass it to the :"
"func:`repr` or :func:`str` functions."
msgstr ""
"Mais une question demeure, bien sûr : comment convertir des valeurs en "
"chaînes de caractères ? Heureusement, Python fournit plusieurs moyens de "
"convertir n'importe quelle valeur en chaîne : les fonctions :func:`repr` et :"
"func:`str`."

#: ../Doc/tutorial/inputoutput.rst:38
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 à renvoyer des représentations de "
"valeurs qui soient lisibles 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 forceront 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` renverra 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 et les nombres à virgule "
"flottante, en revanche, ont deux représentations distinctes."

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

#: ../Doc/tutorial/inputoutput.rst:70
msgid "Here are two ways to write a table of squares and cubes::"
msgstr "Voici deux façons d'écrire une table de carrés et de cubes : ::"

#: ../Doc/tutorial/inputoutput.rst:102
msgid ""
"(Note that in the first example, one space between each column was added by "
"the way :func:`print` works: it always adds spaces between its arguments.)"
msgstr ""
"(Notez que dans ce premier exemple, un espace entre chaque colonne a été "
"ajouté par la façon dont fonctionne :func:`print`, qui ajoute toujours des "
"espaces entre ses paramètres.)"

#: ../Doc/tutorial/inputoutput.rst:105
msgid ""
"This example demonstrates the :meth:`str.rjust` method of string objects, "
"which 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 ""
"Cet exemple démontre l'utilisation de la méthode :meth:`str.rjust` des "
"chaînes de caractères, qui fait une justification à droite d'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 retournent 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 ; ce qui peut déranger votre mise en page "
"mais 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]``)."

#: ../Doc/tutorial/inputoutput.rst:115
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 : ::"

#: ../Doc/tutorial/inputoutput.rst:125
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 à cela : ::"

#: ../Doc/tutorial/inputoutput.rst:130
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 qu'ils contiennent (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`. ::"

#: ../Doc/tutorial/inputoutput.rst:140
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 : ::"

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

#: ../Doc/tutorial/inputoutput.rst:153
msgid ""
"``'!a'`` (apply :func:`ascii`), ``'!s'`` (apply :func:`str`) and ``'!r'`` "
"(apply :func:`repr`) can be used to convert the value before it is "
"formatted::"
msgstr ""
"``'!a'`` (appliquer :func:`ascii`), ``'!s'`` (appliquer :func:`str`) et ``'!"
"r'`` (appliquer :func:`repr`)peuvent être utilisées pour convertir les "
"valeurs avant leur formatage : ::"

#: ../Doc/tutorial/inputoutput.rst:162
msgid ""
"An optional ``':'`` and format specifier can follow the field name. This "
"allows greater control over how the value is formatted.  The following "
"example rounds Pi to three places after the decimal."
msgstr ""
"Des caractères ``':'`` suivis d'une spécification de formatage peuvent "
"suivre le nom du champ. Ceci offre un niveau de contrôle plus fin sur la "
"façon dont les valeurs sont formatées. L'exemple suivant arrondit Pi à trois "
"décimales : ::"

#: ../Doc/tutorial/inputoutput.rst:170
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making tables pretty. ::"
msgstr ""
"Indiquer 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 : ::"

#: ../Doc/tutorial/inputoutput.rst:181
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 vraiment une longue chaîne de formatage que vous ne voulez pas "
"découper, ce serait bien de pouvoir référencer les variables à formater par "
"leur nom plutôt que par leur position. Cela peut être fait simplement en "
"passant un dictionnaire et en utilisant des crochets ``'[]'`` pour accéder "
"aux clés : ::"

#: ../Doc/tutorial/inputoutput.rst:191
msgid ""
"This could also be done by passing the table as keyword arguments with the "
"'**' notation. ::"
msgstr ""
"On pourrait également faire ça en passant le tableau comme des arguments "
"nommés en utilisant la notation '**' ::"

#: ../Doc/tutorial/inputoutput.rst:198
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 retourne un dictionnaire contenant toutes les variables locales."

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

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

#: ../Doc/tutorial/inputoutput.rst:208
msgid ""
"The ``%`` operator can also be used for string formatting. It interprets the "
"left argument much like a :c:func:`sprintf`\\ -style format string to be "
"applied to the right argument, and returns the string resulting from this "
"formatting operation. For example::"
msgstr ""
"L'opérateur ``%`` peut aussi être utilisé pour formater des chaînes. Il "
"interprète l'argument de gauche un peu comme une chaîne de formatage d'une "
"fonction :c:func:`sprintf` à appliquer à l'argument de droite, et retourne "
"la chaîne résultant de cette opération de formatage. Par exemple : ::"

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

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

#: ../Doc/tutorial/inputoutput.rst:229
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two arguments: ``open(filename, mode)``."
msgstr ""
":func:`open` retourne un :term:`objet fichier`, et est le plus souvent "
"utilisé avecdeux arguments : ``open(filename, mode)``."

#: ../Doc/tutorial/inputoutput.rst:241
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 second "
"argument est une autre chaîne contenant quelques caractères décrivant la "
"façon dont le fichier sera utilisé. *mode* peut être ``'r'`` quand le "
"fichier ne sera 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'``."

#: ../Doc/tutorial/inputoutput.rst:250
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`). ``'b'`` appended to the mode opens the file in :dfn:"
"`binary mode`: now the data is read and written in the form of bytes "
"objects.  This mode should be used for all files that don't contain text."
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, qui y sont encodées avec un encodage donné. Si aucun encodage n'est "
"spécifié, l'encodage par défaut dépendra de la plateforme (voir :func:"
"`open`). ``'b'`` collé à la fin du mode indique que le fichier doit être "
"ouvert en :dfn:`mode binaire` c'est à dire que les données sont lues et "
"écrites sous formes d'octets. Ce mode est à utiliser pour les fichiers "
"contenant autre chose que du texte."

#: ../Doc/tutorial/inputoutput.rst:257
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 comprennent "
"par défaut est d'appliquer l'opération contraire : 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 comme un fichier :file:`JPEG` ou :file:`EXE`. Soyez "
"particulièrement attentifs à ouvrir ces fichiers binaires en mode binaire."

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

#: ../Doc/tutorial/inputoutput.rst:271
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 supposeront qu'un objet fichier "
"appelé ``f`` a déjà été créé."

#: ../Doc/tutorial/inputoutput.rst:274
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* bytes 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(size)``, qui lit une "
"certaine quantité de données et les donne sous la forme d'une chaîne (en "
"mode texte) ou dans un objet *bytes* (en mode binaire). *size* est un "
"argument numérique optionnel. Quand *size* est omis ou négatif, le contenu "
"entier du fichier est lu et donné, c'est votre problème si le fichier est "
"deux fois plus gros que la mémoire de votre machine. Sinon, un maximum de "
"*size* octets sont lus et rendus. Lorsque la fin du fichier est atteinte, "
"``f.read()`` renvoie une chaîne vide (``''``). ::"

#: ../Doc/tutorial/inputoutput.rst:288
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, et 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()`` retourne 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. ::"

#: ../Doc/tutorial/inputoutput.rst:302
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 ""
"Une autre approche de lecture des lignes est de faire une boucle sur l'objet "
"fichier. Cela est plus efficace en terme de gestion mémoire, plus rapide, et "
"donne un code plus simple : ::"

#: ../Doc/tutorial/inputoutput.rst:311
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 lire toutes les lignes d'un fichier, il est aussi possible d'utiliser "
"``list(f)`` ou ``f.readlines()``."

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

#: ../Doc/tutorial/inputoutput.rst:320
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 ""
"D'autres types doivent être convertis, soit en une chaîne (en mode texte) ou "
"un objet *bytes* (en mode binaire), avant de les écrire : ::"

#: ../Doc/tutorial/inputoutput.rst:328
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()`` retourne 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 obscure en mode texte."

#: ../Doc/tutorial/inputoutput.rst:332
msgid ""
"To change the file object's position, use ``f.seek(offset, from_what)``.  "
"The position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *from_what* argument.  A *from_what* "
"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.  "
"*from_what* 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(offset, "
"from_what)``. Laposition est calculée en ajoutant *offset* à un point de "
"référence ; ce point de référence est sélectionné par l'argument "
"*from_what* : 0 pour le début du fichier, 1 pour la position actuelle, et 2 "
"pour la fin du fichier. *from_what* peut être omis et sa valeur par défaut "
"est 0, utilisant le début du fichier comme point de référence : ::"

#: ../Doc/tutorial/inputoutput.rst:351
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 seuls valeurs possible pour le paramètre *offset* sont les valeurs "
"renvoyées par ``f.tell()``, ou zéro. Toute autre valeur pour le paramètre "
"*offset* engendrera un comportement indéfini."

#: ../Doc/tutorial/inputoutput.rst:358
msgid ""
"When you're done with a file, call ``f.close()`` to close it and free up any "
"system resources taken up by the open file.  After calling ``f.close()``, "
"attempts to use the file object will automatically fail. ::"
msgstr ""
"Quand vous avez terminé d'utiliser un fichier, appeler ``f.close()`` pour le "
"fermer et libérer toutes les ressources système qu'il a pu utiliser. Après "
"l'appel de ``f.close()``, toute tentative d'utilisation de l'objet fichier "
"échouera systématiquement : ::"

#: ../Doc/tutorial/inputoutput.rst:368
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  This has the advantage that the file is properly closed after "
"its suite finishes, even if an exception is raised on the way.  It 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. Ceci procure l'avantage de toujours fermer "
"correctement le fichier, même si une exception a été déclenchée. C'est aussi "
"beaucoup plus court que d'utiliser l'équivalent avec des blocs :keyword:`try`"
"\\ - \\ :keyword:`finally` ::"

#: ../Doc/tutorial/inputoutput.rst:378
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."

#: ../Doc/tutorial/inputoutput.rst:386
msgid "Saving structured data with :mod:`json`"
msgstr "Sauvegarder des données structurées avec le module :mod:`json`"

#: ../Doc/tutorial/inputoutput.rst:390
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'efforts, car la méthode :meth:"
"`read` ne retourne que des chaînes, qui doivent donc être passées à une "
"fonction comme :func:`int`, qui prend une chaîne comme ``'123'`` en entrée "
"et retourne 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, les choses se compliquent beaucoup plus."

#: ../Doc/tutorial/inputoutput.rst:397
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) <http://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ées, Python permet d'utiliser `JSON "
"(JavaScript Object Notation) <http://json.org>`_, un format répandu de "
"représentation et d'échange de données. Le module standard appellé :mod:"
"`json` peut transformer des hiérarchies de données Python en leur "
"représentation sous forme de chaîne de caractère. 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 serialisation "
"et sa déserialisation, la chaîne représentant les données peuvent avoir été "
"stockées ou transmises à une autre machine."

#: ../Doc/tutorial/inputoutput.rst:408
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 se retrouve communément dans les applications modernes pour "
"échanger des données. Beaucoup de développeurs sont déjà familier avec le "
"JSON, en faisant un format de prédilection pour l'interopérabilité."

#: ../Doc/tutorial/inputoutput.rst:412
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 simplement voir sa représentation "
"JSON ::"

#: ../Doc/tutorial/inputoutput.rst:418
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 variation de la fonction :func:`~json.dumps`, nommée :func:`~json.dump`, "
"sérialise simplement l'objet donné vers un :term:`fichier texte <text "
"file>`. Donc si ``f`` est un :term:`fichier texte <text file>` ouvert en "
"écriture, il devient possible de faire : ::"

#: ../Doc/tutorial/inputoutput.rst:424
msgid ""
"To decode the object again, if ``f`` is a :term:`text file` object which has "
"been opened for reading::"
msgstr ""
"Pour reconstruire l'objet, si ``f`` est cette fois un :term:`fichier texte` "
"ouverten lecture : ::"

#: ../Doc/tutorial/inputoutput.rst:429
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 serialisation peut sérialiser des listes et des "
"dictionnaires, mais sérialiser d'autres types de données nécessité un peu "
"plus de travail. La documentation du module :mod:`json` explique comment "
"faire."

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

#: ../Doc/tutorial/inputoutput.rst:437
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 ""
"À l'inverse de :ref:`JSON <tut-json>`, *pickle* est un protocole permettant "
"la serialisation d'objets Python arbitrairement complexes. Il est donc "
"spécifique à Python et ne peut être utilisé pour communiquer avec d'autres "
"langages. Il n'est aussi pas sans failles : desérialiser des données au "
"format pickle provenant d'une source malveillante et particulièrement habile "
"pourrait mener exécuter du code arbitraire."