forked from python/python-docs-fr
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathinputoutput.po
More file actions
585 lines (532 loc) · 28.7 KB
/
inputoutput.po
File metadata and controls
585 lines (532 loc) · 28.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
# 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."