python-docs-fr/tutorial.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.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-17 21:44+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/tutorial/appendix.rst:5
msgid "Appendix"
msgstr "Annexe"

#: ../Doc/tutorial/appendix.rst:11 ../Doc/tutorial/interpreter.rst:90
msgid "Interactive Mode"
msgstr "Mode interactif"

#: ../Doc/tutorial/appendix.rst:16
msgid "Error Handling"
msgstr "Gestion des erreurs"

#: ../Doc/tutorial/appendix.rst:18
msgid ""
"When an error occurs, the interpreter prints an error message and a stack "
"trace. In interactive mode, it then returns to the primary prompt; when "
"input came from a file, it exits with a nonzero exit status after printing "
"the stack trace. (Exceptions handled by an :keyword:`except` clause in a :"
"keyword:`try` statement are not errors in this context.)  Some errors are "
"unconditionally fatal and cause an exit with a nonzero exit; this applies to "
"internal inconsistencies and some cases of running out of memory.  All error "
"messages are written to the standard error stream; normal output from "
"executed commands is written to standard output."
msgstr ""
"Quand une erreur se produit, l'interpréteur affiche un message d'erreur et "
"le suivit de la pile. En mode interactif, il revient à l'invite de commande "
"primaire; si l'entrée provient d'un fichier, l'interpréteur se termine avec "
"un état de sortie non nul après avoir affiché le suivit de la pile. (Les "
"exceptions gérées par une clause :keyword:`except` dans une instruction :"
"keyword:`try` ne sont pas des erreurs dans ce contexte.) Certaines erreurs "
"sont inconditionnellement fatales et cause une sortie avec un état non nul; "
"les incohérences internes et, dans certains cas, les pénuries de mémoires, "
"sont traitées de la sorte. Tous les messages d'erreur sont écrits sur la "
"sortie d'erreur standard; les sorties normales issues des commandes "
"exécutées sont écrites sur la sortie standard."

#: ../Doc/tutorial/appendix.rst:28
msgid ""
"Typing the interrupt character (usually :kbd:`Control-C` or :kbd:`Delete`) "
"to the primary or secondary prompt cancels the input and returns to the "
"primary prompt. [#]_ Typing an interrupt while a command is executing raises "
"the :exc:`KeyboardInterrupt` exception, which may be handled by a :keyword:"
"`try` statement."
msgstr ""
"Taper le caractère d'interruption (généralement :kbd:`Ctrl+C` ou :kbd:"
"`Supprimer`) au niveau de l'invite de commande primaire annule l'entrée et "
"revient à l'invite. [#]_ Saisir une interruption tandis qu'une commande "
"s'exécute lève une exception :exc:`KeyboardInterrupt` qui peut être gérée "
"par une instruction :keyword:`try`."

#: ../Doc/tutorial/appendix.rst:38
msgid "Executable Python Scripts"
msgstr "Scripts Python exécutables"

#: ../Doc/tutorial/appendix.rst:40
msgid ""
"On BSD'ish Unix systems, Python scripts can be made directly executable, "
"like shell scripts, by putting the line ::"
msgstr ""
"Sur les systèmes Unix, un script Python peut être rendu directement "
"exécutable comme un script shell en ajoutant la ligne : ::"

#: ../Doc/tutorial/appendix.rst:45
msgid ""
"(assuming that the interpreter is on the user's :envvar:`PATH`) at the "
"beginning of the script and giving the file an executable mode.  The ``#!`` "
"must be the first two characters of the file.  On some platforms, this first "
"line must end with a Unix-style line ending (``'\\n'``), not a Windows "
"(``'\\r\\n'``) line ending.  Note that the hash, or pound, character, "
"``'#'``, is used to start a comment in Python."
msgstr ""
"(en supposant que l'interpréteur est dans le :envvar:`PATH` de "
"l'utilisateur) au début du script et en rendant le fichier exécutable. ``#!"
"`` doivent être les deux premiers caractères du fichier. Sur certaines "
"plateformes, cette première ligne doit finir avec une fin de ligne de type "
"Unix (``'\\n'``) et pas de type Windows (``'\\r\\n'``). Notez que le "
"caractère dièse, ``'#'``, est utilisé pour initier un commentaire en Python."

#: ../Doc/tutorial/appendix.rst:52
msgid ""
"The script can be given an executable mode, or permission, using the :"
"program:`chmod` command."
msgstr ""
"Un script peut être rendu utilisable en utilisant la commande :program:"
"`chmod`."

#: ../Doc/tutorial/appendix.rst:59
msgid ""
"On Windows systems, there is no notion of an \"executable mode\".  The "
"Python installer automatically associates ``.py`` files with ``python.exe`` "
"so that a double-click on a Python file will run it as a script.  The "
"extension can also be ``.pyw``, in that case, the console window that "
"normally appears is suppressed."
msgstr ""
"Sur les système windows il n'y a pas de \"mode executable\". L'installateur "
"Python associe automatiquement les fichier en ``.py`` avec ``python.exe`` de "
"telle sorte qu'un double clic sur un fichier Python le lance comme un "
"script. L'extension peut aussi être ``.pyw``, dans ce cas, la console "
"n'apparait pas."

#: ../Doc/tutorial/appendix.rst:69
msgid "The Interactive Startup File"
msgstr "La configuration du mode interactif"

#: ../Doc/tutorial/appendix.rst:71
msgid ""
"When you use Python interactively, it is frequently handy to have some "
"standard commands executed every time the interpreter is started.  You can "
"do this by setting an environment variable named :envvar:`PYTHONSTARTUP` to "
"the name of a file containing your start-up commands.  This is similar to "
"the :file:`.profile` feature of the Unix shells."
msgstr ""
"En mode interactif, il peut être pratique de faire exécuter quelques "
"commandes au lancement de l'interprète. C'est possible en configurant la "
"variable d'environnement :envvar:`PYTHONSTARTUP`\" avec le nom d'un fichier "
"contenant les instructions à exécuter, à la même manière du :file:`.profile` "
"dans un shell Unix."

#: ../Doc/tutorial/appendix.rst:77
msgid ""
"This file is only read in interactive sessions, not when Python reads "
"commands from a script, and not when :file:`/dev/tty` is given as the "
"explicit source of commands (which otherwise behaves like an interactive "
"session).  It is executed in the same namespace where interactive commands "
"are executed, so that objects that it defines or imports can be used without "
"qualification in the interactive session. You can also change the prompts "
"``sys.ps1`` and ``sys.ps2`` in this file."
msgstr ""
"Ce fichier n'est lu qu'en mode interactif, pas quand Python lis les "
"instructions depuis un fichier, ni quand :file:`/dev/tty` est donné "
"explicitement comme fichier source (qui d'ailleurs se compterait comme une "
"session interactive). Les instructions de ce fichier, sont exécutées dans le "
"même espace de noms que vos commandes, donc les objets définis et modules "
"importés peuvent être utilisées directement dans la session interactive. "
"Dans ce fichier il est aussi possible de changer les prompts ``sys.ps1`` et "
"``sys.ps2``."

#: ../Doc/tutorial/appendix.rst:85
msgid ""
"If you want to read an additional start-up file from the current directory, "
"you can program this in the global start-up file using code like ``if os."
"path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you "
"want to use the startup file in a script, you must do this explicitly in the "
"script::"
msgstr ""
"Si vous voulez exécuter d'autres fichiers dans le dossier courant, vous "
"pouvez le programmer dans le fichier global, par exemple: ``if os.\"\"path."
"isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. Et si vous "
"voulez exécuter le fichier depuis un script, vous devez le faire "
"explicitement."

#: ../Doc/tutorial/appendix.rst:102
msgid "The Customization Modules"
msgstr "Les modules de Personnalisation"

#: ../Doc/tutorial/appendix.rst:104
msgid ""
"Python provides two hooks to let you customize it: :mod:`sitecustomize` and :"
"mod:`usercustomize`.  To see how it works, you need first to find the "
"location of your user site-packages directory.  Start Python and run this "
"code::"
msgstr ""
"Python peut être personnalisé via les modules :mod:`sitecustomize` et :mod:"
"`usercustomize`. Pour découvrir comment ils fonctionnent vous devez d'abord "
"les trouver, ils sont dans un dossier appelé user site-packages. Démarrez "
"Python et exécutez : code::"

#: ../Doc/tutorial/appendix.rst:112
msgid ""
"Now you can create a file named :file:`usercustomize.py` in that directory "
"and put anything you want in it.  It will affect every invocation of Python, "
"unless it is started with the :option:`-s` option to disable the automatic "
"import."
msgstr ""
"Vous pouvez maintenant y créer un fichier :file:`usercustomize.py` \" et y "
"écrire ce que vous voulez. Il sera toujours pris en compte par Python peut "
"importe le mode, sauf si il est démarré avec l'option :option:`-s`, qui "
"désactive l'import automatique."

#: ../Doc/tutorial/appendix.rst:116
msgid ""
":mod:`sitecustomize` works in the same way, but is typically created by an "
"administrator of the computer in the global site-packages directory, and is "
"imported before :mod:`usercustomize`.  See the documentation of the :mod:"
"`site` module for more details."
msgstr ""
":mod:`sitecustomize` fonctionne de la même manière, mais plus typiquement "
"créé par un administrateur et stocké dans le dossier site-packages global. "
"Il est importé avant :mod:`usercustomize`. Pour plus de détails, consultez "
"la documentation de :mod:`site`."

#: ../Doc/tutorial/appendix.rst:123 ../Doc/tutorial/classes.rst:952
#: ../Doc/tutorial/controlflow.rst:759 ../Doc/tutorial/datastructures.rst:707
#: ../Doc/tutorial/interpreter.rst:162 ../Doc/tutorial/introduction.rst:529
#: ../Doc/tutorial/modules.rst:550
msgid "Footnotes"
msgstr "Notes"

#: ../Doc/tutorial/appendix.rst:124
msgid "A problem with the GNU Readline package may prevent this."
msgstr "Un problème avec GNU Readline peut l'en empêcher."

#: ../Doc/tutorial/appetite.rst:5
msgid "Whetting Your Appetite"
msgstr "Mise en bouche"

#: ../Doc/tutorial/appetite.rst:7
msgid ""
"If you do much work on computers, eventually you find that there's some task "
"you'd like to automate.  For example, you may wish to perform a search-and-"
"replace over a large number of text files, or rename and rearrange a bunch "
"of photo files in a complicated way. Perhaps you'd like to write a small "
"custom database, or a specialized GUI application, or a simple game."
msgstr ""
"Si vous faites beaucoup de travail sur ordinateur, vous finirez par vouloir "
"automatiser certaines tâches. Par exemple vous pouvez avoir besoin "
"d'effectuer une recherche et un remplacement sur un grand nombre de fichiers "
"de texte, ou de renommer et réorganiser des photos d'une manière "
"sophistiquée. Peut-être avez-vous besoin de créer une petite base de données "
"ou une application graphique, ou un simple jeu."

#: ../Doc/tutorial/appetite.rst:13
msgid ""
"If you're a professional software developer, you may have to work with "
"several C/C++/Java libraries but find the usual write/compile/test/re-"
"compile cycle is too slow.  Perhaps you're writing a test suite for such a "
"library and find writing the testing code a tedious task.  Or maybe you've "
"written a program that could use an extension language, and you don't want "
"to design and implement a whole new language for your application."
msgstr ""
"Si vous êtes un développeur professionnel, vous pouvez avoir besoin de "
"travailler avec certaines bibliothèques C/C++/Java, mais vous trouvez que le "
"cycle habituel écriture/compilation/test/recompilation est trop lourd. Peut-"
"être écrivez-vous une suite de tests pour une telle bibliothèque et trouvez-"
"vous que l'écriture du code de test est pénible. Ou bien vous avez écrit un "
"logiciel qui a besoin d'être extensible grâce à un langage de script, mais "
"vous ne voulez pas concevoir ni implémenter un nouveau langage pour votre "
"application."

#: ../Doc/tutorial/appetite.rst:20
msgid "Python is just the language for you."
msgstr "Python est le langage parfait pour vous."

#: ../Doc/tutorial/appetite.rst:22
msgid ""
"You could write a Unix shell script or Windows batch files for some of these "
"tasks, but shell scripts are best at moving around files and changing text "
"data, not well-suited for GUI applications or games. You could write a C/C++/"
"Java program, but it can take a lot of development time to get even a first-"
"draft program.  Python is simpler to use, available on Windows, Mac OS X, "
"and Unix operating systems, and will help you get the job done more quickly."
msgstr ""
"Vous pouvez écrire un script shell Unix ou des fichiers batch Windows pour "
"certaines de ces tâches. Les scripts shell sont appropriés pour déplacer des "
"fichiers et modifier des données textuelles, mais pas pour une application "
"ayant une interface graphique ni pour des jeux. Vous pouvez écrire un "
"programme en C/C++/Java, mais cela peut prendre beaucoup de temps, ne serait-"
"ce que pour avoir une première maquette. Python est plus facile à utiliser, "
"il est disponible sous Windows, Mac OS X et Unix, et il vous aidera à "
"terminer plus rapidement votre travail."

#: ../Doc/tutorial/appetite.rst:29
msgid ""
"Python is simple to use, but it is a real programming language, offering "
"much more structure and support for large programs than shell scripts or "
"batch files can offer.  On the other hand, Python also offers much more "
"error checking than C, and, being a *very-high-level language*, it has high-"
"level data types built in, such as flexible arrays and dictionaries.  "
"Because of its more general data types Python is applicable to a much larger "
"problem domain than Awk or even Perl, yet many things are at least as easy "
"in Python as in those languages."
msgstr ""
"Python est facile à utiliser, mais c'est un vrai langage de programmation, "
"offrant une bien meilleure structure et prise en charge des grands "
"programmes que les scripts shell ou les fichiers batch. D'un autre coté, "
"Python offre beaucoup plus de méthodes de vérification d'erreurs que le "
"langage C et, étant un *langage de très haut niveau*, il possède nativement "
"des types de données très évolués tels que des tableaux flexibles ou des "
"dictionnaires. Grâce à ses types de données plus universels, Python est "
"utilisable pour des domaines beaucoup plus variés que Awk ou même Perl. "
"Pourtant, de nombreuses choses sont au moins aussi faciles en Python que "
"dans ces langages."

#: ../Doc/tutorial/appetite.rst:37
msgid ""
"Python allows you to split your program into modules that can be reused in "
"other Python programs.  It comes with a large collection of standard modules "
"that you can use as the basis of your programs --- or as examples to start "
"learning to program in Python.  Some of these modules provide things like "
"file I/O, system calls, sockets, and even interfaces to graphical user "
"interface toolkits like Tk."
msgstr ""
"Python vous permet de découper votre programme en modules qui peuvent être "
"réutilisés dans d'autres programmes en Python. Il est fourni avec une vaste "
"collection de modules standards que vous pouvez utiliser comme base de vos "
"programmes, ou comme exemples pour apprendre à programmer. Certains de ces "
"modules fournissent des services tels que les entrées/sorties, les appels "
"système, les sockets, et même des accès aux outils comme Tk pour créer des "
"interfaces graphiques."

#: ../Doc/tutorial/appetite.rst:44
msgid ""
"Python is an interpreted language, which can save you considerable time "
"during program development because no compilation and linking is necessary.  "
"The interpreter can be used interactively, which makes it easy to experiment "
"with features of the language, to write throw-away programs, or to test "
"functions during bottom-up program development. It is also a handy desk "
"calculator."
msgstr ""
"Python est un langage interprété, ce qui peut vous faire gagner un temps "
"considérable pendant le développement du programme car aucune compilation ni "
"édition de liens n'est nécessaire. L'interpréteur peut être utilisé de "
"manière interactive, pour vous permettre d'expérimenter avec les "
"fonctionnalités du langage, d'écrire des programmes jetables ou de tester "
"des fonctions lors d'un développement incrémental. Il constitue aussi une "
"calculatrice de bureau pratique."

#: ../Doc/tutorial/appetite.rst:50
msgid ""
"Python enables programs to be written compactly and readably.  Programs "
"written in Python are typically much shorter than equivalent C,  C++, or "
"Java programs, for several reasons:"
msgstr ""
"Python permet d'écrire des programmes compacts et lisibles. Les programmes "
"écrits en Python sont généralement beaucoup plus court que l'équivalent en "
"C, C++, ou Java, pour plusieurs raisons :"

#: ../Doc/tutorial/appetite.rst:54
msgid ""
"the high-level data types allow you to express complex operations in a "
"single statement;"
msgstr ""
"les types de données de haut niveau vous permettent d'exprimer des "
"opérations complexes en une seule instruction ;"

#: ../Doc/tutorial/appetite.rst:57
msgid ""
"statement grouping is done by indentation instead of beginning and ending "
"brackets;"
msgstr ""
"les instructions sont regroupées entre elles grâce à l'indentation, plutôt "
"que par l'utilisation d'accolades ;"

#: ../Doc/tutorial/appetite.rst:60
msgid "no variable or argument declarations are necessary."
msgstr "aucune déclaration de variable ou d'argument n'est nécessaire."

#: ../Doc/tutorial/appetite.rst:62
msgid ""
"Python is *extensible*: if you know how to program in C it is easy to add a "
"new built-in function or module to the interpreter, either to perform "
"critical operations at maximum speed, or to link Python programs to "
"libraries that may only be available in binary form (such as a vendor-"
"specific graphics library). Once you are really hooked, you can link the "
"Python interpreter into an application written in C and use it as an "
"extension or command language for that application."
msgstr ""
"Python est *extensible* : si vous savez écrire un programme en C, il est "
"aisé d'ajouter à l'interpréteur une nouvelle fonction primitive ou un "
"module, soit pour effectuer des opérations critiques à vitesse maximale, "
"soit pour lier des programmes en Python à des bibliothèques disponibles "
"uniquement sous forme binaire (par exemple des bibliothèques graphiques "
"dédiées à un matériel). Une fois que vous êtes à l'aise avec ces principes, "
"vous pouvez relier l'interpréteur Python à une application écrite en C et "
"l'utiliser comme un langage d'extensions ou de commandes pour cette "
"application."

#: ../Doc/tutorial/appetite.rst:70
msgid ""
"By the way, the language is named after the BBC show \"Monty Python's Flying "
"Circus\" and has nothing to do with reptiles.  Making references to Monty "
"Python skits in documentation is not only allowed, it is encouraged!"
msgstr ""
"À ce sujet, le nom du langage provient de l'émission de la BBC « Monty "
"Python's Flying Circus » et n'a rien à voir avec les reptiles. Faire "
"référence aux sketchs des Monty Python dans de la documentation n'est pas "
"seulement permis, c'est encouragé !"

#: ../Doc/tutorial/appetite.rst:74
msgid ""
"Now that you are all excited about Python, you'll want to examine it in some "
"more detail.  Since the best way to learn a language is to use it, the "
"tutorial invites you to play with the Python interpreter as you read."
msgstr ""
"Votre soudain enthousiasme à propos de Python va vous pousser à l'examiner "
"un peu plus en détail. Comme la meilleure façon d'apprendre un langage est "
"de l'utiliser, le tutoriel vous invite à jouer avec l'interpréteur pendant "
"la lecture."

#: ../Doc/tutorial/appetite.rst:78
msgid ""
"In the next chapter, the mechanics of using the interpreter are explained.  "
"This is rather mundane information, but essential for trying out the "
"examples shown later."
msgstr ""
"Dans le prochain chapitre, nous allons expliquer comment utiliser "
"l'interpréteur. Ce n'est pas la section la plus passionnante, mais c'est un "
"passage obligé pour tester les exemples montrés plus loin."

#: ../Doc/tutorial/appetite.rst:82
msgid ""
"The rest of the tutorial introduces various features of the Python language "
"and system through examples, beginning with simple expressions, statements "
"and data types, through functions and modules, and finally touching upon "
"advanced concepts like exceptions and user-defined classes."
msgstr ""
"Le reste du tutoriel présente diverses fonctionnalités du langage et du "
"système Python au travers d'exemples, depuis les simples expressions, "
"instructions ou types de données, jusqu'aux fonctions et modules, pour "
"finalement aborder des concepts avancés comme les exceptions et les classes."

#: ../Doc/tutorial/classes.rst:5
msgid "Classes"
msgstr "Classes"

#: ../Doc/tutorial/classes.rst:7
msgid ""
"Compared with other programming languages, Python's class mechanism adds "
"classes with a minimum of new syntax and semantics.  It is a mixture of the "
"class mechanisms found in C++ and Modula-3.  Python classes provide all the "
"standard features of Object Oriented Programming: the class inheritance "
"mechanism allows multiple base classes, a derived class can override any "
"methods of its base class or classes, and a method can call the method of a "
"base class with the same name.  Objects can contain arbitrary amounts and "
"kinds of data.  As is true for modules, classes partake of the dynamic "
"nature of Python: they are created at runtime, and can be modified further "
"after creation."
msgstr ""
"Le mécanisme des classes Python ajoute au langage la notion de classes avec "
"un minimum de syntaxe et de sémantique nouvelles. C'est un mélange des "
"mécanismes rencontrés dans C++ et Modula-3. De la même manière que pour les "
"modules, les classes Python ne posent pas de barrière rigide entre leur "
"définition et l'utilisateur, mais s'appuient sur le respect de l'utilisateur "
"à ne pas causer d'effraction dans la définition. Cependant, les "
"fonctionnalités les plus importantes des classes sont conservées avec toutes "
"leur puissance : le mécanisme d'héritage autorise d'avoir plusieurs classes "
"de base, une classe dérivée peut surcharger toutes les méthodes de sa (ou "
"ses) classe(s) de base et une méthode peut faire appel à la méthode d'une "
"classe de base portant le même nom. Les objets peuvent contenir un nombre "
"arbitraire de données."

#: ../Doc/tutorial/classes.rst:17
msgid ""
"In C++ terminology, normally class members (including the data members) are "
"*public* (except see below :ref:`tut-private`), and all member functions are "
"*virtual*.  As in Modula-3, there are no shorthands for referencing the "
"object's members from its methods: the method function is declared with an "
"explicit first argument representing the object, which is provided "
"implicitly by the call.  As in Smalltalk, classes themselves are objects.  "
"This provides semantics for importing and renaming.  Unlike C++ and "
"Modula-3, built-in types can be used as base classes for extension by the "
"user.  Also, like in C++, most built-in operators with special syntax "
"(arithmetic operators, subscripting etc.) can be redefined for class "
"instances."
msgstr ""
"Dans la terminologie C++, les membres des classes (y compris les données) "
"sont *publics* (sauf exception, voir :ref:`tut-private`) et toutes les "
"fonctions membres sont *virtuelles*. Comme avec Modulo-3, il n'y a aucune "
"façon d'accéder aux membres d'un objet à partir de ses méthodes : une "
"méthode est déclarée avec un premier argument explicite représentant "
"l'objet, et cet argument est transmis de manière implicite lors de l'appel. "
"Comme avec Smalltalk, les classes elles-mêmes sont des objets. Il existe "
"ainsi une sémantique pour les importer et les renommer. Au contraire de C++ "
"et Modulo-3, les types de base peuvent être utilisés comme classes de base "
"pour que l'utilisateur puisse les étendre. Enfin, comme en C++, la plupart "
"des opérateurs de base avec une syntaxe spéciale (opérateurs arithmétiques, "
"sous-indiçage, etc.) peuvent être redéfinis pour les instances de classes."

#: ../Doc/tutorial/classes.rst:28
msgid ""
"(Lacking universally accepted terminology to talk about classes, I will make "
"occasional use of Smalltalk and C++ terms.  I would use Modula-3 terms, "
"since its object-oriented semantics are closer to those of Python than C++, "
"but I expect that few readers have heard of it.)"
msgstr ""
"(Par manque d'une terminologie universellement acceptée pour parler des "
"classes, nous ferons un usage occasionnel des termes de Smalltalk et C++. "
"Nous voulions utiliser les termes de Modula-3 puisque sa sémantique orientée "
"objet est plus proche de celle de Python que de C++, mais il est probable "
"que seul un petit nombre de lecteurs soit susceptibles de les connaître.)"

#: ../Doc/tutorial/classes.rst:37
msgid "A Word About Names and Objects"
msgstr "Quelques mots au sujet des noms et objets"

#: ../Doc/tutorial/classes.rst:39
msgid ""
"Objects have individuality, and multiple names (in multiple scopes) can be "
"bound to the same object.  This is known as aliasing in other languages.  "
"This is usually not appreciated on a first glance at Python, and can be "
"safely ignored when dealing with immutable basic types (numbers, strings, "
"tuples).  However, aliasing has a possibly surprising effect on the "
"semantics of Python code involving mutable objects such as lists, "
"dictionaries, and most other types. This is usually used to the benefit of "
"the program, since aliases behave like pointers in some respects.  For "
"example, passing an object is cheap since only a pointer is passed by the "
"implementation; and if a function modifies an object passed as an argument, "
"the caller will see the change --- this eliminates the need for two "
"different argument passing mechanisms as in Pascal."
msgstr ""
"Les objets possèdent une existence propre et plusieurs noms peuvent être "
"utilisés (dans divers contextes) pour faire référence au même objet. Ceux-ci "
"sont connus sous le nom d'alias dans d'autres langages. Ceci est "
"habituellement peu apprécié lors d'un premier coup d'œil à Python et peut "
"être ignoré lorsqu'on travaille avec des types de base non mutables "
"(nombres, chaînes, tuples). Cependant, les alias ont éventuellement des "
"effets surprenants sur la sémantique d'un code Python mettant en jeu des "
"objets mutables comme les listes, les dictionnaires et la plupart des autres "
"types. C'est généralement utilisé au bénéfice du programme car les alias se "
"comportent, d'un certain point de vue, comme des pointeurs. Par exemple, "
"transmettre un objet n'a aucun coût car c'est simplement un pointeur qui est "
"transmis par l'implémentation ; et si une fonction modifie un objet passé en "
"argument, le code à l'origine de l'appel verra le changement. Ceci élimine "
"le besoin d'avoir deux mécanismes de transmission d'arguments comme en "
"Pascal."

#: ../Doc/tutorial/classes.rst:55
msgid "Python Scopes and Namespaces"
msgstr "Portées et espaces de noms en Python"

#: ../Doc/tutorial/classes.rst:57
msgid ""
"Before introducing classes, I first have to tell you something about "
"Python's scope rules.  Class definitions play some neat tricks with "
"namespaces, and you need to know how scopes and namespaces work to fully "
"understand what's going on. Incidentally, knowledge about this subject is "
"useful for any advanced Python programmer."
msgstr ""
"Avant de présenter les classes, nous devons parler un peu de la notion de "
"portée en Python. Les définitions de classes font d'habiles manipulations "
"avec les espaces de noms, et vous devez savoir comment les portées et les "
"espaces de noms fonctionnent. Soit dit en passant, toute connaissance sur ce "
"sujet est aussi utile aux développeurs Python expérimentés."

#: ../Doc/tutorial/classes.rst:63
msgid "Let's begin with some definitions."
msgstr "Tout d'abord, quelques définitions."

#: ../Doc/tutorial/classes.rst:65
msgid ""
"A *namespace* is a mapping from names to objects.  Most namespaces are "
"currently implemented as Python dictionaries, but that's normally not "
"noticeable in any way (except for performance), and it may change in the "
"future.  Examples of namespaces are: the set of built-in names (containing "
"functions such as :func:`abs`, and built-in exception names); the global "
"names in a module; and the local names in a function invocation.  In a sense "
"the set of attributes of an object also form a namespace.  The important "
"thing to know about namespaces is that there is absolutely no relation "
"between names in different namespaces; for instance, two different modules "
"may both define a function ``maximize`` without confusion --- users of the "
"modules must prefix it with the module name."
msgstr ""
"Un *espace de nom* est une table de correspondance entre des noms et des "
"objets. La plupart des espaces de noms sont actuellement implémentés sous "
"forme de dictionnaires Python, mais ceci n'est normalement pas visible (sauf "
"pour les performances) et peut changer dans le futur. Comme exemples "
"d'espaces de noms, nous pouvons citer les primitives (fonctions comme :func:"
"`abs`, et les noms des exceptions de base) ; les noms globaux dans un "
"module ; et les noms locaux lors d'un appel de fonction. D'une certaine "
"manière, l'ensemble des attributs d'un objet forme lui-même un espace de "
"noms. La chose importante à retenir à propos des espaces de noms est qu'il "
"n'y a absolument aucun lien entre les noms de plusieurs espaces de noms ; "
"par exemple, deux modules différents peuvent définir une fonction "
"``maximize`` sans qu'il y ait de confusion. Les utilisateurs des modules "
"doivent préfixer le nom de la fonction avec celui du module."

#: ../Doc/tutorial/classes.rst:76
msgid ""
"By the way, I use the word *attribute* for any name following a dot --- for "
"example, in the expression ``z.real``, ``real`` is an attribute of the "
"object ``z``.  Strictly speaking, references to names in modules are "
"attribute references: in the expression ``modname.funcname``, ``modname`` is "
"a module object and ``funcname`` is an attribute of it.  In this case there "
"happens to be a straightforward mapping between the module's attributes and "
"the global names defined in the module: they share the same namespace!  [#]_"
msgstr ""
"À ce propos, nous utilisons le mot *attribut* pour tout nom suivant un "
"point. Par exemple, dans l'expression ``z.real``, ``real`` est un attribut "
"de l'objet ``z``. Rigoureusement parlant, les références à des noms dans des "
"modules sont des références d'attributs : dans l'expression ``modname."
"funcname``, ``modname`` est un objet module et ``funcname`` est un attribut "
"de cet objet. Dans ces conditions, il existe une correspondance directe "
"entre les attributs du module et les noms globaux définis dans le module : "
"ils partagent le même espace de noms ! [#]_"

#: ../Doc/tutorial/classes.rst:84
msgid ""
"Attributes may be read-only or writable.  In the latter case, assignment to "
"attributes is possible.  Module attributes are writable: you can write "
"``modname.the_answer = 42``.  Writable attributes may also be deleted with "
"the :keyword:`del` statement.  For example, ``del modname.the_answer`` will "
"remove the attribute :attr:`the_answer` from the object named by ``modname``."
msgstr ""
"Les attributs peuvent être seulement lisibles ou aussi modifiables. S'ils "
"sont modifiables, l'affectation à un attribut est possible. Les attributs de "
"modules sont modifiables : vous pouvez écrire ``modname.the_answer = 42``. "
"Les attributs modifiables peuvent aussi être effacés avec l'instruction :"
"keyword:`del`. Par exemple, ``del modname.the_answer`` supprime l'attribut :"
"attr:`the_answer` de l'objet nommé ``modname``."

#: ../Doc/tutorial/classes.rst:90
msgid ""
"Namespaces are created at different moments and have different lifetimes.  "
"The namespace containing the built-in names is created when the Python "
"interpreter starts up, and is never deleted.  The global namespace for a "
"module is created when the module definition is read in; normally, module "
"namespaces also last until the interpreter quits.  The statements executed "
"by the top-level invocation of the interpreter, either read from a script "
"file or interactively, are considered part of a module called :mod:"
"`__main__`, so they have their own global namespace.  (The built-in names "
"actually also live in a module; this is called :mod:`builtins`.)"
msgstr ""
"Les espaces de noms sont créés à différents moments et ont différentes "
"durées de vie. L'espace de noms contenant les primitives est créé au "
"démarrage de l'interpréteur Python et n'est jamais effacé. L'espace de nom "
"global pour un module est créé lorsque la définition du module est lue. "
"Habituellement, les espaces de noms des modules durent aussi jusqu'à l'arrêt "
"de l'interpréteur. Les instructions exécutées par la première invocation de "
"l'interpréteur, qu'ils soient lus depuis un fichier de script ou de manière "
"interactive, sont considérés comme faisant partie d'un module appelé :mod:"
"`__main__`, de façon qu'elles possèdent leur propre espace de noms. (les "
"primitives vivent elles-mêmes dans un module, appelé :mod:`builtins`.)"

#: ../Doc/tutorial/classes.rst:100
msgid ""
"The local namespace for a function is created when the function is called, "
"and deleted when the function returns or raises an exception that is not "
"handled within the function.  (Actually, forgetting would be a better way to "
"describe what actually happens.)  Of course, recursive invocations each have "
"their own local namespace."
msgstr ""
"L'espace de noms local d'une fonction est créé lors de son appel, puis "
"effacé lorsqu'elle renvoie un résultat ou lève une exception non prise en "
"charge. (En fait, « oublié » serait une meilleure façon de décrire ce qui se "
"passe réellement). Bien sûr, des invocations récursives ont chacune leur "
"propre espace de noms."

#: ../Doc/tutorial/classes.rst:106
msgid ""
"A *scope* is a textual region of a Python program where a namespace is "
"directly accessible.  \"Directly accessible\" here means that an unqualified "
"reference to a name attempts to find the name in the namespace."
msgstr ""
"Une *portée* est une zone textuelle d'un programme Python où un espace de "
"noms est directement accessible. « Directement accessible » signifie ici "
"qu'une référence non qualifée à un nom sera recherchée dans l'espace de noms."

#: ../Doc/tutorial/classes.rst:110
msgid ""
"Although scopes are determined statically, they are used dynamically. At any "
"time during execution, there are at least three nested scopes whose "
"namespaces are directly accessible:"
msgstr ""
"Bien que les portées soient déterminées de manière statique, elles sont "
"utilisées de manière dynamique. À n'importe quel moment de l'exécution, il y "
"a au minimum trois portées imbriquées dont les espaces de noms sont "
"directement accessibles :"

#: ../Doc/tutorial/classes.rst:114
msgid "the innermost scope, which is searched first, contains the local names"
msgstr ""
"La portée la plus au centre, celle qui est consultée en premier, contient "
"les noms locaux"

#: ../Doc/tutorial/classes.rst:115
msgid ""
"the scopes of any enclosing functions, which are searched starting with the "
"nearest enclosing scope, contains non-local, but also non-global names"
msgstr ""
"les portées des fonctions englobantes, qui sont consultées en commençant "
"avec la portée englobante la plus proche, contiennent des noms non-locaux "
"mais aussi non-globaux"

#: ../Doc/tutorial/classes.rst:117
msgid "the next-to-last scope contains the current module's global names"
msgstr "l'avant dernière portée contient les noms globaux du module courant"

#: ../Doc/tutorial/classes.rst:118
msgid ""
"the outermost scope (searched last) is the namespace containing built-in "
"names"
msgstr ""
"la portée englobante, consultée en dernier, est l'espace de noms contenant "
"les primitives"

#: ../Doc/tutorial/classes.rst:120
msgid ""
"If a name is declared global, then all references and assignments go "
"directly to the middle scope containing the module's global names.  To "
"rebind variables found outside of the innermost scope, the :keyword:"
"`nonlocal` statement can be used; if not declared nonlocal, those variables "
"are read-only (an attempt to write to such a variable will simply create a "
"*new* local variable in the innermost scope, leaving the identically named "
"outer variable unchanged)."
msgstr ""

#: ../Doc/tutorial/classes.rst:127
msgid ""
"Usually, the local scope references the local names of the (textually) "
"current function.  Outside functions, the local scope references the same "
"namespace as the global scope: the module's namespace. Class definitions "
"place yet another namespace in the local scope."
msgstr ""
"Habituellement, la portée locale référence les noms locaux de la fonction "
"courante. En dehors des fonctions, la portée locale référence le même espace "
"de noms que la portée globale : l'espace de noms du module. Les définitions "
"de classes créent un nouvel espace de noms dans la portée locale."

#: ../Doc/tutorial/classes.rst:132
msgid ""
"It is important to realize that scopes are determined textually: the global "
"scope of a function defined in a module is that module's namespace, no "
"matter from where or by what alias the function is called.  On the other "
"hand, the actual search for names is done dynamically, at run time --- "
"however, the language definition is evolving towards static name resolution, "
"at \"compile\" time, so don't rely on dynamic name resolution!  (In fact, "
"local variables are already determined statically.)"
msgstr ""
"Il est important de réaliser que les portées sont déterminées de manière "
"textuelle : la portée globale d'une fonction définie dans un module est "
"l'espace de nom de ce module, quel que soit la provenance de cet appel. Par "
"contre, la recherche réelle des noms est faite dynamiquement au moment de "
"l'exécution. Cependant la définition du langage est en train d'évoluer vers "
"une résolution statique des noms au moment de la « compilation », donc sans "
"se baser sur une résolution dynamique ! (En réalité, les variables locales "
"sont déjà déterminées de manière statique)."

#: ../Doc/tutorial/classes.rst:140
msgid ""
"A special quirk of Python is that -- if no :keyword:`global` statement is in "
"effect -- assignments to names always go into the innermost scope.  "
"Assignments do not copy data --- they just bind names to objects.  The same "
"is true for deletions: the statement ``del x`` removes the binding of ``x`` "
"from the namespace referenced by the local scope.  In fact, all operations "
"that introduce new names use the local scope: in particular, :keyword:"
"`import` statements and function definitions bind the module or function "
"name in the local scope."
msgstr ""
"Une particularité de Python est que si aucune instruction :keyword:`global` "
"n'est active, les affectations de noms vont toujours dans la portée la plus "
"proche. Les affectations ne copient aucune donnée : elles se contentent de "
"lier des noms à des objets. Ceci est également vrai pour l'effacement : "
"l'instruction ``del x`` supprime la liaison de ``x`` dans l'espace de noms "
"référencé par la portée locale. En réalité, toutes les opérations qui "
"impliquent des nouveaux noms utilisent la portée locale : en particulier, "
"les instructions :keyword:`import` et les définitions de fonctions "
"effectuent une liaison du module ou du nom de fonction dans la portée locale."

#: ../Doc/tutorial/classes.rst:148
msgid ""
"The :keyword:`global` statement can be used to indicate that particular "
"variables live in the global scope and should be rebound there; the :keyword:"
"`nonlocal` statement indicates that particular variables live in an "
"enclosing scope and should be rebound there."
msgstr ""
"L'instruction :keyword:`global` peut être utilisée pour indiquer que "
"certaines variables existent dans la portée globale et doivent être reliées "
"en local ; l'instruction :keyword:`nonlocal` indique que certaines variables "
"existent dans une portée supérieure et doivent être reliées en local."

#: ../Doc/tutorial/classes.rst:156
msgid "Scopes and Namespaces Example"
msgstr "Exemple de portées et d'espaces de noms"

#: ../Doc/tutorial/classes.rst:158
msgid ""
"This is an example demonstrating how to reference the different scopes and "
"namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "
"variable binding::"
msgstr ""
"Ceci est un exemple montrant comment utiliser les différentes portées et "
"espaces de noms, et comment :keyword:`global` et :keyword:`nonlocal` "
"modifient l'affectation de variable : ::"

#: ../Doc/tutorial/classes.rst:185
msgid "The output of the example code is:"
msgstr "Ce code donne le résultat suivant :"

#: ../Doc/tutorial/classes.rst:194
msgid ""
"Note how the *local* assignment (which is default) didn't change *scope_test*"
"\\'s binding of *spam*.  The :keyword:`nonlocal` assignment changed "
"*scope_test*\\'s binding of *spam*, and the :keyword:`global` assignment "
"changed the module-level binding."
msgstr ""
"Vous pouvez constater que l'affectation *locale* (qui est effectuée par "
"défaut) n'a pas modifié la liaison de *spam* dans *scope_test*. "
"L'affectation :keyword:`nonlocal` a changé la liaison de *spam* dans "
"*scope_test* et l'affectation :keyword:`global` a changé la liaison au "
"niveau du module."

#: ../Doc/tutorial/classes.rst:199
msgid ""
"You can also see that there was no previous binding for *spam* before the :"
"keyword:`global` assignment."
msgstr ""
"Vous pouvez également voir qu'aucune liaison pour *spam* n'a été faite avant "
"l'affectation :keyword:`global`."

#: ../Doc/tutorial/classes.rst:206
msgid "A First Look at Classes"
msgstr "Une première approche des classes"

#: ../Doc/tutorial/classes.rst:208
msgid ""
"Classes introduce a little bit of new syntax, three new object types, and "
"some new semantics."
msgstr ""
"Le concept de classes introduit quelques nouveau éléments de syntaxe, trois "
"nouveaux types d'objets ainsi que de nouveaux éléments de sémantique"

#: ../Doc/tutorial/classes.rst:215
msgid "Class Definition Syntax"
msgstr "Syntaxe de définition des classes"

#: ../Doc/tutorial/classes.rst:217
msgid "The simplest form of class definition looks like this::"
msgstr "La forme la plus simple de définition de classe ressemble à ceci : ::"

#: ../Doc/tutorial/classes.rst:226
msgid ""
"Class definitions, like function definitions (:keyword:`def` statements) "
"must be executed before they have any effect.  (You could conceivably place "
"a class definition in a branch of an :keyword:`if` statement, or inside a "
"function.)"
msgstr ""
"Les définitions de classes, comme les définitions de fonctions (définitions :"
"keyword:`def`) doivent être exécutées avant d'avoir un effet. (Vous pouvez "
"tout à fait placer une définition de classe dans une branche d'une "
"instruction conditionnelle :keyword:`if` ou encore à l'intérieur d'une "
"fonction.)"

#: ../Doc/tutorial/classes.rst:230
msgid ""
"In practice, the statements inside a class definition will usually be "
"function definitions, but other statements are allowed, and sometimes useful "
"--- we'll come back to this later.  The function definitions inside a class "
"normally have a peculiar form of argument list, dictated by the calling "
"conventions for methods --- again, this is explained later."
msgstr ""
"Dans la pratique, les déclarations dans une définition de classe seront "
"généralement des définitions de fonctions, mais d'autres déclarations sont "
"permises, et parfois utiles --- Nous reviendrons sur ce point plus tard. Les "
"définitions de fonction à l'intérieur d'une classe ont normalement une forme "
"particulière de liste d'arguments, dictée par les conventions d'appel aux "
"méthodes --- À nouveau, tout ceci sera expliqué plus tard."

#: ../Doc/tutorial/classes.rst:236
msgid ""
"When a class definition is entered, a new namespace is created, and used as "
"the local scope --- thus, all assignments to local variables go into this "
"new namespace.  In particular, function definitions bind the name of the new "
"function here."
msgstr ""
"Quand une classe est définie, un nouvel espace de noms est créé et utilisé "
"comme portée locale --- Ainsi, toutes les affectations de variables locales "
"entrent dans ce nouvel espace de noms. En particulier, les définitions de "
"fonctions y lient le nom de la nouvelle fonction."

#: ../Doc/tutorial/classes.rst:241
msgid ""
"When a class definition is left normally (via the end), a *class object* is "
"created.  This is basically a wrapper around the contents of the namespace "
"created by the class definition; we'll learn more about class objects in the "
"next section.  The original local scope (the one in effect just before the "
"class definition was entered) is reinstated, and the class object is bound "
"here to the class name given in the class definition header (:class:"
"`ClassName` in the example)."
msgstr ""
"A la fin de la définition d'une classe, un *objet classe* est créé. C'est, "
"pour simplifier, une encapsulation du contenu de l'espace de noms créé par "
"la définition de classe. Nous reparlerons des objets classes dans la "
"prochaine section. La portée locale initiale (celle qui prévaut avant le "
"début de la définition de la classe) est réinstanciée, et l'objet de classe "
"est lié ici au nom de classe donné dans l'en-tête de définition de classe (:"
"class:`NomDeLaClasse` dans l'exemple)."

#: ../Doc/tutorial/classes.rst:253
msgid "Class Objects"
msgstr "Les objets classe"

#: ../Doc/tutorial/classes.rst:255
msgid ""
"Class objects support two kinds of operations: attribute references and "
"instantiation."
msgstr ""
"Les objets classes prennent en charge deux types d'opérations : des "
"références à des attributs et l'instanciation."

#: ../Doc/tutorial/classes.rst:258
msgid ""
"*Attribute references* use the standard syntax used for all attribute "
"references in Python: ``obj.name``.  Valid attribute names are all the names "
"that were in the class's namespace when the class object was created.  So, "
"if the class definition looked like this::"
msgstr ""
"Les *références d'attributs* utilisent la syntaxe standard utilisée pour "
"toutes les références d'attributs en Python : ``obj.nom``. Les noms "
"d'attribut valides sont tous les noms qui se trouvaient dans l'espace de "
"noms de la classe quand l'objet classe a été créé. Donc, si la définition de "
"classe ressemble à ceci : ::"

#: ../Doc/tutorial/classes.rst:270
msgid ""
"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
"returning an integer and a function object, respectively. Class attributes "
"can also be assigned to, so you can change the value of ``MyClass.i`` by "
"assignment. :attr:`__doc__` is also a valid attribute, returning the "
"docstring belonging to the class: ``\"A simple example class\"``."
msgstr ""
"alors ``MaClasse.i`` et ``MaClasse.f`` sont des références valides à des "
"attributs, renvoyant respectivement un entier et un objet fonction. Les "
"attributs de classes peuvent également être affectés, de sorte que vous "
"pouvez modifier la valeur de ``MaClasse.i`` par affectation. :attr:`__doc__` "
"est aussi un attribut valide, renvoyant la docstring appartenant à la "
"classe : ``\"Une simple classe d'exemple\"``."

#: ../Doc/tutorial/classes.rst:276
msgid ""
"Class *instantiation* uses function notation.  Just pretend that the class "
"object is a parameterless function that returns a new instance of the class. "
"For example (assuming the above class)::"
msgstr ""
"L'*instanciation* de classes utilise la notation des fonctions. Considérez "
"simplement que l'objet classe est une fonction sans paramètre qui renvoie "
"une nouvelle instance de la classe. Par exemple (en considérant la classe "
"définie ci-dessus) ::"

#: ../Doc/tutorial/classes.rst:282
msgid ""
"creates a new *instance* of the class and assigns this object to the local "
"variable ``x``."
msgstr ""
"crée une nouvelle *instance* de la classe et affecte cet objet à la variable "
"locale ``x``."

#: ../Doc/tutorial/classes.rst:285
msgid ""
"The instantiation operation (\"calling\" a class object) creates an empty "
"object. Many classes like to create objects with instances customized to a "
"specific initial state. Therefore a class may define a special method named :"
"meth:`__init__`, like this::"
msgstr ""
"L'opération d'instanciation (en \"appelant\" un objet classe) crée un objet "
"vide. De nombreuses classes aiment créer des objets personnalisés avec des "
"instances personnalisées en fonction d'un état initial spécifique. Ainsi une "
"classe peut définir une méthode spéciale nommée: :meth:`__init__`, comme "
"ceci : ::"

#: ../Doc/tutorial/classes.rst:293
msgid ""
"When a class defines an :meth:`__init__` method, class instantiation "
"automatically invokes :meth:`__init__` for the newly-created class "
"instance.  So in this example, a new, initialized instance can be obtained "
"by::"
msgstr ""
"Quand une classe définit une méthode :meth:`__init__`, l'instanciation de la "
"classe appelle automatiquement :meth:`__init__` pour la nouvelle instance de "
"la classe. Donc, dans cet exemple, l'initialisation d'une nouvelle instance "
"peut être obtenue par : ::"

#: ../Doc/tutorial/classes.rst:299
msgid ""
"Of course, the :meth:`__init__` method may have arguments for greater "
"flexibility.  In that case, arguments given to the class instantiation "
"operator are passed on to :meth:`__init__`.  For example, ::"
msgstr ""
"Bien sûr, la méthode :meth:`__init__` peut avoir des arguments pour une plus "
"grande flexibilité. Dans ce cas, les arguments donnés à l'opérateur "
"d'instanciation de classe sont transmis à :meth:`__init__`. Par exemple, ::"

#: ../Doc/tutorial/classes.rst:316
msgid "Instance Objects"
msgstr "Objets instance"

#: ../Doc/tutorial/classes.rst:318
msgid ""
"Now what can we do with instance objects?  The only operations understood by "
"instance objects are attribute references.  There are two kinds of valid "
"attribute names, data attributes and methods."
msgstr ""
"Maintenant, que pouvons-nous faire avec des objets instance ? Les seules "
"opérations comprises par les objets instances sont des références "
"d'attributs. Il y a deux sortes de noms d'attributs valides, les attributs "
"données et les méthodes."

#: ../Doc/tutorial/classes.rst:322
msgid ""
"*data attributes* correspond to \"instance variables\" in Smalltalk, and to "
"\"data members\" in C++.  Data attributes need not be declared; like local "
"variables, they spring into existence when they are first assigned to.  For "
"example, if ``x`` is the instance of :class:`MyClass` created above, the "
"following piece of code will print the value ``16``, without leaving a "
"trace::"
msgstr ""
"Les *attributs données* correspondent à des \"variables d'instance\" en "
"Smalltalk, et aux \"membres de données\" en C++. Les attributs données n'ont "
"pas à être déclarés. Comme les variables locales, ils existent dès lors "
"qu'ils sont attribués une première fois. Par exemple, si ``x`` est "
"l'instance de :class:`MyClass` créée ci-dessus, le code suivant affiche la "
"valeur ``16``, sans laisser de traces : ::"

#: ../Doc/tutorial/classes.rst:334
msgid ""
"The other kind of instance attribute reference is a *method*. A method is a "
"function that \"belongs to\" an object.  (In Python, the term method is not "
"unique to class instances: other object types can have methods as well.  For "
"example, list objects have methods called append, insert, remove, sort, and "
"so on. However, in the following discussion, we'll use the term method "
"exclusively to mean methods of class instance objects, unless explicitly "
"stated otherwise.)"
msgstr ""
"L'autre type de référence à un attribut d'instance est une *méthode*. Une "
"méthode est une fonction qui \"appartient à\" un objet (en Python, le terme "
"de méthode n'est pas unique aux instances de classes : d'autres types "
"d'objets peuvent aussi avoir des méthodes. Par exemple, les objets listes "
"ont des méthodes appelées append, insert, remove, sort, et ainsi de suite. "
"Toutefois, dans la discussion qui suit, sauf indication contraire, nous "
"allons utiliser le terme de méthode exclusivement en référence à des "
"méthodes d'objets instances de classe)."

#: ../Doc/tutorial/classes.rst:343
msgid ""
"Valid method names of an instance object depend on its class.  By "
"definition, all attributes of a class that are function  objects define "
"corresponding methods of its instances.  So in our example, ``x.f`` is a "
"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "
"not, since ``MyClass.i`` is not.  But ``x.f`` is not the same thing as "
"``MyClass.f`` --- it is a *method object*, not a function object."
msgstr ""
"Les noms de méthodes valides d'un objet instance dépendent de sa classe. Par "
"définition, tous les attributs d'une classe qui sont des objets  fonction "
"définissent les méthodes correspondantes de ses instances. Donc, dans notre "
"exemple, ``x.f`` est une méthode de référence valide, car ``MaClasse.f`` est "
"une fonction, mais pas ``x.i`` car ``MaClasse.i`` n'en est pas une. "
"Attention cependant, ``x.f`` n'est pas la même chose que ``MaClasse.f`` --- "
"Il s'agit d'un *objet méthode*, pas d'un objet fonction."

#: ../Doc/tutorial/classes.rst:354
msgid "Method Objects"
msgstr "Les objets méthode"

#: ../Doc/tutorial/classes.rst:356
msgid "Usually, a method is called right after it is bound::"
msgstr "Le plus souvent, une méthode est appelée juste après avoir été liée::"

#: ../Doc/tutorial/classes.rst:360
msgid ""
"In the :class:`MyClass` example, this will return the string ``'hello "
"world'``. However, it is not necessary to call a method right away: ``x.f`` "
"is a method object, and can be stored away and called at a later time.  For "
"example::"
msgstr ""
"Dans l'exemple de la class :class:`MaClass`, cela va retourner la chaîne de "
"caractères ``hello world``. Toutefois, il n'est pas nécessaire d'appeler la "
"méthode directement: ``x.f`` est un objet méthode, il peut être gardé de "
"coté et être appelé plus tard. Par exemple::"

#: ../Doc/tutorial/classes.rst:368
msgid "will continue to print ``hello world`` until the end of time."
msgstr "va afficher ``hello world`` jusqu'à la fin des temps."

#: ../Doc/tutorial/classes.rst:370
msgid ""
"What exactly happens when a method is called?  You may have noticed that ``x."
"f()`` was called without an argument above, even though the function "
"definition for :meth:`f` specified an argument.  What happened to the "
"argument? Surely Python raises an exception when a function that requires an "
"argument is called without any --- even if the argument isn't actually "
"used..."
msgstr ""
"Que ce passe-t-il exactement quand une méthode est appelée ? Vous avez dû "
"remarquer que ``x.f()`` a été appelée dans le code ci-dessus sans argument, "
"alors que la définition de la méthode :meth:`f` spécifie bien qu'elle prend "
"un argument. Qu'est-il arrivé à l'argument ? Python doit sûrement lever une "
"exception lorsqu'une fonction qui requiert un argument est appelée sans -- "
"même si l'argument n'est pas utilisé..."

#: ../Doc/tutorial/classes.rst:376
msgid ""
"Actually, you may have guessed the answer: the special thing about methods "
"is that the object is passed as the first argument of the function.  In our "
"example, the call ``x.f()`` is exactly equivalent to ``MyClass.f(x)``.  In "
"general, calling a method with a list of *n* arguments is equivalent to "
"calling the corresponding function with an argument list that is created by "
"inserting the method's object before the first argument."
msgstr ""
"En fait, vous aurez peut-être deviné la réponse : la particularité des "
"méthodes est que l'objet est passé comme premier argument de la fonction. "
"Dans notre exemple, l'appel ``x.f ()`` est exactement équivalent à "
"``MaClasse.f(x)``. En général, appeler une méthode avec une liste "
"d'arguments *n* est équivalent à appeler la fonction correspondante avec "
"cette liste d'arguments modulo l'insertion de l'objet de la méthode avant le "
"premier argument."

#: ../Doc/tutorial/classes.rst:383
msgid ""
"If you still don't understand how methods work, a look at the implementation "
"can perhaps clarify matters.  When an instance attribute is referenced that "
"isn't a data attribute, its class is searched.  If the name denotes a valid "
"class attribute that is a function object, a method object is created by "
"packing (pointers to) the instance object and the function object just found "
"together in an abstract object: this is the method object.  When the method "
"object is called with an argument list, a new argument list is constructed "
"from the instance object and the argument list, and the function object is "
"called with this new argument list."
msgstr ""
"Si vous ne comprenez toujours pas comment les méthodes fonctionnent, un coup "
"d'œil à l'implémentation vous aidera peut être. Lorsque l'instance d'un "
"attribut est référencé qui n'est pas un attribut donnée, sa classe est "
"recherchée. Si le nom correspond à un attribut valide qui est une fonction, "
"un objet méthode est créé en associant (via leurs pointeurs) l'objet "
"instance et l'objet fonction trouvé ensemble dans un nouvel objet abstrait : "
"c'est l'objet méthode. Lorsque l'objet méthode est appelé avec une liste "
"d'arguments, une nouvelle liste d'arguments est construite à partir de "
"l'objet méthode et de la liste des arguments. L'objet fonction est appelé "
"avec cette nouvelle liste d'arguments."

#: ../Doc/tutorial/classes.rst:397
msgid "Class and Instance Variables"
msgstr "Classes et variables d'instance"

#: ../Doc/tutorial/classes.rst:399
msgid ""
"Generally speaking, instance variables are for data unique to each instance "
"and class variables are for attributes and methods shared by all instances "
"of the class::"
msgstr ""
"En général, les variables d'instance stockent des informations relatives à "
"chaque instance alors que les variables de classe servent à stocker les "
"attributs et méthodes communes à toutes les instances de la classe::"

#: ../Doc/tutorial/classes.rst:421
msgid ""
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
"effects with involving :term:`mutable` objects such as lists and "
"dictionaries. For example, the *tricks* list in the following code should "
"not be used as a class variable because just a single list would be shared "
"by all *Dog* instances::"
msgstr ""
"Comme vu dans :ref:`tut-object`, les données partagées :term:`modifiables "
"<mutable>` (tel que les listes, dictionnaires, etc...) peuvent avoir des "
"effets surprenants. Part exemple, la liste *tricks* dans le code suivant ne "
"devrait pas être une variable de classe, car jiate une seule liste serait "
"partagées par toutes les instances de *Dog*::"

#: ../Doc/tutorial/classes.rst:444
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Une conception correcte de la classe serait d'utiliser une variable "
"d'instance à la place : :"

#: ../Doc/tutorial/classes.rst:468
msgid "Random Remarks"
msgstr "Remarques diverses"

#: ../Doc/tutorial/classes.rst:472
msgid ""
"Data attributes override method attributes with the same name; to avoid "
"accidental name conflicts, which may cause hard-to-find bugs in large "
"programs, it is wise to use some kind of convention that minimizes the "
"chance of conflicts.  Possible conventions include capitalizing method "
"names, prefixing data attribute names with a small unique string (perhaps "
"just an underscore), or using verbs for methods and nouns for data "
"attributes."
msgstr ""
"Les attributs de données surchargent les méthodes avec le même nom ; pour "
"éviter des conflits de nommage, qui peuvent causer des bugs difficiles à "
"trouver dans de grands programmes, il est sage d'adopter certaines "
"conventions qui minimisent les risques de conflits. Les conventions "
"possibles comprennent la mise en majuscule des noms de méthodes, le préfixe "
"des noms d'attributs de données par une chaîne courte et unique (parfois "
"juste la caractère souligné), ou l'utilisation de verbes pour les méthodes "
"et de noms pour les attributs de données."

#: ../Doc/tutorial/classes.rst:479
msgid ""
"Data attributes may be referenced by methods as well as by ordinary users "
"(\"clients\") of an object.  In other words, classes are not usable to "
"implement pure abstract data types.  In fact, nothing in Python makes it "
"possible to enforce data hiding --- it is all based upon convention.  (On "
"the other hand, the Python implementation, written in C, can completely hide "
"implementation details and control access to an object if necessary; this "
"can be used by extensions to Python written in C.)"
msgstr ""
"Les attributs de données peuvent être référencés par des méthodes comme par "
"des utilisateurs ordinaires (\"clients\") d'un objet. En d'autres termes, "
"les classes ne sont pas utilisables pour implémenter des types de données "
"purement abstraits. En fait, rien en Python ne rend possible d'imposer de "
"masquer des données --- tout est basé sur des conventions (d'un autre coté, "
"l'implémentation Python, écrite en C, peut complètement masquer les détails "
"d'implémentation et contrôler l'accès à un objet si nécessaire ; ceci peut "
"être utilisé par des extensions de Python écrites en C)."

#: ../Doc/tutorial/classes.rst:487
msgid ""
"Clients should use data attributes with care --- clients may mess up "
"invariants maintained by the methods by stamping on their data attributes.  "
"Note that clients may add data attributes of their own to an instance object "
"without affecting the validity of the methods, as long as name conflicts are "
"avoided --- again, a naming convention can save a lot of headaches here."
msgstr ""
"Les clients doivent utiliser les attributs de données avec précaution --- "
"ils pourraient mettre le désordre dans les invariants gérés par les méthodes "
"avec leurs propres valeurs d'attributs. Remarquez que les clients peuvent "
"ajouter leurs propres attributs de données à une instance d'objet sans "
"altérer la validité des méthodes, pour autant que les noms n'entrent pas en "
"conflit --- aussi, adopter une convention de nommage peut éviter bien des "
"problèmes."

#: ../Doc/tutorial/classes.rst:493
msgid ""
"There is no shorthand for referencing data attributes (or other methods!) "
"from within methods.  I find that this actually increases the readability of "
"methods: there is no chance of confusing local variables and instance "
"variables when glancing through a method."
msgstr ""
"Il n'y a pas de notation abrégée pour référencer des attributs de données "
"(ou d'autres méthodes !) depuis les méthodes. Nous pensons que ceci améliore "
"en fait la lisibilité des méthodes : il n'y a aucune chance de confondre "
"variables locales et variables d'instances quand on regarde le code d'une "
"méthode."

#: ../Doc/tutorial/classes.rst:498
msgid ""
"Often, the first argument of a method is called ``self``.  This is nothing "
"more than a convention: the name ``self`` has absolutely no special meaning "
"to Python.  Note, however, that by not following the convention your code "
"may be less readable to other Python programmers, and it is also conceivable "
"that a *class browser* program might be written that relies upon such a "
"convention."
msgstr ""
"Souvent, le premier argument d'une méthode est nommé ``self``. Ce n'est "
"qu'une convention : le nom ``self`` n'a aucune signification particulière en "
"Python. Notez cependant que si vous ne suivez pas cette convention, votre "
"code risque d'être moins lisible pour d'autres programmeurs Python, et il "
"est aussi possible qu'un programme qui fasse l'introspection de classes "
"repose sur une telle convention."

#: ../Doc/tutorial/classes.rst:504
msgid ""
"Any function object that is a class attribute defines a method for instances "
"of that class.  It is not necessary that the function definition is "
"textually enclosed in the class definition: assigning a function object to a "
"local variable in the class is also ok.  For example::"
msgstr ""
"Tout objet fonction qui est un attribut de classe définit une méthode pour "
"des instances de cette classe. Il n'est pas nécessaire que le texte de "
"définition de la fonction soit dans la définition de la classe : il est "
"possible d'affecter un objet fonction à une variable locale de la classe. "
"Par exemple : ::"

#: ../Doc/tutorial/classes.rst:521
msgid ""
"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer "
"to function objects, and consequently they are all methods of instances of :"
"class:`C` --- ``h`` being exactly equivalent to ``g``.  Note that this "
"practice usually only serves to confuse the reader of a program."
msgstr ""
"Maintenant, ``f``, ``g`` et ``h`` sont tous des attributs des classes :class:"
"`C` faisant référence aux fonctions objets, et par conséquent sont toutes "
"des méthodes des instances de :class:`C` --- ``h`` est exactement identique "
"à ``g``. Remarquez qu'en pratique, ceci ne sert qu'à embrouiller le lecteur "
"d'un programme."

#: ../Doc/tutorial/classes.rst:526
msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Les méthodes peuvent appeler d'autres méthodes en utilisant des méthodes qui "
"sont des attributs de l'argument ``self`` ::"

#: ../Doc/tutorial/classes.rst:540
msgid ""
"Methods may reference global names in the same way as ordinary functions.  "
"The global scope associated with a method is the module containing its "
"definition.  (A class is never used as a global scope.)  While one rarely "
"encounters a good reason for using global data in a method, there are many "
"legitimate uses of the global scope: for one thing, functions and modules "
"imported into the global scope can be used by methods, as well as functions "
"and classes defined in it.  Usually, the class containing the method is "
"itself defined in this global scope, and in the next section we'll find some "
"good reasons why a method would want to reference its own class."
msgstr ""
"Les méthodes peuvent faire référence à des noms globaux de la même manière "
"que les fonctions. La portée globale associée à une méthode est le module "
"contenant la définition de la classe (la classe elle même n'est jamais "
"utilisée en tant que portée globale). Alors qu'on rencontre rarement une "
"bonne raison d'utiliser des données globales dans une méthode, il y a de "
"nombreuses utilisations légitimes d'une portée globale : par exemple, les "
"fonctions et modules importés dans une portée globale peuvent être utilisés "
"par des méthodes, de même que les fonctions et classes définies dans cette "
"même portée. Habituellement, la classe contenant la méthode est elle même "
"définie dans cette portée globale, et dans la section suivante, nous verrons "
"de bonnes raisons pour qu'une méthode référence sa propre classe."

#: ../Doc/tutorial/classes.rst:550
msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Toute valeur est un objet, et a donc une *classe* (appelé aussi son *type*). "
"Elle est stockée dans ``objet.__class__``."

#: ../Doc/tutorial/classes.rst:557
msgid "Inheritance"
msgstr "L'héritage"

#: ../Doc/tutorial/classes.rst:559
msgid ""
"Of course, a language feature would not be worthy of the name \"class\" "
"without supporting inheritance.  The syntax for a derived class definition "
"looks like this::"
msgstr ""
"Bien sûr, ce terme de «classe» ne serait pas utilisé s'il n'y avait pas "
"l'héritage. La syntaxe pour définir une sous-classe ressemble à ceci : ::"

#: ../Doc/tutorial/classes.rst:570
msgid ""
"The name :class:`BaseClassName` must be defined in a scope containing the "
"derived class definition.  In place of a base class name, other arbitrary "
"expressions are also allowed.  This can be useful, for example, when the "
"base class is defined in another module::"
msgstr ""
"Le nom :class:`ClasseDeBase` doit être défini dans un espace contenant la "
"définition de la classe dérivée. A la place du nom d'une classe de base, une "
"expression est aussi autorisée. Ceci peut être utile, par exemple, lorsque "
"la classe est définie dans un autre module : ::"

#: ../Doc/tutorial/classes.rst:577
msgid ""
"Execution of a derived class definition proceeds the same as for a base "
"class. When the class object is constructed, the base class is remembered.  "
"This is used for resolving attribute references: if a requested attribute is "
"not found in the class, the search proceeds to look in the base class.  This "
"rule is applied recursively if the base class itself is derived from some "
"other class."
msgstr ""
"L'exécution d'une définition de classe dérivée se déroule comme pour une "
"classe de base. Quand l'objet de la classe est construit, la classe de base "
"est mémorisée. Elle est utilisée pour la résolution des références "
"d'attributs : si un attribut n'est pas trouvé dans la classe, la recherche "
"procède en regardant dans la classe de base. Cette règle est appliquée "
"récursivement si la classe de base est elle-même dérivée d'une autre classe."

#: ../Doc/tutorial/classes.rst:583
msgid ""
"There's nothing special about instantiation of derived classes: "
"``DerivedClassName()`` creates a new instance of the class.  Method "
"references are resolved as follows: the corresponding class attribute is "
"searched, descending down the chain of base classes if necessary, and the "
"method reference is valid if this yields a function object."
msgstr ""
"Il n'y a rien de particulier dans l'instantiation des classes dérivées : "
"``DerivedClassName()`` crée une nouvelle instance de la classe. Les "
"références aux méthodes sont résolues comme suit : l'attribut correspondant "
"de la classe est recherché, en remontant la hiérarchie des classes de base "
"si nécessaire, et la référence de méthode est valide si cela conduit à une "
"fonction."

#: ../Doc/tutorial/classes.rst:589
msgid ""
"Derived classes may override methods of their base classes.  Because methods "
"have no special privileges when calling other methods of the same object, a "
"method of a base class that calls another method defined in the same base "
"class may end up calling a method of a derived class that overrides it.  "
"(For C++ programmers: all methods in Python are effectively ``virtual``.)"
msgstr ""
"Les classes dérivées peuvent surcharger des méthodes de leurs classes de "
"base. Comme les méthodes n'ont aucun privilège particulier quand elles "
"appellent d'autres méthodes d'un même objet, une méthode d'une classe de "
"base qui appelle une autre méthode définie dans la même classe peut en fait "
"appeler une méthode d'une classe dérivée qui la surcharge (pour les "
"programmeurs C++ : toutes les méthodes de Python sont en effet ``virtual``)."

#: ../Doc/tutorial/classes.rst:595
msgid ""
"An overriding method in a derived class may in fact want to extend rather "
"than simply replace the base class method of the same name. There is a "
"simple way to call the base class method directly: just call ``BaseClassName."
"methodname(self, arguments)``.  This is occasionally useful to clients as "
"well.  (Note that this only works if the base class is accessible as "
"``BaseClassName`` in the global scope.)"
msgstr ""
"Une méthode surchargée dans une classe dérivée peut en fait vouloir étendre "
"plutôt que simplement remplacer la méthode du même nom de sa classe de base. "
"Il y a une façon simple d'appeler la méthode de la classe de base "
"directement : appelez simplement ``BaseClassName.methodname(self, "
"arguments)``. Ceci est parfois utile également aux clients (notez bien que "
"ceci ne fonctionne que si la classe de base est accessible en tant que "
"``ClasseDeBase`` dans la portée globale)."

#: ../Doc/tutorial/classes.rst:602
msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python a deux fonctions primitives qui gèrent l'héritage :"

#: ../Doc/tutorial/classes.rst:604
msgid ""
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
"derived from :class:`int`."
msgstr ""
"Utilisez :func:`isinstance` pour tester le type d'une instance : "
"``isinstance(obj, int)`` renverra ``True`` seulement si ``obj.__class__`` "
"est égal à :class:`int` ou à une autre classe dérivée de :class:`int`."

#: ../Doc/tutorial/classes.rst:608
msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
"is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
"subclass of :class:`int`."
msgstr ""
"Utilisez :func:`issubclass` pour tester l'héritage d'une class : "
"``issubclass(bool, int)`` renvoie ``True`` car la class :class:`bool` est "
"une sous-classe de :class:`int`. Par contre, ``issubclass(float, int)`` "
"renvoie ``False`` car :class:`float` n'est pas une sous-classe de :class:"
"`int`."

#: ../Doc/tutorial/classes.rst:618
msgid "Multiple Inheritance"
msgstr "L'héritage multiple"

#: ../Doc/tutorial/classes.rst:620
msgid ""
"Python supports a form of multiple inheritance as well.  A class definition "
"with multiple base classes looks like this::"
msgstr ""
"Python gère également une forme d'héritage multiple. Une définition de "
"classe ayant plusieurs classes de base ressemble à : ::"

#: ../Doc/tutorial/classes.rst:630
msgid ""
"For most purposes, in the simplest cases, you can think of the search for "
"attributes inherited from a parent class as depth-first, left-to-right, not "
"searching twice in the same class where there is an overlap in the "
"hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, "
"it is searched for in :class:`Base1`, then (recursively) in the base classes "
"of :class:`Base1`, and if it was not found there, it was searched for in :"
"class:`Base2`, and so on."
msgstr ""
"Dans la plupart des cas, vous pouvez imaginer la recherche d'attributs dans "
"les classes parentes comme étant : le plus profond d'abord, de gauche à "
"droite, sans chercher deux fois dans la même classe si elle apparaît "
"plusieurs fois dans la hiérarchie. Ainsi, si un attribut n'est pas trouvé "
"dans :class:`DerivedClassName`, il est recherché dans :class:`Base1`, puis "
"(récursivement) dans les classes de base de :class:`Base1` ; s'il n'y est "
"pas trouvé, il est recherché dans :class:`Base2` et ses classes de base, et "
"ainsi de suite."

#: ../Doc/tutorial/classes.rst:637
msgid ""
"In fact, it is slightly more complex than that; the method resolution order "
"changes dynamically to support cooperative calls to :func:`super`.  This "
"approach is known in some other multiple-inheritance languages as call-next-"
"method and is more powerful than the super call found in single-inheritance "
"languages."
msgstr ""
"Dans les faits, c'est un peu plus complexe que ça, l'ordre de la recherche "
"(method resolution order, ou MRO) change dynamiquement pour gérer des appels "
"coopératifs à :func:`super`. Cette approche est connue sous le nom de la "
"\"méthode la plus proche\" (\"call-next-method\") dans d'autres langages "
"supportant l'héritage multiple, et est plus puissante que l'appel à super "
"trouve dans les langages à héritage simple."

#: ../Doc/tutorial/classes.rst:643
msgid ""
"Dynamic ordering is necessary because all cases of multiple inheritance "
"exhibit one or more diamond relationships (where at least one of the parent "
"classes can be accessed through multiple paths from the bottommost class).  "
"For example, all classes inherit from :class:`object`, so any case of "
"multiple inheritance provides more than one path to reach :class:`object`.  "
"To keep the base classes from being accessed more than once, the dynamic "
"algorithm linearizes the search order in a way that preserves the left-to-"
"right ordering specified in each class, that calls each parent only once, "
"and that is monotonic (meaning that a class can be subclassed without "
"affecting the precedence order of its parents). Taken together, these "
"properties make it possible to design reliable and extensible classes with "
"multiple inheritance.  For more detail, see https://www.python.org/download/"
"releases/2.3/mro/."
msgstr ""
"L'ordre défini dynamiquement est nécessaire car tous les cas d'héritage "
"multiple comportent une ou plusieurs relations en losange (où au moins une "
"classe peut être accédée à partir de plusieurs chemins en pariant de la "
"classe la plus base). Par exemple, puisque toutes les classes héritent de :"
"class:`object`, tout héritage multiple ouvre plusieurs chemins pour "
"atteindre :class:`object`. Pour qu'une classe de base ne soit pas appelée "
"plusieurs fois, l'algorithme dynamique linéarise l'ordre de recherche d'une "
"façon qui préserve l'ordre d'héritage, de lagauche vers la droite, spécifié "
"dans chaque classe, qui appelle chaque classe parente une seule fois, qui "
"est monotone (ce qui signifie qu'une classe peut être sous-classée sans "
"affecter l'ordre d'héritage de ses parents). Prises ensemble, ces propriétés "
"permettent de concevoir des classes de façon fiable et extensible dans un "
"contexte d'héritage multiple. Pour plus de détail, consultez http://www."
"python.org/download/releases/2.3/mro/."

#: ../Doc/tutorial/classes.rst:660
msgid "Private Variables"
msgstr "Variables privées"

#: ../Doc/tutorial/classes.rst:662
msgid ""
"\"Private\" instance variables that cannot be accessed except from inside an "
"object don't exist in Python.  However, there is a convention that is "
"followed by most Python code: a name prefixed with an underscore (e.g. "
"``_spam``) should be treated as a non-public part of the API (whether it is "
"a function, a method or a data member).  It should be considered an "
"implementation detail and subject to change without notice."
msgstr ""
"Les membres \"privés\", qui ne peuvent être accédés en dehors d'un objet, "
"n'existent pas en Python. Toutefois, il existe une convention respectée par "
"la majorité du code Python : un nom préfixé par un tiret bas (comme "
"``_spam``) doit être vu comme une partie non publique de l'API (qu'il "
"s'agisse d'une fonction, d'une méthode ou d'une variable membre). Il doit "
"être considéré comme un détail d'implémentation pouvant faire l'objet de "
"modification futures sans préavis."

#: ../Doc/tutorial/classes.rst:669
msgid ""
"Since there is a valid use-case for class-private members (namely to avoid "
"name clashes of names with names defined by subclasses), there is limited "
"support for such a mechanism, called :dfn:`name mangling`.  Any identifier "
"of the form ``__spam`` (at least two leading underscores, at most one "
"trailing underscore) is textually replaced with ``_classname__spam``, where "
"``classname`` is the current class name with leading underscore(s) "
"stripped.  This mangling is done without regard to the syntactic position of "
"the identifier, as long as it occurs within the definition of a class."
msgstr ""
"Dès lors qu'il y a un cas d'utilisation valable pour avoir des membres "
"privés (notamment pour éviter des conflits avec des noms définis dans des "
"sous-classes), il existe un support (certes limité) pour un tel mécanisme, "
"appelé :dfn:`name mangling`. Tout identifiant sous la forme ``__spam`` (avec "
"au moins deux underscores en tête, et au plus un à la fin) est remplacé "
"textuellement par ``_classname__spam``, où ``classname`` est le nom de la "
"classe sans le(s) premier(s) underscore(s). Ce \"bricolage\" est effectué "
"sans tenir compte de la position syntaxique de l'identifiant, tant qu'il est "
"présent dans la définition d'une classe."

#: ../Doc/tutorial/classes.rst:678
msgid ""
"Name mangling is helpful for letting subclasses override methods without "
"breaking intraclass method calls.  For example::"
msgstr ""
"Ce changement de nom est utile pour permettre à des sous-classes de "
"surcharger des méthodes sans interrompre les appels de méthodes intra-"
"classes. Par exemple : ::"

#: ../Doc/tutorial/classes.rst:700
msgid ""
"Note that the mangling rules are designed mostly to avoid accidents; it "
"still is possible to access or modify a variable that is considered "
"private.  This can even be useful in special circumstances, such as in the "
"debugger."
msgstr ""
"Notez que ces règles sont conçues avant tout pour éviter les accidents ; il "
"reste possible d'accéder ou de modifier une variable considérée comme "
"privée. Ceci peut même être utile dans certaines circonstances, comme au "
"sein du débogueur."

#: ../Doc/tutorial/classes.rst:704
msgid ""
"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "
"classname of the invoking class to be the current class; this is similar to "
"the effect of the ``global`` statement, the effect of which is likewise "
"restricted to code that is byte-compiled together.  The same restriction "
"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "
"referencing ``__dict__`` directly."
msgstr ""
"Notez que le code passé à ``exec()``, ``eval()`` ne considère pas le nom de "
"la classe appelante comme étant la classe courante ; le même effet "
"s'applique à la directive ``global``, dont l'effet est de la même façon "
"restreint au code compilé dans le même ensemble de byte-code. Les mêmes "
"restrictions s'appliquent à ``getattr()``, ``setattr()`` et ``delattr()``, "
"ainsi qu'aux références directes à ``__dict__``."

#: ../Doc/tutorial/classes.rst:715
msgid "Odds and Ends"
msgstr "Trucs et astuces"

#: ../Doc/tutorial/classes.rst:717
msgid ""
"Sometimes it is useful to have a data type similar to the Pascal \"record\" "
"or C \"struct\", bundling together a few named data items.  An empty class "
"definition will do nicely::"
msgstr ""
"Il est parfois utile d'avoir un type de donnée similaire au \"record\" du "
"Pascal ou au \"struct\" du C, qui regroupent ensemble quelques attributs "
"nommés. La définition d'une classe vide remplit parfaitement ce besoin : ::"

#: ../Doc/tutorial/classes.rst:731
msgid ""
"A piece of Python code that expects a particular abstract data type can "
"often be passed a class that emulates the methods of that data type "
"instead.  For instance, if you have a function that formats some data from a "
"file object, you can define a class with methods :meth:`read` and :meth:`!"
"readline` that get the data from a string buffer instead, and pass it as an "
"argument."
msgstr ""
"On peut souvent fournir, à du code Python qui s'attend à recevoir un type de "
"donnée abstrait spécifique, une classe qui simule les méthodes de ce type. "
"Par exemple, si vous avez une fonction qui formate des données extraites "
"d'un objet fichier, vous pouvez définir une classe avec des méthodes :meth:"
"`read` et :meth:`!readline` qui extrait ses données d'un tampon de chaînes "
"de caractères à la place, et lui passer une instance comme argument."

#: ../Doc/tutorial/classes.rst:742
msgid ""
"Instance method objects have attributes, too: ``m.__self__`` is the instance "
"object with the method :meth:`m`, and ``m.__func__`` is the function object "
"corresponding to the method."
msgstr ""
"Les objets méthodes d'instances ont également des attributs : ``m.im_self`` "
"est l'instance d'objet avec la méthode :meth:`m`, et ``m.im_func`` est "
"l'objet fonction correspondant à la méthode."

#: ../Doc/tutorial/classes.rst:750
msgid "Exceptions Are Classes Too"
msgstr "Les exceptions sont aussi des classes"

#: ../Doc/tutorial/classes.rst:752
msgid ""
"User-defined exceptions are identified by classes as well.  Using this "
"mechanism it is possible to create extensible hierarchies of exceptions."
msgstr ""
"Les exceptions définies par l'utilisateur sont également définies par des "
"classes. En utilisant ce mécanisme, il est possible de créer des hiérarchies "
"d'exceptions extensibles."

#: ../Doc/tutorial/classes.rst:755
msgid ""
"There are two new valid (semantic) forms for the :keyword:`raise` statement::"
msgstr ""
"Il y a deux nouvelles formes (sémantiques) pour l'instruction :keyword:"
"`raise` ::"

#: ../Doc/tutorial/classes.rst:761
msgid ""
"In the first form, ``Class`` must be an instance of :class:`type` or of a "
"class derived from it.  The first form is a shorthand for::"
msgstr ""
"Dans la première forme, ``Class`` doit être une instance de :class:`type` ou "
"d'une classe dérivée. La seconde forme est un raccourci pour : ::"

#: ../Doc/tutorial/classes.rst:766
msgid ""
"A class in an :keyword:`except` clause is compatible with an exception if it "
"is the same class or a base class thereof (but not the other way around --- "
"an except clause listing a derived class is not compatible with a base "
"class).  For example, the following code will print B, C, D in that order::"
msgstr ""
"Une classe dans une clause :keyword:`except` est compatible avec une "
"exception si elle est de la même classe ou d'une de ses classes dérivées "
"(mais l'inverse n'est pas vrai --- une clause except spécifiant une classe "
"dérivée n'est pas compatible avec une classe de base.) Par exemple, le code "
"suivant imprimera B, C et D dans cet ordre : ::"

#: ../Doc/tutorial/classes.rst:788
msgid ""
"Note that if the except clauses were reversed (with ``except B`` first), it "
"would have printed B, B, B --- the first matching except clause is triggered."
msgstr ""
"Notez que si les clauses except avaient été inversées (avec ``except B`` en "
"premier), il aurait imprimé B, B, B --- la première clause except "
"correspondante étant déclenchée."

#: ../Doc/tutorial/classes.rst:791
msgid ""
"When an error message is printed for an unhandled exception, the exception's "
"class name is printed, then a colon and a space, and finally the instance "
"converted to a string using the built-in function :func:`str`."
msgstr ""
"Quand un message d'erreur est imprimé pour une exception non traitée, la "
"classe de l'exception est indiquée, suivie de deux points, d'un espace et de "
"l'instance convertie en chaîne de caractères via la fonction :func:`str`."

#: ../Doc/tutorial/classes.rst:799
msgid "Iterators"
msgstr "Itérateurs"

#: ../Doc/tutorial/classes.rst:801
msgid ""
"By now you have probably noticed that most container objects can be looped "
"over using a :keyword:`for` statement::"
msgstr ""
"Vous avez maintenant certainement remarqué que l'on peut itérer sur la "
"plupart des objets conteneurs en utilisant une instruction :keyword:`for` ::"

#: ../Doc/tutorial/classes.rst:815
msgid ""
"This style of access is clear, concise, and convenient.  The use of "
"iterators pervades and unifies Python.  Behind the scenes, the :keyword:"
"`for` statement calls :func:`iter` on the container object.  The function "
"returns an iterator object that defines the method :meth:`~iterator."
"__next__` which accesses elements in the container one at a time.  When "
"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
"`StopIteration` exception which tells the :keyword:`for` loop to terminate.  "
"You can call the :meth:`~iterator.__next__` method using the :func:`next` "
"built-in function; this example shows how it all works::"
msgstr ""
"Ce mode d'accès est simple, concis et pratique. L'utilisation d'itérateurs "
"imprègne et unifie Python. En arrière plan, l'instruction :keyword:`for` "
"appelle la fonction :func:`iter` sur l'objet conteneur. Cette fonction "
"renvoie un itérateur qui définit la méthode :meth:`~iterator.__next__`, "
"laquelle accèdeaux éléments du conteneur un par un. Lorsqu'il n'y a plus "
"d'élément, :meth:`~iterator.__next__` lève une exception :exc:"
"`StopIteration` qui indique à la boucle de l'instruction :keyword:`for` de "
"se terminer. Vous pouvez appeller la méthode :meth:`~iterator.__next__` en "
"utilisant la fonction native :func:`next`. Cet exemple montre comment tout "
"cela fonctionne::"

#: ../Doc/tutorial/classes.rst:840
msgid ""
"Having seen the mechanics behind the iterator protocol, it is easy to add "
"iterator behavior to your classes.  Define an :meth:`__iter__` method which "
"returns an object with a :meth:`~iterator.__next__` method.  If the class "
"defines :meth:`__next__`, then :meth:`__iter__` can just return ``self``::"
msgstr ""
"Une fois compris les mécanismes de gestion des itérateurs, il est simple "
"d'ajouter ce comportement à vos classes. Définissez une méthode :meth:"
"`__iter__`, qui retourne un objet disposant d'une méthode :meth:`~iterator."
"__next__`. Sila classe définit elle-même la méthode :meth:`__next__`, alors :"
"meth:`__iter__` peut simplement renvoyer ``self`` ::"

#: ../Doc/tutorial/classes.rst:877
msgid "Generators"
msgstr "Générateurs"

#: ../Doc/tutorial/classes.rst:879
msgid ""
":term:`Generator`\\s are a simple and powerful tool for creating iterators.  "
"They are written like regular functions but use the :keyword:`yield` "
"statement whenever they want to return data.  Each time :func:`next` is "
"called on it, the generator resumes where it left off (it remembers all the "
"data values and which statement was last executed).  An example shows that "
"generators can be trivially easy to create::"
msgstr ""
"Les :term:`générateur`\\s sont des outils simples et puissants pour créer "
"des itérateurs. Ils sont écrits comme des fonctions classiques mais "
"utilisent l'instruction :keyword:`yield` lorsqu'ils veulent renvoyer des "
"données. À chaque fois que :func:`next` est appelée, le générateur reprend "
"son exécution là où il s'était arrété (en conservant tout son contexte "
"d'exécution). Un exemple montre très bien combien les générateurs sont "
"simples à créer : ::"

#: ../Doc/tutorial/classes.rst:900
msgid ""
"Anything that can be done with generators can also be done with class-based "
"iterators as described in the previous section.  What makes generators so "
"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods "
"are created automatically."
msgstr ""
"Tout ce qui peut être fait avec des générateurs peut également être fait "
"avec des itérateurs basés sur des classes, comme décrit dans le paragraphe "
"précédent. Si qui fait que les générateurs sont si compacts est que les "
"méthodes :meth:`__iter__` et :meth:`~generator.__next__` sont créées "
"automatiquement."

#: ../Doc/tutorial/classes.rst:905
msgid ""
"Another key feature is that the local variables and execution state are "
"automatically saved between calls.  This made the function easier to write "
"and much more clear than an approach using instance variables like ``self."
"index`` and ``self.data``."
msgstr ""
"Une autre fonctionnalité clé est que les variables locales ainsi que le "
"contexte d'exécution sont sauvegardés automatiquement entre les appels. Cela "
"simplifie d'autant plus l'écriture de ces fonctions, et rend leur code "
"beaucoup plus lisible qu'avec une approche utilisant des variables "
"d'instance telles que ``self.index`` et ``self.data``."

#: ../Doc/tutorial/classes.rst:910
msgid ""
"In addition to automatic method creation and saving program state, when "
"generators terminate, they automatically raise :exc:`StopIteration`. In "
"combination, these features make it easy to create iterators with no more "
"effort than writing a regular function."
msgstr ""
"En plus de la création automatique de méthodes et de la sauvegarde du "
"contexte d'exécution, les générateurs lèvent automatiquement une exception :"
"exc:`StopIteration` lorsqu'ils terminent leur exécution. Combinées, ces "
"fonctionnalités rendent très simple la création d'itérateurs sans plus "
"d'effort que l'écriture d'une fonction classique."

#: ../Doc/tutorial/classes.rst:919
msgid "Generator Expressions"
msgstr "Expressions et générateurs"

#: ../Doc/tutorial/classes.rst:921
msgid ""
"Some simple generators can be coded succinctly as expressions using a syntax "
"similar to list comprehensions but with parentheses instead of brackets.  "
"These expressions are designed for situations where the generator is used "
"right away by an enclosing function.  Generator expressions are more compact "
"but less versatile than full generator definitions and tend to be more "
"memory friendly than equivalent list comprehensions."
msgstr ""
"Des générateurs simples peuvent être codés très rapidement avec des "
"expressions utilisant la même syntaxe que les compréhensions de listes, mais "
"en utilisant des parenthèses à la place des crochets. Ces expressions sont "
"conçues pour des situations où le générateur est utilisé tout de suite dans "
"une fonction. Ces expressions sont plus compactes mais moins souples que des "
"définitions complètes de générateurs, et ont tendance à être plus économes "
"en mémoire que leur équivalent en compréhension de listes."

#: ../Doc/tutorial/classes.rst:928
msgid "Examples::"
msgstr "Exemples : ::"

#: ../Doc/tutorial/classes.rst:953
msgid ""
"Except for one thing.  Module objects have a secret read-only attribute "
"called :attr:`~object.__dict__` which returns the dictionary used to "
"implement the module's namespace; the name :attr:`~object.__dict__` is an "
"attribute but not a global name. Obviously, using this violates the "
"abstraction of namespace implementation, and should be restricted to things "
"like post-mortem debuggers."
msgstr ""

#: ../Doc/tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
msgstr "D'autres outils de contrôle de flux"

#: ../Doc/tutorial/controlflow.rst:7
msgid ""
"Besides the :keyword:`while` statement just introduced, Python knows the "
"usual control flow statements known from other languages, with some twists."
msgstr ""
"En plus de l'instruction :keyword:`while` qui vient d'être présentée, Python "
"dispose des instructions de contrôle de flux classiques que l'on trouve dans "
"d'autres langages, mais toujours avec ses propres tournures."

#: ../Doc/tutorial/controlflow.rst:14
msgid ":keyword:`if` Statements"
msgstr "L'instruction :keyword:`if`"

#: ../Doc/tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
msgstr ""
"L'instruction :keyword:`if` est sans doute la plus connue. Par exemple : ::"

#: ../Doc/tutorial/controlflow.rst:33
msgid ""
"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "
"part is optional.  The keyword ':keyword:`elif`' is short for 'else if', and "
"is useful to avoid excessive indentation.  An  :keyword:`if` ... :keyword:"
"`elif` ... :keyword:`elif` ... sequence is a substitute for the ``switch`` "
"or ``case`` statements found in other languages."
msgstr ""
"Il peut y avoir un nombre quelconque de parties :keyword:`elif`, et la "
"partie :keyword:`else` est facultative. Le mot clé ':keyword:`elif`' est un "
"raccourci pour 'else if', mais permet de gagner un niveau d'indentation. Une "
"séquence :keyword:`if` ... :keyword:`elif` ... :keyword:`elif` ... est par "
"ailleurs équivalente aux instructions ``switch`` ou ``case`` disponibles "
"dans d'autres langages."

#: ../Doc/tutorial/controlflow.rst:43
msgid ":keyword:`for` Statements"
msgstr "L'instruction :keyword:`for`"

#: ../Doc/tutorial/controlflow.rst:48
msgid ""
"The :keyword:`for` statement in Python differs a bit from what you may be "
"used to in C or Pascal.  Rather than always iterating over an arithmetic "
"progression of numbers (like in Pascal), or giving the user the ability to "
"define both the iteration step and halting condition (as C), Python's :"
"keyword:`for` statement iterates over the items of any sequence (a list or a "
"string), in the order that they appear in the sequence.  For example (no pun "
"intended):"
msgstr ""
"L'instruction :keyword:`for` que propose Python est un peu différente de "
"celle que l'on peut trouver en C ou en Pascal. Au lieu de toujours itérer "
"sur une suite arithmétique de nombres (comme en Pascal), ou de donner à "
"l'utilisateur la possibilité de définir le pas d'itération et la condition "
"de fin (comme en C), l'instruction :keyword:`for` en Python itère sur les "
"éléments d'une séquence (qui peut être une liste, une chaîne de "
"caractères...), dans l'ordre dans lequel ils apparaissent dans la séquence. "
"Par exemple (sans jeu de mots) :"

#: ../Doc/tutorial/controlflow.rst:69
msgid ""
"If you need to modify the sequence you are iterating over while inside the "
"loop (for example to duplicate selected items), it is recommended that you "
"first make a copy.  Iterating over a sequence does not implicitly make a "
"copy.  The slice notation makes this especially convenient::"
msgstr ""
"Si vous devez modifier la séquence sur laquelle s'effectue l'itération à "
"l'intérieur de la boucle (par exemple pour dupliquer ou supprimer un "
"élément), il est plus que recommandé de commencer par en faire une copie, "
"celle-ci n'étant pas implicite. La notation \"par tranches\" rend cette "
"opération particulièrement simple : ::"

#: ../Doc/tutorial/controlflow.rst:81
msgid ""
"With ``for w in words:``, the example would attempt to create an infinite "
"list, inserting ``defenestrate`` over and over again."
msgstr ""

#: ../Doc/tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
msgstr "La fonction :func:`range`"

#: ../Doc/tutorial/controlflow.rst:90
msgid ""
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy.  It generates arithmetic progressions::"
msgstr ""
"Si vous devez itérer sur une suite de nombres, la fonction intégrée :func:"
"`range` est faite pour cela. Elle génère des suites arithmétiques : :"

#: ../Doc/tutorial/controlflow.rst:102
msgid ""
"The given end point is never part of the generated sequence; ``range(10)`` "
"generates 10 values, the legal indices for items of a sequence of length "
"10.  It is possible to let the range start at another number, or to specify "
"a different increment (even negative; sometimes this is called the 'step')::"
msgstr ""
"Le dernier élément fourni en paramètre ne fait jamais partie de la liste "
"générée ; ``range(10)`` génère une liste de 10 valeurs, dont les valeurs "
"vont de 0 à 9. Il est possible de spécifier une valeur de début et/ou une "
"valeur d'incrément différente(s) (y compris négative pour cette dernière, "
"que l'on appelle également parfois le 'pas') ::"

#: ../Doc/tutorial/controlflow.rst:116
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr ""
"Pour itérer sur les indices d'une séquence, on peut combiner les fonctions :"
"func:`range` et :func:`len` ::"

#: ../Doc/tutorial/controlflow.rst:129
msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr ""
"Cependant, dans la plupart des cas, il est plus pratique d'utiliser la "
"fonction :func:`enumerate`. Voyez pour cela :ref:`tut-loopidioms`."

#: ../Doc/tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
msgstr "Une chose étrange se produit lorsqu'on affiche un range : :"

#: ../Doc/tutorial/controlflow.rst:137
msgid ""
"In many ways the object returned by :func:`range` behaves as if it is a "
"list, but in fact it isn't. It is an object which returns the successive "
"items of the desired sequence when you iterate over it, but it doesn't "
"really make the list, thus saving space."
msgstr ""
"Les objets données par :func:`range` se comportent presque comme des listes, "
"mais n'en sont pas. Ce sont des objets qui génèrent les éléments de la "
"séquence au fur et à mesure de leur itération, économisant ainsi de l'espace."

#: ../Doc/tutorial/controlflow.rst:142
msgid ""
"We say such an object is *iterable*, that is, suitable as a target for "
"functions and constructs that expect something from which they can obtain "
"successive items until the supply is exhausted. We have seen that the :"
"keyword:`for` statement is such an *iterator*. The function :func:`list` is "
"another; it creates lists from iterables::"
msgstr ""
"On appelle de tels objets des *iterables*, c'est à dire des objets qui "
"conviennent à des *iterateurs*, des fonctions ou constructions qui "
"s'attendent à quelque-chose duquel ils peuvent tirer des éléments, "
"successives successivement, jusqu'à épuisement. On a vu que l'instruction :"
"keyword:`for` est un iterateur. La fonction :func:`list` en est un autre, "
"qui créé des listes à partir d'iterables : ::"

#: ../Doc/tutorial/controlflow.rst:152
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"argument."
msgstr ""
"Plus loin nous verrons d'autre fonctions qui donnent des iterables ou en "
"prennent en paramètre."

#: ../Doc/tutorial/controlflow.rst:158
msgid ""
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
"Clauses on Loops"
msgstr ""
"Les instructions :keyword:`break` et :keyword:`continue`, et les clauses :"
"keyword:`else` au sein des boucles"

#: ../Doc/tutorial/controlflow.rst:160
msgid ""
"The :keyword:`break` statement, like in C, breaks out of the smallest "
"enclosing :keyword:`for` or :keyword:`while` loop."
msgstr ""
"L'instruction :keyword:`break`, comme en C, interrompt la boucle :keyword:"
"`for` ou :keyword:`while` la plus imbriquée."

#: ../Doc/tutorial/controlflow.rst:163
msgid ""
"Loop statements may have an ``else`` clause; it is executed when the loop "
"terminates through exhaustion of the list (with :keyword:`for`) or when the "
"condition becomes false (with :keyword:`while`), but not when the loop is "
"terminated by a :keyword:`break` statement.  This is exemplified by the "
"following loop, which searches for prime numbers::"
msgstr ""
"Les boucles peuvent également disposer d'une instruction ``else`` ; celle-ci "
"est exécutée lorsqu'une boucle se termine alors que tous ses éléments ont "
"été traités (dans le cas d'un :keyword:`for`) ou que la condition devient "
"fausse (dans le cas d'un :keyword:`while`), mais pas lorsque la boucle est "
"interrompue par une instruction :keyword:`break`. L'exemple suivant, qui "
"effectue une recherche de nombres premiers, en est une démonstration : ::"

#: ../Doc/tutorial/controlflow.rst:187
msgid ""
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
msgstr ""
"(Oui, ce code est correct. Regardez attentivement : l'instruction ``else`` "
"est rattachée à la boucle :keyword:`for`, et **non** à l'instruction :"
"keyword:`if`.)"

#: ../Doc/tutorial/controlflow.rst:190
msgid ""
"When used with a loop, the ``else`` clause has more in common with the "
"``else`` clause of a :keyword:`try` statement than it does that of :keyword:"
"`if` statements: a :keyword:`try` statement's ``else`` clause runs when no "
"exception occurs, and a loop's ``else`` clause runs when no ``break`` "
"occurs. For more on the :keyword:`try` statement and exceptions, see :ref:"
"`tut-handling`."
msgstr ""
"Lorsqu'elle utilisée dans une boucle, la clause ``else`` est donc plus "
"proche de celle associée à une instruction :keyword:`try` que de celle "
"associée à une instruction :keyword:`if` : la clause ``else`` d'une "
"instruction :keyword:`try` s'exécute lorsqu'aucune exception n'est "
"déclenchée, et celle d'une boucle lorsque aucun ``break`` n'intervient. Plus "
"plus d'informations sur l'instruction :keyword:`try` et le traitement des "
"exceptions, consultez :ref:`tut-handling`."

#: ../Doc/tutorial/controlflow.rst:197
msgid ""
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
msgstr ""
"L'instruction :keyword:`continue`, également empruntée au C, fait passer la "
"boucle à son itération suivante : ::"

#: ../Doc/tutorial/controlflow.rst:217
msgid ":keyword:`pass` Statements"
msgstr "L'instruction :keyword:`pass`"

#: ../Doc/tutorial/controlflow.rst:219
msgid ""
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
msgstr ""
"L'instruction :keyword:`pass` ne fait rien. Elle peut être utilisée "
"lorsqu'une instruction est nécessaire pour fournir une syntaxe correcte, "
"mais qu'aucune action ne doit être effectuée. Par exemple : ::"

#: ../Doc/tutorial/controlflow.rst:226
msgid "This is commonly used for creating minimal classes::"
msgstr ""
"On utilise couramment cette instruction pour créer des classes minimales : ::"

#: ../Doc/tutorial/controlflow.rst:232
msgid ""
"Another place :keyword:`pass` can be used is as a place-holder for a "
"function or conditional body when you are working on new code, allowing you "
"to keep thinking at a more abstract level.  The :keyword:`pass` is silently "
"ignored::"
msgstr ""
"Un autre cas d'utilisation du :keyword:`pass` est de réserver un espace en "
"phase de développement pour une fonction ou un traitement conditionnel, vous "
"permettant ainsi de construire votre code à un niveau plus abstrait. "
"L'instruction :keyword:`pass` est alors ignorée silencieusement : ::"

#: ../Doc/tutorial/controlflow.rst:243
msgid "Defining Functions"
msgstr "Définir des fonctions"

#: ../Doc/tutorial/controlflow.rst:245
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr ""
"On peut créer une fonction qui écrit la suite de Fibonacci jusqu'à une "
"limite imposée : ::"

#: ../Doc/tutorial/controlflow.rst:265
msgid ""
"The keyword :keyword:`def` introduces a function *definition*.  It must be "
"followed by the function name and the parenthesized list of formal "
"parameters. The statements that form the body of the function start at the "
"next line, and must be indented."
msgstr ""
"Le mot-clé :keyword:`def` introduit une *définition* de fonction. Il doit "
"être suivi du nom de la fonction et d'une liste entre parenthèses de ses "
"paramètres. L'instruction qui constitue le corps de la fonction débute à la "
"ligne suivante, et doit être indentée."

#: ../Doc/tutorial/controlflow.rst:270
msgid ""
"The first statement of the function body can optionally be a string literal; "
"this string literal is the function's documentation string, or :dfn:"
"`docstring`. (More about docstrings can be found in the section :ref:`tut-"
"docstrings`.) There are tools which use docstrings to automatically produce "
"online or printed documentation, or to let the user interactively browse "
"through code; it's good practice to include docstrings in code that you "
"write, so make a habit of it."
msgstr ""
"La première instruction d'une fonction peut, de façon facultative, être une "
"chaîne de caractères littérale ; cette chaîne de caractères sera alors la "
"chaîne de documentation de la fonction, ou :dfn:`docstring` (consultez la "
"section :ref:`tut-docstrings` pour en savoir plus). Il existe des outils qui "
"utilisent ces chaînes de documentation pour générer automatiquement une "
"documentation en ligne ou imprimée, ou pour permettre à l'utilisateur de "
"naviguer de façon interactive dans le code ; prenez-en l'habitude, c'est une "
"bonne habitude que de documenter le code que vous écrivez !"

#: ../Doc/tutorial/controlflow.rst:277
msgid ""
"The *execution* of a function introduces a new symbol table used for the "
"local variables of the function.  More precisely, all variable assignments "
"in a function store the value in the local symbol table; whereas variable "
"references first look in the local symbol table, then in the local symbol "
"tables of enclosing functions, then in the global symbol table, and finally "
"in the table of built-in names. Thus, global variables cannot be directly "
"assigned a value within a function (unless named in a :keyword:`global` "
"statement), although they may be referenced."
msgstr ""
"*L'exécution* d'une fonction introduit une nouvelle table de symboles "
"utilisée par les variables locales de la fonction. Plus précisément, toutes "
"les affectations de variables effectuées au sein d'une fonction stockent la "
"valeur dans la table de symboles locale ; tandis que les références de "
"variables sont recherchées dans la table de symboles locale, puis dans la "
"table de symboles locale des fonctions englobantes, puis dans la table de "
"symboles globale et finallement dans la table de noms des primitives. Par "
"conséquent, il est impossible d'affecter une valeur à une variable globale "
"(sauf en utilisant une instruction :keyword:`global`), bien qu'elles "
"puissent être référencées."

#: ../Doc/tutorial/controlflow.rst:286
msgid ""
"The actual parameters (arguments) to a function call are introduced in the "
"local symbol table of the called function when it is called; thus, arguments "
"are passed using *call by value* (where the *value* is always an object "
"*reference*, not the value of the object). [#]_ When a function calls "
"another function, a new local symbol table is created for that call."
msgstr ""
"Les paramètres effectifs (arguments) d'une fonction sont introduits dans la "
"table de symboles locale de la fonction appelée lorsqu'elle est appelée ; "
"par conséquent, les passages de paramètres se font *par valeur*, la *valeur* "
"étant toujours une *référence* à un objet, et non la valeur de l'objet lui-"
"même. [#]_ Lorsqu'une fonction appelle une autre fonction, une nouvelle "
"table de symboles locale est créée pour cet appel."

#: ../Doc/tutorial/controlflow.rst:292
msgid ""
"A function definition introduces the function name in the current symbol "
"table. The value of the function name has a type that is recognized by the "
"interpreter as a user-defined function.  This value can be assigned to "
"another name which can then also be used as a function.  This serves as a "
"general renaming mechanism::"
msgstr ""
"Une définition de fonction introduit le nom de la fonction dans la table de "
"symboles courante. La valeur du nom de la fonction est un type qui est "
"reconnu par l'interpréteur comme une fonction utilisateur. Cette valeur peut "
"être affectée à un autre nom qui pourra alors être utilisé également comme "
"une fonction. Ceci fournit un mécanisme de renommage général : ::"

#: ../Doc/tutorial/controlflow.rst:304
msgid ""
"Coming from other languages, you might object that ``fib`` is not a function "
"but a procedure since it doesn't return a value.  In fact, even functions "
"without a :keyword:`return` statement do return a value, albeit a rather "
"boring one.  This value is called ``None`` (it's a built-in name).  Writing "
"the value ``None`` is normally suppressed by the interpreter if it would be "
"the only value written. You can see it if you really want to using :func:"
"`print`::"
msgstr ""
"Si vous venez d'autres langages, vous pouvez penser que ``fib`` n'est pas "
"une fonction mais une procédure, puisqu'elle ne renvoie pas de résultat. En "
"fait, même les fonctions sans instruction :keyword:`return` renvoient une "
"valeur, quoique ennuyeuse. Cette valeur est appelée ``None`` (c'est le nom "
"d'une primitive). Écrire la valeur ``None`` est normalement supprimé par "
"l'interpréteur lorsqu'il s'agit de la seule value écrite. Vous pouvez le "
"voir si vous y tenez vraiment en utilisant :func:`print` ::"

#: ../Doc/tutorial/controlflow.rst:315
msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr ""
"Il est facile d'écrire une fonction qui renvoie une liste de la série de "
"Fibonacci au lieu de l'imprimer : ::"

#: ../Doc/tutorial/controlflow.rst:331
msgid "This example, as usual, demonstrates some new Python features:"
msgstr ""
"Cet exemple, comme d'habitude, illustre de nouvelles fonctionnalités de "
"Python :"

#: ../Doc/tutorial/controlflow.rst:333
msgid ""
"The :keyword:`return` statement returns with a value from a function. :"
"keyword:`return` without an expression argument returns ``None``. Falling "
"off the end of a function also returns ``None``."
msgstr ""
"L'instruction :keyword:`return` provoque la sortie de la fonction en "
"renvoyant une valeur. :keyword:`return` sans expression en paramètre renvoie "
"``None``. Arriver à la fin d'une fonction renvoie également ``None``."

#: ../Doc/tutorial/controlflow.rst:337
msgid ""
"The statement ``result.append(a)`` calls a *method* of the list object "
"``result``.  A method is a function that 'belongs' to an object and is named "
"``obj.methodname``, where ``obj`` is some object (this may be an "
"expression), and ``methodname`` is the name of a method that is defined by "
"the object's type. Different types define different methods.  Methods of "
"different types may have the same name without causing ambiguity.  (It is "
"possible to define your own object types and methods, using *classes*, see :"
"ref:`tut-classes`) The method :meth:`append` shown in the example is defined "
"for list objects; it adds a new element at the end of the list.  In this "
"example it is equivalent to ``result = result + [a]``, but more efficient."
msgstr ""
"L'instruction ``result.append(a)`` appelle une *méthode* de l'objet "
"``result`` qui est une liste. Une méthode est une fonction qui 'appartient' "
"à un objet et qui est nommée ``obj.methodname``, où ``obj`` est un objet (il "
"peut également s'agir d'une expression), et ``methodname`` est le nom d'une "
"méthode définie par le type de l'objet. Différents types définissent "
"différentes méthodes. Des méthodes de différents types peuvent porter le "
"même nom sans qu'il n'y ait d'ambigüité (vous pouvez définir vos propres "
"types d'objets et leurs méthodes en utilisant des *classes*, voir :ref:`tut-"
"classes`). La méthode :meth:`append` donnée dans cet exemple est définie "
"pour les listes ; elles ajoute un nouvel élément à la fin de la liste. Dans "
"cet exemple, elle est l'équivalent de ``result = result + [a]``, mais elle "
"est plus efficace."

#: ../Doc/tutorial/controlflow.rst:352
msgid "More on Defining Functions"
msgstr "D'avantage sur la définition des fonctions"

#: ../Doc/tutorial/controlflow.rst:354
msgid ""
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
msgstr ""
"Il est également possible de définir des fonctions avec un nombre variable "
"d'arguments. Trois syntaxes peuvent être utilisées, éventuellement combinées."

#: ../Doc/tutorial/controlflow.rst:361
msgid "Default Argument Values"
msgstr "Valeur par défaut des arguments"

#: ../Doc/tutorial/controlflow.rst:363
msgid ""
"The most useful form is to specify a default value for one or more "
"arguments. This creates a function that can be called with fewer arguments "
"than it is defined to allow.  For example::"
msgstr ""
"La forme la plus utile consiste à indiquer une valeur par défaut pour "
"certains arguments. Ceci crée une fonction qui pourra être appelée avec "
"moins d'arguments que ceux présents dans sa définition. Par exemple : ::"

#: ../Doc/tutorial/controlflow.rst:379
msgid "This function can be called in several ways:"
msgstr "Cette fonction peut être appelée de plusieurs façons :"

#: ../Doc/tutorial/controlflow.rst:381
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
msgstr ""
"en ne fournissant que les arguments obligatoires : ``ask_ok('Voulez-vous "
"vraiment quitter ?')``"

#: ../Doc/tutorial/controlflow.rst:383
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
"en fournissant une partie des arguments facultatifs : ``ask_ok('OK pour "
"écraser le fichier ?', 2)``"

#: ../Doc/tutorial/controlflow.rst:385
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
msgstr ""
"en fournissant tous les arguments : ``ask_ok('OK pour écraser le fichier ?', "
"2, 'Allez, seulement oui ou non !')``"

#: ../Doc/tutorial/controlflow.rst:388
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr ""
"Cet exemple présente également le mot-clé :keyword:`in`. Celui-ci permet de "
"tester si une séquence contient une certaine valeur."

#: ../Doc/tutorial/controlflow.rst:391
msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr ""
"Les valeurs par défaut sont évaluées lors de la définition de la fonction "
"dans la portée de *définition*, de telle sorte que : ::"

#: ../Doc/tutorial/controlflow.rst:402
msgid "will print ``5``."
msgstr "imprimera ``5``."

#: ../Doc/tutorial/controlflow.rst:404
msgid ""
"**Important warning:**  The default value is evaluated only once. This makes "
"a difference when the default is a mutable object such as a list, "
"dictionary, or instances of most classes.  For example, the following "
"function accumulates the arguments passed to it on subsequent calls::"
msgstr ""
"**Avertissement important :** La valeur par défaut n'est évaluée qu'une "
"seule fois. Ceci fait une différence lorsque cette valeur par défaut est un "
"objet mutable tel qu'une liste, un dictionnaire ou des instances de la "
"plupart des classes. Par exemple, la fonction suivante accumule les "
"arguments qui lui sont passés au fil des appels successifs : ::"

#: ../Doc/tutorial/controlflow.rst:417
msgid "This will print ::"
msgstr "Ceci imprimera : ::"

#: ../Doc/tutorial/controlflow.rst:423
msgid ""
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
msgstr ""
"Si vous ne voulez pas que cette valeur par défaut soit partagée entre des "
"appels successifs, vous pouvez écrire la fonction de cette façon : ::"

#: ../Doc/tutorial/controlflow.rst:436
msgid "Keyword Arguments"
msgstr "Les arguments nommés"

#: ../Doc/tutorial/controlflow.rst:438
msgid ""
"Functions can also be called using :term:`keyword arguments <keyword "
"argument>` of the form ``kwarg=value``.  For instance, the following "
"function::"
msgstr ""
"Les fonctions peuvent également être appelées en utilisant des :term:"
"`arguments nommés <keyword argument>` sous la form ``kwarg=value``. Par "
"exemple, la fonction suivante : ::"

#: ../Doc/tutorial/controlflow.rst:447
msgid ""
"accepts one required argument (``voltage``) and three optional arguments "
"(``state``, ``action``, and ``type``).  This function can be called in any "
"of the following ways::"
msgstr ""
"accepte un argument obligatoire (``voltage``) et trois arguments facultatifs "
"(``state``, ``action`` et ``type``). Cette fonction peut être appelée de "
"n'importe laquelle des façons suivantes : ::"

#: ../Doc/tutorial/controlflow.rst:458
msgid "but all the following calls would be invalid::"
msgstr "mais tous les appels qui suivent sont incorrects : ::"

#: ../Doc/tutorial/controlflow.rst:465
msgid ""
"In a function call, keyword arguments must follow positional arguments. All "
"the keyword arguments passed must match one of the arguments accepted by the "
"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "
"function), and their order is not important.  This also includes non-"
"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "
"may receive a value more than once. Here's an example that fails due to this "
"restriction::"
msgstr ""
"Dans un appel de fonction, les arguments nommés doivent suivre les arguments "
"positionnés. Tous les arguments nommés doivent correspondre à l'un des "
"arguments acceptés par la fonction (par exemple, ``actor`` n'est pas un "
"argument accepté par la fonction ``parrot``), mais leur ordre n'est pas "
"important. Ceci inclut également les arguments facultatifs "
"(``parrot(voltage=1000)`` est également correct). Aucun argument ne peut "
"recevoir une valeur plus d'une fois, comme l'illustre cet exemple incorrect "
"du fait de cette restriction : ::"

#: ../Doc/tutorial/controlflow.rst:481
msgid ""
"When a final formal parameter of the form ``**name`` is present, it receives "
"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "
"except for those corresponding to a formal parameter.  This may be combined "
"with a formal parameter of the form ``*name`` (described in the next "
"subsection) which receives a tuple containing the positional arguments "
"beyond the formal parameter list.  (``*name`` must occur before ``**name``.) "
"For example, if we define a function like this::"
msgstr ""
"Quand un dernier paramètre formel est présent sous la forme ``**name``, il "
"reçoit un dictionnaire (voir :ref:`typesmapping`) contenant tous les "
"arguments nommés à l'exception de ceux correspondant à un paramètre formel. "
"Ceci peut être combiné à un paramètre formel sous la forme ``*name`` (décrit "
"dans la section suivante) qui lui reçoit un tuple contenant les arguments "
"positionnés au-delà de la liste des paramètres formels (``*name`` doit être "
"présent avant ``**name``). Par exemple, si vous définissez une fonction "
"comme ceci :"

#: ../Doc/tutorial/controlflow.rst:499
msgid "It could be called like this::"
msgstr "Elle pourrait être appelée comme ceci : ::"

#: ../Doc/tutorial/controlflow.rst:507
msgid "and of course it would print:"
msgstr ""

#: ../Doc/tutorial/controlflow.rst:520
msgid ""
"Note that the list of keyword argument names is created by sorting the "
"result of the keywords dictionary's ``keys()`` method before printing its "
"contents; if this is not done, the order in which the arguments are printed "
"is undefined."
msgstr ""
"Notez que la liste des arguments nommés est créée en triant les clés du "
"dictionnaire extraites par la méthode ``keys()`` avant de les imprimer. Si "
"celà n'est pas fait, l'ordre dans lequel les arguments sont imprimée n'est "
"pas défini."

#: ../Doc/tutorial/controlflow.rst:527
msgid "Arbitrary Argument Lists"
msgstr "Listes d'arguments arbitraires"

#: ../Doc/tutorial/controlflow.rst:532
msgid ""
"Finally, the least frequently used option is to specify that a function can "
"be called with an arbitrary number of arguments.  These arguments will be "
"wrapped up in a tuple (see :ref:`tut-tuples`).  Before the variable number "
"of arguments, zero or more normal arguments may occur. ::"
msgstr ""
"Pour terminer, l'option la moins fréquente consiste à indiquer qu'une "
"fonction peut être appelée avec un nombre arbitraire d'arguments. Ces "
"arguments sont intégrés dans un tuple (voir :ref:`tut-tuples`). Avant le "
"nombre variable d'arguments, zéro arguments normaux ou plus peuvent "
"apparaître : ::"

#: ../Doc/tutorial/controlflow.rst:541
msgid ""
"Normally, these ``variadic`` arguments will be last in the list of formal "
"parameters, because they scoop up all remaining input arguments that are "
"passed to the function. Any formal parameters which occur after the "
"``*args`` parameter are 'keyword-only' arguments, meaning that they can only "
"be used as keywords rather than positional arguments. ::"
msgstr ""
"Normalement, c'est arguments ``variadiques`` sont les derniers paramètres, "
"parce qu'ils agrègent toutes les valeurs suivantes. Tout paramètre placé "
"après le paramètre ``*arg`` ne pourront être utilisées que par leur nom."

#: ../Doc/tutorial/controlflow.rst:558
msgid "Unpacking Argument Lists"
msgstr "Séparation des listes d'arguments"

#: ../Doc/tutorial/controlflow.rst:560
msgid ""
"The reverse situation occurs when the arguments are already in a list or "
"tuple but need to be unpacked for a function call requiring separate "
"positional arguments.  For instance, the built-in :func:`range` function "
"expects separate *start* and *stop* arguments.  If they are not available "
"separately, write the function call with the  ``*``\\ -operator to unpack "
"the arguments out of a list or tuple::"
msgstr ""
"La situation inverse intervient lorsque les arguments sont déjà dans une "
"liste ou un tuple mais doivent être séparés pour un appel de fonction "
"nécessitant des arguments positionnés séparés. Par exemple, la primitive :"
"func:`range` attend des arguments *start* et *stop* distincts. S'ils ne sont "
"pas disponibles séparément, écrivez l'appel de fonction en utilisant "
"l'opérateur ``*`` pour séparer les arguments présents dans une liste ou un "
"tuple : ::"

#: ../Doc/tutorial/controlflow.rst:576
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
msgstr ""
"De la même façon, les dictionnaires peuvent fournir des arguments nommés en "
"utilisant l'opérateur ``**`` ::"

#: ../Doc/tutorial/controlflow.rst:592
msgid "Lambda Expressions"
msgstr "Fonctions anonymes"

#: ../Doc/tutorial/controlflow.rst:594
msgid ""
"Small anonymous functions can be created with the :keyword:`lambda` keyword. "
"This function returns the sum of its two arguments: ``lambda a, b: a+b``. "
"Lambda functions can be used wherever function objects are required.  They "
"are syntactically restricted to a single expression.  Semantically, they are "
"just syntactic sugar for a normal function definition.  Like nested function "
"definitions, lambda functions can reference variables from the containing "
"scope::"
msgstr ""
"Avec le mot-clé :keyword:`lambda`, on peut créer de petites fonctions "
"anonymes. Voilàune fonction qui renvoie la somme de ses deux arguments : "
"``lambda a, b: a+b``. Les fonctions lambda peuvent être utilisées partout où "
"un objet fonction est attendu. Elles sont syntaxiquement restreintes à une "
"seule expression. Sémantiquement, elles ne sont qu'un sucre syntaxique pour "
"une définition de fonction normale. Comme les fonctions imbriquées, les "
"fonctions lambda peuvent référencer des variables de la portée "
"englobante : ::"

#: ../Doc/tutorial/controlflow.rst:611
msgid ""
"The above example uses a lambda expression to return a function.  Another "
"use is to pass a small function as an argument::"
msgstr ""
"L'exemple précédent utilise une fonction anonyme pour renvoyer une fonction. "
"Un aute usage typique est de donner une fonction minimaliste directement en "
"temps que paramètre::"

#: ../Doc/tutorial/controlflow.rst:623
msgid "Documentation Strings"
msgstr "Chaînes de documentation"

#: ../Doc/tutorial/controlflow.rst:630
msgid ""
"Here are some conventions about the content and formatting of documentation "
"strings."
msgstr ""
"Voici quelques conventions concernant le contenu et le format des chaînes de "
"documentation."

#: ../Doc/tutorial/controlflow.rst:633
msgid ""
"The first line should always be a short, concise summary of the object's "
"purpose.  For brevity, it should not explicitly state the object's name or "
"type, since these are available by other means (except if the name happens "
"to be a verb describing a function's operation).  This line should begin "
"with a capital letter and end with a period."
msgstr ""
"La première ligne devrait toujours être courte, un résumé concis de "
"l'utilité de l'objet. Pour être bref, nul besoin de rappeler le nom de "
"l'objet ou son type, qui sont accessibles par d'autres moyens (sauf si le "
"nom est un verbe qui décrit une opération). Cette ligne devrait commencer "
"avec une majuscule et se terminer par un point."

#: ../Doc/tutorial/controlflow.rst:639
msgid ""
"If there are more lines in the documentation string, the second line should "
"be blank, visually separating the summary from the rest of the description.  "
"The following lines should be one or more paragraphs describing the object's "
"calling conventions, its side effects, etc."
msgstr ""
"Si il a d'autres lignes dans la chaîne de documentation, la seconde ligne "
"devrait être vide, pour la séparer visuellement du reste de la description. "
"Les autres lignes peuvent alors constituer un ou plusieurs paragraphes "
"décrivant le mode d'utilisation de l'objet, ses effets de bord, etc."

#: ../Doc/tutorial/controlflow.rst:644
msgid ""
"The Python parser does not strip indentation from multi-line string literals "
"in Python, so tools that process documentation have to strip indentation if "
"desired.  This is done using the following convention. The first non-blank "
"line *after* the first line of the string determines the amount of "
"indentation for the entire documentation string.  (We can't use the first "
"line since it is generally adjacent to the string's opening quotes so its "
"indentation is not apparent in the string literal.)  Whitespace \"equivalent"
"\" to this indentation is then stripped from the start of all lines of the "
"string.  Lines that are indented less should not occur, but if they occur "
"all their leading whitespace should be stripped.  Equivalence of whitespace "
"should be tested after expansion of tabs (to 8 spaces, normally)."
msgstr ""
"L'analyseur de code Python ne supprime pas l'indentation des chaînes de "
"caractères littérales multi-lignes, donc les outils qui utilisent la "
"documentation doivent si besoin faire cette opération eux-mêmes. La "
"convention suivante s'applique : la première ligne non vide *après* la "
"première détermine la profondeur d'indentation de l'ensemble de la chaîne de "
"documentation (on ne peut pas utiliser la première ligne qui est "
"généralement accolée aux guillemets d'ouverture de la chaîne de caractères "
"et dont l'indentation n'est donc pas visible). Les espaces \"correspondant\" "
"à cette profondeur d'indentation sont alors supprimés du début de chacune "
"des lignes de la chaîne. Aucune ligne ne devrait présenter un niveau "
"d'indentation inférieur mais si cela arrive, tous les espaces situés en "
"début de ligne doivent être supprimés. L'équivalent des espaces doit être "
"testé après expansion des tabulations (normalement remplacés par 4 espaces)."

#: ../Doc/tutorial/controlflow.rst:656
msgid "Here is an example of a multi-line docstring::"
msgstr "Voici un exemple de chaîne de documentation multi-lignes : ::"

#: ../Doc/tutorial/controlflow.rst:674
msgid "Function Annotations"
msgstr "Annotations de fonctions"

#: ../Doc/tutorial/controlflow.rst:681
msgid ""
":ref:`Function annotations <function>` are completely optional metadata "
"information about the types used by user-defined functions (see :pep:`484` "
"for more information)."
msgstr ""
":ref:`Function annotations <function>` sont des métadonnée optionnelles "
"décrivant les types utilisées par une fonction définie par l'utilisateur "
"(Voir la :pep:`484` pour plus d'informations)."

#: ../Doc/tutorial/controlflow.rst:685
msgid ""
"Annotations are stored in the :attr:`__annotations__` attribute of the "
"function as a dictionary and have no effect on any other part of the "
"function.  Parameter annotations are defined by a colon after the parameter "
"name, followed by an expression evaluating to the value of the annotation.  "
"Return annotations are defined by a literal ``->``, followed by an "
"expression, between the parameter list and the colon denoting the end of "
"the :keyword:`def` statement.  The following example has a positional "
"argument, a keyword argument, and the return value annotated::"
msgstr ""
"Les annotations sont stockées dans l'attribut :attr:`__annotations__` de la "
"fonction, sous forme d'un dictionnaire, et n'ont aucun autre effet. Les "
"annotations sur les paramètres sont définis par deux points (:) après le nom "
"du paramètre suivi d'une expression donnant la valeur de l'annotation. Les "
"annotations de retour sont définies par ``->`` suivi d'une expression, entre "
"la liste des paramètres et les deux points de fin de l'instruction :keyword:"
"`def`. L'exemple suivant a un paramètre positionnel, un paramètre nommé, et "
"une valeur de retour annotée : ::"

#: ../Doc/tutorial/controlflow.rst:707
msgid "Intermezzo: Coding Style"
msgstr "Un style de codage : Intermezzo"

#: ../Doc/tutorial/controlflow.rst:712
msgid ""
"Now that you are about to write longer, more complex pieces of Python, it is "
"a good time to talk about *coding style*.  Most languages can be written (or "
"more concise, *formatted*) in different styles; some are more readable than "
"others. Making it easy for others to read your code is always a good idea, "
"and adopting a nice coding style helps tremendously for that."
msgstr ""
"Maintenant que vous êtes prêt à écrire des programmes plus longs et plus "
"complexes, il est temps de parler du *style de codage*. La plupart des "
"langages peuvent être écrits (ou plutôt *formattés*) selon différents "
"styles ; certains sont plus lisibles que d'autres. Rendre la lecture de "
"votre code plus facile aux autres est toujours une bonne idée, et adopter un "
"bon style de codage peut énormément vous y aider."

#: ../Doc/tutorial/controlflow.rst:718
msgid ""
"For Python, :pep:`8` has emerged as the style guide that most projects "
"adhere to; it promotes a very readable and eye-pleasing coding style.  Every "
"Python developer should read it at some point; here are the most important "
"points extracted for you:"
msgstr ""
"En Python, la :pep:`8` a émergé comme étant un guide auquel la plupart des "
"projets adhèrent ; elle met en avant un style de codage très lisible et "
"agréable à l'oeil. Chaque développeur Python devrait donc la lire et s'en "
"inspirer autant que possible ; voici ses principaux points notables :"

#: ../Doc/tutorial/controlflow.rst:723
msgid "Use 4-space indentation, and no tabs."
msgstr "Utilisez des indentations de 4 espaces, et pas de tabulation."

#: ../Doc/tutorial/controlflow.rst:725
msgid ""
"4 spaces are a good compromise between small indentation (allows greater "
"nesting depth) and large indentation (easier to read).  Tabs introduce "
"confusion, and are best left out."
msgstr ""
"4 espaces constituent un bon compromis entre une indentation courte (qui "
"permet une profondeur d'imbrication plus importante) et une longue (qui rend "
"le code plus facile à lire). Les tabulations introduisent de la confusion, "
"et doivent être proscrites autant que possible."

#: ../Doc/tutorial/controlflow.rst:729
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr ""
"Faites des retours à la ligne, de telle sorte qu'elles n'excèdent pas 79 "
"caractères."

#: ../Doc/tutorial/controlflow.rst:731
msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr ""
"Ceci aide les utilisateurs ne disposant que de petits écrans, et permet sur "
"de plus grands de disposer plusieurs fichiers côte à côte sans difficulté."

#: ../Doc/tutorial/controlflow.rst:734
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of code "
"inside functions."
msgstr ""
"Utilisez des lignes vides pour séparer les fonctions et les classes, ou pour "
"scinder de gros blocs de code à l'intérieur de fonctions."

#: ../Doc/tutorial/controlflow.rst:737
msgid "When possible, put comments on a line of their own."
msgstr ""
"Lorsque c'est possible, placez les commentaires sur leur propres lignes."

#: ../Doc/tutorial/controlflow.rst:739
msgid "Use docstrings."
msgstr "Utilisez les chaînes de documentation"

#: ../Doc/tutorial/controlflow.rst:741
msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr ""
"Utilisez des espaces autour des opérateurs et après les virgules, mais pas "
"directement à l'intérieur des parenthèses : ``a = f(1, 2) + g(3, 4)``."

#: ../Doc/tutorial/controlflow.rst:744
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``CamelCase`` for classes and ``lower_case_with_underscores`` for functions "
"and methods.  Always use ``self`` as the name for the first method argument "
"(see :ref:`tut-firstclasses` for more on classes and methods)."
msgstr ""
"Nommez toujours vos classes et fonctions de la même manière ; la convention "
"est d'utiliser une notation ``CamelCase`` pour les classes, et "
"``minuscules_avec_trait_bas`` pour les fonctions et méthodes. Utilisez "
"toujours ``self`` comme nom du premier argument des méthodes (voyez :ref:"
"`tut-firstclasses` pour en savoir plus sur les classes et les méthodes)."

#: ../Doc/tutorial/controlflow.rst:749
msgid ""
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Python's default, UTF-8, or even plain ASCII work best in any "
"case."
msgstr ""
"N'utilisez pas d'encodages exotiques dès lors que votre code est sensé être "
"utilisé dans des environnements internationaux. Par défaut, Python travaille "
"en UTF-8, ou sinon du simple ASCII fonctionne dans la plupart des cas."

#: ../Doc/tutorial/controlflow.rst:753
msgid ""
"Likewise, don't use non-ASCII characters in identifiers if there is only the "
"slightest chance people speaking a different language will read or maintain "
"the code."
msgstr ""
"De la même manière, n'utilisez que des caractères ASCII pour vos noms de "
"variables si vous soupçonnez qu'un personne parlant une autre langue lira ou "
"devra modifier votre code."

#: ../Doc/tutorial/controlflow.rst:760
msgid ""
"Actually, *call by object reference* would be a better description, since if "
"a mutable object is passed, the caller will see any changes the callee makes "
"to it (items inserted into a list)."
msgstr ""
"En fait, *appels par référence d'objets* serait sans doute une desciption "
"plus juste, dans la mesure où si un objet mutable est passé en argument, "
"l'appelant verra toutes les modifications qui lui auront été apportées par "
"l'appelé (insertion d'éléments dans une liste...)."

#: ../Doc/tutorial/datastructures.rst:5
msgid "Data Structures"
msgstr "Structures de données"

#: ../Doc/tutorial/datastructures.rst:7
msgid ""
"This chapter describes some things you've learned about already in more "
"detail, and adds some new things as well."
msgstr ""
"Ce chapitre reprend plus en détail quelques point déjà décrits précédemment, "
"et introduit également de nouvelles notions."

#: ../Doc/tutorial/datastructures.rst:13
msgid "More on Lists"
msgstr "Compléments sur les listes"

#: ../Doc/tutorial/datastructures.rst:15
msgid ""
"The list data type has some more methods.  Here are all of the methods of "
"list objects:"
msgstr ""
"Le type liste dispose de méthodes supplémentaires. Voici la liste complète "
"des méthodes des objets de type liste :"

#: ../Doc/tutorial/datastructures.rst:22
msgid ""
"Add an item to the end of the list.  Equivalent to ``a[len(a):] = [x]``."
msgstr ""
"Ajoute un élément à la fin de la liste. Equivalent à ``a[len(a):] = [x]``."

#: ../Doc/tutorial/datastructures.rst:28
msgid ""
"Extend the list by appending all the items in the given list.  Equivalent to "
"``a[len(a):] = L``."
msgstr ""
"Étend la liste en y ajoutant tous les éléments de la liste fournie."
"Équivalent à ``a[len(a):] = L``."

#: ../Doc/tutorial/datastructures.rst:35
msgid ""
"Insert an item at a given position.  The first argument is the index of the "
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
msgstr ""
"Insère un élément à la position indiquée. Le premier argument est la "
"position de l'élément courant avant lequel l'insertion doit s'effectuer, "
"donc ``a.insert(0, x)`` insère l'élément en tête de la liste, et ``a."
"insert(len(a), x)`` est équivalent à ``a.append(x)``."

#: ../Doc/tutorial/datastructures.rst:43
msgid ""
"Remove the first item from the list whose value is *x*.  It is an error if "
"there is no such item."
msgstr ""
"Supprime de la liste le premier élément dont la valeur est *x*. Une "
"exception est levée s'il existe aucun élément avec cette valeur."

#: ../Doc/tutorial/datastructures.rst:50
msgid ""
"Remove the item at the given position in the list, and return it.  If no "
"index is specified, ``a.pop()`` removes and returns the last item in the "
"list.  (The square brackets around the *i* in the method signature denote "
"that the parameter is optional, not that you should type square brackets at "
"that position.  You will see this notation frequently in the Python Library "
"Reference.)"
msgstr ""
"Enlève de la liste l'élément situé à la position indiquée, et le retourne. "
"Si aucune position n'est indiqué, ``a.pop()`` enlève et retourne le dernier "
"élément de la liste (les crochets autour du *i* dans la signature de la "
"méthode indiquent bien que ce paramètre est facultatif, et non que vous "
"devez placer des crochets dans votre code ! Vous retrouverez cette notation "
"fréquemment dans le Guide de Référence de la Bibliothèque Python)."

#: ../Doc/tutorial/datastructures.rst:60
msgid "Remove all items from the list.  Equivalent to ``del a[:]``."
msgstr "Supprime tous les éléments de la liste, équivalent à ``del a[:]``."

#: ../Doc/tutorial/datastructures.rst:66
msgid ""
"Return the index in the list of the first item whose value is *x*. It is an "
"error if there is no such item."
msgstr ""
"Retourne la position du premier élément de la liste ayant la valeur *x*. Une "
"exception est levée s'il n'existe aucun élément avec cette valeur."

#: ../Doc/tutorial/datastructures.rst:73
msgid "Return the number of times *x* appears in the list."
msgstr "Retourne le nombre d'éléments ayant la valeur *x* dans la liste."

#: ../Doc/tutorial/datastructures.rst:79
msgid ""
"Sort the items of the list in place (the arguments can be used for sort "
"customization, see :func:`sorted` for their explanation)."
msgstr ""
"Trie les éléments sur place, (les arguments peuvent personaliser le tri, "
"voir :func:`sorted` pour leur explication)."

#: ../Doc/tutorial/datastructures.rst:86
msgid "Reverse the elements of the list in place."
msgstr "Inverse l'ordre des éléments de la liste, sur place."

#: ../Doc/tutorial/datastructures.rst:92
msgid "Return a shallow copy of the list.  Equivalent to ``a[:]``."
msgstr "Renvoie une copie superficielle de la liste. Équivalent à ``a[:]``."

#: ../Doc/tutorial/datastructures.rst:95
msgid "An example that uses most of the list methods::"
msgstr "L'exemple suivant utilise la plupart des méthodes des listes : ::"

#: ../Doc/tutorial/datastructures.rst:120
msgid ""
"You might have noticed that methods like ``insert``, ``remove`` or ``sort`` "
"that only modify the list have no return value printed -- they return the "
"default ``None``. [1]_  This is a design principle for all mutable data "
"structures in Python."
msgstr ""
"Vous avez probablement remarqué que les méthodes tel que ``insert``, "
"``remove`` ou ``sort``, qui ne font que modifier la liste, ne renvoient pas "
"de valeur mais ``None``. [1]_ C'est un principe respecté par toutes les "
"structures de données variables en Python."

#: ../Doc/tutorial/datastructures.rst:129
msgid "Using Lists as Stacks"
msgstr "Utiliser les listes comme des piles"

#: ../Doc/tutorial/datastructures.rst:134
msgid ""
"The list methods make it very easy to use a list as a stack, where the last "
"element added is the first element retrieved (\"last-in, first-out\").  To "
"add an item to the top of the stack, use :meth:`append`.  To retrieve an "
"item from the top of the stack, use :meth:`pop` without an explicit index.  "
"For example::"
msgstr ""
"Les méthodes des listes rendent très facile leur utilisation comme des "
"piles, où le dernier élément ajouté est le premier récupéré (\"dernier "
"entré, premier sorti\", ou LIFO pour \"last-in, first-out\"). Pour ajouter "
"un élément sur la pile, utilisez la méthode :meth:`append`. Pour récupérer "
"l'objet au sommet de la pile, utilisez la méthode :meth:`pop`, sans "
"indicateur de position. Par exemple : ::"

#: ../Doc/tutorial/datastructures.rst:159
msgid "Using Lists as Queues"
msgstr "Utiliser les listes comme des files"

#: ../Doc/tutorial/datastructures.rst:163
msgid ""
"It is also possible to use a list as a queue, where the first element added "
"is the first element retrieved (\"first-in, first-out\"); however, lists are "
"not efficient for this purpose.  While appends and pops from the end of list "
"are fast, doing inserts or pops from the beginning of a list is slow "
"(because all of the other elements have to be shifted by one)."
msgstr ""
"Il est également possible d'utiliser une liste comme une file, où le premier "
"élément ajouté est le premier récupéré (\"premier entré, premier sorti\", ou "
"FIFO pour \"first-in, first-out\") ; touefois, les listes ne sont pas très "
"efficaces pour ce type de traitement. Alors que les ajouts et suppressions "
"en fin de liste sont rapides, les opérations d'insertions ou de retraits en "
"début de liste sont lentes (car tous les autres éléments doivent être "
"décalés d'une position)."

#: ../Doc/tutorial/datastructures.rst:169
msgid ""
"To implement a queue, use :class:`collections.deque` which was designed to "
"have fast appends and pops from both ends.  For example::"
msgstr ""
"Pour implémenter une file, utilisez donc la classe :class:`collections."
"deque` qui a été conçue pour fournir des opérations d'ajouts et de retraits "
"rapides aux deux extrémités. Par exemple : ::"

#: ../Doc/tutorial/datastructures.rst:187
msgid "List Comprehensions"
msgstr "Compréhensions de listes"

#: ../Doc/tutorial/datastructures.rst:189
msgid ""
"List comprehensions provide a concise way to create lists. Common "
"applications are to make new lists where each element is the result of some "
"operations applied to each member of another sequence or iterable, or to "
"create a subsequence of those elements that satisfy a certain condition."
msgstr ""
"Les compréhensions de listes fournissent un moyen de construire des listes "
"de manière très concice. Une application classique est la construction de "
"nouvelles listes où chaque élément est le résultat d'une opération appliquée "
"à chaque élément d'une autre séquence, ou de créer une sous-séquence des "
"éléments satisfaisant une condition spécifique."

#: ../Doc/tutorial/datastructures.rst:194
msgid "For example, assume we want to create a list of squares, like::"
msgstr ""
"Par exemple, supposons que l'on veuille créer une liste de carrés, comme : ::"

#: ../Doc/tutorial/datastructures.rst:203
msgid ""
"Note that this creates (or overwrites) a variable named ``x`` that still "
"exists after the loop completes.  We can calculate the list of squares "
"without any side effects using::"
msgstr ""
"Notez que cela créé (ou écrase) une variable nommée ``x`` qui existe "
"toujours après l'exécution de la boucle. On peut calculer une liste de "
"carrés sans effet de bord, avec : ::"

#: ../Doc/tutorial/datastructures.rst:209
msgid "or, equivalently::"
msgstr "ou : ::"

#: ../Doc/tutorial/datastructures.rst:213
msgid "which is more concise and readable."
msgstr "qui est plus court et lisible."

#: ../Doc/tutorial/datastructures.rst:215
msgid ""
"A list comprehension consists of brackets containing an expression followed "
"by a :keyword:`for` clause, then zero or more :keyword:`for` or :keyword:"
"`if` clauses.  The result will be a new list resulting from evaluating the "
"expression in the context of the :keyword:`for` and :keyword:`if` clauses "
"which follow it. For example, this listcomp combines the elements of two "
"lists if they are not equal::"
msgstr ""
"Une compréhension de liste consiste en crochets contenant une expression "
"suivie par une clause :keyword:`for`, puis par zéro ou plus clauses :keyword:"
"`for` ou :keyword:`if`. Le résultat sera une nouvelle liste résultat de "
"l'évaluation de l'expression dans le contexte des clauses :keyword:`for` et :"
"keyword:`if` qui la suivent. Par exemple, cette compréhension de liste "
"combine les éléments de deux listes s'ils ne sont pas égaux : ::"

#: ../Doc/tutorial/datastructures.rst:225
msgid "and it's equivalent to::"
msgstr "et c'est équivaent à : ::"

#: ../Doc/tutorial/datastructures.rst:236
msgid ""
"Note how the order of the :keyword:`for` and :keyword:`if` statements is the "
"same in both these snippets."
msgstr ""
"Notez que l'ordre des instructions :keyword:`for` et :keyword:`if` est le "
"même dans ces différents extraits de code."

#: ../Doc/tutorial/datastructures.rst:239
msgid ""
"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "
"it must be parenthesized. ::"
msgstr ""
"Si l'expression est un tuple (c'est à dire ``(x, y)`` dans cet exemple), "
"elle doit être entourée par des parenthèses : ::"

#: ../Doc/tutorial/datastructures.rst:270
msgid ""
"List comprehensions can contain complex expressions and nested functions::"
msgstr ""
"Les compréhensions de listes peuvent contenir des expressions complexes et "
"des fonctions imbriquées : ::"

#: ../Doc/tutorial/datastructures.rst:277
msgid "Nested List Comprehensions"
msgstr "Compréhensions de listes imbriquées"

#: ../Doc/tutorial/datastructures.rst:279
msgid ""
"The initial expression in a list comprehension can be any arbitrary "
"expression, including another list comprehension."
msgstr ""
"La première expression dans une compréhension de liste peut être n'importe "
"quelle expression, y compris une autre compréhension de liste."

#: ../Doc/tutorial/datastructures.rst:282
msgid ""
"Consider the following example of a 3x4 matrix implemented as a list of 3 "
"lists of length 4::"
msgstr ""
"Voyez l'exemple suivant d'une matrice de 3x4, implémentée sous la forme de 3 "
"listes de 4 éléments : ::"

#: ../Doc/tutorial/datastructures.rst:291
msgid "The following list comprehension will transpose rows and columns::"
msgstr ""
"Cette compréhension de liste va transposer les lignes et les colonnes : ::"

#: ../Doc/tutorial/datastructures.rst:296
msgid ""
"As we saw in the previous section, the nested listcomp is evaluated in the "
"context of the :keyword:`for` that follows it, so this example is equivalent "
"to::"
msgstr ""
"Comme on l'a vu dans la section précédente, la compréhension de liste "
"imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui "
"la suit, donc cet exemple est équivalent à : ::"

#: ../Doc/tutorial/datastructures.rst:307
msgid "which, in turn, is the same as::"
msgstr "lequel à son tour est équivalent à : ::"

#: ../Doc/tutorial/datastructures.rst:320
msgid ""
"In the real world, you should prefer built-in functions to complex flow "
"statements. The :func:`zip` function would do a great job for this use case::"
msgstr ""
"Dans des cas concrets, il est toujours préférable d'utiliser des fonctions "
"natives plutôt que des instructions de contrôle de flux complexes. La "
"fonction :func:`zip` ferait dans ce cas un excellent travail : ::"

#: ../Doc/tutorial/datastructures.rst:326
msgid ""
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
msgstr ""
"Voyez :ref:`tut-unpacking-arguments` pour plus de détails sur cette ligne."

#: ../Doc/tutorial/datastructures.rst:331
msgid "The :keyword:`del` statement"
msgstr "L'instruction :keyword:`del`"

#: ../Doc/tutorial/datastructures.rst:333
msgid ""
"There is a way to remove an item from a list given its index instead of its "
"value: the :keyword:`del` statement.  This differs from the :meth:`pop` "
"method which returns a value.  The :keyword:`del` statement can also be used "
"to remove slices from a list or clear the entire list (which we did earlier "
"by assignment of an empty list to the slice).  For example::"
msgstr ""
"Il existe un moyen de retirer un élément d'une liste à partir de sa position "
"au lieu de sa valeur : l'instruction :keyword:`del`. Elle diffère de la "
"méthode :meth:`pop` qui, elle, renvoie une valeur. L'instruction :keyword:"
"`del` peut également être utilisée pour supprimer des tranches d'une liste "
"ou la vider complètement (ce que nous avions fait auparavent en affectant "
"une liste vide à la tranche). Par exemple : ::"

#: ../Doc/tutorial/datastructures.rst:350
msgid ":keyword:`del` can also be used to delete entire variables::"
msgstr ""
":keyword:`del` peut aussi être utilisée pour supprimer des variables : ::"

#: ../Doc/tutorial/datastructures.rst:354
msgid ""
"Referencing the name ``a`` hereafter is an error (at least until another "
"value is assigned to it).  We'll find other uses for :keyword:`del` later."
msgstr ""
"À partir de là, référencer le nom ``a`` est une erreur (au moins jusqu'à ce "
"qu'une autre valeur lui soit affectée). Vous trouverez d'autres utilisations "
"de la fonction :keyword:`del` plus tard."

#: ../Doc/tutorial/datastructures.rst:361
msgid "Tuples and Sequences"
msgstr "Tuples et séquences"

#: ../Doc/tutorial/datastructures.rst:363
msgid ""
"We saw that lists and strings have many common properties, such as indexing "
"and slicing operations.  They are two examples of *sequence* data types "
"(see :ref:`typesseq`).  Since Python is an evolving language, other sequence "
"data types may be added.  There is also another standard sequence data type: "
"the *tuple*."
msgstr ""
"Nous avons vu que les listes et les chaînes de caractères ont beaucoup de "
"propriétés en commun, comme l'indexation et les opérations sur des tranches. "
"Ce sont deux exemple de *séquences* (voir :ref:`typesseq`). Comme Python est "
"un langage en constante évolution, d'autres types de séquences y seront peut-"
"être ajoutés. Il existe également un autre type standard de séquence : le "
"*tuple*."

#: ../Doc/tutorial/datastructures.rst:369
msgid ""
"A tuple consists of a number of values separated by commas, for instance::"
msgstr ""
"Un tuple consiste en différentes valeurs séparées par des virgules, comme "
"par exemple : ::"

#: ../Doc/tutorial/datastructures.rst:391
msgid ""
"As you see, on output tuples are always enclosed in parentheses, so that "
"nested tuples are interpreted correctly; they may be input with or without "
"surrounding parentheses, although often parentheses are necessary anyway (if "
"the tuple is part of a larger expression).  It is not possible to assign to "
"the individual items of a tuple, however it is possible to create tuples "
"which contain mutable objects, such as lists."
msgstr ""
"Comme vous pouvez le voir, à l'affichage les tuples sont toujours encadrés "
"par des parenthèses, de façon à ce que des tuples imbriqués soient "
"interprétés correctement ; ils peuvent être entrés avec ou sans parenthèses, "
"même si celles-ci sont souvent nécessaires (notamment lorsqu'un tuple fait "
"partie d'une expression plus longue). Il n'est pas possible d'affecter de "
"valeur à un élément d'un tuple ; par contre, il est possible de créer des "
"tuples contenant des objets mutables, comme des listes."

#: ../Doc/tutorial/datastructures.rst:398
msgid ""
"Though tuples may seem similar to lists, they are often used in different "
"situations and for different purposes. Tuples are :term:`immutable`, and "
"usually contain a heterogeneous sequence of elements that are accessed via "
"unpacking (see later in this section) or indexing (or even by attribute in "
"the case of :func:`namedtuples <collections.namedtuple>`). Lists are :term:"
"`mutable`, and their elements are usually homogeneous and are accessed by "
"iterating over the list."
msgstr ""

#: ../Doc/tutorial/datastructures.rst:406
msgid ""
"A special problem is the construction of tuples containing 0 or 1 items: the "
"syntax has some extra quirks to accommodate these.  Empty tuples are "
"constructed by an empty pair of parentheses; a tuple with one item is "
"constructed by following a value with a comma (it is not sufficient to "
"enclose a single value in parentheses). Ugly, but effective.  For example::"
msgstr ""
"Un problème spécifique est la construction de tuples ne contenant aucun ou "
"un seul élément : la syntaxe a quelques tournures spécifiques pour s'en "
"accomoder. Les tuples vides sont construits par une paire de parenthèses "
"vides ; un tuple avec un seul élément est construit en faisant suivre la "
"valeur par une virgule (il n'est pas suffisant de placer cette valeur entre "
"parenthèses). Pas très joli, mais efficace. Par exemple : ::"

#: ../Doc/tutorial/datastructures.rst:421
msgid ""
"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
"together in a tuple. The reverse operation is also possible::"
msgstr ""
"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple d'un *emballage "
"de tuple* : les valeurs ``12345``, ``54321`` et ``hello !`` sont emballées "
"ensemble dans un tuple. L'opération inverse est aussi possible : ::"

#: ../Doc/tutorial/datastructures.rst:427
msgid ""
"This is called, appropriately enough, *sequence unpacking* and works for any "
"sequence on the right-hand side.  Sequence unpacking requires that there are "
"as many variables on the left side of the equals sign as there are elements "
"in the sequence.  Note that multiple assignment is really just a combination "
"of tuple packing and sequence unpacking."
msgstr ""
"Ceci est appelé, de façon plus ou moins appropriée, un *déballage de "
"séquence* et fonctionne pour toute séquence placée à droite de l'expression. "
"Ce déballage requiert autant de variables dans la partie gauche qu'il y a "
"d'éléments dans la séquence. Notez également que cette affectation multiple "
"est juste une combinaison entre un emballage de tuple et un déballage de "
"séquence."

#: ../Doc/tutorial/datastructures.rst:437
msgid "Sets"
msgstr "Les ensembles"

#: ../Doc/tutorial/datastructures.rst:439
msgid ""
"Python also includes a data type for *sets*.  A set is an unordered "
"collection with no duplicate elements.  Basic uses include membership "
"testing and eliminating duplicate entries.  Set objects also support "
"mathematical operations like union, intersection, difference, and symmetric "
"difference."
msgstr ""
"Python fournit également un type de donnée pour les *ensembles*. Un ensemble "
"est une collection non ordonnée sans élément dupliqué. Des utilisations "
"basiques concernent par exemple des tests d'appartenance ou des suppressons "
"de doublons. Les ensembles supportent également les opérations mathématiques "
"comme les unions, intersections, différences et différences symétriques."

#: ../Doc/tutorial/datastructures.rst:444
msgid ""
"Curly braces or the :func:`set` function can be used to create sets.  Note: "
"to create an empty set you have to use ``set()``, not ``{}``; the latter "
"creates an empty dictionary, a data structure that we discuss in the next "
"section."
msgstr ""
"Des accolades, ou la fonction :func:`set` peuvent être utilisés pour créer "
"des ensembles.    Notez que pour créer un ensemble vide, ``{}`` ne "
"fonctionne pas, cela créé un dictionnaire vide. Utilisez plutôt ``set()``."

#: ../Doc/tutorial/datastructures.rst:448
msgid "Here is a brief demonstration::"
msgstr "Voici une brève démonstration : ::"

#: ../Doc/tutorial/datastructures.rst:473
msgid ""
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
"are also supported::"
msgstr ""
"Tout comme les :ref:`comprehensions de listes <tut-listcomps>`, il est "
"possibled'écrire des comprehensions d'ensembles : ::"

#: ../Doc/tutorial/datastructures.rst:484
msgid "Dictionaries"
msgstr "Dictionnaires"

#: ../Doc/tutorial/datastructures.rst:486
msgid ""
"Another useful data type built into Python is the *dictionary* (see :ref:"
"`typesmapping`). Dictionaries are sometimes found in other languages as "
"\"associative memories\" or \"associative arrays\".  Unlike sequences, which "
"are indexed by a range of numbers, dictionaries are indexed by *keys*, which "
"can be any immutable type; strings and numbers can always be keys.  Tuples "
"can be used as keys if they contain only strings, numbers, or tuples; if a "
"tuple contains any mutable object either directly or indirectly, it cannot "
"be used as a key. You can't use lists as keys, since lists can be modified "
"in place using index assignments, slice assignments, or methods like :meth:"
"`append` and :meth:`extend`."
msgstr ""
"Un autre type de donnée très utile, natif dans Python, est le *dictionnaire* "
"(voir :ref:`typesmapping`). Ces dictionnaires sont parfois présents dans "
"d'autres langages sous le nom de \"mémoires associatives\" ou de \"tableaux "
"associatifs\". À la différence des séquences, qui sont indexées par des "
"nombres, les dictionnaires sont indexés par des *clés*, qui peuvent être de "
"n'importe quel type immuable ; les chaînes de caractères et les nombres "
"peuvent toujours être des clés. Des tuples peuvent être utilisés comme clés "
"s'ils ne contiennent que des chaînes, des nombres ou des tuples ; si un "
"tuple contient un objet mutable, de façon directe ou indirecte, il ne peut "
"pas être utilisé comme une clé. Vous ne pouvez pas utiliser des listes comme "
"clés, car les listes peuvent être modifiées en place en utilisant des "
"affectations par position, par tranches ou via des méthodes comme :meth:"
"`append` ou :meth:`extend`."

#: ../Doc/tutorial/datastructures.rst:497
msgid ""
"It is best to think of a dictionary as an unordered set of *key: value* "
"pairs, with the requirement that the keys are unique (within one "
"dictionary). A pair of braces creates an empty dictionary: ``{}``. Placing a "
"comma-separated list of key:value pairs within the braces adds initial key:"
"value pairs to the dictionary; this is also the way dictionaries are written "
"on output."
msgstr ""
"Le plus simple est de considérer les dictionnaires comme des ensembles non "
"ordonnés de paires *clé: valeur*, les clés devant être uniques (au sein d'un "
"dictionnaire). Une paire d'accolades crée un dictionnaire vide : ``{}``. "
"Placer une liste de paires clé:valeur séparées par des virgules à "
"l'intérieur des accolades ajoute les valeurs correspondantes au "
"dictionnaire ; c'est également de cette façon que les dictionnaires sont "
"affichés en sortie."

#: ../Doc/tutorial/datastructures.rst:503
msgid ""
"The main operations on a dictionary are storing a value with some key and "
"extracting the value given the key.  It is also possible to delete a key:"
"value pair with ``del``. If you store using a key that is already in use, "
"the old value associated with that key is forgotten.  It is an error to "
"extract a value using a non-existent key."
msgstr ""
"Les principales opérations effectuées sur un dictionnaire consistent à "
"stocker une valeur pour une clé et à extraire la valeur correspondant à une "
"clé. Il est également possible de supprimer une paire clé:valeur avec "
"``del``. Si vous stockez une valeur pour une clé qui est déjà utilisée, "
"l'ancienne valeur associée à cette clé est perdue. Si vous tentez d'extraire "
"une valeur associée à une clé qui n'existe pas, une exception est levée."

#: ../Doc/tutorial/datastructures.rst:509
msgid ""
"Performing ``list(d.keys())`` on a dictionary returns a list of all the keys "
"used in the dictionary, in arbitrary order (if you want it sorted, just use "
"``sorted(d.keys())`` instead). [2]_  To check whether a single key is in the "
"dictionary, use the :keyword:`in` keyword."
msgstr ""
"Exécuter ``list(d.keys())`` sur un dictionnaire ``d`` retourne une liste de "
"toutes lesclés utilisées dans le dictionnaire, dans un ordre arbitraire (si "
"vous voulez qu'elles soient triées, utilisez ``sorted(d.keys())``). [2]_ "
"Pour tester si une clé est dans le dictionnaire, utilisez le mot-clé :"
"keyword:`in`."

#: ../Doc/tutorial/datastructures.rst:514
msgid "Here is a small example using a dictionary::"
msgstr "Voici un petit exemple utilisant un dictionnaire : ::"

#: ../Doc/tutorial/datastructures.rst:535
msgid ""
"The :func:`dict` constructor builds dictionaries directly from sequences of "
"key-value pairs::"
msgstr ""
"Le constructeur :func:`dict` fabrique un dictionnaire directement à partir "
"d'une liste de paires clé-valeur stockées sous la forme de tuples : ::"

#: ../Doc/tutorial/datastructures.rst:541
msgid ""
"In addition, dict comprehensions can be used to create dictionaries from "
"arbitrary key and value expressions::"
msgstr ""
"De plus, il est possible de créer des dictionnaires par compréhension depuis "
"un jeu de clef et valeurs : ::"

#: ../Doc/tutorial/datastructures.rst:547
msgid ""
"When the keys are simple strings, it is sometimes easier to specify pairs "
"using keyword arguments::"
msgstr ""
"Lorsque les clés sont de simples chaînes de caractères, il est parfois plus "
"facile de spécifier les paires en utilisant des paramètres nommés : ::"

#: ../Doc/tutorial/datastructures.rst:557
msgid "Looping Techniques"
msgstr "Techniques de boucles"

#: ../Doc/tutorial/datastructures.rst:559
msgid ""
"When looping through dictionaries, the key and corresponding value can be "
"retrieved at the same time using the :meth:`items` method. ::"
msgstr ""
"Lorsque vous faites une boucle sur un dictionnaire, les clés et leurs "
"valeurs peuvent être récupérées en même temps en utilisant la méthode :meth:"
"`items` ::"

#: ../Doc/tutorial/datastructures.rst:569
msgid ""
"When looping through a sequence, the position index and corresponding value "
"can be retrieved at the same time using the :func:`enumerate` function. ::"
msgstr ""
"Lorsque vous itérez sur une séquence, la position et la valeur "
"correspondante peuvent être récupérées en même temps en utilisant la "
"fonction :func:`enumerate`."

#: ../Doc/tutorial/datastructures.rst:579
msgid ""
"To loop over two or more sequences at the same time, the entries can be "
"paired with the :func:`zip` function. ::"
msgstr ""
"Pour faire des boucles sur deux séquences ou plus en même temps, les "
"éléments peuvent être associés par la fonction :func:`zip` ::"

#: ../Doc/tutorial/datastructures.rst:591
msgid ""
"To loop over a sequence in reverse, first specify the sequence in a forward "
"direction and then call the :func:`reversed` function. ::"
msgstr ""
"Pour faire une boucle sur une séquence inversée, commencez par créer la "
"séquence dans son ordre normal, puis appliquez la fonction :func:"
"`reversed` ::"

#: ../Doc/tutorial/datastructures.rst:603
msgid ""
"To loop over a sequence in sorted order, use the :func:`sorted` function "
"which returns a new sorted list while leaving the source unaltered. ::"
msgstr ""
"Pour faire une boucle sur une séquence triée, utilisez la fonction :func:"
"`sorted`, qui renvoie une nouvelle liste triée sans altérer la source : ::"

#: ../Doc/tutorial/datastructures.rst:615
msgid ""
"It is sometimes tempting to change a list while you are looping over it; "
"however, it is often simpler and safer to create a new list instead. ::"
msgstr ""
"Il est parfois tentant de changer une liste pendant son itération, "
"cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste "
"à la place. ::"

#: ../Doc/tutorial/datastructures.rst:632
msgid "More on Conditions"
msgstr "Plus d'informations sur les conditions"

#: ../Doc/tutorial/datastructures.rst:634
msgid ""
"The conditions used in ``while`` and ``if`` statements can contain any "
"operators, not just comparisons."
msgstr ""
"Les conditions utilisées dans une instruction ``while`` ou ``if`` peuvent "
"contenir n'importe quel opérateur, pas seulement des comparaisons."

#: ../Doc/tutorial/datastructures.rst:637
msgid ""
"The comparison operators ``in`` and ``not in`` check whether a value occurs "
"(does not occur) in a sequence.  The operators ``is`` and ``is not`` compare "
"whether two objects are really the same object; this only matters for "
"mutable objects like lists.  All comparison operators have the same "
"priority, which is lower than that of all numerical operators."
msgstr ""
"Les opérateurs de comparaison ``in`` et ``not in`` testent si une valeur est "
"présente ou non dans une séquence. Les opérateurs ``is`` et ``is not`` "
"testent si deux objets sont vraiment le même objet ; ceci n'est important "
"que pour des objets mutables comme des listes. Tous les opérateurs de "
"comparaison ont la même priorité, qui est plus faible que celle des "
"opérateurs numériques."

#: ../Doc/tutorial/datastructures.rst:643
msgid ""
"Comparisons can be chained.  For example, ``a < b == c`` tests whether ``a`` "
"is less than ``b`` and moreover ``b`` equals ``c``."
msgstr ""
"Les comparaison peuvent être enchaînées. Par exemple, ``a < b == c`` teste "
"si ``a`` est inférieur ou égal à ``b`` et par ailleurs si ``b`` est égal à "
"``c``."

#: ../Doc/tutorial/datastructures.rst:646
msgid ""
"Comparisons may be combined using the Boolean operators ``and`` and ``or``, "
"and the outcome of a comparison (or of any other Boolean expression) may be "
"negated with ``not``.  These have lower priorities than comparison "
"operators; between them, ``not`` has the highest priority and ``or`` the "
"lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or "
"C``. As always, parentheses can be used to express the desired composition."
msgstr ""
"Les comparaisons peuvent être combinées en utilisant les opérateurs booléens "
"``and`` et ``or``, le résultat d'une comparaison (ou de toute expression "
"booléenne) pouvant être inversé avec ``not``. Ces opérateurs ont une "
"priorité inférieure à celle des opérateurs de comparaison ; entre eux, "
"``not`` a la priorité la plus élevée et ``or`` la plus faible, de telle "
"sorte que ``A and not B or C`` est équivalent à ``(A and (not B)) or C``. "
"Comme toujours, des parenthèses peuvent être utilisées pour exprimer "
"l'instruction désirée."

#: ../Doc/tutorial/datastructures.rst:653
msgid ""
"The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "
"operators: their arguments are evaluated from left to right, and evaluation "
"stops as soon as the outcome is determined.  For example, if ``A`` and ``C`` "
"are true but ``B`` is false, ``A and B and C`` does not evaluate the "
"expression ``C``.  When used as a general value and not as a Boolean, the "
"return value of a short-circuit operator is the last evaluated argument."
msgstr ""
"Les opérateurs booléens ``and`` et ``or`` sont appelés opérateurs *en "
"circuit court* : leurs arguments sont évalués de la gauche vers la droite, "
"et l'évaluation s'arrête dès que le résultat est déterminé. Par exemple, si "
"``A`` et ``C`` sont vrais et ``B`` est faux, ``A and B and C`` n'évalue pas "
"l'expression ``C``. Lorsqu'elle est utilisée en tant que valeur et non en "
"tant que booléen, la valeur de retour d'un opérateur en circuit court est "
"celle du dernier argument évalué."

#: ../Doc/tutorial/datastructures.rst:660
msgid ""
"It is possible to assign the result of a comparison or other Boolean "
"expression to a variable.  For example, ::"
msgstr ""
"Il est possible d'affecter le résultat d'une comparaison ou d'une autre "
"expression booléenne à une variable. Par exemple : ::"

#: ../Doc/tutorial/datastructures.rst:668
msgid ""
"Note that in Python, unlike C, assignment cannot occur inside expressions. C "
"programmers may grumble about this, but it avoids a common class of problems "
"encountered in C programs: typing ``=`` in an expression when ``==`` was "
"intended."
msgstr ""
"Notez qu'en Python, à la différence du C, des affectations ne peuvent pas "
"intervenir à l'intérieur d'expressions. Les programmeurs C râleront peut-"
"être après cela, mais cela évite des erreurs fréquentes que l'on rencontre "
"en C, lorsque l'expression ``=`` est placée alors qu'une expression ``==`` "
"était attendue."

#: ../Doc/tutorial/datastructures.rst:677
msgid "Comparing Sequences and Other Types"
msgstr "Comparer des séquences avec d'autres types"

#: ../Doc/tutorial/datastructures.rst:679
msgid ""
"Sequence objects may be compared to other objects with the same sequence "
"type. The comparison uses *lexicographical* ordering: first the first two "
"items are compared, and if they differ this determines the outcome of the "
"comparison; if they are equal, the next two items are compared, and so on, "
"until either sequence is exhausted. If two items to be compared are "
"themselves sequences of the same type, the lexicographical comparison is "
"carried out recursively.  If all items of two sequences compare equal, the "
"sequences are considered equal. If one sequence is an initial sub-sequence "
"of the other, the shorter sequence is the smaller (lesser) one.  "
"Lexicographical ordering for strings uses the Unicode code point number to "
"order individual characters.  Some examples of comparisons between sequences "
"of the same type::"
msgstr ""
"Des séquences peuvent être comparées avec d'autres séquences du même type. "
"La comparaison utilise un ordre *lexicographique* : les deux premiers "
"éléments de chaque séquence sont comparés, et s'ils diffèrent cela détermine "
"le résultat de la comparaison ; s'ils sont égaux, les deux éléments suivants "
"sont comparés à leur tour, et ainsi de suite jusqu'à ce que l'une des "
"séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des "
"séquences du même type, alors la comparaison lexicographique est effectuée "
"récursivement. Si tous les éléments des deux séquences sont égaux, les deux "
"séquences sont alors considérées comme égales. Si une séquence est une sous-"
"séquence de l'autre, la séquence la plus courte est celle dont la valeur est "
"inférieure. La comparaison lexicographique des chaînes de caractères utilise "
"le code Unicode des caractères. Voici quelques exemples de comparaisons "
"entre séquences de même type : ::"

#: ../Doc/tutorial/datastructures.rst:699
msgid ""
"Note that comparing objects of different types with ``<`` or ``>`` is legal "
"provided that the objects have appropriate comparison methods.  For example, "
"mixed numeric types are compared according to their numeric value, so 0 "
"equals 0.0, etc.  Otherwise, rather than providing an arbitrary ordering, "
"the interpreter will raise a :exc:`TypeError` exception."
msgstr ""
"Comparer des objets de type différents avec ``<`` ou ``>`` est autorisé si "
"les objets ont des méthodes de comparaison appropriées. Par exemple, les "
"types numériques sont comparées via leur valeur numérique, donc 0 est égal à "
"0,0, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
"l'interpréteur lancera une exception :exc:`TypeError`."

#: ../Doc/tutorial/datastructures.rst:708
msgid ""
"Other languages may return the mutated object, which allows method chaining, "
"such as ``d->insert(\"a\")->remove(\"b\")->sort();``."
msgstr ""
"D'autres langages pourraient renvoie l'objet modifié, qui permet de chaîner "
"les méthodes, tel que : ``d->insert(\"a\")->remove(\"b\")->sort();``."

#: ../Doc/tutorial/datastructures.rst:711
msgid ""
"Calling ``d.keys()`` will return a :dfn:`dictionary view` object.  It "
"supports operations like membership test and iteration, but its contents are "
"not independent of the original dictionary -- it is only a *view*."
msgstr ""
"Appeler ``d.keys()`` renvoie un objet :dfn:`dictionary view`, qui gère les "
"opérations du type test d'appartenance (``in``) et l'itération. Mais son "
"contenu n'est pas indépendant du dictionnaire d'origine, c'est une simple "
"*vue*."

#: ../Doc/tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Erreurs et exceptions"

#: ../Doc/tutorial/errors.rst:7
msgid ""
"Until now error messages haven't been more than mentioned, but if you have "
"tried out the examples you have probably seen some.  There are (at least) "
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr ""
"Jusqu'à maintenant, les messages d'erreurs ont seulement été mentionnés, "
"mais si vous avez essayé les exemples vous avez certainement vu plus que "
"cela. En fait, il y a au moins deux types d'erreurs à distinguer : les "
"*erreurs de syntaxe* et les *exceptions*."

#: ../Doc/tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Les erreurs de syntaxe"

#: ../Doc/tutorial/errors.rst:17
msgid ""
"Syntax errors, also known as parsing errors, are perhaps the most common "
"kind of complaint you get while you are still learning Python::"
msgstr ""
"Les erreurs de syntaxe, qui sont des erreurs d'analyse du code, sont peut-"
"être celles que vous rencontrez le plus souvent lorsque vous êtes encore en "
"phase d'apprentissage de Python : ::"

#: ../Doc/tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays a little 'arrow' pointing "
"at the earliest point in the line where the error was detected.  The error "
"is caused by (or at least detected at) the token *preceding* the arrow: in "
"the example, the error is detected at the function :func:`print`, since a "
"colon (``':'``) is missing before it.  File name and line number are printed "
"so you know where to look in case the input came from a script."
msgstr ""
"L'analyseur répère la ligne incriminée et affiche une petite 'flèche' "
"pointant vers le premier endroit de la ligne où l'erreur a été détectée. "
"L'erreur est causée (ou, au moins, a été détectée comme telle) par le "
"symbole placé *avant* la flèche. Dans cet exemple la flèche est sur la "
"fonction :func:`print` car il manque deux points (``':'``) justeavant. Le "
"nom de fichier et le numéro de ligne sont affichés pour vous permettre de "
"localiser facilement l'erreur lorsque le code provient d'un script."

#: ../Doc/tutorial/errors.rst:37
msgid "Exceptions"
msgstr "Les exceptions"

#: ../Doc/tutorial/errors.rst:39
msgid ""
"Even if a statement or expression is syntactically correct, it may cause an "
"error when an attempt is made to execute it. Errors detected during "
"execution are called *exceptions* and are not unconditionally fatal: you "
"will soon learn how to handle them in Python programs.  Most exceptions are "
"not handled by programs, however, and result in error messages as shown "
"here::"
msgstr ""
"Même si une instruction ou une expression est syntaxiquement correcte, elle "
"peut générer une erreur lors de son exécution. Les erreurs détectées durant "
"l'exécution son appelées des *exceptions* et ne sont pas toujours fatales : "
"vous apprendrez bientôt comment les traîter dans vos programmes. La plupart "
"des exceptions toutefois ne sont pas prises en charge par les programmes, ce "
"qui génère des messages d'erreurs comme celui-ci : ::"

#: ../Doc/tutorial/errors.rst:58
msgid ""
"The last line of the error message indicates what happened. Exceptions come "
"in different types, and the type is printed as part of the message: the "
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
"`TypeError`. The string printed as the exception type is the name of the "
"built-in exception that occurred.  This is true for all built-in exceptions, "
"but need not be true for user-defined exceptions (although it is a useful "
"convention). Standard exception names are built-in identifiers (not reserved "
"keywords)."
msgstr ""
"La dernière ligne du message d'erreur indique la cause de l'erreur. Les "
"exceptions peuvent être de différents types, et ce type est indiqué dans le "
"message : les types indiqués dans l'exemple sont :exc:`ZeroDivisionError`, :"
"exc:`NameError` et :exc:`TypeError`. Le texte affiché comme type de "
"l'exception est le nom de l'exception native qui a été déclenchée. Ceci est "
"vrai pour toutes les exceptions natives, mais n'est pas une obligation pour "
"les exceptions définies par l'utilisateur (même si c'est une convention bien "
"pratique). Les noms des exceptions standards sont des identifiants natifs "
"(pas des mots réservés)."

#: ../Doc/tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what "
"caused it."
msgstr ""
"Le reste de la ligne fournit plus de détails en fonction du type de "
"l'exception et de ce qui l'a causé."

#: ../Doc/tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception happened, in the form of a stack traceback. In general it contains "
"a stack traceback listing source lines; however, it will not display lines "
"read from standard input."
msgstr ""
"La partie précédente du message d'erreur montre le contexte dans lequel "
"s'est produite l'exception, sous la forme d'une trace de pile d'exécution. "
"En général, celle-ci contient les lignes du code source ; toutefois, les "
"lignes lues à partir de l'entrée standard ne seront pas affichées."

#: ../Doc/tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
"Vous trouverez dans :ref:`bltin-exceptions` la liste des exceptions natives "
"et leur signification."

#: ../Doc/tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Gestion des exceptions"

#: ../Doc/tutorial/errors.rst:82
msgid ""
"It is possible to write programs that handle selected exceptions. Look at "
"the following example, which asks the user for input until a valid integer "
"has been entered, but allows the user to interrupt the program (using :kbd:"
"`Control-C` or whatever the operating system supports); note that a user-"
"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
"exception. ::"
msgstr ""
"Il est possible d'écrire des programmes qui prennent en charge certaines "
"exceptions. Regardez l'exemple suivant, qui demande une saisie à "
"l'utilisateur jusqu'à ce qu'un entier valide ait été entré, mais permet à "
"l'utilisateur d'interrompre le programme (en utilisant :kbd:`Control-C` ou "
"un autre raccourci que le système supporte) ; notez qu'une interruption "
"générée par l'utilisateur est signalée en levant l'exception :exc:"
"`KeyboardInterrupt`."

#: ../Doc/tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "L'instruction :keyword:`try` fonctionne comme ceci."

#: ../Doc/tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
"keyword:`except` keywords) is executed."
msgstr ""
"Premièrement, la *clause try* (instruction(s) placée(s) entre les mots-clés :"
"keyword:`try` et :keyword:`except`) est exécutée."

#: ../Doc/tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the :"
"keyword:`try` statement is finished."
msgstr ""
"Si aucune exception n'intervient, la *clause except* est sautée et "
"l'exécution de l'instruction :keyword:`try` est terminée."

#: ../Doc/tutorial/errors.rst:104
msgid ""
"If an exception occurs during execution of the try clause, the rest of the "
"clause is skipped.  Then if its type matches the exception named after the :"
"keyword:`except` keyword, the except clause is executed, and then execution "
"continues after the :keyword:`try` statement."
msgstr ""
"Si une exception intervient pendant l'exécution de la clause 'try', le reste "
"de cette clause est sauté. Si son type correspond à un nom d'exception "
"indiqué après le mot-clé :keyword:`except`, la clause 'except' "
"correspondante est exécutée, puis l'exécution continue après l'instruction :"
"keyword:`try`."

#: ../Doc/tutorial/errors.rst:109
msgid ""
"If an exception occurs which does not match the exception named in the "
"except clause, it is passed on to outer :keyword:`try` statements; if no "
"handler is found, it is an *unhandled exception* and execution stops with a "
"message as shown above."
msgstr ""
"Si une exception intervient qui ne corresponde à aucune exception mentionnée "
"dans la clause 'except', elle est transmise à l'instruction :keyword:`try` "
"de niveau supérieur ; si aucun gestionnaire d'exception n'est trouvé, il "
"s'agit d'une *exception non gérée* et l'exécution s'arrête avec un message "
"comme indiqué ci-dessus."

#: ../Doc/tutorial/errors.rst:114
msgid ""
"A :keyword:`try` statement may have more than one except clause, to specify "
"handlers for different exceptions.  At most one handler will be executed. "
"Handlers only handle exceptions that occur in the corresponding try clause, "
"not in other handlers of the same :keyword:`try` statement.  An except "
"clause may name multiple exceptions as a parenthesized tuple, for example::"
msgstr ""
"Une instruction :keyword:`try` peut comporter plusieurs clauses except, pour "
"permettre la prise en charge de différentes exceptions. Mais un seul "
"gestionnaire, au plus, sera exécuté. Les gestionnaires ne prennent en charge "
"que les exceptions qui interviennent dans la clause try correspondante, pas "
"dans d'autres gestionnaires de la même instruction :keyword:`try`. Mais une "
"même clause except peut citer plusieurs exceptions sous la forme d'un tuple "
"entre parenthèses, comme dans cet exemple : ::"

#: ../Doc/tutorial/errors.rst:123
msgid ""
"The last except clause may omit the exception name(s), to serve as a "
"wildcard. Use this with extreme caution, since it is easy to mask a real "
"programming error in this way!  It can also be used to print an error "
"message and then re-raise the exception (allowing a caller to handle the "
"exception as well)::"
msgstr ""
"La dernière clause except peut omettre le(s) nom(s) d'exception(s), pour "
"servir de joker. C'est toutefois à utiliser avec beaucoup de précautions, "
"car il est très facile de masquer une vraie erreur de programmation par ce "
"biais. Elle peut aussi être utilisée pour afficher un message d'erreur avant "
"de re-lever l'exception (en permettant à un appelant de prendre également en "
"charge l'exception) ::"

#: ../Doc/tutorial/errors.rst:142
msgid ""
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
"clause*, which, when present, must follow all except clauses.  It is useful "
"for code that must be executed if the try clause does not raise an "
"exception.  For example::"
msgstr ""
"L'instruction :keyword:`try` ... :keyword:`except` a également une *clause "
"else* optionnelle qui, lorsqu'elle est présente, doit suivre toutes les "
"clauses except. Elle est utile pour du code qui doit être exécuté "
"lorsqu'aucune exception n'a été levée par la clause try. Par exemple : ::"

#: ../Doc/tutorial/errors.rst:156
msgid ""
"The use of the :keyword:`else` clause is better than adding additional code "
"to the :keyword:`try` clause because it avoids accidentally catching an "
"exception that wasn't raised by the code being protected by the :keyword:"
"`try` ... :keyword:`except` statement."
msgstr ""
"Il vaut mieux utiliser la clause :keyword:`else`, plutôt que d'ajouter du "
"code à la clause :keyword:`try`, car cela évite de capturer accidentellement "
"une exception qui n'a pas été levée par le code initialement protégé par "
"l'instruction :keyword:`try` ... :keyword:`except`."

#: ../Doc/tutorial/errors.rst:161
msgid ""
"When an exception occurs, it may have an associated value, also known as the "
"exception's *argument*. The presence and type of the argument depend on the "
"exception type."
msgstr ""
"Quand une exception intervient, une valeur peut lui être associée, que l'on "
"appelle également *l'argument* de l'exception. La présence de cet argument "
"et son type dépendent du type de l'exception."

#: ../Doc/tutorial/errors.rst:165
msgid ""
"The except clause may specify a variable after the exception name.  The "
"variable is bound to an exception instance with the arguments stored in "
"``instance.args``.  For convenience, the exception instance defines :meth:"
"`__str__` so the arguments can be printed directly without having to "
"reference ``.args``.  One may also instantiate an exception first before "
"raising it and add any attributes to it as desired. ::"
msgstr ""
"La clause except peut spécifier un nom de variable après le nom de "
"l'exception. Cette variable est liée à une instance d'exception avec les "
"arguments stockés dans ``instance.args``. Pour plus de commodité, l'instance "
"de l'exception définit la méthode :meth:`__str__` afin que les arguments "
"puissent être affichés directement sans avoir à référencer ``.args``. Il est "
"possible de construire une exception, y ajouter ses attributs, puis la "
"lancer plus tard. ::"

#: ../Doc/tutorial/errors.rst:189
msgid ""
"If an exception has arguments, they are printed as the last part ('detail') "
"of the message for unhandled exceptions."
msgstr ""
"Si une exception a un argument, il est affiché dans la dernière partie "
"('detail') du message des exceptions non gérées."

#: ../Doc/tutorial/errors.rst:192
msgid ""
"Exception handlers don't just handle exceptions if they occur immediately in "
"the try clause, but also if they occur inside functions that are called "
"(even indirectly) in the try clause. For example::"
msgstr ""
"Les gestionnaires d'exceptions n'interceptent pas que les exceptions qui "
"sont levées immédiatement dans leur clause try, mais aussi celles qui sont "
"levées au sein de fonctions appelées (parfois indirectement) dans la clause "
"try. Par exemple : ::"

#: ../Doc/tutorial/errors.rst:210
msgid "Raising Exceptions"
msgstr "Déclencher des exceptions"

#: ../Doc/tutorial/errors.rst:212
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"L'instruction :keyword:`raise` permet au programmeur de déclencher une "
"exception spécifique. Par exemple : ::"

#: ../Doc/tutorial/errors.rst:220
msgid ""
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
"This must be either an exception instance or an exception class (a class "
"that derives from :class:`Exception`)."
msgstr ""
"Le seul argument à :keyword:`raise` indique l'exception à déclencher. Cela "
"peut être soit une instance d'exception, soit une classe d'exception (une "
"classe dérivée de :class:`Exception`)."

#: ../Doc/tutorial/errors.rst:224
msgid ""
"If you need to determine whether an exception was raised but don't intend to "
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
"raise the exception::"
msgstr ""
"Si vous devez savoir qu'une exception a été levée mais sans intention de la "
"prendre en charge, une forme plus simple de l'instruction :keyword:`raise` "
"permet de re-déclencher l'exception : ::"

#: ../Doc/tutorial/errors.rst:243
msgid "User-defined Exceptions"
msgstr "Exceptions définies par l'utilisateur"

#: ../Doc/tutorial/errors.rst:245
msgid ""
"Programs may name their own exceptions by creating a new exception class "
"(see :ref:`tut-classes` for more about Python classes).  Exceptions should "
"typically be derived from the :exc:`Exception` class, either directly or "
"indirectly."
msgstr ""

#: ../Doc/tutorial/errors.rst:249
msgid ""
"Exception classes can be defined which do anything any other class can do, "
"but are usually kept simple, often only offering a number of attributes that "
"allow information about the error to be extracted by handlers for the "
"exception.  When creating a module that can raise several distinct errors, a "
"common practice is to create a base class for exceptions defined by that "
"module, and subclass that to create specific exception classes for different "
"error conditions::"
msgstr ""
"Les classes d'exceptions peuvent être définies pour faire tout ce qu'une "
"autre classe peut faire. Mais elles sont le plus souvent assez simples, "
"n'offrant que les attributs permettant aux gestionnaires de ces exceptions "
"d'extraire les informations relatives à l'erreur qui s'est produite. Lorsque "
"l'on crée un module qui peut déclencher plusieurs types d'erreurs distincts, "
"une pratique courante est de créer une classe de base pour l'ensemble des "
"exceptions définies dans ce module, et de créer des sous-classes spécifiques "
"d'exceptions pour les différentes conditions d'erreurs : ::"

#: ../Doc/tutorial/errors.rst:287
msgid ""
"Most exceptions are defined with names that end in \"Error,\" similar to the "
"naming of the standard exceptions."
msgstr ""
"La plupart des exceptions sont définies avec des noms qui se terminent par "
"\"Error\", comme pour les exceptions standards."

#: ../Doc/tutorial/errors.rst:290
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define.  More information on classes is presented in "
"chapter :ref:`tut-classes`."
msgstr ""
"La plupart des modules standards définissent leurs propres exceptions pour "
"décrire les erreurs que l'on peut rencontrer dans les fonctions qu'ils "
"définissent. Plus d'informations sur les classes sont présentées dans le "
"chapitre :ref:`tut-classes`."

#: ../Doc/tutorial/errors.rst:298
msgid "Defining Clean-up Actions"
msgstr "Définition d'actions de nettoyage"

#: ../Doc/tutorial/errors.rst:300
msgid ""
"The :keyword:`try` statement has another optional clause which is intended "
"to define clean-up actions that must be executed under all circumstances.  "
"For example::"
msgstr ""
"L'instruction :keyword:`try` a une autre clause optionnelle qui est destinée "
"à définir des actions de nettoyage devant être exécutées dans certaines "
"circonstances. Par exemple : ::"

#: ../Doc/tutorial/errors.rst:314
msgid ""
"A *finally clause* is always executed before leaving the :keyword:`try` "
"statement, whether an exception has occurred or not. When an exception has "
"occurred in the :keyword:`try` clause and has not been handled by an :"
"keyword:`except` clause (or it has occurred in an :keyword:`except` or :"
"keyword:`else` clause), it is re-raised after the :keyword:`finally` clause "
"has been executed.  The :keyword:`finally` clause is also executed \"on the "
"way out\" when any other clause of the :keyword:`try` statement is left via "
"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement.  A "
"more complicated example::"
msgstr ""
"Une *clause finally* est toujours exécutée avant de quitter l'instruction :"
"keyword:`try`, qu'une exception ait été déclenchée ou non. Quand "
"uneexception a été déclenchée dans la clause :keyword:`try` et n'a pas été "
"prise en charge par une clause :keyword:`except` (ou si elle a été "
"déclenchée dans une clause :keyword:`except` ou :keyword:`else`), elle est "
"re-déclenchée après l'exécution de la clause :keyword:`finally`. La clause :"
"keyword:`finally` est également exécutée \"à la sortie\" quand "
"n'importequelle autre clause de l'instruction :keyword:`try` est abandonnée "
"par une instruction :keyword:`break`, :keyword:`continue` ou :keyword:"
"`return`. Voici un exemple plus compliqué : ::"

#: ../Doc/tutorial/errors.rst:347
msgid ""
"As you can see, the :keyword:`finally` clause is executed in any event.  "
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
"keyword:`except` clause and therefore re-raised after the :keyword:`finally` "
"clause has been executed."
msgstr ""
"Comme vous pouvez le voir, la clause :keyword:`finally` est exécutée dans "
"tous les cas. L'exception de type :exc:`TypeError` déclenchée en divisant "
"deux chaînes de caractères n'est pas prise en charge par la clause :keyword:"
"`except` et est donc re-déclenchée après que la clause :keyword:`finally` "
"ait été exécutée."

#: ../Doc/tutorial/errors.rst:352
msgid ""
"In real world applications, the :keyword:`finally` clause is useful for "
"releasing external resources (such as files or network connections), "
"regardless of whether the use of the resource was successful."
msgstr ""
"Dans les vraies applicatons, la clause :keyword:`finally` est notamment "
"utile pour libérer des ressources externes (telles que des fichiers ou des "
"connections réseau), que l'utilisation de ces ressources ait réussi ou non."

#: ../Doc/tutorial/errors.rst:360
msgid "Predefined Clean-up Actions"
msgstr "Actions de nettoyage prédéfinies"

#: ../Doc/tutorial/errors.rst:362
msgid ""
"Some objects define standard clean-up actions to be undertaken when the "
"object is no longer needed, regardless of whether or not the operation using "
"the object succeeded or failed. Look at the following example, which tries "
"to open a file and print its contents to the screen. ::"
msgstr ""
"Certains objets définissent des actions de nettoyage standards qui doivent "
"être exécutées lorsque l'objet n'est plus nécessaire, indépendamment du fait "
"que l'opération ayant utilisé l'objet ait réussi ou non. Regardez l'exemple "
"suivant, qui tente d'ouvrir un fichier et d'afficher son contenu à "
"l'écran : ::"

#: ../Doc/tutorial/errors.rst:370
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after this part of the code has finished "
"executing. This is not an issue in simple scripts, but can be a problem for "
"larger applications. The :keyword:`with` statement allows objects like files "
"to be used in a way that ensures they are always cleaned up promptly and "
"correctly. ::"
msgstr ""
"Le problème avec ce code est qu'il laisse le fichier ouvert pendant une "
"durée indéterminée après que le code ait fini de s'exécuter. Ce n'est pas un "
"problème avec des scripts simples, mais peut l'être au sein d'applications "
"plus conséquentes. L'instruction :keyword:`with` permet d'utiliser certains "
"objets comme des fichiers d'une façon qui assure qu'ils seront toujours "
"nettoyés rapidement et correctement. ::"

#: ../Doc/tutorial/errors.rst:380
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Objects which, like "
"files, provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""
"Dès que l'instruction est exécutée, le fichier *f* est toujours fermé, même "
"si un problème est survenu pendant l'exécution de ces lignes. D'autres "
"objets qui, comme pour les fichiers, fournissent des actions de nettoyage "
"prédéfinies l'indiquent dans leur documentation."

#: ../Doc/tutorial/floatingpoint.rst:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "Arithmétique en Nombre à Virgule Flottante : Problèmes et Limites"

#: ../Doc/tutorial/floatingpoint.rst:14
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the decimal fraction ::"
msgstr ""
"Les nombres à virgule flottante sont représentés, au niveau matériel, en "
"fractions de nombres binaires (base 2). Par exemple, la fraction "
"décimale : ::"

#: ../Doc/tutorial/floatingpoint.rst:19
msgid ""
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
msgstr ""
"a la valeur 1/10 + 2/100 + 5/1000, et de la même manière, la fraction "
"binaire : ::"

#: ../Doc/tutorial/floatingpoint.rst:23
msgid ""
"has value 0/2 + 0/4 + 1/8.  These two fractions have identical values, the "
"only real difference being that the first is written in base 10 fractional "
"notation, and the second in base 2."
msgstr ""
"a la valeur 0/2 + 0/4 + 1/8. Ces deux fractions ont une valeur identique, la "
"seule différence est que la première est une fraction décimale, la seconde "
"binaire."

#: ../Doc/tutorial/floatingpoint.rst:27
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions.  A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"Malheureusement, la plupart des fractions décimales n'ont pas de "
"représentation exacte en fractions binaires. Par conséquent, en général, les "
"nombres à virgule flottante que vous donnez sont seulement approximés en "
"fraction binaire pour être stocké dans la machine."

#: ../Doc/tutorial/floatingpoint.rst:32
msgid ""
"The problem is easier to understand at first in base 10.  Consider the "
"fraction 1/3.  You can approximate that as a base 10 fraction::"
msgstr ""
"Le problème est plus simple à aborder en base 10. Prenons par exemple, la "
"fraction 1/3. Vous pouvez l'approximer en une fraction décimale::"

#: ../Doc/tutorial/floatingpoint.rst:37 ../Doc/tutorial/floatingpoint.rst:41
msgid "or, better, ::"
msgstr "ou, mieux, ::"

#: ../Doc/tutorial/floatingpoint.rst:45
msgid ""
"and so on.  No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"etc... Peu importe le nombre de décimales que vous écrirez, le résultat ne "
"sera jamais exactement 1/3, mais une estimation s'en approchant toujours "
"mieux."

#: ../Doc/tutorial/floatingpoint.rst:49
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the "
"decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"De la même manière, peu importe combien de décimales en base 2 vous "
"utiliserez, la valeur décimale 0.1 ne peut être représentée exactement en "
"fraction binaire. En base 2, 1/10 est le nombre périodique suivant : ::"

#: ../Doc/tutorial/floatingpoint.rst:55
msgid ""
"Stop at any finite number of bits, and you get an approximation.  On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and "
"with the denominator as a power of two.  In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
"equal to the true value of 1/10."
msgstr ""
"En se limitant à une quantité finie de bits, on ne peut obtenir qu'une "
"approximation. Sur la majorité des machines aujourd'hui, les nombres à "
"virgule flottante sont approximés par une fraction binaire avec les 53 "
"premiers bits comme numérateur et une puissance de deux au dénominateur. "
"Dans le cas de 1/10, la fraction binaire est ``3602879701896397 / 2 ** 55`` "
"qui est proche mais pas exactement 1/10."

#: ../Doc/tutorial/floatingpoint.rst:62
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed.  Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine.  On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display ::"
msgstr ""
"Il est facile d'oublier que la valeur stockée est une approximation de la "
"fraction décimale d'origine, du fait de la manière dont les flottants sont "
"affichés dans l'interpréteur. Python n'affiche qu'une approximation décimale "
"de la valeur stockée en binaire. Si Python devait afficher la vraie valeur "
"décimale de l'approximation binaire stockée pour 0,1, il afficherait : ::"

#: ../Doc/tutorial/floatingpoint.rst:71
msgid ""
"That is more digits than most people find useful, so Python keeps the number "
"of digits manageable by displaying a rounded value instead ::"
msgstr ""
"C'est bien plus de décimales que nécessaire, donc Python affiche une valeur "
"arrondie afin d'améliorer la lisibilité : ::"

#: ../Doc/tutorial/floatingpoint.rst:77
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"Il faut se rappeler, bien que la valeur affichée ressemble à la valeur "
"exacte de 1/10, que la valeur stockée est la représentation la plus proche "
"en fraction binaire."

#: ../Doc/tutorial/floatingpoint.rst:80
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction.  For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``.  Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"Il existe beaucoup de nombres décimaux qui partagent une même approximation "
"en fraction binaire. Par exemple, ``0.1``, ``0.10000000000000001``, et "
"``0.1000000000000000055511151231257827021181583404541015625`` ont tous pour "
"approximation ``3602879701896397 / 2 ** 55``. Puisques toutes ces valeurs "
"décimales partagent la même approximation, chacune peut être affichée tout "
"en respectant ``eval(repr(x)) == x``."

#: ../Doc/tutorial/floatingpoint.rst:88
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``.   "
"Starting with Python 3.1, Python (on most systems) is now able to choose the "
"shortest of these and simply display ``0.1``."
msgstr ""
"Historiquement, le mode interactif de Python et la primitive :func:`repr` "
"auraient choisi la version avec 17 décimales significatives, "
"``0.10000000000000001``. Python, depuis la version 3.1 (sur la majorité des "
"systèmes) est maintenant capable de choisir la plus courte représentation et "
"n'afficher que ``0.1``."

#: ../Doc/tutorial/floatingpoint.rst:93
msgid ""
"Note that this is in the very nature of binary floating-point: this is not a "
"bug in Python, and it is not a bug in your code either.  You'll see the same "
"kind of thing in all languages that support your hardware's floating-point "
"arithmetic (although some languages may not *display* the difference by "
"default, or in all output modes)."
msgstr ""
"Ce comportement est inhérent au comportement des nombres à virgule "
"flottante : ce n'est pas un bug dans Python, et ce n'est pas non plus un bug "
"dans votre code. Vous verrez le même type de comportement dans tous les "
"autres langages utilisant le support matériel pour le calcul des nombres à "
"virgules flottante (bien que certains langages ne rendent pas visible la "
"différence par défaut, ou pas dans tous les modes d'affichage)."

#: ../Doc/tutorial/floatingpoint.rst:99
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits::"
msgstr ""
"Pour obtenir un affichage plus plaisant, les fonctions de formatage de "
"chaînes de caractères peuvent limiter le nombre de décimales significatives "
"affichées::"

#: ../Doc/tutorial/floatingpoint.rst:111
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're "
"simply rounding the *display* of the true machine value."
msgstr ""
"Il est important de comprendre qu'en réalité, c'est une illusion : Python "
"arrondit simplement, la vraie valeur stockée, à *l'affichage*."

#: ../Doc/tutorial/floatingpoint.rst:114
msgid ""
"One illusion may beget another.  For example, since 0.1 is not exactly 1/10, "
"summing three values of 0.1 may not yield exactly 0.3, either::"
msgstr ""
"Une autre conséquence du fait que 0,1 n'est pas exactement stocké 1/10 est "
"que la somme de trois valeurs de 0,1 ne donne pas 0,3 non plus : ::"

#: ../Doc/tutorial/floatingpoint.rst:120
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
"func:`round` function cannot help::"
msgstr ""
"Aussi, puisque 0,1 ne peut pas être stocké avec une représentation plus "
"proche de sa valeur exacte 1/10, comme 0,3 qui ne peut pas être plus proche "
"de sa valeur exacte 3/10, arrondir avec la fonction :func:`round` n'aide en "
"rien : ::"

#: ../Doc/tutorial/floatingpoint.rst:127
msgid ""
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`round` function can be useful for post-rounding so that results "
"with inexact values become comparable to one another::"
msgstr ""
"Bien que les nombres ne peuvent se rapprocher plus de la valeur qu'on attend "
"qu'ils aient, la fonction :func:`round` peut être utile à posteriori pour "
"arrondir deux valeurs inexactes et les rendre comparables : ::"

#: ../Doc/tutorial/floatingpoint.rst:134
msgid ""
"Binary floating-point arithmetic holds many surprises like this.  The "
"problem with \"0.1\" is explained in precise detail below, in the "
"\"Representation Error\" section.  See `The Perils of Floating Point <http://"
"www.lahey.com/float.htm>`_ for a more complete account of other common "
"surprises."
msgstr ""
"L'arithmétique des nombres binaires à virgule flottante réserve beaucoup de "
"surprises de ce genre. Le problème avec \"0.1\" est expliqué en détails ci-"
"desous, dans la section \"Représentation d'Erreur\". Voir `The Perils of "
"Floating Point <http://www.lahey.com/float.htm>`_ pour une liste plus "
"complète de ce genre de surprises."

#: ../Doc/tutorial/floatingpoint.rst:139
msgid ""
"As that says near the end, \"there are no easy answers.\"  Still, don't be "
"unduly wary of floating-point!  The errors in Python float operations are "
"inherited from the floating-point hardware, and on most machines are on the "
"order of no more than 1 part in 2\\*\\*53 per operation.  That's more than "
"adequate for most tasks, but you do need to keep in mind that it's not "
"decimal arithmetic and that every float operation can suffer a new rounding "
"error."
msgstr ""
"Il est vrai qu'il n'existe pas de réponse simple, cependant ne vous méfiez "
"pas trop des nombres à virtule flottante ! Les erreurs, en Python, dans les "
"opérations de nombres à virgule flottante sont dues au matériel sous-jacent, "
"et sur la plupart des machines ne sont pas plus importantes que 1 sur 2\\*"
"\\*53 par opération. C'est plus que nécessaire pour la plupart des tâches, "
"mais vous devez garder à l'esprit que ce ne sont pas des opérations "
"décimales, et que chaque opération sur des nombres à virgule flottante peut "
"souffrir d'une nouvelle erreur."

#: ../Doc/tutorial/floatingpoint.rst:146
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the :meth:"
"`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"Bien que des cas pathologiques existent, pour la plupart des cas "
"d'utilisations courants vous obtiendrez le résultat attendu à la fin et en "
"arrondissant simplement au nombre de décimales désirées à l'affichage avec :"
"func:`str`. Pour un contrôle fin sur la manière dont les décimales sont "
"affichées, consultez dans :ref:`formatstrings` les spécifications de "
"formattage de la méthode :meth:`str.format`."

#: ../Doc/tutorial/floatingpoint.rst:152
msgid ""
"For use cases which require exact decimal representation, try using the :mod:"
"`decimal` module which implements decimal arithmetic suitable for accounting "
"applications and high-precision applications."
msgstr ""
"Pour les cas requérant une représentation décimale exacte, le module :mod:"
"`decimal` peut être utile, il implémente l'arithmétique décimale et peut "
"donc être un choix adapté pour des applications nécessitant une grande "
"précision."

#: ../Doc/tutorial/floatingpoint.rst:156
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module "
"which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"Une autre forme d'arithmétique exacte est implémentée dans le module :mod:"
"`fractions` qui se base sur les nombre rationnels (donc 1/3 peut y être "
"représenté exactement)."

#: ../Doc/tutorial/floatingpoint.rst:160
msgid ""
"If you are a heavy user of floating point operations you should take a look "
"at the Numerical Python package and many other packages for mathematical and "
"statistical operations supplied by the SciPy project. See <https://scipy."
"org>."
msgstr ""

#: ../Doc/tutorial/floatingpoint.rst:164
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float.  The :meth:`float."
"as_integer_ratio` method expresses the value of a float as a fraction::"
msgstr ""
"Python fournit des outils qui peuvent être utils dans les rares occasions ou "
"vous voulez réellement connaître la valeur exacte d'un nombre à virgule "
"flottante. La méthode :meth:`float.as_integer_ratio` donne la valeur du "
"nombre sous forme de fraction : ::"

#: ../Doc/tutorial/floatingpoint.rst:173
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value::"
msgstr ""
"Puisque le ratio est exact, il peut être utilisé pour recréer la valeur "
"originale dans perte : ::"

#: ../Doc/tutorial/floatingpoint.rst:179
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer::"
msgstr ""
"La méthode :meth:`float.hex` donne le nombre en hexadécimal (base 16), "
"donnant ici aussi la valeur exacte stockée par la machine : ::"

#: ../Doc/tutorial/floatingpoint.rst:185
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly::"
msgstr ""
"Cette représentation hexadécimale petit être utilisée pour reconstruire, "
"sans approximation, le *float* ::"

#: ../Doc/tutorial/floatingpoint.rst:191
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"Puisque cette représentation est exacte, elle est pratique pour échanger des "
"valeurs entre différentes version de Python (indépendamment de la machine) "
"ou d'autres langages qui comprennent ce format (tel que Java et C99)."

#: ../Doc/tutorial/floatingpoint.rst:195
msgid ""
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
"loss-of-precision during summation.  It tracks \"lost digits\" as values are "
"added onto a running total.  That can make a difference in overall accuracy "
"so that the errors do not accumulate to the point where they affect the "
"final total:"
msgstr ""
"Une autre fonction utile est :func:`math.fsum`, qui aide à diminuer les "
"pertes de précision lors des additions. Elle surveille les *décimales "
"perdues* au fur et à mesure que les valeurs sont ajoutées au total. Cela "
"peut faire une différence au niveau de la précision globale car cela empêche "
"les erreurs de s'accumuler jusqu'au point ou le résultat final est affecté:"

#: ../Doc/tutorial/floatingpoint.rst:209
msgid "Representation Error"
msgstr "Erreurs de représentation"

#: ../Doc/tutorial/floatingpoint.rst:211
msgid ""
"This section explains the \"0.1\" example in detail, and shows how you can "
"perform an exact analysis of cases like this yourself.  Basic familiarity "
"with binary floating-point representation is assumed."
msgstr ""
"Cette section explique en détail l'exemple du \"0.1\", et montre comment "
"vous pouvez effectuer une analyse exacte de ce type de cas par vous-même. Il "
"est supposé que vous êtes déjà familier de la représentation binaire des "
"nombres flottants."

#: ../Doc/tutorial/floatingpoint.rst:215
msgid ""
":dfn:`Representation error` refers to the fact that some (most, actually) "
"decimal fractions cannot be represented exactly as binary (base 2) "
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
"Fortran, and many others) often won't display the exact decimal number you "
"expect."
msgstr ""
"Le terme :dfn:`Representation error` signifie que la plupart des fractions "
"décimales ne peuvent être représentées exactement en binaire. C'est la "
"principale raison pour laquelle Python (ou Perl, C, C++, Java, Fortran, et "
"beuacoup d'autres) n'affiche habituellement pas le résultat exact en décimal."

#: ../Doc/tutorial/floatingpoint.rst:220
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction. Almost "
"all machines today (November 2000) use IEEE-754 floating point arithmetic, "
"and almost all platforms map Python floats to IEEE-754 \"double precision"
"\".  754 doubles contain 53 bits of precision, so on input the computer "
"strives to convert 0.1 to the closest fraction it can of the form *J*/2**\\ "
"*N* where *J* is an integer containing exactly 53 bits.  Rewriting ::"
msgstr ""
"Pourquoi ? 1/10 n'est pas représentable de manière exacte en fractions "
"binaires. Cependant, toutes les machines d'aujourd'hui (Juillet 2010) "
"suivent la norme IEEE-754 en ce qui concerne l'arithmétique des nombres à "
"virgule flottante. et la plupart des plateformes utilisent un \"IEEE-754 "
"double precision\" pour représenter les floats de Python. Les \"IEEE-754 "
"double precision\" utilisent 53 bits de précision, donc a la lecture "
"l'ordinateur essaie de convertir 0,1 dans la fraction la plus proche "
"possible de la forme *J*/2**\\ *N* avec *J* un nombre entier d'exactement 53 "
"bits. Réecrire : ::"

#: ../Doc/tutorial/floatingpoint.rst:229
msgid "as ::"
msgstr "en : ::"

#: ../Doc/tutorial/floatingpoint.rst:233
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56::"
msgstr ""
"en se rappelant que *J* fait exactement 53 bits (donc ``>= 2**52`` mais ``< "
"2**53``), la meilleur valeur possible pour *N* est 56::"

#: ../Doc/tutorial/floatingpoint.rst:239
msgid ""
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits.  "
"The best possible value for *J* is then that quotient rounded::"
msgstr ""
"Donc 56 est la seule valeur possible pour *N* qui laisse exactement 53 bits "
"pour *J*. La meilleure valeur possible pour *J* est donc ce quotient, "
"arrondi::"

#: ../Doc/tutorial/floatingpoint.rst:246
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up::"
msgstr ""
"Puisque la retenue est plus grande que la moitié de 10, la meilleure "
"approximation est obtenue en arrondissant par le haut:"

#: ../Doc/tutorial/floatingpoint.rst:252
msgid ""
"Therefore the best possible approximation to 1/10 in 754 double precision "
"is::"
msgstr ""
"Par conséquent la meilleure approximation possible pour 1/10 en \"IEEE-754 "
"double precision\" est cette au desus de 2\\*\\*56, soit : ::"

#: ../Doc/tutorial/floatingpoint.rst:256
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr ""
"Diviser le numérateur et le dénominateur par deux réduit la fraction à : ::"

#: ../Doc/tutorial/floatingpoint.rst:260
msgid ""
"Note that since we rounded up, this is actually a little bit larger than "
"1/10; if we had not rounded up, the quotient would have been a little bit "
"smaller than 1/10.  But in no case can it be *exactly* 1/10!"
msgstr ""
"Notez que puisque l'arrondi a été fait vers le haut, le résultat est en "
"réalité légèrement plus grand que 1/10; si nous n'avions pas arrondi par le "
"haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun "
"cas il ne vaut *exactement* 1/10 !"

#: ../Doc/tutorial/floatingpoint.rst:264
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best 754 double approximation it can get::"
msgstr ""
"Donc l'ordinateur ne \"voit\" jamais 1/10: ce qu'il voit est la fraction "
"exacte donnée ci-dessus, la meilleure approximation utilisant les nombres à "
"virgule flottante double précision de l'\"IEEE-754\""

#: ../Doc/tutorial/floatingpoint.rst:270
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits::"
msgstr ""
"Si on multiplie cette fraction par 10\\*\\*30, on peut observer les valeurs "
"de ses 55 décimales de poid fort::"

#: ../Doc/tutorial/floatingpoint.rst:276
msgid ""
"meaning that the exact number stored in the computer is equal to the decimal "
"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
"displaying the full decimal value, many languages (including older versions "
"of Python), round the result to 17 significant digits::"
msgstr ""
"la valeur stockée dans l'ordinateur est donc égale à "
"0,1000000000000000055511151231257827021181583404541015625. Au lieu "
"d'afficher toutes les décimales, beaucoup de langages (dont les vieilles "
"version de Python) arrondissent le résultat à la 17eme décimale "
"significative."

#: ../Doc/tutorial/floatingpoint.rst:284
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
"easy::"
msgstr ""
"Les modules :mod:`fractions` et :mod:`decimal` rendent simples ces "
"calculs : ::"

#: ../Doc/tutorial/index.rst:5
msgid "The Python Tutorial"
msgstr "Le tutoriel python"

#: ../Doc/tutorial/index.rst:7
msgid ""
"Python is an easy to learn, powerful programming language. It has efficient "
"high-level data structures and a simple but effective approach to object-"
"oriented programming. Python's elegant syntax and dynamic typing, together "
"with its interpreted nature, make it an ideal language for scripting and "
"rapid application development in many areas on most platforms."
msgstr ""
"Python est un langage de programmation puissant et facile à apprendre. Il "
"dispose de structures de données de haut niveau et d'une approche de la "
"programmation orientée objet simple mais efficace. Parce que sa syntaxe est "
"élégante, que son typage est dynamique et qu'il est interprété, Python est "
"un langage idéal pour l'écriture de scripts et le développement rapide "
"d'applications dans de nombreux domaines et sur de nombreuses plateformes."

#: ../Doc/tutorial/index.rst:13
msgid ""
"The Python interpreter and the extensive standard library are freely "
"available in source or binary form for all major platforms from the Python "
"Web site, https://www.python.org/, and may be freely distributed. The same "
"site also contains distributions of and pointers to many free third party "
"Python modules, programs and tools, and additional documentation."
msgstr ""
"L'interpréteur Python et sa vaste bibliothèque standard sont disponibles "
"librement, sous forme de sources ou de binaires, pour toutes les plateformes "
"majeures, depuis le site Internet http://www.python.org/ et peuvent être "
"librement redistribués. Le même site distribue et contient des liens vers "
"des modules, des programmes et des outils tiers ainsi que vers de la "
"documentation supplémentaire."

#: ../Doc/tutorial/index.rst:19
msgid ""
"The Python interpreter is easily extended with new functions and data types "
"implemented in C or C++ (or other languages callable from C). Python is also "
"suitable as an extension language for customizable applications."
msgstr ""
"L'interpréteur Python peut être facilement étendu par de nouvelles fonctions "
"et types de données implémentés en C ou C++ (ou tout autre langage appelable "
"depuis le C). Python est également adapté comme langage d'extension pour "
"personnaliser des applications."

#: ../Doc/tutorial/index.rst:23
msgid ""
"This tutorial introduces the reader informally to the basic concepts and "
"features of the Python language and system. It helps to have a Python "
"interpreter handy for hands-on experience, but all examples are self-"
"contained, so the tutorial can be read off-line as well."
msgstr ""
"Ce tutoriel introduit au lecteur, de façon informelle, les concepts de base "
"ainsi que les fonctionnalités du langage Python et de son écosystème. Il "
"aide à prendre en main l'interpréteur Python pour une utilisation sur des "
"cas pratiques. Les exemples étant indépendants, le tutoriel est adapté à une "
"lecture hors ligne."

#: ../Doc/tutorial/index.rst:28
msgid ""
"For a description of standard objects and modules, see :ref:`library-"
"index`. :ref:`reference-index` gives a more formal definition of the "
"language.  To write extensions in C or C++, read :ref:`extending-index` and :"
"ref:`c-api-index`. There are also several books covering Python in depth."
msgstr ""
"Pour une description des objets et modules de la bibliothèque standard, "
"voyez :ref:`library-index`. :ref:`reference-index` présente une définition "
"plus formelle du langage. Pour écrire des extensions en C ou en C++, lisez :"
"ref:`extending-index` et :ref:`c-api-index`. Des livres sont également "
"disponibles qui couvrent Python dans le détail."

#: ../Doc/tutorial/index.rst:33
msgid ""
"This tutorial does not attempt to be comprehensive and cover every single "
"feature, or even every commonly used feature. Instead, it introduces many of "
"Python's most noteworthy features, and will give you a good idea of the "
"language's flavor and style. After reading it, you will be able to read and "
"write Python modules and programs, and you will be ready to learn more about "
"the various Python library modules described in :ref:`library-index`."
msgstr ""
"L'ambition de ce tutoriel n'est pas d'être exhaustif et de couvrir chaque "
"fonctionnalités, ni même toutes les fonctionnalités les plus utilisées. Il "
"cherche, par contre, à introduire plusieurs des fonctionnalités les plus "
"notables et à vous donner une bonne idée de la saveur et du style du "
"langage. Après l'avoir lu, vous serez capable de lire et d'écrire des "
"modules et des programmes Python et vous serez prêts à en apprendre "
"d'avantage sur les modules de la bibliothèque Python décrits dans :ref:"
"`library-index`."

#: ../Doc/tutorial/index.rst:40
msgid "The :ref:`glossary` is also worth going through."
msgstr "Pensez aussi à consulter le :ref:`glossary`."

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

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

#: ../Doc/tutorial/interactive.rst:5
msgid "Interactive Input Editing and History Substitution"
msgstr "Édition interactive des entrées et substitution d'historique"

#: ../Doc/tutorial/interactive.rst:7
msgid ""
"Some versions of the Python interpreter support editing of the current input "
"line and history substitution, similar to facilities found in the Korn shell "
"and the GNU Bash shell.  This is implemented using the `GNU Readline`_ "
"library, which supports various styles of editing.  This library has its own "
"documentation which we won't duplicate here."
msgstr ""
"Certaines versions de l'interpréteur Python prennent en charge l'édition de "
"la ligne d'entrée courante et la substitution d'historique, similaires aux "
"facilités que l'on trouve dans le shell Korn et dans le shell GNU Bash. "
"C'est implémenté en utilisant la bibliothèque `GNU Readline`_, qui supporte "
"plusieurs styles d'édition. La bibliothèque a sa propre documentation qui ne "
"va pas être dupliquée ici."

#: ../Doc/tutorial/interactive.rst:17
msgid "Tab Completion and History Editing"
msgstr "Complément Automatique et édition de l'historique"

#: ../Doc/tutorial/interactive.rst:19
msgid ""
"Completion of variable and module names is :ref:`automatically enabled "
"<rlcompleter-config>` at interpreter startup so that the :kbd:`Tab` key "
"invokes the completion function; it looks at Python statement names, the "
"current local variables, and the available module names.  For dotted "
"expressions such as ``string.a``, it will evaluate the expression up to the "
"final ``'.'`` and then suggest completions from the attributes of the "
"resulting object.  Note that this may execute application-defined code if an "
"object with a :meth:`__getattr__` method is part of the expression.  The "
"default configuration also saves your history into a file named :file:`."
"python_history` in your user directory. The history will be available again "
"during the next interactive interpreter session."
msgstr ""
"La complétion de variables et de noms de modules est :ref:`automatiquement "
"activé <rlcompleter-config>` lors du démarrage de l'interpréteur, tel que la "
"touche :kbd:`Tab` invoque la fonction de complétion, donc taper la touche :"
"kbd:`Tab` deux fois de suite suggère les options disponibles ; la recherche "
"s'effectue dans les noms d'instructions Python, les noms des variables "
"locales et les noms de modules disponibles. Pour les expressions pointées "
"telles que ``string.a``, l'expression est évaluée jusqu'au dernier ``'.'`` "
"avant de suggérer les options disponibles à partir des attributs de l'objet "
"résultant de cette évaluation. Notez bien que ceci peut exécuter une partie "
"du code de l'application si un objet disposant d'une méthode :meth:"
"`__getattr__` fait partie de l'expression. La configuration par défaut "
"sauvegarde l'historique dans un fichier nommé :file:`.python_history` dans "
"votre dossier d'utilisateur. L'historique sera à nouveau disponible lors de "
"la prochaine session interactive."

#: ../Doc/tutorial/interactive.rst:36
msgid "Alternatives to the Interactive Interpreter"
msgstr "Alternatives à l'interpréteur interactif"

#: ../Doc/tutorial/interactive.rst:38
msgid ""
"This facility is an enormous step forward compared to earlier versions of "
"the interpreter; however, some wishes are left: It would be nice if the "
"proper indentation were suggested on continuation lines (the parser knows if "
"an indent token is required next).  The completion mechanism might use the "
"interpreter's symbol table.  A command to check (or even suggest) matching "
"parentheses, quotes, etc., would also be useful."
msgstr ""
"Cette facilité constitue un énorme pas en avant comparé aux versions "
"précédentes de l'interpréteur ; toutefois, certains souhaits sont laissés de "
"côté : ce serait bien si une indentation correcte était proposée sur les "
"lignes de continuation (l'analyseur sait si une indentation doit suivre). Le "
"mécanisme de complétion devrait utiliser la table de symboles de "
"l'interpréteur. Une commande pour vérifier (ou même suggérer) les "
"correspondances de parenthèses, de guillemets..., serait également utile."

#: ../Doc/tutorial/interactive.rst:45
msgid ""
"One alternative enhanced interactive interpreter that has been around for "
"quite some time is IPython_, which features tab completion, object "
"exploration and advanced history management.  It can also be thoroughly "
"customized and embedded into other applications.  Another similar enhanced "
"interactive environment is bpython_."
msgstr ""
"Une alternative améliorée de l'interpréteur interactif qui a été développée "
"depuis maintenant quelques temps est IPython_, qui fournit la complétude, "
"l'exploration d'objets et une gestion avancée de l'historique. Il peut "
"également être personnalisé en profondeur et embarqué dans d'autres "
"applications. Un autre environnement interactif amélioré similaire est "
"bpython_."

#: ../Doc/tutorial/interpreter.rst:5
msgid "Using the Python Interpreter"
msgstr "Utiliser l'interpréteur Python"

#: ../Doc/tutorial/interpreter.rst:11
msgid "Invoking the Interpreter"
msgstr "Invoquer l'interpréteur"

#: ../Doc/tutorial/interpreter.rst:13
msgid ""
"The Python interpreter is usually installed as :file:`/usr/local/bin/"
"python3.6` on those machines where it is available; putting :file:`/usr/"
"local/bin` in your Unix shell's search path makes it possible to start it by "
"typing the command:"
msgstr ""

#: ../Doc/tutorial/interpreter.rst:21
msgid ""
"to the shell. [#]_ Since the choice of the directory where the interpreter "
"lives is an installation option, other places are possible; check with your "
"local Python guru or system administrator.  (E.g., :file:`/usr/local/python` "
"is a popular alternative location.)"
msgstr ""
"dans le shell. [#]_ Le choix du répertoire où se trouve l'interpréteur étant "
"uneoption d'installation, d'autres chemins sont possibles; voyez avec votre "
"guru Python local ou votre administrateur système. (Par exemple, :file:`/usr/"
"local/python` est une localisation courante.)"

#: ../Doc/tutorial/interpreter.rst:26
msgid ""
"On Windows machines, the Python installation is usually placed in :file:`C:\\"
"\\Python36`, though you can change this when you're running the installer.  "
"To add this directory to your path,  you can type the following command into "
"the command prompt in a DOS box::"
msgstr ""

#: ../Doc/tutorial/interpreter.rst:33
msgid ""
"Typing an end-of-file character (:kbd:`Control-D` on Unix, :kbd:`Control-Z` "
"on Windows) at the primary prompt causes the interpreter to exit with a zero "
"exit status.  If that doesn't work, you can exit the interpreter by typing "
"the following command: ``quit()``."
msgstr ""
"Taper un caractère de fin de fichier (:kbd:`Ctrl-D` sous Unix, :kbd:`Ctrl-Z` "
"sous Windows) suive à une invite de commande primaire provoque la fermeture "
"de l'interpréteur avec un statut d'erreur nul. Si cela ne fonctionne pas, "
"vous pouvez fermer l'interpréteur en tapant la commande ``quit()``."

#: ../Doc/tutorial/interpreter.rst:38
msgid ""
"The interpreter's line-editing features include interactive editing, history "
"substitution and code completion on systems that support readline.  Perhaps "
"the quickest check to see whether command line editing is supported is "
"typing :kbd:`Control-P` to the first Python prompt you get.  If it beeps, "
"you have command line editing; see Appendix :ref:`tut-interacting` for an "
"introduction to the keys.  If nothing appears to happen, or if ``^P`` is "
"echoed, command line editing isn't available; you'll only be able to use "
"backspace to remove characters from the current line."
msgstr ""
"Les fonctionnalités d'édition de l'interpréteur comprennent l'édition "
"interactive, la substitution depuis l'historique, et la complétion, sur les "
"systèmes qui gèrent readline. Le moyen le plus rapide de tester si l'édition "
"de la ligne decommande est gérée est peut-être de taper :kbd:`Control-P` "
"suite au premier invite de commande que vous rencontrez. Si cela bip, vous "
"disposez de l'édition de la ligne de commande; voyez l'appendice :ref:`tut-"
"interacting` pour une introduction aux touches. Si rien ne semble se "
"produire ou si ``^P`` s'affiche, l'édition de la ligne de commande n'est pas "
"disponible; vous serez seulement en mesure d'utiliser la touche retour "
"arrière pour supprimer des caractères de la ligne courante."

#: ../Doc/tutorial/interpreter.rst:47
msgid ""
"The interpreter operates somewhat like the Unix shell: when called with "
"standard input connected to a tty device, it reads and executes commands "
"interactively; when called with a file name argument or with a file as "
"standard input, it reads and executes a *script* from that file."
msgstr ""
"L'interpréteur opère de façon similaire au shell Unix : lorsqu'il est appelé "
"avec l'entrée standard connectée à un périphérique tty, il lit et exécute "
"les commandes de façon interactive; lorsqu'il est appelé avec un nom de "
"fichier en argument ou avec un fichier comme entrée standard, il lit et "
"exécute un *script* depuis ce fichier."

#: ../Doc/tutorial/interpreter.rst:52
msgid ""
"A second way of starting the interpreter is ``python -c command [arg] ...``, "
"which executes the statement(s) in *command*, analogous to the shell's :"
"option:`-c` option.  Since Python statements often contain spaces or other "
"characters that are special to the shell, it is usually advised to quote "
"*command* in its entirety with single quotes."
msgstr ""
"Une autre façon de lancer l'interpréteur est ``python -c commande [arg] ..."
"``. Cela exécute les instructions de *commande* de façon analogue à "
"l'option :option:`-c` du shell. Parce que les instructions Python "
"contiennent souvent des espaces et d'autres caractères spéciaux pour le "
"shell, il est généralement conseillé de mettre *commande* entre guillemets "
"simples."

#: ../Doc/tutorial/interpreter.rst:58
msgid ""
"Some Python modules are also useful as scripts.  These can be invoked using "
"``python -m module [arg] ...``, which executes the source file for *module* "
"as if you had spelled out its full name on the command line."
msgstr ""
"Certains modules Python sont aussi utiles en tant que scripts. Ils peuvent "
"être appelé avec ``python -m module [arg] ...`` qui exécute le fichier "
"source de *module* comme si vous aviez tapé son nom complet dans la ligne de "
"commande."

#: ../Doc/tutorial/interpreter.rst:62
msgid ""
"When a script file is used, it is sometimes useful to be able to run the "
"script and enter interactive mode afterwards.  This can be done by passing :"
"option:`-i` before the script."
msgstr ""
"Quand un fichier de script est utilisé, il est parfois utile de pouvoir "
"lancer le script puis d'entrer dans le mode interactif après coup. Cela est "
"possible en passant :option:`-i` avant le script."

#: ../Doc/tutorial/interpreter.rst:66
msgid "All command line options are described in :ref:`using-on-general`."
msgstr ""
"Tous les paramètres utilisables en ligne de commande sont documentés dans :"
"ref:`using-on-general`."

#: ../Doc/tutorial/interpreter.rst:72
msgid "Argument Passing"
msgstr "Passage d'arguments"

#: ../Doc/tutorial/interpreter.rst:74
msgid ""
"When known to the interpreter, the script name and additional arguments "
"thereafter are turned into a list of strings and assigned to the ``argv`` "
"variable in the ``sys`` module.  You can access this list by executing "
"``import sys``.  The length of the list is at least one; when no script and "
"no arguments are given, ``sys.argv[0]`` is an empty string.  When the script "
"name is given as ``'-'`` (meaning  standard input), ``sys.argv[0]`` is set "
"to ``'-'``.  When :option:`-c` *command* is used, ``sys.argv[0]`` is set to "
"``'-c'``.  When :option:`-m` *module* is used, ``sys.argv[0]``  is set to "
"the full name of the located module.  Options found after  :option:`-c` "
"*command* or :option:`-m` *module* are not consumed  by the Python "
"interpreter's option processing but left in ``sys.argv`` for  the command or "
"module to handle."
msgstr ""
"Lorsqu'ils sont connus de l'interpréteur, le nom du script et les arguments "
"additionnels sont représentés sous forme d'une liste assignée à la variable "
"``argv`` du module ``sys``. Vous pouvez y accéder en exécutant ``import "
"sys``. La liste contient au minimum un élément; quand aucun script ni aucun "
"arguments ne sont donnés, ``sys.argv[0]`` est une chaine vide. Quand ``'-'`` "
"(qui représente l'entrée standard) est passé comme nom de script, ``sys."
"argv[0]`` contient ``'-'``. Quand :option:`-c` *commande* est utilisé, ``sys."
"argv[0]`` contient ``'-c'``. Enfin, quand :option:`-m` *module* est utilisé, "
"le nom complet du module est assigné à ``sys.argv[0]``. Les options trouvées "
"après :option:`-c` *commande* ou :option:`-m` *module* ne sont pas lues "
"comme options de l'interpréteur Python mais laissées dans ``sys.argv`` pour "
"être utilisée par le module ou la commande."

#: ../Doc/tutorial/interpreter.rst:92
msgid ""
"When commands are read from a tty, the interpreter is said to be in "
"*interactive mode*.  In this mode it prompts for the next command with the "
"*primary prompt*, usually three greater-than signs (``>>>``); for "
"continuation lines it prompts with the *secondary prompt*, by default three "
"dots (``...``). The interpreter prints a welcome message stating its version "
"number and a copyright notice before printing the first prompt:"
msgstr ""

#: ../Doc/tutorial/interpreter.rst:109
msgid ""
"Continuation lines are needed when entering a multi-line construct. As an "
"example, take a look at this :keyword:`if` statement::"
msgstr ""
"Les lignes de continuation sont nécessaires pour entrer une construction "
"multi-lignes. Par exemple, regardez cette instruction :keyword:`if` ::"

#: ../Doc/tutorial/interpreter.rst:119
msgid "For more on interactive mode, see :ref:`tut-interac`."
msgstr ""
"Pour plus d'informations sur le mode interactif, voir :ref:`tut-interac`."

#: ../Doc/tutorial/interpreter.rst:125
msgid "The Interpreter and Its Environment"
msgstr "L'interpréteur et son environnement"

#: ../Doc/tutorial/interpreter.rst:131
msgid "Source Code Encoding"
msgstr "Encodage du code source"

#: ../Doc/tutorial/interpreter.rst:133
msgid ""
"By default, Python source files are treated as encoded in UTF-8.  In that "
"encoding, characters of most languages in the world can be used "
"simultaneously in string literals, identifiers and comments --- although the "
"standard library only uses ASCII characters for identifiers, a convention "
"that any portable code should follow.  To display all these characters "
"properly, your editor must recognize that the file is UTF-8, and it must use "
"a font that supports all the characters in the file."
msgstr ""
"Par défaut Python considère que ses fichiers source sont encodés en UTF-8. "
"Dans cet encodage, les caractères de la plupart des langues peuvent être "
"utilisés ensemble dans les chaînes de caractères, identifiants, et "
"commentaires, bien que la bibliothèque standard n'utilise que des caractères "
"ASCII dans ses identifiants, une bonne habitude que tout code portable "
"devrait suivre. Pour afficher correctement tous ces caractères, votre "
"éditeur doit reconnaître que le fichier est en UTF-8, et utiliser une fonte "
"de caractère qui comprend tous les caractères utilisés dans le fichier."

#: ../Doc/tutorial/interpreter.rst:141
msgid ""
"It is also possible to specify a different encoding for source files.  In "
"order to do this, put one more special comment line right after the ``#!`` "
"line to define the source file encoding::"
msgstr ""
"Il est possible d'utiliser un autre encodage dans un fichier source Python. "
"La meilleure façon de faire est de placer un commentaire spécial "
"supplémentaire juste après le ``#!`` pour définir l'encodage du fichier "
"source::"

#: ../Doc/tutorial/interpreter.rst:147
msgid ""
"With that declaration, everything in the source file will be treated as "
"having the encoding *encoding* instead of UTF-8.  The list of possible "
"encodings can be found in the Python Library Reference, in the section on :"
"mod:`codecs`."
msgstr ""
"Avec cette déclaration, tous les caractères du fichier source sont traités "
"comme étant dans l'encodage *encoding* au lieu d'UTF-8. La liste des "
"encodages disponibles peut être trouvée dans la référence de la bibliothèque "
"Python dans la partie à propos de :mod:`codecs`."

#: ../Doc/tutorial/interpreter.rst:151
msgid ""
"For example, if your editor of choice does not support UTF-8 encoded files "
"and insists on using some other encoding, say Windows-1252, you can write::"
msgstr ""
"Par exemple, si votre éditeur de gère pas l'UTF-8 et insiste pour utiliser "
"un autre encodage, disons Windows-1252, vous pouvez écrire : ::"

#: ../Doc/tutorial/interpreter.rst:156
msgid ""
"and still use all characters in the Windows-1252 character set in the source "
"files.  The special encoding comment must be in the *first or second* line "
"within the file."
msgstr ""
"et continuer d'utiliser tous les caractères de Windows-1252 dans votre code. "
"Ce commentaire spécial spécifiant l'encodage doit être à *la première ou "
"deuxième* ligne du fichier."

#: ../Doc/tutorial/interpreter.rst:163
msgid ""
"On Unix, the Python 3.x interpreter is by default not installed with the "
"executable named ``python``, so that it does not conflict with a "
"simultaneously installed Python 2.x executable."
msgstr ""
"Sur Unix, l'interpréteur Python 3.x n'est pas, par défaut, installé sous le "
"nom de ``python`` pour ne pas entrer en conflit avec une éventuelle "
"installation de Python 2.x."

#: ../Doc/tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Introduction informelle à Python"

#: ../Doc/tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"Dans les exemples qui suivent, les entrées et sorties se distinguent par la "
"présence ou l'absence d'invite (:term:`>>>` et :term:`...`) : pour "
"reproduire les exemples, vous devez taper tout ce qui est après l'invite, au "
"moment où celle-ci apparaît ; les lignes qui n'affichent pas d'invite sont "
"les sorties de l'interpréteur. Notez qu'une invite secondaire affichée seule "
"sur une ligne dans un exemple indique que vous devez entrer une ligne vide ; "
"ceci est utilisé pour terminer une commande multi-lignes."

#: ../Doc/tutorial/introduction.rst:14
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments.  Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line.  A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal.  A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
"Beaucoup d'exemples de ce manuel, même ceux saisis à l'invite de "
"l'interpréteur, incluent des commentaires. Les commentaires en Python "
"commencent avec un caractère dièse, ``#``, et s'étendent jusqu'à la fin de "
"la ligne. Un commentaire peut apparaître au début d'une ligne ou à la suite "
"d'un espace ou de code, mais pas à l'intérieur d'une chaîne de caractères "
"littérale. Un caractère dièse à l'intérieur d'une chaîne de caractères est "
"juste un caractère dièse. Comme les commentaires ne servent qu'à expliquer "
"le code et ne sont pas interprétés par Python, ils peuvent être ignorés "
"lorsque vous tapez les exemples."

#: ../Doc/tutorial/introduction.rst:33
msgid "Using Python as a Calculator"
msgstr "Utiliser Python comme une calculatrice"

#: ../Doc/tutorial/introduction.rst:35
msgid ""
"Let's try some simple Python commands.  Start the interpreter and wait for "
"the primary prompt, ``>>>``.  (It shouldn't take long.)"
msgstr ""
"Essayons quelques commandes Python simples. Démarrez l'interpréteur et "
"attendez l'invite primaire, ``>>>``. Ça ne devrait pas être long."

#: ../Doc/tutorial/introduction.rst:42
msgid "Numbers"
msgstr "Les nombres"

#: ../Doc/tutorial/introduction.rst:44
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value.  Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
"L'interpréteur agit comme une simple calculatrice : vous pouvez lui entrer "
"une expression et il vous affiche la valeur. La syntaxe des expressions est "
"simple : les opérateurs ``+``, ``-``, ``*`` et ``/`` fonctionnent comme dans "
"la plupart des langages (par exemple, Pascal ou C) ; les parenthèses peuvent "
"être utilisées pour faire des regroupements. Par exemple : ::"

#: ../Doc/tutorial/introduction.rst:59
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`.  We will see more about numeric types later in the tutorial."
msgstr ""
"Les nombre entiers (comme ``2``, ``4``, ``20``) sont de type :class:`int`, "
"alors que les décimaux (comme ``5.0``, ``1.6``) sont de type :class:`float`. "
"Plus de détails sont données sur les types numériques plus loin dans ce "
"tutoriel."

#: ../Doc/tutorial/introduction.rst:63
msgid ""
"Division (``/``) always returns a float.  To do :term:`floor division` and "
"get an integer result (discarding any fractional result) you can use the ``//"
"`` operator; to calculate the remainder you can use ``%``::"
msgstr ""
"Les divisions (``/``) donnent toujours des :class:`float`. Utilisez "
"l'opérateur ``//`` pour effectuer des divisions entières, et donc obtenir un "
"résultat entier. Pour obtenir le reste de cette division entière, utilisez "
"l'opérateur ``%`` ::"

#: ../Doc/tutorial/introduction.rst:77
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"Avec Python il est possible de calculer des puissances avec l'opérateur "
"``**`` [#]_ ::"

#: ../Doc/tutorial/introduction.rst:84
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"Le signe égal (``=``) est utilisé pour affecter une valeur à une variable. "
"Après cela, aucun résultat n'est affiché avant l'invite suivante : ::"

#: ../Doc/tutorial/introduction.rst:92
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"Si une variable n'est pas \"définie\" (si aucune valeur ne lui a été "
"affecté), l'utiliser engendrera une erreur : ::"

#: ../Doc/tutorial/introduction.rst:100
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"Il y a un support complet des nombres à virgule flottante ; les opérateurs "
"avec des types d'opérandes mélangés convertissent l'opérande entier en "
"virgule flottante : ::"

#: ../Doc/tutorial/introduction.rst:108
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``.  This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"En mode interactif, la dernière expression affichée est affectée à la "
"variable ``_``. Ce qui signifie que lorsque vous utilisez Python comme "
"calculatrice, il est parfois plus simple de continuer des calculs, par "
"exemple : ::"

#: ../Doc/tutorial/introduction.rst:121
msgid ""
"This variable should be treated as read-only by the user.  Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
"Cette variable doit être considérée comme une variable en lecture seule par "
"l'utilisateur. Ne lui affectez pas de valeur explicitement --- vous créeriez "
"ainsi une variable locale indépendante avec le même nom qui masquerait la "
"variable native et son fonctionnement magique."

#: ../Doc/tutorial/introduction.rst:125
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
"Fraction`. Python also has built-in support for :ref:`complex numbers "
"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
"En plus des :class:`int` et des :class:`float`, il existe les :class:"
"`~decimal.Decimal` et les :class:`~fractions.Fraction`. Python gère aussi "
"les :ref:`nombre complexes <typesnumeric>`, en utilisant le suffixe ``j`` ou "
"``J`` pour indiquer la partie imaginaire (tel que: ``3+5j``)."

#: ../Doc/tutorial/introduction.rst:135
msgid "Strings"
msgstr "Les chaînes de caractères"

#: ../Doc/tutorial/introduction.rst:137
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways.  They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_.  ``\\`` can be used "
"to escape quotes::"
msgstr ""
"Au delà des nombres, Python peut aussi manipuler des chaînes de caractères, "
"qui peuvent être exprimés de différentes manières. Elles peuvent être "
"écrites entre guillemets simples (``'...'``) ou entre guillemets (``\"..."
"\"``) sans distinction [#]_. ``\\`` peut être utilisé pour protéger un "
"guillemet : ::"

#: ../Doc/tutorial/introduction.rst:155
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes.  While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent.  The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes.  The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
"En mode interactif, l'interpréteur affiche les chaînes de caractères entre "
"guillemets et en protégant les guillemets et autres caractères spéciaux avec "
"des antislash. Bien que cela puisse paraître différent de ce qui a été donné "
"(les guillemets peuvent changer) La chaîne est affichée entre guillemets si "
"elle contient un guillemet simple mais aucun guillemet, sinon elle est "
"affichée entreguillemets simples. La fonction :func:`print` affiche les "
"chaînes de manière plus lisible, en retirant les guillemets et en affichant "
"les caractères spéciaux qui étaient protégées par un antislash : ::"

#: ../Doc/tutorial/introduction.rst:175
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"Pour éviter que les caractères précédées d'un ``\\`` ne soient interprétés "
"comme étant spéciaux, utilisez les *chaînes brutes* (*raw strings*) en "
"préfixant la chaîne d'un ``r`` ::"

#: ../Doc/tutorial/introduction.rst:185
msgid ""
"String literals can span multiple lines.  One way is using triple-quotes: ``"
"\"\"\"...\"\"\"`` or ``'''...'''``.  End of lines are automatically included "
"in the string, but it's possible to prevent this by adding a ``\\`` at the "
"end of the line.  The following example::"
msgstr ""
"Les chaînes de caractères peuvent s'étendre sur plusieurs lignes. On peut "
"utiliser les triples guillemets, simples ou doubles: ``'''...'''`` ou ``"
"\"\"\"...\"\"\"``. Les retours à la ligne sont automatiquement inclus, mais "
"on peut l'en empêcher en ajoutant ``\\`` à la fin de la ligne. L'exemple "
"suivant : ::"

#: ../Doc/tutorial/introduction.rst:196
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
"produit l'affichage suivant (notez que le premier retour à la ligne n'est "
"pas inclus) :"

#: ../Doc/tutorial/introduction.rst:204
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
"Les chaines peuvent être concaténées (collées ensemble) avec l'opérateur ``"
"+``, et répétées avec l'opérateur ``*``::"

#: ../Doc/tutorial/introduction.rst:211
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"Plusieurs chaînes de caractères, écrites littéralement (c'est à dire entre "
"guillemets), côte à côte, sont automatiquement concaténées. ::"

#: ../Doc/tutorial/introduction.rst:217
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"Cela ne fonctionne cependant qu'avec les chaînes littérales, pas les "
"variables ni les expressions : ::"

#: ../Doc/tutorial/introduction.rst:227
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"Pour concaténer des variables, ou des variables avec des chaînes littérales, "
"utilisez l'opérateur ``+``::"

#: ../Doc/tutorial/introduction.rst:232
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
"Cette fonctionnalité est surtout intéressante pour couper des chaînes trop "
"longues : ::"

#: ../Doc/tutorial/introduction.rst:239
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
"Les chaînes de caractères peuvent être indexées (accéder aux caractères par "
"leur position), le premiercaractère d'une chaîne est à la position 0. Il "
"n'existe pas de type distinct pour les caractères, un caractère est "
"simplement une chaîne de longueur 1 ::"

#: ../Doc/tutorial/introduction.rst:249
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"Les indices peuvent également être négatifs, pour effectuer un décompte en "
"partant de la droite. Par exemple : ::"

#: ../Doc/tutorial/introduction.rst:258
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "Notez que puisque -0 égal 0, les indices négatifs commencent par -1."

#: ../Doc/tutorial/introduction.rst:260
msgid ""
"In addition to indexing, *slicing* is also supported.  While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"En plus d'accéder à un élément par son indice, il est aussi possible de "
"*trancher* une liste. Accéder à une chaîne par un indice permet d'obtenir un "
"caractère, alors que la *trancher* permet d'obtenir une sous-chaïne : ::"

#: ../Doc/tutorial/introduction.rst:268
msgid ""
"Note how the start is always included, and the end always excluded.  This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"Notez que le début est toujours inclus et la fin toujours exclue. Cela "
"assure que ``s[:i] + s[i:]`` est toujours égal à ``s`` ::"

#: ../Doc/tutorial/introduction.rst:276
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"Les indices par tranches ont des valeurs par défaut utiles ; le premier "
"indice lorsqu'il est omis équivaut à zéro, le second à la taille de la "
"chaîne de caractères : ::"

#: ../Doc/tutorial/introduction.rst:286
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"Une façon de mémoriser la façon dont les tranches fonctionnent est de penser "
"que les indices pointent *entre* les caractères, le côté gauche du premier "
"caractère ayant la position 0. Le côté droit du dernier caractère d'une "
"chaîne de *n* caractères a alors pour indice *n*, par exemple : ::"

#: ../Doc/tutorial/introduction.rst:297
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"La première ligne de nombres donne la position des indices 0...6 dans la "
"chaîne ; la deuxième ligne donne l'indice négatif correspondant. La tranche "
"de *i* à *j* est constituée de tous les caractères situés entre les bords "
"libellés *i* et *j*, respectivement."

#: ../Doc/tutorial/introduction.rst:302
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds.  For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"Pour des indices non négatifs, la longueur d'une tranche est la différence "
"entre ces indices, si les deux sont entre les bornes. Par exemple, la longue "
"de ``word[1:3]`` est 2."

#: ../Doc/tutorial/introduction.rst:306
msgid "Attempting to use an index that is too large will result in an error::"
msgstr "Utiliser un indice trop grand générera une erreur : ::"

#: ../Doc/tutorial/introduction.rst:313
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"Cependant, les indices hors bornes sont gérés silencieusement lorsqu'ils "
"sont utilisés dans des tranches : ::"

#: ../Doc/tutorial/introduction.rst:321
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"Les chaînes de caractères, en Python ne peuvent pas être modifiées, on dit "
"quelles sont :term:`immutable`. Affecter une nouvelle valeur à un indice "
"dans une chaîne produit une erreur : ::"

#: ../Doc/tutorial/introduction.rst:331
msgid "If you need a different string, you should create a new one::"
msgstr ""
"Si vous avez besoin d'une chaîne différente, vous devez en créer une "
"autre : ::"

#: ../Doc/tutorial/introduction.rst:338
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "La fonction native :func:`len` renvoie la longueur d'une chaîne : ::"

#: ../Doc/tutorial/introduction.rst:349
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../Doc/tutorial/introduction.rst:348
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"Les chaînes de caractères sont des exemples de *types séquences*, et "
"supportent donc lesopérations classiques prises en charge par ces types."

#: ../Doc/tutorial/introduction.rst:353
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../Doc/tutorial/introduction.rst:352
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
"Les chaînes de caractères supportent un large éventail de méthodes de "
"transformations basiques et de recherche."

#: ../Doc/tutorial/introduction.rst:356
msgid ":ref:`f-strings`"
msgstr ""

#: ../Doc/tutorial/introduction.rst:356
msgid "String literals that have embedded expressions."
msgstr ""

#: ../Doc/tutorial/introduction.rst:359
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"

#: ../Doc/tutorial/introduction.rst:359
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
"Informations sur le formatage des chaînes avec la méthode :meth:`str.format`."

#: ../Doc/tutorial/introduction.rst:362
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"

#: ../Doc/tutorial/introduction.rst:362
msgid ""
"The old formatting operations invoked when strings and Unicode strings are "
"the left operand of the ``%`` operator are described in more detail here."
msgstr ""
"Les anciennes opérations de formatage appelées lorsque les chaînes de "
"caractères et les chaînes Unicode sont les opérandes placés à gauche de "
"l'opérateur ``%`` sont décrites plus en détail ici."

#: ../Doc/tutorial/introduction.rst:369
msgid "Lists"
msgstr "Les listes"

#: ../Doc/tutorial/introduction.rst:371
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values.  The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets.  Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"Python connaît différents types de données *combinés*, utilisés pour "
"regrouper plusieurs valeurs. La plus souple est la *liste*, qui peut être "
"écrite comme une suite de valeurs (éléments) séparés par des virgules placée "
"entre crochets. Les éléments d'une liste ne sont pas obligatoirement tous du "
"même type, bien qu'à l'usage ce soit souvent le cas. ::"

#: ../Doc/tutorial/introduction.rst:380
msgid ""
"Like strings (and all other built-in :term:`sequence` type), lists can be "
"indexed and sliced::"
msgstr ""
"Comme les chaînes de caractères (et toute autre types de :term:`sequence`), "
"les listes peuvent être indicées et découpées : ::"

#: ../Doc/tutorial/introduction.rst:390
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a new (shallow) copy of the "
"list::"
msgstr ""
"Toutes les opérations par tranches renvoient une nouvelle liste contenant "
"les éléments demandés. Ce qui signifie que l'opération suivante renvoie une "
"copie superficielle de la liste : ::"

#: ../Doc/tutorial/introduction.rst:396
msgid "Lists also support operations like concatenation::"
msgstr "Les listes gèrent aussi les opérations comme les concaténations : ::"

#: ../Doc/tutorial/introduction.rst:401
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
"Mais à la différence des listes qui sont :term:`immuable`\\s, les listes "
"sont :term:`mutable`\\s : il est possible de changer leur contenu : ::"

#: ../Doc/tutorial/introduction.rst:411
msgid ""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr ""
"Il est aussi possible d'ajouter de nouveaux éléments à la fin d'une liste "
"avec la méthode :meth:`~list.append`. (Les méthodes seront abordées plus "
"tard) ::"

#: ../Doc/tutorial/introduction.rst:419
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Des affectations de tranches sont également possibles, ce qui peut même "
"modifier la taille de la liste ou la vider complètement : ::"

#: ../Doc/tutorial/introduction.rst:438
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "La primitive :func:`len` s'applique aussi aux listes : ::"

#: ../Doc/tutorial/introduction.rst:444
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"Il est possible d'imbriquer des listes (de créer des listes contenant "
"d'autres listes), par exemple : ::"

#: ../Doc/tutorial/introduction.rst:460
msgid "First Steps Towards Programming"
msgstr "Premiers pas vers la programmation"

#: ../Doc/tutorial/introduction.rst:462
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together.  For instance, we can write an initial sub-sequence of the "
"*Fibonacci* series as follows::"
msgstr ""
"Bien entendu, on peut utiliser Python pour des tâches plus compliquées que "
"d'additionner deux et deux. Par exemple, on peut écrire une sous-séquence "
"initiale de la suite de Fibonacci comme ceci : ::"

#: ../Doc/tutorial/introduction.rst:480
msgid "This example introduces several new features."
msgstr "Cet exemple introduit plusieurs nouvelles fonctionnalités."

#: ../Doc/tutorial/introduction.rst:482
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1.  On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place.  The right-"
"hand side expressions are evaluated  from the left to the right."
msgstr ""
"La première ligne contient une *affectation multiple* : les variables ``a`` "
"et ``b`` se voient affecter simultanément leurs nouvelles valeurs 0 et 1. "
"Cette méthode est encore utilisée à la dernière ligne, pour démontrer que "
"les expressions sur la partie droite de l'affectation sont toutes évaluées "
"avant que les affectations ne soient effectuées. Ces expressions en partie "
"droite sont toujours évaluées de la gauche vers la droite."

#: ../Doc/tutorial/introduction.rst:488
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``b < "
"10``) remains true.  In Python, like in C, any non-zero integer value is "
"true; zero is false.  The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false.  The test used in the example is a simple comparison.  The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"La boucle :keyword:`while` s'exécute tant que la condition (ici : ``b < "
"10``) reste vraie. En Python, comme en C, tout entier différent de zéro est "
"vrai et zéro est faux. La condition peut aussi être une chaîne de "
"caractères, une liste, ou en fait toute séquence ; une séquence avec une "
"valeur non nulle est vraie, une séquence vide est fausse. Le test utilisé "
"dans l'exemple est une simple comparaison. Les opérateurs de comparaison "
"standards sont écrits comme en C : ``<`` (inférieur), ``>`` (supérieur), "
"``==`` (égal), ``<=`` (inférieur ou égal), ``>=`` (supérieur ou égal) et ``!"
"=`` (non égal)."

#: ../Doc/tutorial/introduction.rst:497
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements.  At the interactive prompt, you have to type a tab or "
"space(s) for each indented line.  In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility.  When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line).  Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"Le *corps* de la boucle est *indenté* : l'indentation est la méthode "
"utilisée par Python pour regrouper des instructions. En mode interactif, "
"vous devez saisir une tabulation ou des espaces pour chaque ligne indentée. "
"En pratique, vous aurez intérêt à utiliser un éditeur de texte pour les "
"saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom "
"disposent d'une fonction d'auto-indentation. Lorsqu'une expression composée "
"est saisie en mode interactif, elle doit être suivie d'une ligne vide pour "
"indiquer qu'elle est terminée (car l'analyseur ne peut pas deviner que vous "
"venez de saisir la dernière ligne). Notez bien que toutes les lignes à "
"l'intérieur d'un bloc doivent être indentées au même niveau."

#: ../Doc/tutorial/introduction.rst:506
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings.  Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
"La fonction :func:`print` écrit les valeur des paramètres qui lui sont "
"fournis. Ce n'est pas la même chose que d'écrire l'expression que vousvoulez "
"afficher (comme nous l'avons fait dans l'exemple de la calculatrice), dû à "
"la manière de ``print`` de gérer les paramètres multiples, les nombres "
"décimaux, et les chaînes. Les chaînes sont affichées sans apostrophes et "
"unespace est inséré entre les éléments de telle sorte que vous pouvez "
"facilement formater les choses, comme ceci : ::"

#: ../Doc/tutorial/introduction.rst:517
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"Le paramètre nommé *end* peut servir pour enlever le retour à la ligne, ou "
"terminer la ligne par une autre chaîne : ::"

#: ../Doc/tutorial/introduction.rst:530
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"Puisque ``**`` est prioritaire sur ``-``, ``-3 ** 2`` sera interprété ``-(3 "
"** 2)`` et vaudra donc ``-9``. Pour éviter cela et obtenir ``9``, utilisez "
"des parenthèses : ``(-3) ** 2``."

#: ../Doc/tutorial/introduction.rst:534
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"Contrairement à d'autres langages, les caractères spéciaux comme ``\\n`` ont "
"la même signification entre guillemets (`\"...\"`) ou guillemets simples "
"(`'...'`). La seule différence est que dans une chaîne entre guillemets il "
"n'est pas nécessaire de protéger les guillemets simples et vice-versa."

#: ../Doc/tutorial/modules.rst:5
msgid "Modules"
msgstr "Modules"

#: ../Doc/tutorial/modules.rst:7
msgid ""
"If you quit from the Python interpreter and enter it again, the definitions "
"you have made (functions and variables) are lost. Therefore, if you want to "
"write a somewhat longer program, you are better off using a text editor to "
"prepare the input for the interpreter and running it with that file as input "
"instead.  This is known as creating a *script*.  As your program gets "
"longer, you may want to split it into several files for easier maintenance.  "
"You may also want to use a handy function that you've written in several "
"programs without copying its definition into each program."
msgstr ""
"Lorsque vous quittez et entrez à nouveau dans l'interpréteur Python, tout ce "
"que vous avez déclaré dans la session précédente est perdu. Afin de rédiger "
"des programmes plus longs, vous devriez utiliser un éditeur de texte, "
"préparer votre code dans un fichier, et exécuter Python avec ce fichier en "
"paramètre. Ça s'appelle créé un *script*. Lorsque votre programme deviendra "
"plus long encore, vous pourrez séparer votre code dans plusieurs fichiers, "
"et vous trouverez aussi pratique de réutiliser des fonctions écrites pour un "
"programme dans un autre sans avoir à les copier."

#: ../Doc/tutorial/modules.rst:16
msgid ""
"To support this, Python has a way to put definitions in a file and use them "
"in a script or in an interactive instance of the interpreter. Such a file is "
"called a *module*; definitions from a module can be *imported* into other "
"modules or into the *main* module (the collection of variables that you have "
"access to in a script executed at the top level and in calculator mode)."
msgstr ""
"Pour gérer ça, Python à un moyen de rédiger des définitions dans un fichier "
"et les utiliser dans un script ou une session interactive. Un tel fichier "
"est appelé un *module*, et les définitions d'un module peuvent être "
"importées dans un autre module ou dans le module *main* (qui est le module "
"qui contiens vous variables et définitions lors de l'exécution d'un script "
"ou en mode interactif)."

#: ../Doc/tutorial/modules.rst:22
msgid ""
"A module is a file containing Python definitions and statements.  The file "
"name is the module name with the suffix :file:`.py` appended.  Within a "
"module, the module's name (as a string) is available as the value of the "
"global variable ``__name__``.  For instance, use your favorite text editor "
"to create a file called :file:`fibo.py` in the current directory with the "
"following contents::"
msgstr ""
"Un module est un fichier contenant des définitions et des instructions.  Son "
"nom de fichier est le même que son nom, suffixé de :file:`.py`. À "
"l'intérieur d'un module, son propre nom est accessible dans la variable "
"``__name__``. Par exemple, prenez votre éditeur favori et créez un fichier :"
"file:`fibo.py` contenant : ::"

#: ../Doc/tutorial/modules.rst:45
msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""
"Maintenant, en étant dans le même dossier, ouvrez un interpréteur et "
"importez le module en tapant : ::"

#: ../Doc/tutorial/modules.rst:50
msgid ""
"This does not enter the names of the functions defined in ``fibo``  directly "
"in the current symbol table; it only enters the module name ``fibo`` there. "
"Using the module name you can access the functions::"
msgstr ""
"Cela n'importe pas les noms des fonctions définies dans ``fibo`` directement "
"dans la table des symboles courante, mais y ajoute simplement ``fibo``. Vous "
"pouvez donc appeler les fonctions via le nom du module : ::"

#: ../Doc/tutorial/modules.rst:61
msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""
"Si vous avez l'intention d'utiliser une fonction souvent, il est possible de "
"lui assigner un nom local : ::"

#: ../Doc/tutorial/modules.rst:71
msgid "More on Modules"
msgstr "Les modules en détails"

#: ../Doc/tutorial/modules.rst:73
msgid ""
"A module can contain executable statements as well as function definitions. "
"These statements are intended to initialize the module. They are executed "
"only the *first* time the module name is encountered in an import statement. "
"[#]_ (They are also run if the file is executed as a script.)"
msgstr ""
"Un module peut contenir aussi bien des instructions que des déclarations de "
"fonctions. C'est instructions permettent d'initialiser le module, et ne sont "
"donc exécutées que la première fois que le nom d'un module est trouvé dans "
"un ``import``. [#]_ (Elles sont aussi exécutées lorsque le fichier est "
"exécuté en temps que script.)"

#: ../Doc/tutorial/modules.rst:78
msgid ""
"Each module has its own private symbol table, which is used as the global "
"symbol table by all functions defined in the module. Thus, the author of a "
"module can use global variables in the module without worrying about "
"accidental clashes with a user's global variables. On the other hand, if you "
"know what you are doing you can touch a module's global variables with the "
"same notation used to refer to its functions, ``modname.itemname``."
msgstr ""
"Chaque module a sa propre table de symboles, utilisée comme table de "
"symboles globaux par toutes les fonctions définies par le module. Ainsi "
"l'auteur d'un module peut utiliser des variables globales dans un module "
"sans se soucier de collisions de noms avec des globales définies par "
"l'utilisateur du module. D'un autre côté, si vous savez ce que vous faites, "
"vous pouvez modifier une variable globale d'un module avec la même notation "
"que pour accéder aux fonctions : ``modname.itemname``."

#: ../Doc/tutorial/modules.rst:85
msgid ""
"Modules can import other modules.  It is customary but not required to place "
"all :keyword:`import` statements at the beginning of a module (or script, "
"for that matter).  The imported module names are placed in the importing "
"module's global symbol table."
msgstr ""
"Des modules peuvent importer d'autres modules. Il est habituel mais pas "
"obligatoire de ranger tous les :keyword:`import` au début du module (ou du "
"script). Les noms des module importés sont insérés dans la table des "
"symboles globaux du module qui importe."

#: ../Doc/tutorial/modules.rst:90
msgid ""
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's symbol table.  For "
"example::"
msgstr ""
"Il existe une variation à l'instruction :keyword:`import` qui importe les "
"noms d'un module directement dans la table de symboles du module qui "
"l'importe, par exemple : ::"

#: ../Doc/tutorial/modules.rst:97
msgid ""
"This does not introduce the module name from which the imports are taken in "
"the local symbol table (so in the example, ``fibo`` is not defined)."
msgstr ""
"Cela n'insère pas le nom du module depuis lequel les définitions sont "
"récupérées dans la table locale de symboles (dans cet exemple, ``fibo`` "
"n'est pas défini)."

#: ../Doc/tutorial/modules.rst:100
msgid "There is even a variant to import all names that a module defines::"
msgstr ""
"Il existe même une variation permettant d'importer tous les noms qu'un "
"module définit : ::"

#: ../Doc/tutorial/modules.rst:106
msgid ""
"This imports all names except those beginning with an underscore (``_``). In "
"most cases Python programmers do not use this facility since it introduces "
"an unknown set of names into the interpreter, possibly hiding some things "
"you have already defined."
msgstr ""
"Tous les noms ne commencant pas par un tiret bas (``_``) sont importés. Dans "
"la grande majorité des cas, les développeurs n'utilisent pas cette syntaxe "
"puisqu'en important un ensemble indéfini de noms, des noms déjà définis "
"peuvent se retrouver cachés."

#: ../Doc/tutorial/modules.rst:111
msgid ""
"Note that in general the practice of importing ``*`` from a module or "
"package is frowned upon, since it often causes poorly readable code. "
"However, it is okay to use it to save typing in interactive sessions."
msgstr ""
"Notez qu'en général, importer ``*`` d'un module ou d'un paquet est "
"déconseillé, en général ça engendre du code difficilement lisible. "
"Cependant, c'est acceptable de l'utiliser pour gagner quelques secondes en "
"mode interactif."

#: ../Doc/tutorial/modules.rst:117
msgid ""
"For efficiency reasons, each module is only imported once per interpreter "
"session.  Therefore, if you change your modules, you must restart the "
"interpreter -- or, if it's just one module you want to test interactively, "
"use :func:`importlib.reload`, e.g. ``import importlib; importlib."
"reload(modulename)``."
msgstr ""
"Pour des raisons de performance, chaque module n'est importé qu'une fois par "
"session. Si vous changez le code d'un module vous devez donc redémarrer "
"l'interpréteur afin d'en voir l'impact. Ou le re-importer explicitement en "
"utilisant :func:`importlib.reload`, par exemple : ``import importlib; "
"importlib.reload(modulename)``."

#: ../Doc/tutorial/modules.rst:127
msgid "Executing modules as scripts"
msgstr "Exécuter des modules comme des scripts"

#: ../Doc/tutorial/modules.rst:129
msgid "When you run a Python module with ::"
msgstr "Lorsque vous exécutez un module Python avec : ::"

#: ../Doc/tutorial/modules.rst:133
msgid ""
"the code in the module will be executed, just as if you imported it, but "
"with the ``__name__`` set to ``\"__main__\"``.  That means that by adding "
"this code at the end of your module::"
msgstr ""
"le code du module sera exécuté comme si vous l'aviez importé, mais son "
"``__name__`` vaudra ``\"__main__\"``. Donc en ajoutant ces lignes à la fin "
"du module : ::"

#: ../Doc/tutorial/modules.rst:141
msgid ""
"you can make the file usable as a script as well as an importable module, "
"because the code that parses the command line only runs if the module is "
"executed as the \"main\" file:"
msgstr ""

#: ../Doc/tutorial/modules.rst:150
msgid "If the module is imported, the code is not run::"
msgstr "Si le fichier est importé, le code n'est pas exécuté : ::"

#: ../Doc/tutorial/modules.rst:155
msgid ""
"This is often used either to provide a convenient user interface to a "
"module, or for testing purposes (running the module as a script executes a "
"test suite)."
msgstr ""
"C'est typiquement utilisé soit pour proposer une interface utilisateur pour "
"un module, soit pour lancer les tests sur le module (où exécuter le module "
"en temps que script lance les tests)."

#: ../Doc/tutorial/modules.rst:162
msgid "The Module Search Path"
msgstr "Les dossiers de recherche de modules"

#: ../Doc/tutorial/modules.rst:166
msgid ""
"When a module named :mod:`spam` is imported, the interpreter first searches "
"for a built-in module with that name. If not found, it then searches for a "
"file named :file:`spam.py` in a list of directories given by the variable :"
"data:`sys.path`.  :data:`sys.path` is initialized from these locations:"
msgstr ""
"Lorsqu'un module nommé par exemple :mod:`spam` est importé, il est d'abord "
"recherché parmis les modules natifs, puis s'il n'y est pas trouvé, "
"l'interpréteur va chercher un fichier nommé :file:`spam.py` dans une liste "
"de dossiers donnés par la variable :data:`sys.path`, :data:`sys.path` est "
"initialisée par défaut à : ::"

#: ../Doc/tutorial/modules.rst:171
msgid ""
"The directory containing the input script (or the current directory when no "
"file is specified)."
msgstr ""
"Le dossier contenant le script courant (ou le dossier courant si aucun "
"script n'est donné)."

#: ../Doc/tutorial/modules.rst:173
msgid ""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
"shell variable :envvar:`PATH`)."
msgstr ""
":envvar:`PYTHONPATH` (une liste de dossiers, utilisant la même syntaxe que "
"la variable shell :envvar:`PATH`)."

#: ../Doc/tutorial/modules.rst:175
msgid "The installation-dependent default."
msgstr "La valeur par défaut, dépendante de l'installation."

#: ../Doc/tutorial/modules.rst:178
msgid ""
"On file systems which support symlinks, the directory containing the input "
"script is calculated after the symlink is followed. In other words the "
"directory containing the symlink is **not** added to the module search path."
msgstr ""
"Sur les systèmes qui gèrent les liens symboliques, le dossier contenant le "
"script courant est résolu après avoir suivi le lien sublimer du script. "
"Autrement dit le dossier contenant le lien symbolique n'est **pas** ajouté "
"au dossiers de recherche de modules."

#: ../Doc/tutorial/modules.rst:182
msgid ""
"After initialization, Python programs can modify :data:`sys.path`.  The "
"directory containing the script being run is placed at the beginning of the "
"search path, ahead of the standard library path. This means that scripts in "
"that directory will be loaded instead of modules of the same name in the "
"library directory. This is an error unless the replacement is intended.  See "
"section :ref:`tut-standardmodules` for more information."
msgstr ""
"Après leur initialisation, les programmes Python peuvent modifier leur :data:"
"`sys.path`. Le dossier contenant le script courant est placé au début de la "
"liste des dossiers à rechercher, avant les dossiers de bibliothèques, Cela "
"signifie qu'un module dans ce dossier, ayant le même nom qu'un module, sera "
"chargé à sa place. C'est une erreur typique, à moins que ce soit voulu. "
"Voir :ref:`tut-standardmodules` pour plus d'informations."

#: ../Doc/tutorial/modules.rst:193
msgid "\"Compiled\" Python files"
msgstr "Fichiers Python \"compilés\""

#: ../Doc/tutorial/modules.rst:195
msgid ""
"To speed up loading modules, Python caches the compiled version of each "
"module in the ``__pycache__`` directory under the name :file:`module."
"{version}.pyc`, where the version encodes the format of the compiled file; "
"it generally contains the Python version number.  For example, in CPython "
"release 3.3 the compiled version of spam.py would be cached as ``__pycache__/"
"spam.cpython-33.pyc``.  This naming convention allows compiled modules from "
"different releases and different versions of Python to coexist."
msgstr ""
"Pour accélérer le chargement des modules, Python cache une version compilée "
"de chaque module, dans un fichier nommé :file:`module(version).pyc` (ou "
"*version* représente le format du fichier compilé, typiquement une version "
"de Python) dans le dossier ``__pycache__``. Par exemple avec CPython 3.3 la "
"version compilée de spam.py serait ``__pycache__/spam.cpython-33.pyc``. "
"Cette règle de nommage permet à des versions compilées par des versions de "
"Python différentes de coexister."

#: ../Doc/tutorial/modules.rst:203
msgid ""
"Python checks the modification date of the source against the compiled "
"version to see if it's out of date and needs to be recompiled.  This is a "
"completely automatic process.  Also, the compiled modules are platform-"
"independent, so the same library can be shared among systems with different "
"architectures."
msgstr ""
"Python compare les dates de modification du fichier source et de sa version "
"compilée pour voir si le module doit être recompilé. Ce processus est "
"entièrement automatique, et les versions compilées sont indépendantes de la "
"plateforme, et peuvent donc être partagées entre des systèmes d'architecture "
"différente."

#: ../Doc/tutorial/modules.rst:208
msgid ""
"Python does not check the cache in two circumstances.  First, it always "
"recompiles and does not store the result for the module that's loaded "
"directly from the command line.  Second, it does not check the cache if "
"there is no source module.  To support a non-source (compiled only) "
"distribution, the compiled module must be in the source directory, and there "
"must not be a source module."
msgstr ""
"Il existe deux circonstances pour lesquelles Python ne vérifie pas le "
"cache : Le premier cas lorsque le module est donné par la ligne de commande "
"(cas où le module est toujours recompilé, sans même cacher sa version "
"compilée), le second cas est lorsque le module n'a pas de source dans ce cas "
"Python n'essaye pas de charger la version compilée. Pour gérer un module "
"sans source (seulement compilé) le module compilé doit être dans le dossier "
"source et sa source ne doit pas être présente."

#: ../Doc/tutorial/modules.rst:215
msgid "Some tips for experts:"
msgstr "Astuces pour les experts :"

#: ../Doc/tutorial/modules.rst:217
msgid ""
"You can use the :option:`-O` or :option:`-OO` switches on the Python command "
"to reduce the size of a compiled module.  The ``-O`` switch removes assert "
"statements, the ``-OO`` switch removes both assert statements and __doc__ "
"strings.  Since some programs may rely on having these available, you should "
"only use this option if you know what you're doing.  \"Optimized\" modules "
"have an ``opt-`` tag and are usually smaller.  Future releases may change "
"the effects of optimization."
msgstr ""
"Vous pouvez utiliser les options :option:`-O` ou :option:`-OO` lors de "
"l'appel à Python pour réduire la taille des modules compilés. L'option ``-"
"O`` supprime les instructions ``assert``, et l'option ``-OO`` supprime aussi "
"les documentations ``__doc__``. Cependant, puisque certains programmes ont "
"besoin de ces ``__doc__``, vous ne devriez utiliser ``-OO`` que si vous "
"savez ce que vous faites. Les modules \"optimisés\" sont marqués d'un ``opt-"
"`` et sont généralement plus petits. Les versions futures de Python "
"pourraient changer les effets de l'optimisation."

#: ../Doc/tutorial/modules.rst:225
msgid ""
"A program doesn't run any faster when it is read from a ``.pyc`` file than "
"when it is read from a ``.py`` file; the only thing that's faster about ``."
"pyc`` files is the speed with which they are loaded."
msgstr ""
"Un programme ne s'exécute pas plus vite lorsqu'il est lu depuis un ``.pyc``, "
"il est cependant chargé plus vite puisque le ``.pyc`` est plut petit que le "
"``.py``."

#: ../Doc/tutorial/modules.rst:229
msgid ""
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
msgstr ""
"Le module :mod:`compileall` peut créer des fichiers ``.pyc`` pour tous les "
"modules d'un dossier."

#: ../Doc/tutorial/modules.rst:232
msgid ""
"There is more detail on this process, including a flow chart of the "
"decisions, in PEP 3147."
msgstr ""
"Voilà plus de détails sur le processus, ainsi qu'un organigramme des "
"decisions, dans la PEP 3147."

#: ../Doc/tutorial/modules.rst:239
msgid "Standard Modules"
msgstr "Modules standards"

#: ../Doc/tutorial/modules.rst:243
msgid ""
"Python comes with a library of standard modules, described in a separate "
"document, the Python Library Reference (\"Library Reference\" hereafter).  "
"Some modules are built into the interpreter; these provide access to "
"operations that are not part of the core of the language but are "
"nevertheless built in, either for efficiency or to provide access to "
"operating system primitives such as system calls.  The set of such modules "
"is a configuration option which also depends on the underlying platform.  "
"For example, the :mod:`winreg` module is only provided on Windows systems. "
"One particular module deserves some attention: :mod:`sys`, which is built "
"into every Python interpreter.  The variables ``sys.ps1`` and ``sys.ps2`` "
"define the strings used as primary and secondary prompts::"
msgstr ""
"Python est accompagné d'une bibliothèque de modules standards, décrits dans "
"la documentation de la Bibliothèque Python, plus loin. Certains modules sont "
"intégrés dans l'interpréteur, ils exposent des outils qui ne font pas partie "
"du langage, mais qui font tout de même partie de l'interpréteur, soit pour "
"le côté pratique, soit pour exposer des outils essentiels tels que l'accès "
"aux appels systems. La composition de ces modules est configurable à la "
"compilation, et dépend aussi de la plateforme ciblée. Par exemple, le "
"module :mod:`winreg` n'est proposé que sur les systèmes Windows. Un module "
"mérite une attention particulière, le module :mod:`sys`, qui est présent "
"dans tous les interpréteurs Python. Les variables ``sys.ps1`` et ``sys.ps2`` "
"définissent les chaînes d'invites principales et secondaires : ::"

#: ../Doc/tutorial/modules.rst:266
msgid ""
"These two variables are only defined if the interpreter is in interactive "
"mode."
msgstr ""
"Ces deux variables ne sont définies que si l'interpréteur est en mode "
"interactif."

#: ../Doc/tutorial/modules.rst:268
msgid ""
"The variable ``sys.path`` is a list of strings that determines the "
"interpreter's search path for modules. It is initialized to a default path "
"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in "
"default if :envvar:`PYTHONPATH` is not set.  You can modify it using "
"standard list operations::"
msgstr ""
"La variable ``sys.path`` est une liste de chaînes qui détermine les chemins "
"de recherche de modules pour l'interpréteur. Il est initialisé à un chemin "
"par défaut pris de la variable d'environnement :envvar:`PYTHONPATH`, ou "
"d'une valeur par défaut interne si :envvar:`PYTHONPATH` n'est pas définie. "
"``sys.path`` est modifiable en utilisant les opérations habituelles des "
"listes : ::"

#: ../Doc/tutorial/modules.rst:281
msgid "The :func:`dir` Function"
msgstr "La fonction :func:`dir`"

#: ../Doc/tutorial/modules.rst:283
msgid ""
"The built-in function :func:`dir` is used to find out which names a module "
"defines.  It returns a sorted list of strings::"
msgstr ""
"La fonction interne :func:`dir` est utilisée pour trouver quels noms sont "
"définies par un module. Elle donne une liste triée de chaînes :;"

#: ../Doc/tutorial/modules.rst:308
msgid ""
"Without arguments, :func:`dir` lists the names you have defined currently::"
msgstr "Sans paramètres, :func:`dir` listes les noms actuellement définis : ::"

#: ../Doc/tutorial/modules.rst:316
msgid ""
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr ""
"Notez qu'elle liste tout types de noms : les variables, fonctions, modules, "
"etc."

#: ../Doc/tutorial/modules.rst:320
msgid ""
":func:`dir` does not list the names of built-in functions and variables.  If "
"you want a list of those, they are defined in the standard module :mod:"
"`builtins`::"
msgstr ""
":func:`dir` ne liste ni les fonctions primitives ni les variables internes. "
"Si vous voulez les lister, ils sont définis dans le module :mod:`builtins` ::"

#: ../Doc/tutorial/modules.rst:359
msgid "Packages"
msgstr "Les paquets"

#: ../Doc/tutorial/modules.rst:361
msgid ""
"Packages are a way of structuring Python's module namespace by using "
"\"dotted module names\".  For example, the module name :mod:`A.B` designates "
"a submodule named ``B`` in a package named ``A``.  Just like the use of "
"modules saves the authors of different modules from having to worry about "
"each other's global variable names, the use of dotted module names saves the "
"authors of multi-module packages like NumPy or the Python Imaging Library "
"from having to worry about each other's module names."
msgstr ""
"Les paquets sont un moyen de structurer les espaces de noms des modules "
"Python en utilisant une notations \"pointée\". Par exemple, le nom de "
"module :mod:`A.B` désigne le sous-module ``B`` du paquet ``A``. De la même "
"manière que l'utilisation des modules évite aux auteurs de différents "
"modules d'avoir à se soucier des noms de variables globales des autres, "
"l'utilisation des noms de modules avec des points évite aux auteurs de "
"paquets contenant plusieurs modules tel que NumPy ou \"Python Image Library"
"\" d'avoir à se soucier des noms des modules des autres."

#: ../Doc/tutorial/modules.rst:369
msgid ""
"Suppose you want to design a collection of modules (a \"package\") for the "
"uniform handling of sound files and sound data.  There are many different "
"sound file formats (usually recognized by their extension, for example: :"
"file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and "
"maintain a growing collection of modules for the conversion between the "
"various file formats. There are also many different operations you might "
"want to perform on sound data (such as mixing, adding echo, applying an "
"equalizer function, creating an artificial stereo effect), so in addition "
"you will be writing a never-ending stream of modules to perform these "
"operations.  Here's a possible structure for your package (expressed in "
"terms of a hierarchical filesystem):"
msgstr ""
"Imaginez que vous voulez constuire une collections de modules (un \"paquet"
"\") pour gérer uniformément les fichiers contenant du son et des données "
"sonores. Il existe un grand nombre de formats de fichiers pour stocker du "
"son (généralement repérés par leur extension, par exemple :file:`.wav`, :"
"file:`.aiff`, :file:`.au`), vous aurez donc envie de créer et maintenir un "
"nombre croissant de modules pour gérer la conversion entre tous ces formats. "
"Il existe aussi tout une floppée d'opérations que vous voudriez pouvoir "
"faire sur du son (mixer, ajouter de l'écho, égaliser, ajouter un effet "
"stéréo articifiel), donc, en plus des modules de conversion, vous allez "
"écrire un nombre illimité de modules permettant d'effectuer ces opérations. "
"Voici une structure possible pour votre paquet (exprimée comme un système de "
"fichier, hierarchiquement) :"

#: ../Doc/tutorial/modules.rst:406
msgid ""
"When importing the package, Python searches through the directories on ``sys."
"path`` looking for the package subdirectory."
msgstr ""
"Lorsqu'il importe des paquets, Python cherche dans chaque dossiers de ``sys."
"path``, à la recherche du dossier du paquet."

#: ../Doc/tutorial/modules.rst:409
msgid ""
"The :file:`__init__.py` files are required to make Python treat the "
"directories as containing packages; this is done to prevent directories with "
"a common name, such as ``string``, from unintentionally hiding valid modules "
"that occur later on the module search path. In the simplest case, :file:"
"`__init__.py` can just be an empty file, but it can also execute "
"initialization code for the package or set the ``__all__`` variable, "
"described later."
msgstr ""
"Les fichiers :file:`__init__.py` sont nécessaires pour que Python considère "
"les dossiers comme contenant des paquets, ça évite des dossiers ayant des "
"noms courants comme ``string`` de cacher des modules qui auraient été "
"trouvés plus loin dans les dossiers de recherche. Dans le plus simple des "
"cas, :file:`__init__.py` peut être vide, mais il peut exécuter du code "
"d'initialisation pour son paquet ou configurer la variable ``__all__`` "
"(documentée plus loin)."

#: ../Doc/tutorial/modules.rst:416
msgid ""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr ""
"Les utilisateurs d'un module peuvent importer ses modules individuellement, "
"par exemple : ::"

#: ../Doc/tutorial/modules.rst:421
msgid ""
"This loads the submodule :mod:`sound.effects.echo`.  It must be referenced "
"with its full name. ::"
msgstr ""
"Chargera le sous-module :mod:`sound.effects.echo`. Il dit être référencé par "
"son nom complet. ::"

#: ../Doc/tutorial/modules.rst:426
msgid "An alternative way of importing the submodule is::"
msgstr "Une autre manière d'importer des sous-modules est : ::"

#: ../Doc/tutorial/modules.rst:430
msgid ""
"This also loads the submodule :mod:`echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""
"Chargera aussi le sous-module :mod:`echo`, et le rendra disponible dans le "
"préfixe du paquet, il peut donc être utilisé comme ça : ::"

#: ../Doc/tutorial/modules.rst:435
msgid ""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr ""
"Une autre méthode consisterait à importer la fonction ou variable désirée "
"directement : ::"

#: ../Doc/tutorial/modules.rst:439
msgid ""
"Again, this loads the submodule :mod:`echo`, but this makes its function :"
"func:`echofilter` directly available::"
msgstr ""
"Le sous-module :mod:`echo` est toujours chargé, mais ici la fonction :func:"
"`echofilter` est disponible directement : ::"

#: ../Doc/tutorial/modules.rst:444
msgid ""
"Note that when using ``from package import item``, the item can be either a "
"submodule (or subpackage) of the package, or some  other name defined in the "
"package, like a function, class or variable.  The ``import`` statement first "
"tests whether the item is defined in the package; if not, it assumes it is a "
"module and attempts to load it.  If it fails to find it, an :exc:"
"`ImportError` exception is raised."
msgstr ""
"Notez que lorsque vous utilisez ``from package import item``, ``item`` peut "
"aussi bien être un sous-module, un sous-paquet, ou simplement un nom déclaré "
"dans le paquet (une variable, une fonction ou une classe). L'instruction "
"``import`` cherche en premier si ``item`` est définit dans le paquet, s'il "
"ne l'est pas, elle cherche à charger un module, et si elle n'y arrive pas, "
"une exception :exc:`ImportError` est levée."

#: ../Doc/tutorial/modules.rst:451
msgid ""
"Contrarily, when using syntax like ``import item.subitem.subsubitem``, each "
"item except for the last must be a package; the last item can be a module or "
"a package but can't be a class or function or variable defined in the "
"previous item."
msgstr ""
"Au contraire, en utilisant la syntaxe ``import item.item.subitement."
"subsubitem``, chaque ``item`` sauf le dernier doivent être des paquets. Le "
"dernier ``item`` peut être un module ou un paquet, mais ne peut être ni une "
"fonction, ni une classe, ni une variable défini dans l'élément précédent."

#: ../Doc/tutorial/modules.rst:460
msgid "Importing \\* From a Package"
msgstr "Importer \\* depuis un paquet"

#: ../Doc/tutorial/modules.rst:464
msgid ""
"Now what happens when the user writes ``from sound.effects import *``?  "
"Ideally, one would hope that this somehow goes out to the filesystem, finds "
"which submodules are present in the package, and imports them all.  This "
"could take a long time and importing sub-modules might have unwanted side-"
"effects that should only happen when the sub-module is explicitly imported."
msgstr ""
"Qu'arrive-il lorsqu'un utilisateur écrit ``from sound.effects import *`` ? "
"Dans l'idéal on pourrait espérer que ça irait chercher tous les sous-modules "
"du paquet sur le système de fichiers, et qu'ils seraient tous importés. Ça "
"pourrait être long, et importer certains sous-modules pourrait avoir des "
"effets secondaires indésirables, du moins, désirés seulement lorsque le sous "
"module est importé explicitement."

#: ../Doc/tutorial/modules.rst:470
msgid ""
"The only solution is for the package author to provide an explicit index of "
"the package.  The :keyword:`import` statement uses the following convention: "
"if a package's :file:`__init__.py` code defines a list named ``__all__``, it "
"is taken to be the list of module names that should be imported when ``from "
"package import *`` is encountered.  It is up to the package author to keep "
"this list up-to-date when a new version of the package is released.  Package "
"authors may also decide not to support it, if they don't see a use for "
"importing \\* from their package.  For example, the file :file:`sound/"
"effects/__init__.py` could contain the following code::"
msgstr ""
"La seule solution, pour l'auteur du paquet, est de fournir un index "
"explicite du contenu du paquet. L'instruction :keyword:`import` utilise la "
"convention suivante: Si le fichier :file:`__init__.py` du paquet définit une "
"liste nommée ``__all__``, cette liste sera utilisée comme liste des noms de "
"modules devant être importés lorsque ``from package import *`` est utilisé. "
"C'est le rôle de l'auteur du paquet de maintenir cette liste à jour lorsque "
"de nouvelles version du paquet sont publiées. Un auteur de paquet peut aussi "
"décider de ne pas autoriser d'importer ``*`` de leur paquet. Par exemple, le "
"fichier :file:`sound/effects/__init__.py` peut contenir le code suivant : ::"

#: ../Doc/tutorial/modules.rst:482
msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`sound` package."
msgstr ""
"Cela signifierai que ``from sound.effects import *`` importait les trois "
"sous-modules du paquet :mod:`sound`."

#: ../Doc/tutorial/modules.rst:485
msgid ""
"If ``__all__`` is not defined, the statement ``from sound.effects import *`` "
"does *not* import all submodules from the package :mod:`sound.effects` into "
"the current namespace; it only ensures that the package :mod:`sound.effects` "
"has been imported (possibly running any initialization code in :file:"
"`__init__.py`) and then imports whatever names are defined in the package.  "
"This includes any names defined (and submodules explicitly loaded) by :file:"
"`__init__.py`.  It also includes any submodules of the package that were "
"explicitly loaded by previous :keyword:`import` statements.  Consider this "
"code::"
msgstr ""
"Si ``__all__`` n'est pas défini, l'instruction ``from sound.effects import "
"*`` n'importera *pas* tous les sous-modules du paquet :mod:`sound.effects` "
"dans l'espace de nom courant, mais s'assurera seulement que le paquet :mod:"
"`sound.effects` à été importé (que tout le code du fichier :file:`__init__."
"py` à été executé) et importe ensuite n'importe quels noms définis dans le "
"paquet. Cela inclu tous les noms définis (et sous modules chargés "
"explicitement) par :file:`__init__.py`. Elle inclu aussi tous les sous-"
"modules du paquet ayant été chargés explicitement par une instruction :"
"keyword:`import`. Typiquement : ::"

#: ../Doc/tutorial/modules.rst:498
msgid ""
"In this example, the :mod:`echo` and :mod:`surround` modules are imported in "
"the current namespace because they are defined in the :mod:`sound.effects` "
"package when the ``from...import`` statement is executed.  (This also works "
"when ``__all__`` is defined.)"
msgstr ""
"Dans cet exemple, les modules :mod:`echo` et :mod:`surround` sont importés "
"dans l'espace de noms courant lorsque ``from...import`` est exécuté, parce "
"qu'ils sont définis dans le paquet :mod:`sound.effects`. (Cela fonctionne "
"lorsque ``__all__`` est défini.)"

#: ../Doc/tutorial/modules.rst:503
msgid ""
"Although certain modules are designed to export only names that follow "
"certain patterns when you use ``import *``, it is still considered bad "
"practise in production code."
msgstr ""
"Bien que certains modules ont été pensés pour n'exporter que les noms "
"respectant une certaine structure lorsque ``import *`` est utilisé, ``import "
"*`` reste considéré comme une mauvaise pratique."

#: ../Doc/tutorial/modules.rst:507
msgid ""
"Remember, there is nothing wrong with using ``from Package import "
"specific_submodule``!  In fact, this is the recommended notation unless the "
"importing module needs to use submodules with the same name from different "
"packages."
msgstr ""
"Rappelez-vous qu'il n'y a rien de mauvais à utiliser ``from Package import "
"specific_submodule`` ! C'est d'ailleurs la manière recommandée à moins que "
"le module qui fait les imports ai besoin de sous-modules ayant le même nom "
"mais provenant se paquets différents."

#: ../Doc/tutorial/modules.rst:514
msgid "Intra-package References"
msgstr "Références internes dans un paquet"

#: ../Doc/tutorial/modules.rst:516
msgid ""
"When packages are structured into subpackages (as with the :mod:`sound` "
"package in the example), you can use absolute imports to refer to submodules "
"of siblings packages.  For example, if the module :mod:`sound.filters."
"vocoder` needs to use the :mod:`echo` module in the :mod:`sound.effects` "
"package, it can use ``from sound.effects import echo``."
msgstr ""
"Lorsque les paquets sont organisés en sous-paquets (comme le paquet :mod:"
"`sound` par exemple), vous pouvez utiliser des imports absolus pour cibler "
"des paquets voisins. Par exemple, si le module :mod:`sound.filters.vocoder` "
"a besoin du module :mod:`echo` du paquet :mod:`sound.effects`, il peut "
"utiliser ``from sound.effects import echo``."

#: ../Doc/tutorial/modules.rst:522
msgid ""
"You can also write relative imports, with the ``from module import name`` "
"form of import statement.  These imports use leading dots to indicate the "
"current and parent packages involved in the relative import.  From the :mod:"
"`surround` module for example, you might use::"
msgstr ""
"Il est aussi possible d'écrire des imports relatifs de la forme ``from "
"module import name``. Ces imports sont préfixés par des points pour indiquer "
"leur origine (paquet courant ou parent). Depuis le module :mod:`surround`, "
"par exemple vous pourriez faire : ::"

#: ../Doc/tutorial/modules.rst:531
msgid ""
"Note that relative imports are based on the name of the current module.  "
"Since the name of the main module is always ``\"__main__\"``, modules "
"intended for use as the main module of a Python application must always use "
"absolute imports."
msgstr ""
"Notez que les imports relatifs se fient au nom du module actuel. Puisque le "
"nom du module principal est toujours ``\"__main__\"``, les modules utilisés "
"par le module principal d'une application ne peuvent être importées que par "
"des imports absolus."

#: ../Doc/tutorial/modules.rst:537
msgid "Packages in Multiple Directories"
msgstr "Paquets dans plusieurs dossiers"

#: ../Doc/tutorial/modules.rst:539
msgid ""
"Packages support one more special attribute, :attr:`__path__`.  This is "
"initialized to be a list containing the name of the directory holding the "
"package's :file:`__init__.py` before the code in that file is executed.  "
"This variable can be modified; doing so affects future searches for modules "
"and subpackages contained in the package."
msgstr ""
"Les paquets exposent un attribut supplémentaire, :attr:`__path__`, contenant "
"une liste, initialisée avant l'exécution du fichier :file:`__init__.py`, "
"contenant le nom de son dossier dans le système de fichier. Cette liste peut "
"être modifiée, altérant ainsi les futures recherches de modules et sous-"
"paquets contenus dans le paquet."

#: ../Doc/tutorial/modules.rst:545
msgid ""
"While this feature is not often needed, it can be used to extend the set of "
"modules found in a package."
msgstr ""
"Bien que cette fonctionnalité ne soit que rarement utile, elle peut servir à "
"élargir la liste des modules trouvés dans un paquet."

#: ../Doc/tutorial/modules.rst:551
msgid ""
"In fact function definitions are also 'statements' that are 'executed'; the "
"execution of a module-level function definition enters the function name in "
"the module's global symbol table."
msgstr ""
"En réalité, la déclaration d'une fonction est elle même une instruction, "
"sont l'exécution enregistre le nom de la fonction dans la table des symboles "
"globaux du module."

#: ../Doc/tutorial/stdlib.rst:5
msgid "Brief Tour of the Standard Library"
msgstr "Survol de la Bibliothèque Standard"

#: ../Doc/tutorial/stdlib.rst:11
msgid "Operating System Interface"
msgstr "Interface avec le Système d'Exploitation"

#: ../Doc/tutorial/stdlib.rst:13
msgid ""
"The :mod:`os` module provides dozens of functions for interacting with the "
"operating system::"
msgstr ""
"Le modules :mod:`os` propose pléthore fonctions pour interagir avec le "
"système d'exploitation : ::"

#: ../Doc/tutorial/stdlib.rst:23
msgid ""
"Be sure to use the ``import os`` style instead of ``from os import *``.  "
"This will keep :func:`os.open` from shadowing the built-in :func:`open` "
"function which operates much differently."
msgstr ""
"Mais, encore une fois, préférez ``import os``, à ``from os import *``, sans "
"quoi :func:`os.open` cacherait la primitive :func:`open`, qui fonctionne "
"différemment."

#: ../Doc/tutorial/stdlib.rst:29
msgid ""
"The built-in :func:`dir` and :func:`help` functions are useful as "
"interactive aids for working with large modules like :mod:`os`::"
msgstr ""
"Les primitives :func:`dir` et :func:`help` sont des outils utiles lorsque "
"vous travaillez en mode interactif avez des gros modules comme :mod:`os` ::"

#: ../Doc/tutorial/stdlib.rst:38
msgid ""
"For daily file and directory management tasks, the :mod:`shutil` module "
"provides a higher level interface that is easier to use::"
msgstr ""
"Pour la gestion des fichiers et dossiers, le module :mod:`shutil` expose une "
"interface plus abstraite et plus facile à utiliser : ::"

#: ../Doc/tutorial/stdlib.rst:51
msgid "File Wildcards"
msgstr "Jokers sur les noms de Fichiers"

#: ../Doc/tutorial/stdlib.rst:53
msgid ""
"The :mod:`glob` module provides a function for making file lists from "
"directory wildcard searches::"
msgstr ""
"Le module :mod:`glob` fournit une fonction pour construire des listes de "
"fichiers à partir de motifs : ::"

#: ../Doc/tutorial/stdlib.rst:64
msgid "Command Line Arguments"
msgstr "Paramètres en ligne de Commande"

#: ../Doc/tutorial/stdlib.rst:66
msgid ""
"Common utility scripts often need to process command line arguments. These "
"arguments are stored in the :mod:`sys` module's *argv* attribute as a list.  "
"For instance the following output results from running ``python demo.py one "
"two three`` at the command line::"
msgstr ""
"Typiquement, les outils en ligne de commande ont besoin de lire les "
"paramètres qui leur sont donnés. Ces paramètres sont stockés dans la "
"variable ``argv`` dans le module :mod:`sys` sous forme de liste. Par "
"exemple, l'affichage suivant vient de l'exécution de ``python demo.py one "
"two three`` depuis la ligne de commande : ::"

#: ../Doc/tutorial/stdlib.rst:75
msgid ""
"The :mod:`getopt` module processes *sys.argv* using the conventions of the "
"Unix :func:`getopt` function.  More powerful and flexible command line "
"processing is provided by the :mod:`argparse` module."
msgstr ""
"Le module :mod:`getopt` comprend *sys.argv* en utilisant les conventions "
"habituelles de la fonction Unix :func:`getopt`. Des outils de compréhension "
"des paramètres de la ligne de commande plus flexibles et avancés sont "
"disponibles dnas le module :mod:`argparse`."

#: ../Doc/tutorial/stdlib.rst:83
msgid "Error Output Redirection and Program Termination"
msgstr "Redirection de la sortie d'erreur et fin d'exécution"

#: ../Doc/tutorial/stdlib.rst:85
msgid ""
"The :mod:`sys` module also has attributes for *stdin*, *stdout*, and "
"*stderr*. The latter is useful for emitting warnings and error messages to "
"make them visible even when *stdout* has been redirected::"
msgstr ""
"Le module :mod:`sys` à aussi des attributs pour *stdin*, *stdout*, et "
"*stderr*. Ce dernier est utile pour émettre des messages d'avertissement ou "
"d'erreur qui restent visibles même si *stdout* est redirigé : ::"

#: ../Doc/tutorial/stdlib.rst:92
msgid "The most direct way to terminate a script is to use ``sys.exit()``."
msgstr ""
"Le moyen le plus direct de terminer un script est d'utiliser ``sys.exit()``."

#: ../Doc/tutorial/stdlib.rst:98
msgid "String Pattern Matching"
msgstr "Recherche de motifs dans les Chaînes"

#: ../Doc/tutorial/stdlib.rst:100
msgid ""
"The :mod:`re` module provides regular expression tools for advanced string "
"processing. For complex matching and manipulation, regular expressions offer "
"succinct, optimized solutions::"
msgstr ""
"Le module :mod:`re` fournit des outils basés sur les expressions "
"rationnelles permettant des opérations complexes sur les chaînes. C'est une "
"solution optimisée, utilisant une syntaxe consise, pour rechercher des "
"motifs complexes, ou effectuer des remplacements complexes dans les "
"chaînes : ::"

#: ../Doc/tutorial/stdlib.rst:110
msgid ""
"When only simple capabilities are needed, string methods are preferred "
"because they are easier to read and debug::"
msgstr ""
"Lorsque les opérations sont simples, il est préférable d'utiliser les "
"méthodes des chaînes, elles sont plus lisibles et plus facile à débugger : ::"

#: ../Doc/tutorial/stdlib.rst:120
msgid "Mathematics"
msgstr "Mathématiques"

#: ../Doc/tutorial/stdlib.rst:122
msgid ""
"The :mod:`math` module gives access to the underlying C library functions "
"for floating point math::"
msgstr ""
"Le module :mod:`math` expose des fonctions d'opération sur les \"float* de "
"la bibliothèque C ::"

#: ../Doc/tutorial/stdlib.rst:131
msgid "The :mod:`random` module provides tools for making random selections::"
msgstr ""
"Le module :mod:`random` offre des outils pour faire des sélections "
"aléatoires : ::"

#: ../Doc/tutorial/stdlib.rst:143
msgid ""
"The :mod:`statistics` module calculates basic statistical properties (the "
"mean, median, variance, etc.) of numeric data::"
msgstr ""
"Le module :mod:`statistics` permet de calculer des valeurs statistiques "
"basiques (la moyenne, la médiane, la variance, ...) ::"

#: ../Doc/tutorial/stdlib.rst:155
msgid ""
"The SciPy project <https://scipy.org> has many other modules for numerical "
"computations."
msgstr ""

#: ../Doc/tutorial/stdlib.rst:161
msgid "Internet Access"
msgstr "Accès à internet"

#: ../Doc/tutorial/stdlib.rst:163
msgid ""
"There are a number of modules for accessing the internet and processing "
"internet protocols. Two of the simplest are :mod:`urllib.request` for "
"retrieving data from URLs and :mod:`smtplib` for sending mail::"
msgstr ""
"Il existe tout un tat de modules permettant d'accéder à internet et gérer "
"des protocoles utilisés sur internet. Les deux plus simples sont :mod:"
"`urllib.request`, qui permet de télécharger à partir d'une URL, et :mod:"
"`smtplib` pour envoyer des emails : ::"

#: ../Doc/tutorial/stdlib.rst:186
msgid "(Note that the second example needs a mailserver running on localhost.)"
msgstr ""
"(Notez que le deuxième exemple a besoin d'un serveur mail tournant "
"localement.)"

#: ../Doc/tutorial/stdlib.rst:192
msgid "Dates and Times"
msgstr "Dates et heures"

#: ../Doc/tutorial/stdlib.rst:194
msgid ""
"The :mod:`datetime` module supplies classes for manipulating dates and times "
"in both simple and complex ways. While date and time arithmetic is "
"supported, the focus of the implementation is on efficient member extraction "
"for output formatting and manipulation.  The module also supports objects "
"that are timezone aware. ::"
msgstr ""
"Les module :mod:`datetime` propose des classes pour manipuler les dates et "
"les heures, que le besoin soit simple ou compliqué. Bien que faire des "
"calculs de dates est possible, l'implémentation à être optimisée pour "
"l'accès aux propriétés, le formatage et la manipulation. Le module gère "
"aussi les objets conscients des fuseaux horaires : ::"

#: ../Doc/tutorial/stdlib.rst:218
msgid "Data Compression"
msgstr "Compression de donnée"

#: ../Doc/tutorial/stdlib.rst:220
msgid ""
"Common data archiving and compression formats are directly supported by "
"modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :mod:"
"`zipfile` and :mod:`tarfile`. ::"
msgstr ""
"Les formats d'archivage et de compression les plus communs sont directement "
"gérés par les modules :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :"
"mod:`zipfile`, et :mod:`tarfile` ::"

#: ../Doc/tutorial/stdlib.rst:240
msgid "Performance Measurement"
msgstr "Mesure des Performances"

#: ../Doc/tutorial/stdlib.rst:242
msgid ""
"Some Python users develop a deep interest in knowing the relative "
"performance of different approaches to the same problem. Python provides a "
"measurement tool that answers those questions immediately."
msgstr ""
"Certains utilisateurs de Python développent un intérêt profond des "
"performances de différentes approches d'un même problème. Python propose un "
"outil de mesure répondant simplement à ces questions."

#: ../Doc/tutorial/stdlib.rst:246
msgid ""
"For example, it may be tempting to use the tuple packing and unpacking "
"feature instead of the traditional approach to swapping arguments. The :mod:"
"`timeit` module quickly demonstrates a modest performance advantage::"
msgstr ""
"Par exemple, pour échanger deux variables, il peut être tentant d'utiliser "
"l'empaquetage et le dépaquetage de tuples plutôt que la méthode "
"traditionnelle. Le module :mod:`timeit` montre simplement laquelle est la "
"plus efficace : ::"

#: ../Doc/tutorial/stdlib.rst:256
msgid ""
"In contrast to :mod:`timeit`'s fine level of granularity, the :mod:`profile` "
"and :mod:`pstats` modules provide tools for identifying time critical "
"sections in larger blocks of code."
msgstr ""
"En opposition à :mod:`timeit` et sa granularité fine, :mod:`profile` et :mod:"
"`pstats` fournissent des outils permettant d'identifier les parties les plus "
"gourmandes en temps d'exécution dans des volumes de code plus grands."

#: ../Doc/tutorial/stdlib.rst:264
msgid "Quality Control"
msgstr "Contrôle Qualité"

#: ../Doc/tutorial/stdlib.rst:266
msgid ""
"One approach for developing high quality software is to write tests for each "
"function as it is developed and to run those tests frequently during the "
"development process."
msgstr ""
"Une approche possible pour développer des application de très bonne qualité "
"est d'écrire des tests pour chaque fonction au fur et à mesure de son "
"développement, et d'exécuter ces tests fréquemment lors du processus de "
"développement."

#: ../Doc/tutorial/stdlib.rst:270
msgid ""
"The :mod:`doctest` module provides a tool for scanning a module and "
"validating tests embedded in a program's docstrings.  Test construction is "
"as simple as cutting-and-pasting a typical call along with its results into "
"the docstring. This improves the documentation by providing the user with an "
"example and it allows the doctest module to make sure the code remains true "
"to the documentation::"
msgstr ""
"Le module :mod:`doctest` permet de chercher des tests dans les chaînes de "
"documentation. Un tests ressemble à un simple copié-collé d'un appel et son "
"résultat depuis le mode interactif. Cela améliore la documentation en "
"fournissant des exemples tout en prouvant qu'ils sont justes : ::"

#: ../Doc/tutorial/stdlib.rst:288
msgid ""
"The :mod:`unittest` module is not as effortless as the :mod:`doctest` "
"module, but it allows a more comprehensive set of tests to be maintained in "
"a separate file::"
msgstr ""
"Le module :mod:`unittest` est plus lourd que le module :mod:`doctest`, mais "
"il permet de construire un jeu de tests plus complet, maintenable, et "
"compréhensible dans un fichier séparé : ::"

#: ../Doc/tutorial/stdlib.rst:310
msgid "Batteries Included"
msgstr "Piles Fournies"

#: ../Doc/tutorial/stdlib.rst:312
msgid ""
"Python has a \"batteries included\" philosophy.  This is best seen through "
"the sophisticated and robust capabilities of its larger packages. For "
"example:"
msgstr ""
"Python respecte la philosophie \"piles fournies\". C'est plus évident en "
"regardant les capacités sophistiquées et solides de ses plus gros paquets. "
"Par exemple:"

#: ../Doc/tutorial/stdlib.rst:315
msgid ""
"The :mod:`xmlrpc.client` and :mod:`xmlrpc.server` modules make implementing "
"remote procedure calls into an almost trivial task.  Despite the modules "
"names, no direct knowledge or handling of XML is needed."
msgstr ""
"Les modules :mod:`xmlrpc.client` et :mod:`xmlrpc.server` permettent "
"d'appeler des fonctions à distance quasiment sans effort. En dépit du nom "
"des modules, aucune connaissance du XML n'est nécessaire."

#: ../Doc/tutorial/stdlib.rst:319
msgid ""
"The :mod:`email` package is a library for managing email messages, including "
"MIME and other RFC 2822-based message documents. Unlike :mod:`smtplib` and :"
"mod:`poplib` which actually send and receive messages, the email package has "
"a complete toolset for building or decoding complex message structures "
"(including attachments) and for implementing internet encoding and header "
"protocols."
msgstr ""
"Le paquet :mod:`email` est une bibliothèque pour gérer les messages "
"electroniques, incluant les MIME et autre encodages basés sur la RFC 2822. "
"Contrairement à :mod:`smtplib` et :mod:`poplib`, qui envoient et reçoivent "
"des messages, le paquet email est une boite à outils pour construire, lire "
"des structures de messages complexes (comprenant des pièces jointes), ou "
"implémenter des encodages et protocoles."

#: ../Doc/tutorial/stdlib.rst:326
msgid ""
"The :mod:`json` package provides robust support for parsing this popular "
"data interchange format.  The :mod:`csv` module supports direct reading and "
"writing of files in Comma-Separated Value format, commonly supported by "
"databases and spreadsheets.  XML processing is supported by the :mod:`xml."
"etree.ElementTree`, :mod:`xml.dom` and :mod:`xml.sax` packages. Together, "
"these modules and packages greatly simplify data interchange between Python "
"applications and other tools."
msgstr ""
"Le paquet :mod:`json` permet de lire et d'écrire du JSON, format d'encodage "
"de donnée répandu. Le module :mod:`csv` gère la lecture et l'écriture de "
"données stockés sous forme de valeurs séparés par des virgules dans des "
"fichiers (Coma-Separated Values), typique des base de donnée et feuiles de "
"calculs. Pour la lecture du XML, utilisez les paquet :mod:`xml.etree."
"ElementTree`, :mod:`xml.dom` et :mod:`xml.sax`. Réunis, ces modules et "
"paquets simplifient grandement l'échange de données entre les applications "
"Python et les autres outils."

#: ../Doc/tutorial/stdlib.rst:335
msgid ""
"The :mod:`sqlite3` module is a wrapper for the SQLite database library, "
"providing a persistent database that can be updated and accessed using "
"slightly nonstandard SQL syntax."
msgstr ""
"Le module :mod:`sqlite3` est une abstraction de la bibliothèque SQLite, "
"permettant de manipuler une base de donnée persistante, accédée et manipulée "
"en utilisant une syntaxe  SQL quasi standard."

#: ../Doc/tutorial/stdlib.rst:339
msgid ""
"Internationalization is supported by a number of modules including :mod:"
"`gettext`, :mod:`locale`, and the :mod:`codecs` package."
msgstr ""
"L'internationalisation est possible grâce à moulte paquets, comme :mod:"
"`gettext`, :mod:`locale`, ou :mod:`codecs`."

#: ../Doc/tutorial/stdlib2.rst:5
msgid "Brief Tour of the Standard Library -- Part II"
msgstr "Rapide tour de la Bibliothèque Standard -- Deuxième partie"

#: ../Doc/tutorial/stdlib2.rst:7
msgid ""
"This second tour covers more advanced modules that support professional "
"programming needs.  These modules rarely occur in small scripts."
msgstr ""
"Cette seconde visite vous fera découvrir des modules d'un usage plus "
"professionnel. Ces modules sont rarement nécessaires dans de petits scripts."

#: ../Doc/tutorial/stdlib2.rst:14
msgid "Output Formatting"
msgstr "Formatage"

#: ../Doc/tutorial/stdlib2.rst:16
msgid ""
"The :mod:`reprlib` module provides a version of :func:`repr` customized for "
"abbreviated displays of large or deeply nested containers::"
msgstr ""
"Le module :mod:`reprlib` est une variante de la fonction :func:`repr`, "
"spécialisée dans l'affichage concis de conteneurs volumineux ou fortement "
"imbriqués : ::"

#: ../Doc/tutorial/stdlib2.rst:23
msgid ""
"The :mod:`pprint` module offers more sophisticated control over printing "
"both built-in and user defined objects in a way that is readable by the "
"interpreter. When the result is longer than one line, the \"pretty printer\" "
"adds line breaks and indentation to more clearly reveal data structure::"
msgstr ""
"Le module :mod:`pprint` propose un contrôle plus fin de l'affichage des "
"objets, aussi bien primitifs que définis par l'utilisateur, et souvent "
"lisible part l'interpréteur. Lorsque le résultat fait plus d'une ligne, il "
"est séparé sur plusieurs lignes et indenté pour rendre la structure plus "
"visible : ::"

#: ../Doc/tutorial/stdlib2.rst:39
msgid ""
"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "
"width::"
msgstr ""
"Le module :mod:`textwrap` formatte des paragraphes de texte pour tenir sur "
"un écran d'une largeur donnée : ::"

#: ../Doc/tutorial/stdlib2.rst:53
msgid ""
"The :mod:`locale` module accesses a database of culture specific data "
"formats. The grouping attribute of locale's format function provides a "
"direct way of formatting numbers with group separators::"
msgstr ""
"Le module :mod:`locale` offre une base de donnée de formats de donnée "
"spécifique à chaque région. L'attribut ``grouping`` de la fonction de "
"formattage permet de formater directement des nombres avec un séparateur : ::"

#: ../Doc/tutorial/stdlib2.rst:72
msgid "Templating"
msgstr "Gabarits (Templates)"

#: ../Doc/tutorial/stdlib2.rst:74
msgid ""
"The :mod:`string` module includes a versatile :class:`~string.Template` "
"class with a simplified syntax suitable for editing by end-users.  This "
"allows users to customize their applications without having to alter the "
"application."
msgstr ""
"Le module :mod:`string`  contiens une classe fort polyvalente : :class:"
"`~string.Template` permettant d'écrire des gabarits (dits \"templates\") "
"avec une syntaxe simple, si simple qu'elle est compréhensible par des non-"
"développeurs. Cela permet donc à vous utilisateurs de personnaliser leur "
"application sans la modifier."

#: ../Doc/tutorial/stdlib2.rst:78
msgid ""
"The format uses placeholder names formed by ``$`` with valid Python "
"identifiers (alphanumeric characters and underscores).  Surrounding the "
"placeholder with braces allows it to be followed by more alphanumeric "
"letters with no intervening spaces.  Writing ``$$`` creates a single escaped "
"``$``::"
msgstr ""
"Le format est constitué de marqueurs formés d'un ``$`` suivi d'un "
"identifiant Python valide (caractères alphanumériques et tirets-bas). "
"Entourer le marqueur d'accolades permet de lui coller d'autres caractères "
"alphanumériques sans intercaler un espace. Écrire ``$$`` créé un simple ``"
"$``."

#: ../Doc/tutorial/stdlib2.rst:88
msgid ""
"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when "
"a placeholder is not supplied in a dictionary or a keyword argument.  For "
"mail-merge style applications, user supplied data may be incomplete and the :"
"meth:`~string.Template.safe_substitute` method may be more appropriate --- "
"it will leave placeholders unchanged if data is missing::"
msgstr ""
"La méthode :meth:`~string.Template.substitute` lève une exception :exc:"
"`KeyError` lorsqu'un marqueur n'a pas été fourni, ni dans un dictionnaire, "
"ni sous forme d'un paramètre nommé. Dans certains cas, lorsque la donnée à "
"appliquer n'est connur que partiellement, la méthode :meth:`~string.Template."
"safe_substitute` est plus appropriée car elle laissera tel quel les "
"marqueurs manquants : ::"

#: ../Doc/tutorial/stdlib2.rst:103
msgid ""
"Template subclasses can specify a custom delimiter.  For example, a batch "
"renaming utility for a photo browser may elect to use percent signs for "
"placeholders such as the current date, image sequence number, or file "
"format::"
msgstr ""
"Les classes filles de ``Template`` peuvent définir leur propre délimiteur. "
"Typiquement, un script de renommage de photos par lots peut choisir le "
"symbole pourcent comme marqueur pour, par exemple, la date actuelle, le "
"numéro de l'image, ou son format : ::"

#: ../Doc/tutorial/stdlib2.rst:125
msgid ""
"Another application for templating is separating program logic from the "
"details of multiple output formats.  This makes it possible to substitute "
"custom templates for XML files, plain text reports, and HTML web reports."
msgstr ""
"Un autre usage des templates est de séparer la logique métier dub côté et "
"les détails spécifiques à chaque format de sortie. Il est possible de "
"générer de cette manière des fichiers XML, texte, HTML, ..."

#: ../Doc/tutorial/stdlib2.rst:133
msgid "Working with Binary Data Record Layouts"
msgstr "Travailler avec des données binaires"

#: ../Doc/tutorial/stdlib2.rst:135
msgid ""
"The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct."
"unpack` functions for working with variable length binary record formats.  "
"The following example shows how to loop through header information in a ZIP "
"file without using the :mod:`zipfile` module.  Pack codes ``\"H\"`` and ``\"I"
"\"`` represent two and four byte unsigned numbers respectively.  The ``\"<"
"\"`` indicates that they are standard size and in little-endian byte order::"
msgstr ""
"Le module :mod:`struct` expose les fonctions :func:`~struct.pack` et :func:"
"`~struct.unpack` permettant de travailler avec des données binaires. "
"L'exemple suivant montre comment parcourir une entête de fichier ZIP sans "
"recourir au module :mod:`zipfile`. Les marqueurs ``\"H\"`` et ``\"I\"`` "
"représentent des nombres entiers non signés, stockés respectivement sur deux "
"et quatre octets. Le ``\"<\"`` indique qu'ils ont une taille standard et "
"dans le style petit-boutiste."

#: ../Doc/tutorial/stdlib2.rst:166
msgid "Multi-threading"
msgstr "Threads"

#: ../Doc/tutorial/stdlib2.rst:168
msgid ""
"Threading is a technique for decoupling tasks which are not sequentially "
"dependent.  Threads can be used to improve the responsiveness of "
"applications that accept user input while other tasks run in the "
"background.  A related use case is running I/O in parallel with computations "
"in another thread."
msgstr ""
"Des tâches indépendantes peuvent être exécutées simultanément (on parle de "
"concourrance), en utilisant des threads.Les threads peuvent améliorer la "
"réactivité d'une application qui accepterait d'interagir avec l'utilisateur "
"pendant que d'autres traitements sont exécutés en arrière plan. Un autre "
"usage typique est de séparer sur deux threads distincts les I/O (entrées / "
"sorties) et le calcul."

#: ../Doc/tutorial/stdlib2.rst:173
msgid ""
"The following code shows how the high level :mod:`threading` module can run "
"tasks in background while the main program continues to run::"
msgstr ""
"Le code suivant donne un exemple d'usage du module :mod:`threading` "
"exécutant des tâches en arrière plan pendant que le programme principal "
"continue de s'exécuter : ::"

#: ../Doc/tutorial/stdlib2.rst:197
msgid ""
"The principal challenge of multi-threaded applications is coordinating "
"threads that share data or other resources.  To that end, the threading "
"module provides a number of synchronization primitives including locks, "
"events, condition variables, and semaphores."
msgstr ""
"Le challenge principal des applications multi tâches est la coordination "
"entre les threads qui partagent des données ou des ressources. Pour ce "
"faire, le module ``threading`` expose quelques outils dédiés à la "
"synchronisation comme les verrous (locks), événement (events), variables "
"conditionnelles (condition variables), et les sémaphores."

#: ../Doc/tutorial/stdlib2.rst:202
msgid ""
"While those tools are powerful, minor design errors can result in problems "
"that are difficult to reproduce.  So, the preferred approach to task "
"coordination is to concentrate all access to a resource in a single thread "
"and then use the :mod:`queue` module to feed that thread with requests from "
"other threads. Applications using :class:`~queue.Queue` objects for inter-"
"thread communication and coordination are easier to design, more readable, "
"and more reliable."
msgstr ""
"Bien que ces outils soient puissants, des erreurs de conceptions peuvent "
"engendrer des problèmes difficiles à reproduire. Donc, l'approche favorite "
"pour coordonner des tâches est de restreindre l'accès d'une ressource à un "
"seul thread, et d'utiliser le module :mod:`queue` pour alimenter ce thread "
"de requêtes venant d'autres threads. Les applications utilisant des :class:"
"`~queue.Queue` pour leurs communication et coordination entre threads sont "
"plus simples à concevoir, plus lisible, et plus fiables."

#: ../Doc/tutorial/stdlib2.rst:213
msgid "Logging"
msgstr "Journalisation"

#: ../Doc/tutorial/stdlib2.rst:215
msgid ""
"The :mod:`logging` module offers a full featured and flexible logging "
"system. At its simplest, log messages are sent to a file or to ``sys."
"stderr``::"
msgstr ""
"Le module :mod:`logging` est un système de journalisation complet. Dans son "
"utilisation la plus élémentaire, les messages sont simplement envoyés dans "
"un fichier ou sur ``sys.stderr`` ::"

#: ../Doc/tutorial/stdlib2.rst:225
msgid "This produces the following output:"
msgstr "Produisant l'affichage suivant :"

#: ../Doc/tutorial/stdlib2.rst:233
msgid ""
"By default, informational and debugging messages are suppressed and the "
"output is sent to standard error.  Other output options include routing "
"messages through email, datagrams, sockets, or to an HTTP Server.  New "
"filters can select different routing based on message priority: :const:"
"`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :const:"
"`~logging.ERROR`, and :const:`~logging.CRITICAL`."
msgstr ""
"Par défaut, les messages d'information et de débogage sont ignorés, les "
"autres écrites sur la sortie standard. Il est aussi possible d'envoyer les "
"messages par email, datagrammes, sur des sockets, ou postés sur un serveur "
"HTTP. Les nouveaux filtres permettent d'utiliser des sorties différentes en "
"fonction de la priorité du message : :const:`~logging.DEBUG`, :const:"
"`~logging.INFO`, :const:`~logging.WARNING`, :const:`~logging.ERROR`, et :"
"const:`~logging.CRITICAL`."

#: ../Doc/tutorial/stdlib2.rst:240
msgid ""
"The logging system can be configured directly from Python or can be loaded "
"from a user editable configuration file for customized logging without "
"altering the application."
msgstr ""
"depuis un fichier de configuration, permettant de personnaliser le log sans "
"modifier l'application."

#: ../Doc/tutorial/stdlib2.rst:248
msgid "Weak References"
msgstr "Références faibles"

#: ../Doc/tutorial/stdlib2.rst:250
msgid ""
"Python does automatic memory management (reference counting for most objects "
"and :term:`garbage collection` to eliminate cycles).  The memory is freed "
"shortly after the last reference to it has been eliminated."
msgstr ""
"Python gère lui même la mémoire (par comptage de référence pour la majorité "
"des objets, et en utilisant un :term:`ramasse-miettes`\\s (garbage "
"collector) pour éliminer les cycles). La mémoire est libérée rapidement "
"lorsque sa dernière référence est perdue."

#: ../Doc/tutorial/stdlib2.rst:254
msgid ""
"This approach works fine for most applications but occasionally there is a "
"need to track objects only as long as they are being used by something else. "
"Unfortunately, just tracking them creates a reference that makes them "
"permanent. The :mod:`weakref` module provides tools for tracking objects "
"without creating a reference.  When the object is no longer needed, it is "
"automatically removed from a weakref table and a callback is triggered for "
"weakref objects.  Typical applications include caching objects that are "
"expensive to create::"
msgstr ""
"Cette approche fonctionne bien pour la majorité des applications, mais, "
"parfois, il est nécessaire de surveiller un objet seulement durant son "
"utilisation par quelque chose d'autre. Malheureusement, le simple fait de le "
"suivre crée une référence, qui rend l'objet permanent. Le module :mod:"
"`weakref` expose des outils pour suivre les objets sans pour autant créer "
"une référence. Lorsqu'un objet n'est pas utilisé, il est automatiquement "
"supprimé du tableau des références faibles, et une fonction de rappel "
"(callback) est appelée. Un exemple typique est le cache d'objets coûteux à "
"créer : ::"

#: ../Doc/tutorial/stdlib2.rst:289
msgid "Tools for Working with Lists"
msgstr "Outils pour travailler avec des listes"

#: ../Doc/tutorial/stdlib2.rst:291
msgid ""
"Many data structure needs can be met with the built-in list type. However, "
"sometimes there is a need for alternative implementations with different "
"performance trade-offs."
msgstr ""
"Beaucoup de structures de données peuvent être représentés avec des listes "
"natives. Cependant, parfois, d'autres besoins émergent, pour des structures "
"ayant des caractéristiques différentes, typiquement en terme de performance."

#: ../Doc/tutorial/stdlib2.rst:295
msgid ""
"The :mod:`array` module provides an :class:`~array.array()` object that is "
"like a list that stores only homogeneous data and stores it more compactly.  "
"The following example shows an array of numbers stored as two byte unsigned "
"binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry "
"for regular lists of Python int objects::"
msgstr ""
"Le module :mod:`array` fournit un objet :class:`~array.array()`, ne "
"permettant de stocker que des listes homogènes, mais d'une manière plus "
"compacte. L'exemple suivant montre une liste de nombres, stockés chacun sur "
"deux octets non signés (marqueur ``\"H\"``) plutôt que d'utiliser 16 octets "
"comme l'aurais fait une liste classique : ::"

#: ../Doc/tutorial/stdlib2.rst:308
msgid ""
"The :mod:`collections` module provides a :class:`~collections.deque()` "
"object that is like a list with faster appends and pops from the left side "
"but slower lookups in the middle. These objects are well suited for "
"implementing queues and breadth first tree searches::"
msgstr ""
"Le module :mod:`collections` fournit la classe :class:`~collections."
"deque()`, qui ressemble à une liste, mais plus rapide à insérer ou sortir "
"des éléments par la gauche, et plus lente pour accéder aux éléments du "
"milieu. C'est objets sont particulièrement adaptés pour construire des "
"queues ou des algorithme de parcours d'arbre en largeur : ::"

#: ../Doc/tutorial/stdlib2.rst:329
msgid ""
"In addition to alternative list implementations, the library also offers "
"other tools such as the :mod:`bisect` module with functions for manipulating "
"sorted lists::"
msgstr ""
"Au delà de fournir des implémentations de listes alternatives, la "
"bibliothèque fournit des outils tels que :mod:`bisect`, un module contenant "
"des fonctions de manipulation de listes triées : ::"

#: ../Doc/tutorial/stdlib2.rst:339
msgid ""
"The :mod:`heapq` module provides functions for implementing heaps based on "
"regular lists.  The lowest valued entry is always kept at position zero.  "
"This is useful for applications which repeatedly access the smallest element "
"but do not want to run a full list sort::"
msgstr ""
"Le module :mod:`heapq`, permettant d'implémenter des tas (heaps) à partir de "
"simple listes. La valeur la plus faible est toujours à la première position "
"(indice 0). C'est utile dans les cas où l'application souvent besoin de "
"trouver l'élément le plus petit sans trier entièrement la liste : ::"

#: ../Doc/tutorial/stdlib2.rst:355
msgid "Decimal Floating Point Arithmetic"
msgstr "Arithmétique décimale à Virgule Flottante"

#: ../Doc/tutorial/stdlib2.rst:357
msgid ""
"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for "
"decimal floating point arithmetic.  Compared to the built-in :class:`float` "
"implementation of binary floating point, the class is especially helpful for"
msgstr ""
"Le module :mod:`decimal` expose la classe :class:`~decimal.Decimal`, "
"spécialisée dans le calcul de nombres décimaux représentés en virgule "
"flottante. Par rapport à la classe native :class:`float`, elle est "
"particulièrement utile pour"

#: ../Doc/tutorial/stdlib2.rst:361
msgid ""
"financial applications and other uses which require exact decimal "
"representation,"
msgstr ""
"les application traitant de finance est autres usages nécessitant une "
"représentation décimale exacte,"

#: ../Doc/tutorial/stdlib2.rst:363
msgid "control over precision,"
msgstr "contrôle sur la précision, "

#: ../Doc/tutorial/stdlib2.rst:364
msgid "control over rounding to meet legal or regulatory requirements,"
msgstr ""
"contrôle sur les arrondis pour correspondre aux obligations légales ou du "
"régulateur,"

#: ../Doc/tutorial/stdlib2.rst:365
msgid "tracking of significant decimal places, or"
msgstr "suivre les décimales significatives, ou"

#: ../Doc/tutorial/stdlib2.rst:366
msgid ""
"applications where the user expects the results to match calculations done "
"by hand."
msgstr ""
"les applications avec lesquelles l'utilisateur attend des résultats "
"identiques aux calculs faits à la main."

#: ../Doc/tutorial/stdlib2.rst:369
msgid ""
"For example, calculating a 5% tax on a 70 cent phone charge gives different "
"results in decimal floating point and binary floating point. The difference "
"becomes significant if the results are rounded to the nearest cent::"
msgstr ""
"Par exemple, calculer 5% de taxe sur une facture de 70 centimes donne un "
"résultat différent en nombre a virgule flottantes binaires et décimales. La "
"différence devient significative lorsqu'on arrondit le résultat au centime "
"près : ::"

#: ../Doc/tutorial/stdlib2.rst:379
msgid ""
"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically "
"inferring four place significance from multiplicands with two place "
"significance.  Decimal reproduces mathematics as done by hand and avoids "
"issues that can arise when binary floating point cannot exactly represent "
"decimal quantities."
msgstr ""
"Le résultat d'un calcul donné par :class:`~decimal.Decimal` conserve les "
"zéro non-significatifs. La classe conserve automatiquement quatre décimales "
"significatives pour des opérandes à deux décimales significatives. La classe "
"``Decimal`` imite les mathématiques tels qu'elles pourraient être effectuées "
"à la main, évitant les problèmes typique de l'arithmétique binaire à virgule "
"flottante qui n'est pas capable de représenter exactement certaines "
"quantités décimales."

#: ../Doc/tutorial/stdlib2.rst:385
msgid ""
"Exact representation enables the :class:`~decimal.Decimal` class to perform "
"modulo calculations and equality tests that are unsuitable for binary "
"floating point::"
msgstr ""
"La représentation exacte de la classe :class:`~decimal.Decimal` lui permet "
"de faire des calculs du modulo ou des tests d'égalité qui ne seraient pas "
"possibles avec des virgules flottantes binaires : ::"

#: ../Doc/tutorial/stdlib2.rst:399
msgid ""
"The :mod:`decimal` module provides arithmetic with as much precision as "
"needed::"
msgstr ""
"Le module :mod:`decimal` permet de faire des calculs avec autant de "
"précision que nécessaire : ::"

#: ../Doc/tutorial/venv.rst:6
msgid "Virtual Environments and Packages"
msgstr "Environnements virtuels et Paquets"

#: ../Doc/tutorial/venv.rst:9
msgid "Introduction"
msgstr "Introduction"

#: ../Doc/tutorial/venv.rst:11
msgid ""
"Python applications will often use packages and modules that don't come as "
"part of the standard library.  Applications will sometimes need a specific "
"version of a library, because the application may require that a particular "
"bug has been fixed or the application may be written using an obsolete "
"version of the library's interface."
msgstr ""
"Les programmes Python utilisent souvent des paquets et modules qui ne font "
"pas partie de la bibliothèque standard. Ils nécessitent aussi, parfois, une "
"version spécifique de la bibliothèque, nécessitant par exemple qu'un certain "
"bug ai été corrigé, ou encore que le programme à été implémenté en utilisant "
"une version obsolète de l'interface de la bibliothèque."

#: ../Doc/tutorial/venv.rst:17
msgid ""
"This means it may not be possible for one Python installation to meet the "
"requirements of every application.  If application A needs version 1.0 of a "
"particular module but application B needs version 2.0, then the requirements "
"are in conflict and installing either version 1.0 or 2.0 will leave one "
"application unable to run."
msgstr ""
"Cela signifie qu'il n'est pas forcément possible, pour une installation de "
"Python, de couvrir tous les besoins de toutes les applications. Basiquement, "
"si une application A dépend de la version 1.0 d'un module et qu'une "
"application B dépend de la version 2.0, il y a conflit, et installer la "
"version 1.0 ou 2.0 laissera une des deux application incapable de "
"fonctionner."

#: ../Doc/tutorial/venv.rst:23
msgid ""
"The solution for this problem is to create a :term:`virtual environment`, a "
"self-contained directory tree that contains a Python installation for a "
"particular version of Python, plus a number of additional packages."
msgstr ""

#: ../Doc/tutorial/venv.rst:27
msgid ""
"Different applications can then use different virtual environments. To "
"resolve the earlier example of conflicting requirements, application A can "
"have its own virtual environment with version 1.0 installed while "
"application B has another virtual environment with version 2.0. If "
"application B requires a library be upgraded to version 3.0, this will not "
"affect application A's environment."
msgstr ""

#: ../Doc/tutorial/venv.rst:36
msgid "Creating Virtual Environments"
msgstr "Création d'Environnements Virtuels"

#: ../Doc/tutorial/venv.rst:38
msgid ""
"The module used to create and manage virtual environments is called :mod:"
"`venv`.  :mod:`venv` will usually install the most recent version of Python "
"that you have available. If you have multiple versions of Python on your "
"system, you can select a specific Python version by running ``python3`` or "
"whichever version you want."
msgstr ""

#: ../Doc/tutorial/venv.rst:44
msgid ""
"To create a virtual environment, decide upon a directory where you want to "
"place it, and run the :mod:`venv` module as a script with the directory "
"path::"
msgstr ""

#: ../Doc/tutorial/venv.rst:49
msgid ""
"This will create the ``tutorial-env`` directory if it doesn't exist, and "
"also create directories inside it containing a copy of the Python "
"interpreter, the standard library, and various supporting files."
msgstr ""
"Cela créera le dossier ``tutorial-env`` (s'il n'existe pas) et des sous "
"dossiers contenant une copie de l'interpréteur Python, de la bibliothèque "
"standard, et quelques autres fichiers utiles."

#: ../Doc/tutorial/venv.rst:53
msgid "Once you've created a virtual environment, you may activate it."
msgstr ""

#: ../Doc/tutorial/venv.rst:55
msgid "On Windows, run::"
msgstr "Sur windows, lancez : ::"

#: ../Doc/tutorial/venv.rst:59
msgid "On Unix or MacOS, run::"
msgstr "Sur Unix et MacOS, lancez : ::"

#: ../Doc/tutorial/venv.rst:63
msgid ""
"(This script is written for the bash shell.  If you use the :program:`csh` "
"or :program:`fish` shells, there are alternate ``activate.csh`` and "
"``activate.fish`` scripts you should use instead.)"
msgstr ""
"(Ce script est écrit pour le shell :program:`bash`, si vous utilisez :"
"program:`csh` ou :program:`fish`, utilisez les variantes ``activate.csh`` ou "
"``activate.fish``.)"

#: ../Doc/tutorial/venv.rst:68
msgid ""
"Activating the virtual environment will change your shell's prompt to show "
"what virtual environment you're using, and modify the environment so that "
"running ``python`` will get you that particular version and installation of "
"Python. For example:"
msgstr ""

#: ../Doc/tutorial/venv.rst:87
msgid "Managing Packages with pip"
msgstr "Gérer les Paquets avec pip"

#: ../Doc/tutorial/venv.rst:89
msgid ""
"You can install, upgrade, and remove packages using a program called :"
"program:`pip`.  By default ``pip`` will install packages from the Python "
"Package Index, <https://pypi.python.org/pypi>.  You can browse the Python "
"Package Index by going to it in your web browser, or you can use ``pip``'s "
"limited search feature:"
msgstr ""

#: ../Doc/tutorial/venv.rst:105
msgid ""
"``pip`` has a number of subcommands: \"search\", \"install\", \"uninstall\", "
"\"freeze\", etc.  (Consult the :ref:`installing-index` guide for complete "
"documentation for ``pip``.)"
msgstr ""
"``pip`` a plusieurs sous commandes : \"search\", \"install\", \" uninstall"
"\", \"freeze\", etc... (Consultez le guide :ref:`installing-index` contenant "
"une documentation exhaustive sur ``pip``.)"

#: ../Doc/tutorial/venv.rst:109
msgid ""
"You can install the latest version of a package by specifying a package's "
"name:"
msgstr ""

#: ../Doc/tutorial/venv.rst:120
msgid ""
"You can also install a specific version of a package by giving the package "
"name  followed by ``==`` and the version number:"
msgstr ""

#: ../Doc/tutorial/venv.rst:131
msgid ""
"If you re-run this command, ``pip`` will notice that the requested version "
"is already installed and do nothing.  You can supply a different version "
"number to get that version, or you can run ``pip install --upgrade`` to "
"upgrade the package to the latest version:"
msgstr ""

#: ../Doc/tutorial/venv.rst:146
msgid ""
"``pip uninstall`` followed by one or more package names will remove the "
"packages from the virtual environment."
msgstr ""
"``pip uninstall`` suivi d'un ou plusieurs noms de paquets les supprimera de "
"votre virtualenv."

#: ../Doc/tutorial/venv.rst:149
msgid "``pip show`` will display information about a particular package:"
msgstr ""

#: ../Doc/tutorial/venv.rst:166
msgid ""
"``pip list`` will display all of the packages installed in the virtual "
"environment:"
msgstr ""

#: ../Doc/tutorial/venv.rst:178
msgid ""
"``pip freeze`` will produce a similar list of the installed packages, but "
"the output uses the format that ``pip install`` expects. A common convention "
"is to put this list in a ``requirements.txt`` file:"
msgstr ""

#: ../Doc/tutorial/venv.rst:190
msgid ""
"The ``requirements.txt`` can then be committed to version control and "
"shipped as part of an application.  Users can then install all the necessary "
"packages with ``install -r``:"
msgstr ""

#: ../Doc/tutorial/venv.rst:207
msgid ""
"``pip`` has many more options.  Consult the :ref:`installing-index` guide "
"for complete documentation for ``pip``.  When you've written a package and "
"want to make it available on the Python Package Index, consult the :ref:"
"`distributing-index` guide."
msgstr ""
"``pip`` a beaucoup d'autres options, documentées dans le guide :ref:"
"`installing-index`. Lorsque vous aurez écrit un paquet, si vous voulez le "
"rendre disponible sur PyPI, lisez le guide :ref:`distributing-index`."

#: ../Doc/tutorial/whatnow.rst:5
msgid "What Now?"
msgstr "Et Maintenant ?"

#: ../Doc/tutorial/whatnow.rst:7
msgid ""
"Reading this tutorial has probably reinforced your interest in using Python "
"--- you should be eager to apply Python to solving your real-world problems. "
"Where should you go to learn more?"
msgstr ""
"Lire ce tutoriel a probablement renforcé votre intérêt pour Python, en der "
"l'utiliser pour résoudre des vrais problèmes. Ou devriez vous aller pour en "
"apprendre plus ?"

#: ../Doc/tutorial/whatnow.rst:11
msgid ""
"This tutorial is part of Python's documentation set.   Some other documents "
"in the set are:"
msgstr ""
"Ce tutoriel fait partie de la documentation de Python, mais la documentation "
"de Python est vaste : ::"

#: ../Doc/tutorial/whatnow.rst:14
msgid ":ref:`library-index`:"
msgstr ":ref:`library-index`:"

#: ../Doc/tutorial/whatnow.rst:16
msgid ""
"You should browse through this manual, which gives complete (though terse) "
"reference material about types, functions, and the modules in the standard "
"library.  The standard Python distribution includes a *lot* of additional "
"code. There are modules to read Unix mailboxes, retrieve documents via HTTP, "
"generate random numbers, parse command-line options, write CGI programs, "
"compress data, and many other tasks. Skimming through the Library Reference "
"will give you an idea of what's available."
msgstr ""
"Vous devriez naviguer dans le manuel, il est une référence complète, (et "
"donc laconique...) sur les types, fonctions, et modules de la bibliothèque "
"standard. La distribution standard de Python inclus *énormément* de code "
"supplémentaire. Il existe des modules pour lire des emails, récupérer des "
"documents via HTTP, générer des nombres aléatoires, analyser les paramètres "
"de la ligne de commande, écrire des programmes CGI, compresser de la donnée, "
"et plein d'autres tâches. Vous balader dans la documentation de la "
"bibliothèque vous donnera une idée de ce qui est disponnible."

#: ../Doc/tutorial/whatnow.rst:24
msgid ""
":ref:`installing-index` explains how to install additional modules written "
"by other Python users."
msgstr ""
":ref:`installing-index` explique comment installer des paquets écrits par "
"d'autres utilisateurs de Python."

#: ../Doc/tutorial/whatnow.rst:27
msgid ""
":ref:`reference-index`: A detailed explanation of Python's syntax and "
"semantics.  It's heavy reading, but is useful as a complete guide to the "
"language itself."
msgstr ""
":ref:`reference-index`: Une explication détaillée de la syntaxe et "
"sémantique de Python. C'est une lecture fastidieuse, mais qui a sa place "
"dans une documentation exhaustive."

#: ../Doc/tutorial/whatnow.rst:31
msgid "More Python resources:"
msgstr "D'autres ressources:"

#: ../Doc/tutorial/whatnow.rst:33
msgid ""
"https://www.python.org:  The major Python Web site.  It contains code, "
"documentation, and pointers to Python-related pages around the Web.  This "
"Web site is mirrored in various places around the world, such as Europe, "
"Japan, and Australia; a mirror may be faster than the main site, depending "
"on your geographical location."
msgstr ""
"https://www.python.org: C'est le site principal pour Python, il y contient "
"du code, de la documentation, des liens vers d'autres sites à propos de "
"Python tout autour d'internet. Il est répliqué dans différents endroits "
"autours du globe, comme en Europe, au Japon, et en Australie, ces répliques "
"peuvent dans certains cas être plus rapides que le site principal, tout "
"dépend d'où vous vous situez."

#: ../Doc/tutorial/whatnow.rst:39
msgid "https://docs.python.org:  Fast access to Python's  documentation."
msgstr ""
"https://docs.python.org:  Un accès rapide à la documentation de Python en "
"anglais. (La traduction en français, vous y êtes, est ici: http://www.afpy."
"org/doc/python)"

#: ../Doc/tutorial/whatnow.rst:41
msgid ""
"https://pypi.python.org/pypi: The Python Package Index, previously also "
"nicknamed the Cheese Shop, is an index of user-created Python modules that "
"are available for download.  Once you begin releasing code, you can register "
"it here so that others can find it."
msgstr ""
"https://pypi.python.org/pypi: \"The Python Package Index\", (Le Répertoire "
"des Paquets Python), ou auparavant surnommé \"The Cheese Shop\" (La "
"Fromagerie), est un catalogue de modules Python disponibles au "
"téléchargement, construit par les utilisateurs. Lorsque vous commencez à "
"distribuer du code, vous pouvez l'inscrire ici afin que les autres puissent "
"le trouver."

#: ../Doc/tutorial/whatnow.rst:46
msgid ""
"https://code.activestate.com/recipes/langs/python/: The Python Cookbook is a "
"sizable collection of code examples, larger modules, and useful scripts. "
"Particularly notable contributions are collected in a book also titled "
"Python Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)"
msgstr ""

#: ../Doc/tutorial/whatnow.rst:51
msgid ""
"http://www.pyvideo.org collects links to Python-related videos from "
"conferences and user-group meetings."
msgstr ""
"http://www.pyvideo.org regroupe des liens vers des vidéos relatives à "
"Python, de conférences ou de réunions de groupes d'utilisateurs."

#: ../Doc/tutorial/whatnow.rst:54
msgid ""
"https://scipy.org: The Scientific Python project includes modules for fast "
"array computations and manipulations plus a host of packages for such things "
"as linear algebra, Fourier transforms, non-linear solvers, random number "
"distributions, statistical analysis and the like."
msgstr ""

#: ../Doc/tutorial/whatnow.rst:59
msgid ""
"For Python-related questions and problem reports, you can post to the "
"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at "
"python-list@python.org.  The newsgroup and mailing list are gatewayed, so "
"messages posted to one will automatically be forwarded to the other.  There "
"are hundreds of postings a day, asking (and answering) questions, suggesting "
"new features, and announcing new modules. Mailing list archives are "
"available at https://mail.python.org/pipermail/."
msgstr ""
"Pour poser des questions ou rapporter des problèmes liés à Python, vous "
"pouvez écrire sur le forum :newsgroup:`comp.lang.python`, ou les envoyer à "
"la liste de diffusion à python-list@python.org. Le forum et la liste de "
"diffusion sont liées, un message publié sur l'un sera automatiquement "
"transféré sur l'autre. Il y sont publiés des centaines de messages par jour, "
"demandant (ou répondant) à des questions, suggérant des nouvelles "
"fonctionalités, et annoncant des nouveaux modules. Les archives sont "
"disponibles à https://mail.python.org/pipermail/."

#: ../Doc/tutorial/whatnow.rst:67
msgid ""
"Before posting, be sure to check the list of :ref:`Frequently Asked "
"Questions <faq-index>` (also called the FAQ).  The FAQ answers many of the "
"questions that come up again and again, and may already contain the solution "
"for your problem."
msgstr ""
"Avant de poster, assurez vous d'avoir lu la liste de la :ref:`Foire Aux "
"Questions <faq-index>` (aussi appelée FAQ). La FAQ répond à beaucoup de "
"questions fréquentes, et contient probablement une solution à votre problème."