forked from AFPy/python-docs-fr
586 lines
29 KiB
Plaintext
586 lines
29 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
|
# Copyright (C) 1990-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 2.7\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
|
"PO-Revision-Date: 2017-05-16 23:20+0200\n"
|
|
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
|
"Language-Team: \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 1.8.11\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 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."
|
|
|
|
#: ../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 :keyword:`print` statement. (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 l'instruction :keyword:`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 types have 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 the :meth:`str.format` method."
|
|
msgstr ""
|
|
"Mais vous voudrez souvent avoir plus de contrôle sur le formatage de vos "
|
|
"sorties que de simplement imprimer des valeurs séparées par des espaces. Il "
|
|
"y a deux méthodes pour formater ces sorties ; la première est de gérer les "
|
|
"chaînes de caractères par vous même ; en utilisant des tranches sur vos "
|
|
"chaînes et des opérations de concaténation, vous pouvez créer n'importe "
|
|
"quelle présentation imaginable. Mais les chaînes de caractères disposent "
|
|
"également de méthodes qui facilitent, par exemple, les alignements de "
|
|
"chaînes de caractères selon une certaines largeur de colonne, et qui seront "
|
|
"présentées rapidement. La seconde méthode consiste à utiliser la méthode :"
|
|
"meth:`format`."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:30
|
|
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 "
|
|
"permet aussi de remplacer des valeurs au sein de chaînes de caractères."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:33
|
|
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:37
|
|
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 and floating point numbers, 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:46
|
|
msgid "Some examples::"
|
|
msgstr "Quelques exemples : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:71
|
|
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:103
|
|
msgid ""
|
|
"(Note that in the first example, one space between each column was added by "
|
|
"the way :keyword:`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 :keyword:`print`, qui ajoute toujours "
|
|
"des espaces entre ses arguments.)"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:106
|
|
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 illustre l'utilisation de la méthode :meth:`str.rjust` des "
|
|
"chaînes de caractères ; elle 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]``)."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:116
|
|
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:126
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:131
|
|
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 refers to the position of the object passed into the :meth:`str."
|
|
"format` method. ::"
|
|
msgstr ""
|
|
"Les crochets 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 crochets se réfère à la position de "
|
|
"l'objet passé à la méthode :meth:`str.format` ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:141
|
|
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:148
|
|
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:154
|
|
msgid ""
|
|
"``'!s'`` (apply :func:`str`) and ``'!r'`` (apply :func:`repr`) can be used "
|
|
"to convert the value before it is formatted. ::"
|
|
msgstr ""
|
|
"``'!s'`` (appliquer :func:`str`) et ``'!r'`` (appliquer :func:`repr`) "
|
|
"peuvent être utilisées pour convertir les valeurs avant leur formatage : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:163
|
|
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 ""
|
|
"Un caractère ``':'`` suivi 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 chiffres "
|
|
"après la virgule (NdT : qui, en notation anglo-saxonne, est un point)."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:171
|
|
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: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 : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:192
|
|
msgid ""
|
|
"This could also be done by passing the table as keyword arguments with the "
|
|
"'**' notation. ::"
|
|
msgstr ""
|
|
"Vous pouvez obtenir le même résultat en passant le tableau comme des "
|
|
"arguments nommés en utilisant la notation ``**`` ::"
|
|
|
|
#: ../Doc/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."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:202
|
|
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`."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:207
|
|
msgid "Old string formatting"
|
|
msgstr "Anciennes méthodes de formatage de chaînes"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:209
|
|
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 pratiquement comme une chaîne de formatage "
|
|
"de la fonction :c:func:`sprintf` à appliquer à l'argument de droite, et il "
|
|
"renvoie la chaîne résultant de cette opération de formatage. Par exemple : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:218
|
|
msgid "More information can be found in the :ref:`string-formatting` section."
|
|
msgstr ""
|
|
"Vous trouverez plus d'informations dans la section :ref:`string-formatting`."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:224
|
|
msgid "Reading and Writing Files"
|
|
msgstr "Lecture et écriture de fichiers"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:230
|
|
msgid ""
|
|
":func:`open` returns a file object, and is most commonly used with two "
|
|
"arguments: ``open(filename, mode)``."
|
|
msgstr ""
|
|
":func:`open` retourne un objet fichier, et est le plus souvent utilisé avec "
|
|
"deux arguments : ``open(filename, mode)``."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:239
|
|
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'``."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:248
|
|
msgid ""
|
|
"On Windows, ``'b'`` appended to the mode opens the file in binary mode, so "
|
|
"there are also modes like ``'rb'``, ``'wb'``, and ``'r+b'``. Python on "
|
|
"Windows makes a distinction between text and binary files; the end-of-line "
|
|
"characters in text files are automatically altered slightly when data is "
|
|
"read or written. This behind-the-scenes modification to file data is fine "
|
|
"for ASCII text files, but it'll 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. On Unix, it doesn't hurt to append a "
|
|
"``'b'`` to the mode, so you can use it platform-independently for all binary "
|
|
"files."
|
|
msgstr ""
|
|
"Sous Windows, ``'b'`` ajouté au mode ouvre le fichier en mode binaire, et il "
|
|
"existe donc des modes comme ``'rb'``, ``'wb'`` et ``'r+b'``. Python sous "
|
|
"Windows fait effectivement une distinction entre fichiers texte et "
|
|
"binaires ; le caractère de fin de ligne des fichiers texte est "
|
|
"automatiquement modifié lorsqu'une donnée est lue ou écrite. Cette "
|
|
"modification sous le manteau des données du fichier n'est pas un problème "
|
|
"pour les fichiers textes en ASCII, mais elle peut corrompre les données "
|
|
"binaires comme celles des fichiers :file:`JPEG` ou :file:`EXE`. Soyez donc "
|
|
"attentifs à toujours bien utiliser le mode binaire lorsque vous travaillez "
|
|
"avec de tels fichiers. Sous Unix, le mode binaire n'a aucun effet mais vous "
|
|
"pouvez l'utiliser pour tous les fichiers binaires pour que votre code soit "
|
|
"indépendant de la plate-forme."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:262
|
|
msgid "Methods of File Objects"
|
|
msgstr "Méthodes des objets fichiers"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:264
|
|
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éé."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:267
|
|
msgid ""
|
|
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
|
|
"of data and returns it as a string. *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 retourne sous la forme d'une chaîne de "
|
|
"caractères. *size* est un argument numérique optionnel. Quand *size* est "
|
|
"omis ou négatif, le contenu entier du fichier est lu et retourné ; c'est "
|
|
"votre problème si le fichier est deux fois plus gros que la mémoire de votre "
|
|
"machine. Sinon, au plus *size* octets sont lus et retournés. Lorsque la fin "
|
|
"du fichier est atteinte, ``f.read()`` renvoie une chaîne vide (``\"\"``) ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:280
|
|
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:294
|
|
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 terme de gestion mémoire, plus rapide et donne un "
|
|
"code plus simple : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:303
|
|
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()``."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:306
|
|
msgid ""
|
|
"``f.write(string)`` writes the contents of *string* to the file, returning "
|
|
"``None``. ::"
|
|
msgstr ""
|
|
"``f.write(string)`` écrit le contenu de *string* dans le fichier, et renvoie "
|
|
"``None`` ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:311
|
|
msgid ""
|
|
"To write something other than a string, it needs to be converted to a string "
|
|
"first::"
|
|
msgstr ""
|
|
"Pour écrire autre chose qu'une chaîne, il faut commencer par la convertir en "
|
|
"chaîne ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:318
|
|
msgid ""
|
|
"``f.tell()`` returns an integer giving the file object's current position in "
|
|
"the file, measured in bytes from the beginning of the file. 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 ""
|
|
"``f.tell()`` retourne un entier indiquant la position actuelle dans le "
|
|
"fichier, mesurée en octets à partir du début du fichier. Pour modifier la "
|
|
"position dans le fichier, utilisez ``f.seek(offset, from_what)``. La "
|
|
"position 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:336
|
|
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:346
|
|
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:356
|
|
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:364
|
|
msgid "Saving structured data with :mod:`json`"
|
|
msgstr "Sauvegarde de données structurées avec le module :mod:`json`"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:368
|
|
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é."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:375
|
|
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és, 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 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."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:386
|
|
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îtrise, ce qui en fait "
|
|
"un format de prédilection pour l'interopérabilité."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:390
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:396
|
|
msgid ""
|
|
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
|
|
"dump`, simply serializes the object to a file. So if ``f`` is a :term:`file "
|
|
"object` opened for writing, we can do this::"
|
|
msgstr ""
|
|
"Une autre variante de la fonction :func:`~json.dumps`, appelée :func:`~json."
|
|
"dump` sérialise simplement l'objet dans un fichier. Donc si ``f`` est un :"
|
|
"term:`file object` ouvert en écriture, on peut faire : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:402
|
|
msgid ""
|
|
"To decode the object again, if ``f`` is a :term:`file object` which has been "
|
|
"opened for reading::"
|
|
msgstr ""
|
|
"Pour décoder l'objet à nouveau, si ``f`` est un :term:`file object` ouvert "
|
|
"en lecture : ::"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:407
|
|
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."
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:413
|
|
msgid ":mod:`pickle` - the pickle module"
|
|
msgstr "Le module :mod:`pickle`"
|
|
|
|
#: ../Doc/tutorial/inputoutput.rst:415
|
|
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."
|