tutorial.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2010, 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: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-11-05 09:33\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"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Translate Toolkit 1.7.0\n"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../src/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 ! [#]_"

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

#: ../src/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:`__builtin__`.)"
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`.)"

#: ../src/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, « oublier » 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."

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

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

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

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

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

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

#: ../src/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. "
"Otherwise, all variables found outside of the innermost scope 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 ""
"Si un nom est déclaré global, toutes les références et affectations vont "
"directement dans la portée intermédiaire contenant les noms globaux du "
"module. Pour réattacher des variables trouvées en dehors de la portée la "
"plus au centre, l'instruction :keyword:`nonlocal` peut être utilisée. Si "
"elles ne sont pas déclarées « nonlocal », ces variables sont en lecture "
"seule (toute tentative de modifier une telle variable créera simplement une "
"*nouvelle* variable locale dans la portée la plus au centre, en laissant "
"inchangée la variable du même nom dans la portée englobante)."

#: ../src/Doc/tutorial/classes.rst:126
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."

#: ../src/Doc/tutorial/classes.rst:131
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)."

#: ../src/Doc/tutorial/classes.rst:139
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.  (The :keyword:`global` statement can be used to "
"indicate that particular variables live in the global 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."

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

#: ../src/Doc/tutorial/classes.rst:155
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"

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

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

#: ../src/Doc/tutorial/classes.rst:173
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.)"

#: ../src/Doc/tutorial/classes.rst:177
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."

#: ../src/Doc/tutorial/classes.rst:183
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."

#: ../src/Doc/tutorial/classes.rst:188
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)."

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

#: ../src/Doc/tutorial/classes.rst:202
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."

#: ../src/Doc/tutorial/classes.rst:205
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 ::"

# docstring doit il rester en anglais ou être traduit ?
#: ../src/Doc/tutorial/classes.rst:216
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\"``."

#: ../src/Doc/tutorial/classes.rst:222
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) ::"

#: ../src/Doc/tutorial/classes.rst:228
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``."

#: ../src/Doc/tutorial/classes.rst:231
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 ::"

#: ../src/Doc/tutorial/classes.rst:239
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 ::"

#: ../src/Doc/tutorial/classes.rst:245
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, ::"

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

#: ../src/Doc/tutorial/classes.rst:264
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."

#: ../src/Doc/tutorial/classes.rst:268
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:`MaClasse` créée ci-dessus, le code suivant affiche la "
"valeur ``16 ``, sans laisser de traces ::"

#: ../src/Doc/tutorial/classes.rst:280
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)."

#: ../src/Doc/tutorial/classes.rst:289
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."

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

#: ../src/Doc/tutorial/classes.rst:302
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::"

#: ../src/Doc/tutorial/classes.rst:306
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 methode, il peut être gardé de "
"coté et être appelé plus tard. Par exemple::"

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

#: ../src/Doc/tutorial/classes.rst:316
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é..."

#: ../src/Doc/tutorial/classes.rst:322
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."

#: ../src/Doc/tutorial/classes.rst:329
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."

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

#: ../src/Doc/tutorial/classes.rst:347
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."

#: ../src/Doc/tutorial/classes.rst:354
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)."

#: ../src/Doc/tutorial/classes.rst:362
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."

#: ../src/Doc/tutorial/classes.rst:368
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."

#: ../src/Doc/tutorial/classes.rst:373
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."

#: ../src/Doc/tutorial/classes.rst:379
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 ::"

#: ../src/Doc/tutorial/classes.rst:394
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."

#: ../src/Doc/tutorial/classes.rst:399
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`` ::"

#: ../src/Doc/tutorial/classes.rst:411
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."

#: ../src/Doc/tutorial/classes.rst:421
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__``."

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

#: ../src/Doc/tutorial/classes.rst:430
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 ::"

#: ../src/Doc/tutorial/classes.rst:441
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 ::"

#: ../src/Doc/tutorial/classes.rst:448
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."

#: ../src/Doc/tutorial/classes.rst:454
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."

#: ../src/Doc/tutorial/classes.rst:460
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``)."

#: ../src/Doc/tutorial/classes.rst:466
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)."

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

#: ../src/Doc/tutorial/classes.rst:475
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`."

# 9eda01c71f1b43b2a9f80582775b12b2
#: ../src/Doc/tutorial/classes.rst:479
msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
"is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
"``issubclass(unicode, str)`` is ``False`` since :class:`unicode` is not a "
"subclass of :class:`str` (they only share a common ancestor, :class:"
"`basestring`)."
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(unicode, str)`` renvoie "
"``False`` car :class:`unicode` n'est pas une sous-classe de :class:`str` "
"(ils partagent seulement un ancêtre commun, :class:`basestring`)."

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

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

#: ../src/Doc/tutorial/classes.rst:502
msgid ""
"For old-style classes, the only rule is depth-first, left-to-right.  Thus, "
"if an attribute is not found in :class:`DerivedClassName`, it is searched "
"in :class:`Base1`, then (recursively) in the base classes of :class:`Base1`, "
"and only if it is not found there, it is searched in :class:`Base2`, and so "
"on."
msgstr ""
"Pour les anciennes classes, la seule règle est : en profondeur, de gauche à "
"droite. Ainsi, si un attribut n'est pas trouvé dans :class:"
"`NomDeLaClasseDerivee`, 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."

# 0bd332ed666e47d1b82a9aa6ea6a3afe
#: ../src/Doc/tutorial/classes.rst:507
msgid ""
"(To some people breadth first --- searching :class:`Base2` and :class:"
"`Base3` before the base classes of :class:`Base1` --- looks more natural.  "
"However, this would require you to know whether a particular attribute of :"
"class:`Base1` is actually defined in :class:`Base1` or in one of its base "
"classes before you can figure out the consequences of a name conflict with "
"an attribute of :class:`Base2`.  The depth-first rule makes no differences "
"between direct and inherited attributes of :class:`Base1`.)"
msgstr ""
"(Pour certaines personnes, commencer la recherche \"en largeur\" --- "
"chercher dans :class:`Base2` et :class:`Base3` avant d'aller dans les "
"classes de base de :class:`Base1` --- peut sembler plus naturel. Toutefois, "
"ceci nécessiterait de savoir si un attribut particulier de :class:`Base1` "
"est actuellement défini dans :class:`Base1` ou dans l'une de ses classes de "
"base avant de pouvoir envisager les conséquences d'un conflit de nom avec un "
"attribut de :class:`Base2`. La règle qui consiste à rechercher d'abord en "
"profondeur ne fait aucune différence entre des attributs définis localement "
"et des attributs hérités de :class:`Base1`)."

# 065cbbda1701441f9d8f176d380ca4bf
#: ../src/Doc/tutorial/classes.rst:515
msgid ""
"For :term:`new-style class`\\es, 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 ""
"Pour les nouvelles classes, l'ordre de résolution des méthodes change "
"dynamiquement pour gérer les appels coopératifs de la fonction :func:"
"`super`. Cette approche est connue dans certains langages supportant "
"l'héritage multiple sous le nom de la \"méthode la plus proche\" (\"call-"
"next-method\"), et est plus puissante que le seul appel de la méthode \"super"
"\" que l'on trouve dans les langages ne gérant que l'héritage simple."

# d37280ea9d7743f686abf8f1e1859425
#: ../src/Doc/tutorial/classes.rst:520
msgid ""
"With new-style classes, 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 new-style 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 http://"
"www.python.org/download/releases/2.3/mro/."
msgstr ""
"Avec les nouvelles classes, l'ordre défini dynamiquement est nécessaire car "
"tous les cas d'héritage multiple comportent un arbre d'héritage en losange "
"(au moins l'une des classes parentes peut être accédée via plusieurs chemins "
"à partir d'une même sous-classe). Par exemple, toutes les nouvelles classes "
"héritent de :class:`object`, donc n'importe quel arbre d'héritage multiple "
"fournit plus d'un chemin 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 la "
"gauche 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/."

# 0d63701d735e45d6b0ed3f46e2ff0bea
#: ../src/Doc/tutorial/classes.rst:538
msgid "Private Variables and Class-local References"
msgstr "Variables privées et références locales aux classes"

#: ../src/Doc/tutorial/classes.rst:540
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."

#: ../src/Doc/tutorial/classes.rst:547
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."

# 76822657f61145529176860bfd786541
# Une définition en français pour le "name mangling", littéralement "bricolage" ??
#: ../src/Doc/tutorial/classes.rst:556
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 ::"

#: ../src/Doc/tutorial/classes.rst:578
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."

# 9412d7da01ba4f1c94661f38b627ccda
#: ../src/Doc/tutorial/classes.rst:582
msgid ""
"Notice that code passed to ``exec``, ``eval()`` or ``execfile()`` 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()`` ou ``execfile()`` ne "
"considère pas le nom de la classe appelante comme étant la classe courante ; "
"le même effet s'applique à la directive ``gloabl``, 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__``."

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

#: ../src/Doc/tutorial/classes.rst:595
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 ::"

#: ../src/Doc/tutorial/classes.rst:609
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."

# 7ebc85600b7944a29e6e12ecc0f45219
#: ../src/Doc/tutorial/classes.rst:620
msgid ""
"Instance method objects have attributes, too: ``m.im_self`` is the instance "
"object with the method :meth:`m`, and ``m.im_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."

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

#: ../src/Doc/tutorial/classes.rst:630
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."

#: ../src/Doc/tutorial/classes.rst:633
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` ::"

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

#: ../src/Doc/tutorial/classes.rst:644
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 ::"

#: ../src/Doc/tutorial/classes.rst:666
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."

#: ../src/Doc/tutorial/classes.rst:669
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`."

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

#: ../src/Doc/tutorial/classes.rst:679
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` ::"

# 6aba6be73fbf4173bdf405faaa3f4fbf
#: ../src/Doc/tutorial/classes.rst:693
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:`next` which "
"accesses elements in the container one at a time.  When there are no more "
"elements, :meth:`next` raises a :exc:`StopIteration` exception which tells "
"the :keyword:`for` loop to terminate. 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:`next`, laquelle accède "
"aux éléments du conteneur un par un. Lorsqu'il n'y a plus d'élément, :meth:"
"`next` lève une exception :exc:`StopIteration` qui indique à la boucle de "
"l'instruction :keyword:`for` de se terminer. Cet exemple montre comment tout "
"cela fonctionne ::"

# 3b3fcc0b4bdf44b59d3a21fe85f65bae
#: ../src/Doc/tutorial/classes.rst:717
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:`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:`next`. Si "
"la classe définit elle-même la méthode :meth:`next`, alors :meth:`__iter__` "
"peut simplement renvoyer ``self`` ::"

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

# b93a03d2e68d4a60aa58eb2165d2ff9d
#: ../src/Doc/tutorial/classes.rst:754
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 :meth:`next` is "
"called, 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érateurs` 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 :meth:`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 ::"

# 3d70dcf3a7024e698039ee6bdaf21102
#: ../src/Doc/tutorial/classes.rst:775
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:`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:`next` sont créées automatiquement."

#: ../src/Doc/tutorial/classes.rst:780
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``."

#: ../src/Doc/tutorial/classes.rst:785
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."

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

#: ../src/Doc/tutorial/classes.rst:796
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."

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

#: ../src/Doc/tutorial/classes.rst:827 ../src/Doc/tutorial/controlflow.rst:666
#: ../src/Doc/tutorial/datastructures.rst:740
#: ../src/Doc/tutorial/interactive.rst:166
#: ../src/Doc/tutorial/interpreter.rst:268 ../src/Doc/tutorial/modules.rst:544
msgid "Footnotes"
msgstr "Notes"

#: ../src/Doc/tutorial/classes.rst:828
msgid ""
"Except for one thing.  Module objects have a secret read-only attribute "
"called :attr:`__dict__` which returns the dictionary used to implement the "
"module's namespace; the name :attr:`__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 ""
"Sauf pour une chose. Les modules disposent d'un attribut secret en lecture "
"seule appelé :attr:`__dict__`, qui renvoie le dictionnaire utilisé pour "
"implémenter l'espace de noms du module ; le nom :attr:`__dict__` est un "
"attribut mais pas un nom global. Évidemment, son utilisation brise "
"l'abstraction de l'implémentation des espaces de noms, et ne doit être "
"restreinte qu'à des choses comme des debogueurs post-mortem."

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

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

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

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

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

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

#: ../src/Doc/tutorial/controlflow.rst:49
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) :"

# 8161ee2d167d4d359706f1ee40a4eee8
#: ../src/Doc/tutorial/controlflow.rst:70
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 ::"

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

# e970ab346e7c42babe10861bae0a2397
#: ../src/Doc/tutorial/controlflow.rst:88
msgid ""
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy.  It generates lists containing 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 une liste contenant une simple "
"progression arithmétique ::"

# fe8625ff049a4316af3f2de7977238a9
#: ../src/Doc/tutorial/controlflow.rst:95
msgid ""
"The given end point is never part of the generated list; ``range(10)`` "
"generates a list of 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') ::"

#: ../src/Doc/tutorial/controlflow.rst:107
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` ::"

#: ../src/Doc/tutorial/controlflow.rst:120
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`."

#: ../src/Doc/tutorial/controlflow.rst:127
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"

#: ../src/Doc/tutorial/controlflow.rst:129
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."

#: ../src/Doc/tutorial/controlflow.rst:132
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 ::"

# c8cd94a1717f4d558d3e14aba3c8df90
#: ../src/Doc/tutorial/controlflow.rst:156
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`.)"

# 6d4b3d8e32a34b8a994523658f8824df
#: ../src/Doc/tutorial/controlflow.rst:159
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`."

# 34627fe2528c4c689db6fab5cd77d971
#: ../src/Doc/tutorial/controlflow.rst:166
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:188
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:201
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:214
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 ::"

#: ../src/Doc/tutorial/controlflow.rst:233
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."

#: ../src/Doc/tutorial/controlflow.rst:238
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 !"

#: ../src/Doc/tutorial/controlflow.rst:245
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."

#: ../src/Doc/tutorial/controlflow.rst:254
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."

#: ../src/Doc/tutorial/controlflow.rst:260
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 ::"

# d0c90ca9530a40adbb720f8a235bd80d
#: ../src/Doc/tutorial/controlflow.rst:272
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 :keyword:"
"`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 :keyword:`print` ::"

#: ../src/Doc/tutorial/controlflow.rst:283
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:301
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 sans instruction :keyword:`return` "
"renvoie également ``None``."

#: ../src/Doc/tutorial/controlflow.rst:305
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."

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

#: ../src/Doc/tutorial/controlflow.rst:322
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."

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

#: ../src/Doc/tutorial/controlflow.rst:331
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:349
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 ?')``"

#: ../src/Doc/tutorial/controlflow.rst:351
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)``"

#: ../src/Doc/tutorial/controlflow.rst:353
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 !')``"

#: ../src/Doc/tutorial/controlflow.rst:356
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."

#: ../src/Doc/tutorial/controlflow.rst:359
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:372
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:391
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 ::"

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

# e2d74c8fda244844a959da21ed55e0ae
#: ../src/Doc/tutorial/controlflow.rst:406
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 ::"

# c811328e6e694919804103594d1803a0
#: ../src/Doc/tutorial/controlflow.rst:415
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 ::"

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

# 5665e42f479a44bcbf868c659ab8d3f0
#: ../src/Doc/tutorial/controlflow.rst:433
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 ::"

#: ../src/Doc/tutorial/controlflow.rst:449
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 :"

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

#: ../src/Doc/tutorial/controlflow.rst:475
msgid "and of course it would print::"
msgstr "et imprimera alors ::"

#: ../src/Doc/tutorial/controlflow.rst:486
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."

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

#: ../src/Doc/tutorial/controlflow.rst:498
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 ::"

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

#: ../src/Doc/tutorial/controlflow.rst:512
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 ::"

#: ../src/Doc/tutorial/controlflow.rst:528
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 ``**`` ::"

#: ../src/Doc/tutorial/controlflow.rst:544
msgid "Lambda Forms"
msgstr "Les fonctions lambda"

#: ../src/Doc/tutorial/controlflow.rst:546
msgid ""
"By popular demand, a few features commonly found in functional programming "
"languages like Lisp have been added to Python.  With the :keyword:`lambda` "
"keyword, small anonymous functions can be created. Here's a function that "
"returns the sum of its two arguments: ``lambda a, b: a+b``.  Lambda forms "
"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 forms can reference variables from the containing scope::"
msgstr ""
"À la demande générale, quelques fonctionnalités que l'on trouve souvent dans "
"les langages fonctionnels comme Lisp ont été ajoutées à Python. 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 ::"

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

# 41dfd2967219444194cfcf734c8325c6
#: ../src/Doc/tutorial/controlflow.rst:575
msgid ""
"There are emerging conventions about the content and formatting of "
"documentation strings."
msgstr ""
"Il existe des conventions émergeantes concernant le contenu et le format des "
"chaînes de documentation."

#: ../src/Doc/tutorial/controlflow.rst:578
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."

#: ../src/Doc/tutorial/controlflow.rst:584
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."

#: ../src/Doc/tutorial/controlflow.rst:589
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)."

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

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

#: ../src/Doc/tutorial/controlflow.rst:624
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."

#: ../src/Doc/tutorial/controlflow.rst:630
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 :"

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

#: ../src/Doc/tutorial/controlflow.rst:637
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."

#: ../src/Doc/tutorial/controlflow.rst:641
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."

#: ../src/Doc/tutorial/controlflow.rst:643
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é."

#: ../src/Doc/tutorial/controlflow.rst:646
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."

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

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

#: ../src/Doc/tutorial/controlflow.rst:653
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)``."

#: ../src/Doc/tutorial/controlflow.rst:656
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)."

# 82cc90f14beb4e74801836b553a5595f
#: ../src/Doc/tutorial/controlflow.rst:661
msgid ""
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Plain ASCII works 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. L'ASCII est encore ce qui "
"marche le mieux dans la plupart des cas."

#: ../src/Doc/tutorial/controlflow.rst:667
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...)."

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

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

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

#: ../src/Doc/tutorial/datastructures.rst:16
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 :"

#: ../src/Doc/tutorial/datastructures.rst:23
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 ; équivalent à ``a[len(a):] = [x]``."

#: ../src/Doc/tutorial/datastructures.rst:29
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``."

#: ../src/Doc/tutorial/datastructures.rst:36
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)``."

#: ../src/Doc/tutorial/datastructures.rst:44
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."

#: ../src/Doc/tutorial/datastructures.rst:51
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)."

#: ../src/Doc/tutorial/datastructures.rst:61
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."

#: ../src/Doc/tutorial/datastructures.rst:68
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."

#: ../src/Doc/tutorial/datastructures.rst:74
msgid "Sort the items of the list, in place."
msgstr "Trie les éléments de la liste, en place."

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

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

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

#: ../src/Doc/tutorial/datastructures.rst:112
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 ::"

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

#: ../src/Doc/tutorial/datastructures.rst:141
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)."

#: ../src/Doc/tutorial/datastructures.rst:147
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 ::"

# f37a954339024319a4a38dcc87019274
#: ../src/Doc/tutorial/datastructures.rst:165
msgid "Functional Programming Tools"
msgstr "Outils de programmation fonctionnelle"

# 8ec920989c304fb3b1e7bc3ba16cc69d
#: ../src/Doc/tutorial/datastructures.rst:167
msgid ""
"There are three built-in functions that are very useful when used with "
"lists: :func:`filter`, :func:`map`, and :func:`reduce`."
msgstr ""
"Il existe trois fonctions primitives qui sont très utiles lorsqu'elles sont "
"utilisées avec des listes : :func:`filter`, :func:`map` et :func:`reduce`."

# bd57b7606e0443a0ab47c23c055f820e
#: ../src/Doc/tutorial/datastructures.rst:170
msgid ""
"``filter(function, sequence)`` returns a sequence consisting of those items "
"from the sequence for which ``function(item)`` is true. If *sequence* is a :"
"class:`string` or :class:`tuple`, the result will be of the same type; "
"otherwise, it is always a :class:`list`. For example, to compute a sequence "
"of numbers not divisible by 2 and 3::"
msgstr ""
"``filter(function, sequence)`` retourne une séquence composée des éléments "
"de la séquence initiale pour lesquels la fonction ``function(item)`` est "
"vraie. Si *sequence* est de type :class:`string` ou :class:`tuple`, le "
"résultat sera du même type ; sinon, il sera toujours de type :class:`list`. "
"Par exemple, pour construire une séquence de nombres non divisibles par 2 ni "
"par 3 ::"

# 5f5a7fc45a614c2891bf0573e3d5c5e9
#: ../src/Doc/tutorial/datastructures.rst:181
msgid ""
"``map(function, sequence)`` calls ``function(item)`` for each of the "
"sequence's items and returns a list of the return values.  For example, to "
"compute some cubes::"
msgstr ""
"``map(function, sequence)`` appelle ``function(item)`` pour chaque élément "
"de la séquence et retourne une liste contenant l'ensemble des résultats. Par "
"exemple, pour calculer des cubes ::"

# c1de3d96a00b489784f899a7fc376b1f
#: ../src/Doc/tutorial/datastructures.rst:190
msgid ""
"More than one sequence may be passed; the function must then have as many "
"arguments as there are sequences and is called with the corresponding item "
"from each sequence (or ``None`` if some sequence is shorter than another).  "
"For example::"
msgstr ""
"Plus d'une séquence peut être passée en paramètre ; dans ce cas, la fonction "
"doit avoir autant d'arguments qu'il y a de séquences, et elle sera appelée "
"avec l'élément correspondant de chaque séquence (ou ``None`` si certaines "
"séquences sont plus courtes que d'autres)."

# 8240028754784e7a84b5be66fa08f0ba
#: ../src/Doc/tutorial/datastructures.rst:201
msgid ""
"``reduce(function, sequence)`` returns a single value constructed by calling "
"the binary function *function* on the first two items of the sequence, then "
"on the result and the next item, and so on.  For example, to compute the sum "
"of the numbers 1 through 10::"
msgstr ""
"``reduce(function, sequence)`` retourne une seule valeur construire en "
"appelant la fonction *function* avec comme paramètres les deux premiers "
"éléments de la séquence, puis le premier résultat et l'élément suivant, et "
"ainsi de suite. Par exemple, pour calculer la somme des nombres de 1 à 10 ::"

# cb31dca23a5d44aa970a94dab6c09da5
#: ../src/Doc/tutorial/datastructures.rst:211
msgid ""
"If there's only one item in the sequence, its value is returned; if the "
"sequence is empty, an exception is raised."
msgstr ""
"S'il n'y a qu'un seul élément dans la séquence, sa valeur est retournée ; si "
"la séquence est vide, une exception est levée."

# 67aeb633f3264986a2f5c0fad841946c
#: ../src/Doc/tutorial/datastructures.rst:214
msgid ""
"A third argument can be passed to indicate the starting value.  In this case "
"the starting value is returned for an empty sequence, and the function is "
"first applied to the starting value and the first sequence item, then to the "
"result and the next item, and so on.  For example, ::"
msgstr ""
"Un troisième paramètre peut être ajouté pour indiquer la valeur de départ. "
"Dans ce cas, cette valeur est retournée dans le cas d'une séquence vide ; "
"sinon, la fonction est d'abord appelée avec comme paramètres cette valeur de "
"départ et le premier élément de la séquence, puis ce premier résultat et "
"l'élément suivant, et ainsi de suite. Par exemple ::"

# 4c945638e9fd442d8f09748ac20cbc27
#: ../src/Doc/tutorial/datastructures.rst:228
msgid ""
"Don't use this example's definition of :func:`sum`: since summing numbers is "
"such a common need, a built-in function ``sum(sequence)`` is already "
"provided, and works exactly like this."
msgstr ""
"N'utilisez pas la fonction :func:`sum` fournie dans cet exemple. Effectuer "
"des sommes de nombres est un besoin tellement courant qu'il existe une "
"fonction native ``sum(sequence)`` qui fait exactement la même chose."

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

# bacb848669ad4fa9abb4a3d77791f4c2
#: ../src/Doc/tutorial/datastructures.rst:238
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."

# 037f4e076d664f8389360ada349255eb
#: ../src/Doc/tutorial/datastructures.rst:243
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 ::"

# f1ecaf420bcc491cb856a1f05ad37538
#: ../src/Doc/tutorial/datastructures.rst:252
msgid "We can obtain the same result with::"
msgstr "On peut obtenir le même résultat avec ::"

# d14333f8fdc241f09c158e509605a7f3
#: ../src/Doc/tutorial/datastructures.rst:256
msgid ""
"This is also equivalent to ``squares = map(lambda x: x**2, range(10))``, but "
"it's more concise and readable."
msgstr ""
"C'est également l'équivalent de ``squares = map(lambda x: x**2, range(10))"
"``, mais en plus concis et plus lisible."

# 3467ea01b37a4111a1dc155df11cf9f1
#: ../src/Doc/tutorial/datastructures.rst:259
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 ::"

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

# c6f54fd8b04e497dbf2f03edaa0abc9e
#: ../src/Doc/tutorial/datastructures.rst:280
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."

# d653b9fb2b45432d9e5e67ee70fbecd9
#: ../src/Doc/tutorial/datastructures.rst:283
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 ::"

# 6519493b0333463c9e8d314fd4c1af4c
#: ../src/Doc/tutorial/datastructures.rst:314
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 ::"

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

# 362a977414e741d3b6464df3bf5c11ce
#: ../src/Doc/tutorial/datastructures.rst:324
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."

# a88f2fa3f41144bfbd62a2693612ceb1
#: ../src/Doc/tutorial/datastructures.rst:327
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 ::"

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

# 5661198254ed47449d72c22038e9f2b9
#: ../src/Doc/tutorial/datastructures.rst:341
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 à ::"

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

# 6eb39f5c7cee4c69bcdce5003c9dc1d9
#: ../src/Doc/tutorial/datastructures.rst:366
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 ::"

#: ../src/Doc/tutorial/datastructures.rst:372
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."

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

#: ../src/Doc/tutorial/datastructures.rst:379
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 ::"

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

#: ../src/Doc/tutorial/datastructures.rst:400
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."

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

#: ../src/Doc/tutorial/datastructures.rst:409
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*."

#: ../src/Doc/tutorial/datastructures.rst:415
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 ::"

# a5badcce7c75451982575cc784cb15da
#: ../src/Doc/tutorial/datastructures.rst:437
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."

# b6c3a9f8bf504d2383860d62b9823a5a
#: ../src/Doc/tutorial/datastructures.rst:444
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 an 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 ""
"Si les tuples peuvent sembler similaires aux listes, ils sont souvent "
"utilisés dans des cas différents et pour des raisons différentes. Les tuples "
"sont :term:`immuables` et contiennent souvent des séquences hétérogènes "
"d'éléments qui sont accédés par \"déballage\" (voir plus loin) ou indexation "
"(ou même par attributs dans le cas des :func:`namedtuples <collections."
"namedtuple>`). Les listes sont souvent :term:`mutables`, et contiennent des "
"éléments homogènes qui sont accédés par itération sur la liste."

#: ../src/Doc/tutorial/datastructures.rst:452
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 ::"

#: ../src/Doc/tutorial/datastructures.rst:467
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 ::"

# bee7de83217d467eba7a079c65b7ad5d
#: ../src/Doc/tutorial/datastructures.rst:473
msgid ""
"This is called, appropriately enough, *sequence unpacking* and works for any "
"sequence on the right-hand side.  Sequence unpacking requires the list of "
"variables on the left to have the same number of elements as the length of "
"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."

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

#: ../src/Doc/tutorial/datastructures.rst:485
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."

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

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

#: ../src/Doc/tutorial/datastructures.rst:522
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`."

#: ../src/Doc/tutorial/datastructures.rst:533
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."

#: ../src/Doc/tutorial/datastructures.rst:539
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."

# a554aa7680394a23a6e1b29ad07b5253
#: ../src/Doc/tutorial/datastructures.rst:545
msgid ""
"The :meth:`keys` method of a dictionary object returns a list of all the "
"keys used in the dictionary, in arbitrary order (if you want it sorted, just "
"apply the :func:`sorted` function to it).  To check whether a single key is "
"in the dictionary, use the :keyword:`in` keyword."
msgstr ""
"La méthode :meth:`keys` d'un dictionnaire retourne une liste de toutes les "
"clés utilisées dans le dictionnaire, dans un ordre arbitraire (si vous "
"voulez qu'elle soit triée, appliquez-lui la fonction :func:`sorted`). Pour "
"tester si une clé est dans le dictionnaire, utilisez le mot-clé :keyword:"
"`in`."

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

# da517bdab6f24e778cac08736d919390
#: ../src/Doc/tutorial/datastructures.rst:567
msgid ""
"The :func:`dict` constructor builds dictionaries directly from lists of key-"
"value pairs stored as tuples.  When the pairs form a pattern, list "
"comprehensions can compactly specify the key-value list. ::"
msgstr ""
"Le constructeur :func:`dict` fabrique un dictionnaire directement à partir "
"d'une liste de paires clé-valeur stockées sous la forme de tuples. Lorsque "
"les paires forment un motif, des compréhensions de listes permettent de "
"fournir la liste des clés-valeurs sous une forme compacte ::"

# c6ce45f20f7743deb76e188301a62651
#: ../src/Doc/tutorial/datastructures.rst:576
msgid ""
"Later in the tutorial, we will learn about Generator Expressions which are "
"even better suited for the task of supplying key-values pairs to the :func:"
"`dict` constructor."
msgstr ""
"Plus loin dans ce tutoriel, vous en apprendez plus sur les générateurs qui "
"sont encore plus adaptés à cette tâche consistant à fournir des paires de "
"clés-valeurs au constructeur :func:`dict`."

#: ../src/Doc/tutorial/datastructures.rst:580
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 ::"

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

#: ../src/Doc/tutorial/datastructures.rst:592
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`."

#: ../src/Doc/tutorial/datastructures.rst:602
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` ::"

#: ../src/Doc/tutorial/datastructures.rst:614
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` ::"

#: ../src/Doc/tutorial/datastructures.rst:626
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 ::"

# a1e578bf4b954f29a28fc5bb96bfe66a
#: ../src/Doc/tutorial/datastructures.rst:638
msgid ""
"When looping through dictionaries, the key and corresponding value can be "
"retrieved at the same time using the :meth:`iteritems` 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:"
"`iteritems` ::"

# ce8381976b434e66b7c5471cd5d43209
#: ../src/Doc/tutorial/datastructures.rst:648
msgid ""
"To change a sequence you are iterating over while inside the loop (for "
"example to duplicate certain items), it is recommended that you first make a "
"copy.  Looping over a sequence does not implicitly make a copy.  The slice "
"notation makes this especially convenient::"
msgstr ""
"Si vous devez modifier une séquence sur laquelle vous êtes en train de faire "
"une boucle (par exemple pour dupliquer ou supprimer certains éléments), il "
"est recommandé de commencer par en faire une copie. Celle-ci n'est pas "
"implicite lorsque vous faites une boucle sur une séquence. La notation par "
"tranches rend cette opération particulièrement pratique ::"

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

#: ../src/Doc/tutorial/datastructures.rst:667
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."

#: ../src/Doc/tutorial/datastructures.rst:670
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."

#: ../src/Doc/tutorial/datastructures.rst:676
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``."

#: ../src/Doc/tutorial/datastructures.rst:679
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."

#: ../src/Doc/tutorial/datastructures.rst:686
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é."

#: ../src/Doc/tutorial/datastructures.rst:693
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 ::"

#: ../src/Doc/tutorial/datastructures.rst:701
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."

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

# 41977cc17fef443ea5ee4eb2acbc42b4
#: ../src/Doc/tutorial/datastructures.rst:712
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 ASCII ordering for 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 "
"l'ordre ASCII des caractères. Voici quelques exemples de comparaisons entre "
"séquences de même type ::"

# f6a8739089604c31b9a69729e466dbd3
#: ../src/Doc/tutorial/datastructures.rst:732
msgid ""
"Note that comparing objects of different types is legal.  The outcome is "
"deterministic but arbitrary: the types are ordered by their name. Thus, a "
"list is always smaller than a string, a string is always smaller than a "
"tuple, etc. [#]_ Mixed numeric types are compared according to their numeric "
"value, so 0 equals 0.0, etc."
msgstr ""
"La comparaison d'objets de types différents est autorisée. Le résultat est "
"déterminé mais arbitraire : les types sont ordonnés par leur nom. Ainsi, une "
"liste (type ``list``) est toujours inférieure à une chaîne de caractères "
"(type ``str``), une chaîne de caractères toujours inférieure à un tuple... "
"[#]_ Des types numériques mélangés sont comparés en fonction de leur valeur "
"numérique, donc 0 est égal à 0.0, etc."

# 9443e810e7df404caf028d0caea7657d
#: ../src/Doc/tutorial/datastructures.rst:741
msgid ""
"The rules for comparing objects of different types should not be relied "
"upon; they may change in a future version of the language."
msgstr ""
"Les règles de comparaison d'objets de types différents ne doivent pas être "
"considérées comme fiables ; elles peuvent être amenées à changer dans une "
"future version du langage."

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

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

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

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

# 137385ef98c047a296ca35d560a94016
#: ../src/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 keyword :keyword:`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, ici car il manque deux points (``':'``) "
"avant lui. 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."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# 27502966a9b0494b8e62e5b731c29743
#: ../src/Doc/tutorial/errors.rst:123
msgid ""
"Note that the parentheses around this tuple are required, because ``except "
"ValueError, e:`` was the syntax used for what is normally written as "
"``except ValueError as e:`` in modern Python (described below). The old "
"syntax is still supported for backwards compatibility. This means ``except "
"RuntimeError, TypeError`` is not equivalent to ``except (RuntimeError, "
"TypeError):`` but to ``except RuntimeError as TypeError:`` which is not what "
"you want."
msgstr ""
"Notez que les parenthèses autour de ce tuple sont nécessaires, car ``except "
"ValueError, e:`` est la syntaxe utilisée pour ce qui s'écrit désormais "
"``except ValueError as e:`` dans les dernières versions de Python (comme "
"décrit ci-dessous). L'ancienne syntaxe est toujours supportée pour la "
"compatibilité ascendante. Ce qui signifie que ``except RuntimeError, "
"TypeError:`` n'est pas l'équivalent de ``except (RuntimeError, TypeError):`` "
"mais de ``except RuntimeError as TypeError:``, ce qui n'est pas ce que l'on "
"souhaite."

#: ../src/Doc/tutorial/errors.rst:131
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) ::"

#: ../src/Doc/tutorial/errors.rst:150
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 ::"

#: ../src/Doc/tutorial/errors.rst:164
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`."

#: ../src/Doc/tutorial/errors.rst:169
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."

# 3855bca41cb3406db419bd42ce816d50
#: ../src/Doc/tutorial/errors.rst:173
msgid ""
"The except clause may specify a variable after the exception name (or "
"tuple). 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``."
msgstr ""
"La clause except peut spécifier un nom de variable après le nom de "
"l'exception (ou le tuple). 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 imprimés directement sans avoir à référencer "
"``.args``."

# 9bff2f04b9604cb88961036a1dd56433
#: ../src/Doc/tutorial/errors.rst:179
msgid ""
"One may also instantiate an exception first before raising it and add any "
"attributes to it as desired. ::"
msgstr ""
"On peut aussi instancier une exception et lui ajouter autant d'attributs que "
"nécessaire avant de la déclencher ::"

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

#: ../src/Doc/tutorial/errors.rst:201
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 ::"

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

#: ../src/Doc/tutorial/errors.rst:221
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 ::"

#: ../src/Doc/tutorial/errors.rst:229
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`)."

#: ../src/Doc/tutorial/errors.rst:233
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 ::"

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

#: ../src/Doc/tutorial/errors.rst:254
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.  For example::"
msgstr ""
"Les programmes peuvent nommer leur propres exceptions en créant de nouvelles "
"classes (voir :ref:`tut-classes` à propos des classes Python). Ces "
"exceptions doivent typiquement être dérivées de la classe :exc:`Exception`, "
"directement ou indirectement. Par exemple ::"

#: ../src/Doc/tutorial/errors.rst:276
msgid ""
"In this example, the default :meth:`__init__` of :class:`Exception` has been "
"overridden.  The new behavior simply creates the *value* attribute.  This "
"replaces the default behavior of creating the *args* attribute."
msgstr ""
"Dans cet exemple, la méthode :meth:`__init__` de la classe :class:"
"`Exception` a été surchargée. Le nouveau comportement crée simplement "
"l'attribut *value*. Ceci remplace le comportement par défaut qui crée "
"l'attribut *args*."

#: ../src/Doc/tutorial/errors.rst:280
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 ::"

#: ../src/Doc/tutorial/errors.rst:318
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."

#: ../src/Doc/tutorial/errors.rst:321
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`."

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

#: ../src/Doc/tutorial/errors.rst:331
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 ::"

# c7f7bd06fdcb44f6af089f25280ca0e6
#: ../src/Doc/tutorial/errors.rst:345
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 a :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 (having :keyword:`except` and :keyword:`finally` "
"clauses in the same :keyword:`try` statement works as of Python 2.5)::"
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 une "
"exception 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'importe "
"quelle 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é (l'utilisation de clauses :keyword:`except` "
"et :keyword:`finally` dans la même instruction :keyword:`try` nécessite au "
"moins Python 2.5) ::"

#: ../src/Doc/tutorial/errors.rst:379
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."

#: ../src/Doc/tutorial/errors.rst:384
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."

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

#: ../src/Doc/tutorial/errors.rst:394
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 ::"

# 3e128929b44e4ce8a471c6bfe6295a5d
#: ../src/Doc/tutorial/errors.rst:402
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after 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 ::"

# fa61bd22ee7f41deb8a86ef987c0432e
#: ../src/Doc/tutorial/errors.rst:412
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Other objects which "
"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 intervenu pendant l'exécution de ces lignes. D'autres "
"objets qui fournissent des actions de nettoyage prédéfinies l'indiquent dans "
"leur documentation."

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

#: ../src/Doc/tutorial/floatingpoint.rst:10
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 ::"

#: ../src/Doc/tutorial/floatingpoint.rst:15
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 ::"

#: ../src/Doc/tutorial/floatingpoint.rst:19
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."

#: ../src/Doc/tutorial/floatingpoint.rst:23
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."

#: ../src/Doc/tutorial/floatingpoint.rst:28
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::"

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

#: ../src/Doc/tutorial/floatingpoint.rst:41
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."

#: ../src/Doc/tutorial/floatingpoint.rst:45
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 ::"

# 585f9afa498948edb520ddba73906b61
#: ../src/Doc/tutorial/floatingpoint.rst:51
msgid "Stop at any finite number of bits, and you get an approximation."
msgstr ""
"Arrêtez à n'importe quelle quantité finie de bits, et vous obtiendez une "
"approximation."

# a3e931a40eb6454aaf8258fe6dcc2c2a
#: ../src/Doc/tutorial/floatingpoint.rst:53
msgid ""
"On a typical machine running Python, there are 53 bits of precision "
"available for a Python float, so the value stored internally when you enter "
"the decimal number ``0.1`` is the binary fraction ::"
msgstr ""
"Pour Python, sur une machine typique, 53 bits sont utilisés pour la "
"précision d'un flottant, donc la valeur stockée lorsque vous entrez le "
"nombre décimal ``0.1`` est la fraction binaire ::"

# b19de5faee084120b720b24ac015d415
#: ../src/Doc/tutorial/floatingpoint.rst:59
msgid "which is close to, but not exactly equal to, 1/10."
msgstr "qui est proche, mais pas exactement égale, à 1/10."

# 8933cbcb05124de785ee6c7fe3365adb
#: ../src/Doc/tutorial/floatingpoint.rst:61
msgid ""
"It's easy to forget that the stored value is an approximation to the "
"original decimal fraction, because of the way that floats are displayed at "
"the interpreter prompt.  Python only prints a decimal approximation to the "
"true decimal value of the binary approximation stored by the machine.  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 ::"

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

# 5e4f51ce66ca42769953b535fc42cc18
#: ../src/Doc/tutorial/floatingpoint.rst:77
msgid ""
"It's important to realize that this is, in a real sense, an illusion: the "
"value in the machine is not exactly 1/10, you're simply rounding the "
"*display* of the true machine value.  This fact becomes apparent as soon as "
"you try to do arithmetic with these values ::"
msgstr ""
"Il est important de comprendre qu'en réalité, c'est une illusion : la valeur "
"stockée n'est pas exactement 1/10, c'est simplement à *l'affichage* que la "
"valeur stockée est arrondie. Ceci devient évident dès que vous effectuez des "
"opérations arithmétiques avec ces valeurs ::"

#: ../src/Doc/tutorial/floatingpoint.rst:85
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)."

# e5c2f7d498224bb3b5219ca6b49574e9
#: ../src/Doc/tutorial/floatingpoint.rst:91
msgid ""
"Other surprises follow from this one.  For example, if you try to round the "
"value 2.675 to two decimal places, you get this ::"
msgstr ""
"Une autre surprise est inhérente à celle-ci. Par exemple, si vous tentez "
"d'arrondir la valeur 2.675 à deux décimales, vous obtiendrez ::"

# b6492664b1a14c72aa3e3152d4802419
#: ../src/Doc/tutorial/floatingpoint.rst:97
msgid ""
"The documentation for the built-in :func:`round` function says that it "
"rounds to the nearest value, rounding ties away from zero.  Since the "
"decimal fraction 2.675 is exactly halfway between 2.67 and 2.68, you might "
"expect the result here to be (a binary approximation to) 2.68.  It's not, "
"because when the decimal string ``2.675`` is converted to a binary floating-"
"point number, it's again replaced with a binary approximation, whose exact "
"value is ::"
msgstr ""
"La documentation de la primitive :func:`round` indique qu'elle arrondit à la "
"valeur la plus proche en s'éloignant de zéro. Puisque la fraction décimale "
"est exactement à mi-chemin entre 2.67 et 2.68, vous devriez vous attendre à "
"obtenir (une approximation binaire de) 2.68. Ce n'est pourtant pas le cas, "
"car lorsque la fraction décimale ``2.675`` est convertie en flottant, elle "
"est stockée par une approximation dont la valeur exacte est ::"

# b6ad3e1f39374a2492515e10f77134d6
#: ../src/Doc/tutorial/floatingpoint.rst:106
msgid ""
"Since this approximation is slightly closer to 2.67 than to 2.68, it's "
"rounded down."
msgstr ""
"Puisque l'approximation est légèrement plus proche de 2.67 que 2.68, "
"l'arrondi se fait vers le bas."

# 3683a07c343348568f95d1964fd2a7b7
#: ../src/Doc/tutorial/floatingpoint.rst:109
msgid ""
"If you're in a situation where you care which way your decimal halfway-cases "
"are rounded, you should consider using the :mod:`decimal` module. "
"Incidentally, the :mod:`decimal` module also provides a nice way to \"see\" "
"the exact value that's stored in any particular Python float ::"
msgstr ""
"Si vous êtes dans une situation où les arrondis de nombres décimaux à mi-"
"chemin ont de l'importance, vous devriez utiliser le module :mod:`decimal`. "
"Soit dit en passant, le module :mod:`decimal` propose aussi un moyen "
"pratique de \"voir\" la valeur exacte stockée pour n'importe quel flottant."

# 41ea13ad53d44bb28b904415c1ea2417
#: ../src/Doc/tutorial/floatingpoint.rst:118
msgid ""
"Another consequence is that since 0.1 is not exactly 1/10, summing ten "
"values of 0.1 may not yield exactly 1.0, either::"
msgstr ""
"Une autre conséquence du fait que 0.1 n'est pas exactement stocké 1/10 est "
"que la somme de dix valeurs de 0.1 ne donne pas 1.0 non plus ::"

#: ../src/Doc/tutorial/floatingpoint.rst:128
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."

# 87e3aaf0e7e2477fb17072c49a0e5058
#: ../src/Doc/tutorial/floatingpoint.rst:133
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."

# 0d5b6ba08bee41ae81e33306aca23343
#: ../src/Doc/tutorial/floatingpoint.rst:140
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.  For fine control over how a float is displayed 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 en "
"arrondissant simplement au nombre de décimales désirées à l'affichage. Pour "
"un contrôle fin sur la manière dont les flottants sont affichés, consultez "
"dans :ref:`formatstrings` les spécifications de formattage de la méthode :"
"meth:`str.format`"

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

#: ../src/Doc/tutorial/floatingpoint.rst:152
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."

# e9ea0a68b7bf4ca098eb417f0ed61ccb
#: ../src/Doc/tutorial/floatingpoint.rst:156
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::"

# be0b2bc761654882a6612a05f3ceb463
#: ../src/Doc/tutorial/floatingpoint.rst:164
msgid ""
"Why is that?  1/10 and 2/10 are not exactly representable as a binary "
"fraction. Almost all machines today (July 2010) 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 et 2/10 ne sont 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 ::"


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

#: ../src/Doc/tutorial/floatingpoint.rst:177
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::"

# 2e98f1c2739a481cbe0243853a3217af
#: ../src/Doc/tutorial/floatingpoint.rst:187
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::"

#: ../src/Doc/tutorial/floatingpoint.rst:194
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:"

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

#: ../src/Doc/tutorial/floatingpoint.rst:205
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 !"

#: ../src/Doc/tutorial/floatingpoint.rst:209
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\""

# 387b544ab4cc483783898ef3a17eb2ff
#: ../src/Doc/tutorial/floatingpoint.rst:215
msgid ""
"If we multiply that fraction by 10\\*\\*30, we can see the (truncated) value "
"of its 30 most significant decimal digits::"
msgstr ""
"Si on multiplie cette fraction par 10\\*\\*30, on peut observer les "
"valeurs de ses 30 décimales de poid fort."

# 956b2754e34c462ab54d636a54cbbda9
#: ../src/Doc/tutorial/floatingpoint.rst:221
msgid ""
"meaning that the exact number stored in the computer is approximately equal "
"to the decimal value 0.100000000000000005551115123125.  In versions prior to "
"Python 2.7 and Python 3.1, Python rounded this value to 17 significant "
"digits, giving '0.10000000000000001'.  In current versions, Python displays "
"a value based on the shortest decimal fraction that rounds correctly back to "
"the true binary value, resulting simply in '0.1'."
msgstr ""
"signifiant que la valeur exacte stockée dans l'ordinateur est "
"approximativement évale à la valeur décimale "
"0.100000000000000005551115123125. Dans les versions antérieurs à "
"Python 2.7 et Python 3.1, Python arrondissait ces valeurs à 17 décimales "
"significatives, affichant '0.10000000000000001'. Dans les versions "
"actuelles de Python, la valeur affichée est la valeur dont la fraction "
"est la plus courte possible tout en redonnant exactement la même "
"représentation une fois reconverti en binaire, affichant simplement "
"'0.1'."

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

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

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

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

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

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

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

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

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

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

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

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

# 4f0a1c8e63414433ad1247d6a3397a54
#: ../src/Doc/tutorial/inputoutput.rst:22
msgid ""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values.  There are two ways to format your "
"output; the first way is to do all the string handling yourself; using "
"string slicing and concatenation operations you can create any layout you "
"can imagine.  The string types have some methods that perform useful "
"operations for padding strings to a given column width; these will be "
"discussed shortly.  The second way is to use the :meth:`str.format` method."
msgstr ""
"Mais vous voudrez souvent avoir plus de contrôle sur le formatage de vos "
"sorties que de simplement imprimer des valeurs séparées par des espaces. Il "
"y a deux méthodes pour formater ces sorties ; la première est de gérer les "
"chaînes de caractères par vous même ; en utilisant des tranches sur vos "
"chaînes et des opérations de concaténation, vous pouvez créer n'importe "
"quelle présentation imaginable. Mais les chaînes de caractères disposent "
"également de méthodes qui facilitent, par exemple, les alignements de "
"chaînes de caractères selon une certaines largeur de colonne, et qui seront "
"présentées rapidement. La seconde méthode consiste à utiliser la méthode :"
"meth:`format`."

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

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

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

#: ../src/Doc/tutorial/inputoutput.rst:46
#: ../src/Doc/tutorial/introduction.rst:22
msgid "Some examples::"
msgstr "Quelques exemples ::"

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

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

# e9c272eb28c244f19113ee5315437b51
#: ../src/Doc/tutorial/inputoutput.rst:106
msgid ""
"This example demonstrates the :meth:`str.rjust` method of string objects, "
"which right-justifies a string in a field of a given width by padding it "
"with spaces on the left.  There are similar methods :meth:`str.ljust` and :"
"meth:`str.center`.  These methods do not write anything, they just return a "
"new string.  If the input string is too long, they don't truncate it, but "
"return it unchanged; this will mess up your column lay-out but that's "
"usually better than the alternative, which would be lying about a value.  "
"(If you really want truncation you can always add a slice operation, as in "
"``x.ljust(n)[:n]``.)"
msgstr ""
"Cet exemple 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]``)."

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

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

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

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

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

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

# 5aaef826c29848228e82d92b68e3ed8c
#: ../src/Doc/tutorial/inputoutput.rst:163
msgid ""
"An optional ``':'`` and format specifier can follow the field name. This "
"allows greater control over how the value is formatted.  The following "
"example rounds Pi to three places after the decimal."
msgstr ""
"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 ::"

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

#: ../src/Doc/tutorial/inputoutput.rst:182
msgid ""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position.  This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys ::"
msgstr ""
"Si vous avez 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 ::"

#: ../src/Doc/tutorial/inputoutput.rst:192
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 '**' ::"

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

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

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

# 5f6042e30fbb4813bd0d41dcf6ef2022
#: ../src/Doc/tutorial/inputoutput.rst:209
msgid ""
"The ``%`` operator can also be used for string formatting. It interprets the "
"left argument much like a :c:func:`sprintf`\\ -style format string to be "
"applied to the right argument, and returns the string resulting from this "
"formatting operation. For example::"
msgstr ""
"L'opérateur ``%`` peut aussi être utilisé pour formater des chaînes. Il "
"interprète l'argument de gauche 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 ::"

#: ../src/Doc/tutorial/inputoutput.rst:218
msgid ""
"Since :meth:`str.format` is quite new, a lot of Python code still uses the ``"
"%`` operator. However, because this old style of formatting will eventually "
"be removed from the language, :meth:`str.format` should generally be used."
msgstr ""
"Comme :meth:`str.format` est relativement récente, beaucoup de code Python "
"utilise encore l'opérateur ``%``. Toutefois, dans la mesure où cet ancien "
"style de formatage sera peut-être à terme supprimé du langage, il vaut mieux "
"utiliser :meth:`str.format`."

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

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

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

#: ../src/Doc/tutorial/inputoutput.rst:243
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'``."

# 9ff01378e50d4134a460523dad57e264
#: ../src/Doc/tutorial/inputoutput.rst:252
msgid ""
"On Windows, ``'b'`` appended to the mode opens the file in binary mode, so "
"there are also modes like ``'rb'``, ``'wb'``, and ``'r+b'``.  Python on "
"Windows makes a distinction between text and binary files; the end-of-line "
"characters in text files are automatically altered slightly when data is "
"read or written.  This behind-the-scenes modification to file data is fine "
"for ASCII text files, but it'll corrupt binary data like that in :file:"
"`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when "
"reading and writing such files.  On Unix, it doesn't hurt to append a "
"``'b'`` to the mode, so you can use it platform-independently for all binary "
"files."
msgstr ""
"Sous Windows, ``'b'`` ajouté au mode ouvre le fichier en mode binaire, et il "
"existe donc des modes comme ``'rb'``, ``'wb'`` et ``'r+b'``. Python sous "
"Windows fait effectivement une distinction entre fichiers texte et "
"binaires ; le caractère de fin de ligne des fichiers texte est "
"automatiquement modifié lorsqu'une donnée est lue ou écrite. Cette "
"modification sous le manteau des données du fichier n'est pas un problème "
"pour les fichiers textes en ASCII, mais elle peut corrompre les données "
"binaires comme celles des fichiers :file:`JPEG` ou :file:`EXE`. Soyez donc "
"attentifs à toujours bien utiliser le mode binaire lorsque vous travaillez "
"avec de tels fichiers. Sous Unix, le mode binaire n'a aucun effet mais vous "
"pouvez l'utiliser pour tous les fichiers binaires pour que votre code soit "
"indépendant de la plate-forme."

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

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

# 2a8f9b43ebde48819bcb8e6362c55669
#: ../src/Doc/tutorial/inputoutput.rst:271
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string.  *size* is an optional numeric "
"argument.  When *size* is omitted or negative, the entire contents of the "
"file will be read and returned; it's your problem if the file is twice as "
"large as your machine's memory. Otherwise, at most *size* bytes are read and "
"returned.  If the end of the file has been reached, ``f.read()`` will return "
"an empty string (``\"\"``). ::"
msgstr ""
"Pour lire le contenu d'un fichier, appelez ``f.read(size)``, qui lit une "
"certaine quantité de données et les retourne sous la forme d'une chaîne de "
"caractères. *size* est un argument numérique optionnel. Quand *size* est "
"omis ou négatif, le contenu entier du fichier est lu et retourné ; c'est "
"votre problème si le fichier est deux fois plus gros que la mémoire de votre "
"machine. Sinon, au plus *size* octets sont lus et retournés. Lorsque la fin "
"du fichier est atteinte, ``f.read()`` renvoie une chaîne vide (``\"\"``) ::"

# 1e6e90d979e44728babc12e0982b6fc4
#: ../src/Doc/tutorial/inputoutput.rst:284
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 ::"

#: ../src/Doc/tutorial/inputoutput.rst:298
msgid ""
"``f.readlines()`` returns a list containing all the lines of data in the "
"file. If given an optional parameter *sizehint*, it reads that many bytes "
"from the file and enough more to complete a line, and returns the lines from "
"that.  This is often used to allow efficient reading of a large file by "
"lines, but without having to load the entire file in memory.  Only complete "
"lines will be returned. ::"
msgstr ""
"``f.readlines()`` retourne une liste contenant toutes les lignes du fichier. "
"Si l'argument optionnel *sizehint* est fourni, la méthode lit autant "
"d'octets que le nombre indiqué, plus la quantité juste nécessaire pour "
"compléter une ligne, et retourne toutes les lignes lues. Ceci est souvent "
"utilisé pour permettre une lecture efficace d'un gros fichier par lignes, "
"mais sans avoir à charger tout le fichier en mémoire. Seules des lignes "
"entières sont retournées. ::"

#: ../src/Doc/tutorial/inputoutput.rst:308
msgid ""
"An alternative approach to reading lines is to loop over the file object. "
"This is memory efficient, fast, and leads to simpler 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 ::"

#: ../src/Doc/tutorial/inputoutput.rst:317
msgid ""
"The alternative approach is simpler but does not provide as fine-grained "
"control.  Since the two approaches manage line buffering differently, they "
"should not be mixed."
msgstr ""
"Cette autre méthode est plus simple mais ne permet pas d'avoir un contrôle "
"très fin sur la lecture. Comme les deux approches gèrent la mise en mémoire "
"tampon des lignes différemment, elle ne doivent pas être mélangées."

# 0ead0c7ac8ca40f7bb963339561c47e9
#: ../src/Doc/tutorial/inputoutput.rst:321
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"``None``.   ::"
msgstr ""
"``f.write(string)`` écrit le contenu de *string* dans le fichier, et renvoie "
"``None`` ::"

#: ../src/Doc/tutorial/inputoutput.rst:326
msgid ""
"To write something other than a string, it needs to be converted to a string "
"first::"
msgstr ""
"Pour écrire autre chose qu'une chaîne, il faut commencer par la convertir en "
"chaîne ::"

#: ../src/Doc/tutorial/inputoutput.rst:333
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file, measured in bytes from the beginning of the file.  To change the "
"file object's position, use ``f.seek(offset, from_what)``.  The position is "
"computed from adding *offset* to a reference point; the reference point is "
"selected by the *from_what* argument.  A *from_what* value of 0 measures "
"from the beginning of the file, 1 uses the current file position, and 2 uses "
"the end of the file as the reference point.  *from_what* can be omitted and "
"defaults to 0, using the beginning of the file as the reference point. ::"
msgstr ""
"``f.tell()`` retourne un entier indiquant la position actuelle dans le "
"fichier, mesurée en octets à partir du début du fichier. Pour modifier la "
"position dans le fichier, utilisez ``f.seek(offset, from_what)``. La "
"position est calculée en ajoutant *offset* à un point de référence ; ce "
"point de référence est sélectionné par l'argument *from_what* : 0 pour le "
"début du fichier, 1 pour la position actuelle, et 2 pour la fin du fichier. "
"*from_what* peut être omis et sa valeur par défaut est 0, utilisant le début "
"du fichier comme point de référence ::"

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

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

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

#: ../src/Doc/tutorial/inputoutput.rst:379
msgid "The :mod:`pickle` Module"
msgstr "Le module :mod:`pickle`"

#: ../src/Doc/tutorial/inputoutput.rst:383
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.  However, when you want to save "
"more complex data types like lists, dictionaries, or class instances, things "
"get a lot more 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."

#: ../src/Doc/tutorial/inputoutput.rst:390
msgid ""
"Rather than have users be constantly writing and debugging code to save "
"complicated data types, Python provides a standard module called :mod:"
"`pickle`. This is an amazing module that can take almost any Python object "
"(even some forms of Python code!), and convert it to a string "
"representation; this process is called :dfn:`pickling`.  Reconstructing the "
"object from the string representation is called :dfn:`unpickling`.  Between "
"pickling and unpickling, 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 fournit un module "
"standard appelé :mod:`pickle`. C'est un module extraordinaire qui peut "
"prendre à peu près n'importe quel objet Python (y compris certaines formes "
"de code Python), et les représenter sous la forme de chaînes de caractères ; "
"ce processus est appelé :dfn:`pickling`. La reconstruction des objets à "
"partir de leur représentation sous forme de chaîne est appelée :dfn:"
"`unpickling`. Entre ces deux phases, la chaîne représentant l'objet peut "
"avoir été stockée dans un fichier ou envoyée via une connexion réseau vers "
"une machine distante."

#: ../src/Doc/tutorial/inputoutput.rst:399
msgid ""
"If you have an object ``x``, and a file object ``f`` that's been opened for "
"writing, the simplest way to pickle the object takes only one line of code::"
msgstr ""
"Si vous avez un objet ``x``, et un objet fichier ``f`` qui a été ouvert en "
"écriture, la méthode la plus simple d'écrire cet objet ne prend qu'une ligne "
"de code ::"

#: ../src/Doc/tutorial/inputoutput.rst:404
msgid ""
"To unpickle the object again, if ``f`` is a file object which has been "
"opened for reading::"
msgstr ""
"Pour reconstruire l'objet, si ``f`` est cette fois un objet fichier ouvert "
"en lecture ::"

#: ../src/Doc/tutorial/inputoutput.rst:409
msgid ""
"(There are other variants of this, used when pickling many objects or when "
"you don't want to write the pickled data to a file; consult the complete "
"documentation for :mod:`pickle` in the Python Library Reference.)"
msgstr ""
"(Il existe d'autres variantes, utilisées lorsque vous voulez enregistrer "
"beaucoup d'objets ou lorsque vous ne voulez pas écrire les données dans un "
"fichier ; consultez la documentation complète du module :mod:`pickle` dans "
"le Guide de Référence de la Bibliothèque Standard.)"

#: ../src/Doc/tutorial/inputoutput.rst:413
msgid ""
":mod:`pickle` is the standard way to make Python objects which can be stored "
"and reused by other programs or by a future invocation of the same program; "
"the technical term for this is a :dfn:`persistent` object.  Because :mod:"
"`pickle` is so widely used, many authors who write Python extensions take "
"care to ensure that new data types such as matrices can be properly pickled "
"and unpickled."
msgstr ""
":mod:`pickle` est la façon standard pour enregistrer des objets Python pour "
"les réutiliser dans d'autres programmes ou lors d'une autre invocation du "
"même programme ; le terme technique pour cela est de rendre les objets :dfn:"
"`persistants`. Comme le module :mod:`pickle` est si largement utilisé, "
"beaucoup d'auteurs qui écrivent des extensions Python prennent soin de "
"s'assurer que les nouveaux types de données tels que les matrices peuvent "
"être correctement sauvegardées et reconstruits au travers de ce module."

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

#: ../src/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 Emacs-style and vi-style editing.  This library has "
"its own documentation which I won't duplicate here; however, the basics are "
"easily explained.  The interactive editing and history described here are "
"optionally available in the Unix and Cygwin versions of the interpreter."
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 "
"l'édition en style Emacs et en style Vi. La bibliothèque a sa propre "
"documentation qui ne va pas être dupliquée ici ; toutefois, les bases seront "
"expliquées rapidement. L'éditeur interactif et la gestion d'historique "
"décrits ici sont disponibles en option sous les versions Unix et Cygwin de "
"l'interpréteur."

#: ../src/Doc/tutorial/interactive.rst:15
msgid ""
"This chapter does *not* document the editing facilities of Mark Hammond's "
"PythonWin package or the Tk-based environment, IDLE, distributed with "
"Python. The command line history recall which operates within DOS boxes on "
"NT and some other DOS and Windows flavors  is yet another beast."
msgstr ""
"Ce chapitre *ne décrit pas* les possibilités d'édition du paquet PythonWin "
"de Mark Hammond ou de l'environnement basé sur Tk, IDLE, distribué avec "
"Python. Le rappel d'historique des lignes de commandes qui fonctionne dans "
"des fenêtres DOS sous NT ou d'autres variétés de Windows est encore une "
"autre histoire."

#: ../src/Doc/tutorial/interactive.rst:24
msgid "Line Editing"
msgstr "Édition de ligne"

#: ../src/Doc/tutorial/interactive.rst:26
msgid ""
"If supported, input line editing is active whenever the interpreter prints a "
"primary or secondary prompt.  The current line can be edited using the "
"conventional Emacs control characters.  The most important of these are: :"
"kbd:`C-A` (Control-A) moves the cursor to the beginning of the line, :kbd:`C-"
"E` to the end, :kbd:`C-B` moves it one position to the left, :kbd:`C-F` to "
"the right.  Backspace erases the character to the left of the cursor, :kbd:"
"`C-D` the character to its right. :kbd:`C-K` kills (erases) the rest of the "
"line to the right of the cursor, :kbd:`C-Y` yanks back the last killed "
"string. :kbd:`C-underscore` undoes the last change you made; it can be "
"repeated for cumulative effect."
msgstr ""
"Si elle est supportée, l'édition de la ligne d'entrée est active lorsque "
"l'interpréteur affiche une invite primaire ou secondaire. La ligne courante "
"peut être éditée en utilisant les caractères de contrôles traditionnels "
"d'Emacs. Les plus importants d'entre eux sont : :kbd:`C-A` (Contrôle-A) "
"déplace le curseur au début de la ligne, :kbd:`C-E` à la fin, :kbd:`C-B` "
"d'un caractère vers la gauche, :kbd:`C-F` d'un caractère vers la droite. La "
"touche retour arrière efface le caractère à la gauche du curseur, :kbd:`C-D` "
"le caractère à sa droite. :kbd:`C-K` supprime le reste de la ligne à la "
"droite du curseur, :kbd:`C-Y` rappelle la dernière chaîne supprimée. :kbd:`C-"
"tiret bas` annule la dernière modification ; cette commande peut être "
"répétée pour cumuler ses effets."

#: ../src/Doc/tutorial/interactive.rst:41
msgid "History Substitution"
msgstr "Substitution d'historique"

#: ../src/Doc/tutorial/interactive.rst:43
msgid ""
"History substitution works as follows.  All non-empty input lines issued are "
"saved in a history buffer, and when a new prompt is given you are positioned "
"on a new line at the bottom of this buffer. :kbd:`C-P` moves one line up "
"(back) in the history buffer, :kbd:`C-N` moves one down.  Any line in the "
"history buffer can be edited; an asterisk appears in front of the prompt to "
"mark a line as modified.  Pressing the :kbd:`Return` key passes the current "
"line to the interpreter.  :kbd:`C-R` starts an incremental reverse search; :"
"kbd:`C-S` starts a forward search."
msgstr ""
"La substitution d'historique fonctionne comme ceci. Toutes les lignes non "
"vides reçues sont enregistrées dans un tampon d'historique et, à chaque fois "
"qu'une invite est affichée, vous êtes positionné sur une nouvelle ligne à la "
"fin de ce tampon. :kbd:`C-P` remonte d'une ligne (en arrière) dans ce "
"tampon, :kbd:`C-N` descend d'une ligne. Chaque ligne présente dans le tampon "
"d'historique peut être éditée ; un astérisque apparaît en face de l'invite "
"pour indiquer qu'une ligne a été modifiée. Presser la touche :kbd:`Entrée` "
"envoie la ligne en cours à l'interpréteur. :kbd:`C-R` démarre une recherche "
"incrémentale en arrière ; :kbd:`C-S` démarre une recherche en avant."

#: ../src/Doc/tutorial/interactive.rst:56
msgid "Key Bindings"
msgstr "Raccourcis clavier"

#: ../src/Doc/tutorial/interactive.rst:58
msgid ""
"The key bindings and some other parameters of the Readline library can be "
"customized by placing commands in an initialization file called :file:`~/."
"inputrc`.  Key bindings have the form ::"
msgstr ""
"Les raccourcis clavier ainsi que d'autres paramètres de la bibliothèque "
"Readline peuvent être personnalisés en inscrivant des commandes dans un "
"fichier d'initialisation appelé :file:`~/.inputrc`. Les raccourcis sont de "
"la forme ::"

#: ../src/Doc/tutorial/interactive.rst:64
msgid "or ::"
msgstr "ou ::"

#: ../src/Doc/tutorial/interactive.rst:68
msgid "and options can be set with ::"
msgstr "et les options peuvent être définies avec ::"

#: ../src/Doc/tutorial/interactive.rst:72
msgid "For example::"
msgstr "Par exemple ::"

#: ../src/Doc/tutorial/interactive.rst:85
msgid ""
"Note that the default binding for :kbd:`Tab` in Python is to insert a :kbd:"
"`Tab` character instead of Readline's default filename completion function.  "
"If you insist, you can override this by putting ::"
msgstr ""
"Notez que le raccourci par défaut pour la touche :kbd:`Tab` en Python est "
"d'insérer un caractère de tabulation au lieu de la fonction par défaut de "
"complétion des noms de fichiers de la bibliothèque Readline. Si vous y "
"tenez, vous pouvez surcharger ce comportement en indiquant ::"

#: ../src/Doc/tutorial/interactive.rst:91
msgid ""
"in your :file:`~/.inputrc`.  (Of course, this makes it harder to type "
"indented continuation lines if you're accustomed to using :kbd:`Tab` for "
"that purpose.)"
msgstr ""
"dans votre fichier :file:`~/.inputrc` (bien sûr, avec cela il devient plus "
"difficile d'entrer des lignes de continuation indentées si vous êtes habitué "
"à utiliser :kbd:`Tab` dans ce but)."

#: ../src/Doc/tutorial/interactive.rst:98
msgid ""
"Automatic completion of variable and module names is optionally available.  "
"To enable it in the interpreter's interactive mode, add the following to "
"your startup file: [#]_  ::"
msgstr ""
"La complétude automatique des noms de variables et de modules est disponible "
"de manière optionnelle. Pour l'activer dans le mode interactif de "
"l'interpréteur, ajoutez les lignes suivantes à votre fichier de démarrage : "
"[#]_ ::"

#: ../src/Doc/tutorial/interactive.rst:105
msgid ""
"This binds the :kbd:`Tab` key to the completion function, so hitting the :"
"kbd:`Tab` key twice suggests completions; 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."
msgstr ""
"Ceci lie la touche :kbd:`Tab` à la fonction de complétude, 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."

#: ../src/Doc/tutorial/interactive.rst:113
msgid ""
"A more capable startup file might look like this example.  Note that this "
"deletes the names it creates once they are no longer needed; this is done "
"since the startup file is executed in the same namespace as the interactive "
"commands, and removing the names avoids creating side effects in the "
"interactive environment.  You may find it convenient to keep some of the "
"imported modules, such as :mod:`os`, which turn out to be needed in most "
"sessions with the interpreter. ::"
msgstr ""
"Un fichier de démarrage plus complet peut ressembler à cet exemple. Notez "
"que celui-ci supprime les noms qu'il crée dès qu'ils ne sont plus "
"nécessaires ; ceci est possible car le fichier de démarrage est exécuté dans "
"le même espace de noms que les commandes interactives, et supprimer les noms "
"évite de générer des effets de bord dans l'environnement interactif. Vous "
"pouvez trouver pratique de conserver certains des modules importés, tels "
"que :mod:`os`, qui s'avère nécessaire dans la plupart des sessions avec "
"l'interpréteur."

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

#: ../src/Doc/tutorial/interactive.rst:151
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."

# fe2adb8ab2894fa58e38a0a9e9e22c21
#: ../src/Doc/tutorial/interactive.rst:158
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_."

# 4e8a30bcc9b34e4e8be51474820e2db6
#: ../src/Doc/tutorial/interactive.rst:167
msgid ""
"Python will execute the contents of a file identified by the :envvar:"
"`PYTHONSTARTUP` environment variable when you start an interactive "
"interpreter.  To customize Python even for non-interactive mode, see :ref:"
"`tut-customize`."
msgstr ""
"Python exécute le contenu d'un fichier identifié par la variable "
"d'environnement :envvar:`PYTHONSTARTUP` lorsque vous démarrez un "
"interpréteur interactif. Pour personnaliser Python y compris en mode non "
"interactif, consultez :ref:`tut-customize`."

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

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

# 1fe8d6c4d9b34bf591bf05002c64109c
#: ../src/Doc/tutorial/interpreter.rst:13
msgid ""
"The Python interpreter is usually installed as :file:`/usr/local/bin/python` "
"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 ""
"L'interpréteur python est habituellement installé :file:`/usr/local/bin/"
"python` sur les machines où il est disponible. En mettant :file:`/usr/local/"
"bin` dans les chemins de recherche de votre shell Unix, vous permettez de "
"lancer l'interpréteur Python en tapant la commande ::"

# e074012e6a55498fad926d939d5ce0f7
#: ../src/Doc/tutorial/interpreter.rst:19
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 une "
"option 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.)"

# 9d462e2928f341308d62bcd4963089f4
#: ../src/Doc/tutorial/interpreter.rst:24
msgid ""
"On Windows machines, the Python installation is usually placed in :file:`C:\\"
"\\Python27`, 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 ""
"Sur les machines Windows, l'installation de Python se situe généralement "
"dans :file:`C:\\\\Python27`, bien que vous puissiez changer cela lorsque "
"vous lancer l'installateur. Pour ajouter ce chemin dans vos chemins de "
"recherche, vous pouvez taper la commande suivante dans votre émulateur de "
"terminal DOS ::"

#: ../src/Doc/tutorial/interpreter.rst:31
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()``."

#: ../src/Doc/tutorial/interpreter.rst:36
msgid ""
"The interpreter's line-editing features usually aren't very sophisticated.  "
"On Unix, whoever installed the interpreter may have enabled support for the "
"GNU readline library, which adds more elaborate interactive editing and "
"history features. Perhaps the quickest check to see whether command line "
"editing is supported is typing 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 possibilités d'édition de l'interpréteur ne sont généralement pas très "
"sophistiquées. Sous Unix, quiconque a installé l'interpréteur est "
"susceptible d'avoir la gestion de la bibliothèque GNU readline d'activé, ce "
"qui ajoute une édition interactive plus élaborée et une fonctionnalité "
"d'historique. Le moyen le plus rapide de tester si l'édition de la ligne de "
"commande est gérée est peut-être de taper :kbd:`Ctrl-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."

#: ../src/Doc/tutorial/interpreter.rst:46
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."

#: ../src/Doc/tutorial/interpreter.rst:51
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."

#: ../src/Doc/tutorial/interpreter.rst:57
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."

# 3cbdf83437db4943ba9c24f111feb698
#: ../src/Doc/tutorial/interpreter.rst:61
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."

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

# cf63c591cb9a4616a61a495bd06cf8af
#: ../src/Doc/tutorial/interpreter.rst:71
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."

#: ../src/Doc/tutorial/interpreter.rst:87
msgid "Interactive Mode"
msgstr "Mode interactif"

#: ../src/Doc/tutorial/interpreter.rst:89
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 ""
"Lorsque les commandes sont lues depuis un tty, l'interpréteur est dit *en "
"mode interactif*. Dans ce mode, il attend la prochaine commande en affichant "
"*l'invite de commande primaire*, généralement trois \"signes supérieur à"
"\" (``>>>``); pour demander une ligne de continuation, l'interpréteur "
"affiche *l'invite de commande secondaire*, par défaut trois points (``..."
"``). L'interpréteur affiche un message de bienvenue indiquant son numéro de "
"version et une mention de *copyright* avant d'afficher le premier invite de "
"commande ::"

#: ../src/Doc/tutorial/interpreter.rst:101
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` ::"

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

#: ../src/Doc/tutorial/interpreter.rst:120
msgid "Error Handling"
msgstr "Gestion des erreurs"

#: ../src/Doc/tutorial/interpreter.rst:122
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."

#: ../src/Doc/tutorial/interpreter.rst:132
msgid ""
"Typing the interrupt character (usually Control-C or DEL) 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`."

#: ../src/Doc/tutorial/interpreter.rst:142
msgid "Executable Python Scripts"
msgstr "Scripts Python exécutables"

#: ../src/Doc/tutorial/interpreter.rst:144
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 ::"

#: ../src/Doc/tutorial/interpreter.rst:149
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."

#: ../src/Doc/tutorial/interpreter.rst:156
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 `chmod` ::"

#: ../src/Doc/tutorial/interpreter.rst:161
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."

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

# 5b068a5d06ac42b8bf82ceb101a1e483
#: ../src/Doc/tutorial/interpreter.rst:173
msgid ""
"It is possible to use encodings different than ASCII in Python source files. "
"The best way to do it is to 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 que l'ASCII 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::"

# 168d80cdf66a411d9af2e4d90f8b5fdf
#: ../src/Doc/tutorial/interpreter.rst:180
msgid ""
"With that declaration, all characters in the source file will be treated as "
"having the encoding *encoding*, and it will be possible to directly write "
"Unicode string literals in the selected encoding.  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* et il est possible de d'écrire "
"directement des littéraux de chaîne Unicode dans l'encodage choisi. 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`."

# 136855779690415a8c5aac7ceb545218
#: ../src/Doc/tutorial/interpreter.rst:186
msgid ""
"For example, to write Unicode literals including the Euro currency symbol, "
"the ISO-8859-15 encoding can be used, with the Euro symbol having the "
"ordinal value 164.  This script will print the value 8364 (the Unicode "
"codepoint corresponding to the Euro symbol) and then exit::"
msgstr ""
"Par exemple, l'encodage ISO-8859-15 peut être utilisé pour écrire le "
"littéral Unicode décrivant le symbole Euro, ce dernier portant la valeur "
"ordinal 164 dans cet encodage. Ce script affiche la valeur 8364 (le point de "
"code Unicode correspondant au symbole Euro) et se termine ::"

# f6dd13cd8acb47b1b663b044df22ddf5
#: ../src/Doc/tutorial/interpreter.rst:196
msgid ""
"If your editor supports saving files as ``UTF-8`` with a UTF-8 *byte order "
"mark* (aka BOM), you can use that instead of an encoding declaration. IDLE "
"supports this capability if ``Options/General/Default Source Encoding/"
"UTF-8`` is set. Notice that this signature is not understood in older Python "
"releases (2.2 and earlier), and also not understood by the operating system "
"for script files with ``#!`` lines (only used on Unix systems)."
msgstr ""

# 54d62eeac9bc4555818501cd2d0d843d
#: ../src/Doc/tutorial/interpreter.rst:203
msgid ""
"By using UTF-8 (either through the signature or an encoding declaration), "
"characters of most languages in the world can be used simultaneously in "
"string literals and comments.  Using non-ASCII characters in identifiers is "
"not supported. 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 ""

#: ../src/Doc/tutorial/interpreter.rst:214
msgid "The Interactive Startup File"
msgstr ""

#: ../src/Doc/tutorial/interpreter.rst:216
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 ""

#: ../src/Doc/tutorial/interpreter.rst:225
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 ""

# 4995ff5bd0b54d7e9c48f735d36b160a
#: ../src/Doc/tutorial/interpreter.rst:233
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'): execfile('.pythonrc.py')``.  If you want to use "
"the startup file in a script, you must do this explicitly in the script::"
msgstr ""

# d6945345e3fe4669981e2966a757ef2f
#: ../src/Doc/tutorial/interpreter.rst:247
msgid "The Customization Modules"
msgstr ""

# c1488b1ad1f1415399201ea7a41b8649
#: ../src/Doc/tutorial/interpreter.rst:249
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 ""

# 07d2ef1091ac4086815e9ea6e57edd26
#: ../src/Doc/tutorial/interpreter.rst:257
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 ""

# 83a462362bb84a31bd2553bd13c41e2e
#: ../src/Doc/tutorial/interpreter.rst:261
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 ""

#: ../src/Doc/tutorial/interpreter.rst:269
msgid "A problem with the GNU Readline package may prevent this."
msgstr ""

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

#: ../src/Doc/tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (``>>>`` and ``...``): 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 (``>>>`` et ``...``) : 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."

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

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

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

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

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

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

#: ../src/Doc/tutorial/introduction.rst:72
msgid "A value can be assigned to several variables simultaneously::"
msgstr "Une valeur peut être affectée à plusieurs variables simultanément ::"

#: ../src/Doc/tutorial/introduction.rst:82
msgid ""
"Variables must be \"defined\" (assigned a value) before they can be used, or "
"an error will occur::"
msgstr ""
"Les variables doivent être \"définies\" (une valeur doit leur être affectée) pour "
"qu'elles puissent être utilisées, sans quoi une erreur interviendra ::"

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

#: ../src/Doc/tutorial/introduction.rst:98
msgid ""
"Complex numbers are also supported; imaginary numbers are written with a "
"suffix of ``j`` or ``J``.  Complex numbers with a nonzero real component are "
"written as ``(real+imagj)``, or can be created with the ``complex(real, imag)"
"`` function. ::"
msgstr ""
"Les nombres complexes sont aussi supportés ; les nombres imaginaires sont écrits "
"avec un suffixe ``j`` ou ``J``. Les nombres complexes avec une composante réelle "
"différente de zéro sont écrits sous la forme ``(réel+imagj)``, ou peuvent être "
"créés avec la fonction ``complex(real, imag)``."

#: ../src/Doc/tutorial/introduction.rst:114
msgid ""
"Complex numbers are always represented as two floating point numbers, the "
"real and imaginary part.  To extract these parts from a complex number *z*, "
"use ``z.real`` and ``z.imag``.   ::"
msgstr ""
"Les nombres complexes sont toujours représentés comme deux nombres à virgule "
"flottante, la partie réelle et la partie imaginaire. Pour extraire ces deux parties "
"d'un nombre complexe *z*, utilisez ``z.real`` et ``z.imag`` ::"

# 7e26ce7f84464f10b0c9c677e62c4fd3
#: ../src/Doc/tutorial/introduction.rst:124
msgid ""
"The conversion functions to floating point and integer (:func:`float`, :func:"
"`int` and :func:`long`) don't work for complex numbers --- there is no one "
"correct way to convert a complex number to a real number.  Use ``abs(z)`` to "
"get its magnitude (as a float) or ``z.real`` to get its real part. ::"
msgstr ""
"Les fonctions de conversion en nombres à virgule flottante et en entiers "
":func:`float`, :func:`int` et :func:`long`) ne fonctionnent pas pour les nombres "
"complexes --- il n'y a pas de manière correcte de convertir un nombre complexe en "
"nombre réel. Utilisez ``abs(z)`` pour obtenir sa magnitude (de type flottant) ou "
"``z.real`` pour obtenir sa partie réelle ::"

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

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

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

#: ../src/Doc/tutorial/introduction.rst:164
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::"
msgstr ""
"Au delà des nombres, Python peut aussi manipuler des chaînes de caractères, qui "
"peuvent être exprimées de plusieurs façons. Elles peuvent être entourées par des "
"apostrophes ou des guillemets ::"

# 9c733fd1348b4d048794c552b36f40fe
#: ../src/Doc/tutorial/introduction.rst:180
msgid ""
"The interpreter prints the result of string operations in the same way as "
"they are typed for input: inside quotes, and with quotes and other funny "
"characters escaped by backslashes, to show the precise value.  The string is "
"enclosed in double quotes if the string contains a single quote and no "
"double quotes, else it's enclosed in single quotes.  The :keyword:`print` "
"statement produces a more readable output for such input strings."
msgstr ""
"L'interpréteur affiche le résultat des opérations sur les chaînes de la même façon "
"qu'elles sont saisies en entrée : entre des apostrophes, avec les apostrophes et "
"autres caractères spéciaux protégés par des antislashs, pour indiquer la valeur "
"précise. La chaîne de caractères est entourée de guillemets si elle contient une "
"apostrophe et pas de guillemet, sinon elle est entourée d'apostrophes. L'instruction "
":keyword:`print` produit une sortie plus lisible pour de telles chaînes."

#: ../src/Doc/tutorial/introduction.rst:187
msgid ""
"String literals can span multiple lines in several ways.  Continuation lines "
"can be used, with a backslash as the last character on the line indicating "
"that the next line is a logical continuation of the line::"
msgstr ""
"Les chaînes littérales peuvent être réparties sur plusieurs lignes de plusieurs "
"façons. On peut utiliser des lignes de continuation, un antislash en dernière "
"position d'une ligne indiquant que celle-ci se continue sur la ligne suivante ::"

#: ../src/Doc/tutorial/introduction.rst:198
msgid ""
"Note that newlines still need to be embedded in the string using ``\\n`` -- "
"the newline following the trailing backslash is discarded.  This example "
"would print the following:"
msgstr ""
"Notez que les caractères de fin de ligne doivent faire partie de la chaîne en "
"utilisant ``\\n`` -- le saut de ligne suivant le dernier antislash est écarté. Cet "
"exemple imprimerait ce qui suit :"

#: ../src/Doc/tutorial/introduction.rst:208
msgid ""
"Or, strings can be surrounded in a pair of matching triple-quotes: ``"
"\"\"\"`` or ``'''``.  End of lines do not need to be escaped when using "
"triple-quotes, but they will be included in the string. ::"
msgstr ""
"Les chaînes de caractères peuvent également être entourées de triples-apostrophes "
"ou de triples-guillemets : ``'''`` or ``\"\"\"``. Les fins de lignes n'ont pas "
"besoin d'être protégées lorsque vous utilisez des triples-guillemets, mais elles "
"seront intégrées dans la chaîne ::"

#: ../src/Doc/tutorial/introduction.rst:218
msgid "produces the following output:"
msgstr "produit l'affichage suivant :"

#: ../src/Doc/tutorial/introduction.rst:226
msgid ""
"If we make the string literal a \"raw\" string, ``\\n`` sequences are not "
"converted to newlines, but the backslash at the end of the line, and the "
"newline character in the source, are both included in the string as data.  "
"Thus, the example::"
msgstr ""
"En utilisant une chaîne de caractère brute, (\"raw\" string), les "
"séquence d'échappement``\\n`` ne sont pas convertis en retour à la "
"ligne, mais l'antislash en fin de ligne et le retour à la ligne "
"présent dans le code source sont tous les deux inclus dans la chaîne "
"de caractère. Par exemple::"

#: ../src/Doc/tutorial/introduction.rst:235
msgid "would print:"
msgstr "imprimerait :"

#: ../src/Doc/tutorial/introduction.rst:242
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 ``*``::"

#: ../src/Doc/tutorial/introduction.rst:251
msgid ""
"Two string literals next to each other are automatically concatenated; the "
"first line above could also have been written ``word = 'Help' 'A'``; this "
"only works with two literals, not with arbitrary string expressions::"
msgstr ""
"Deux chaînes de caractères l'une à côté de l'autre sont automatiquement "
"concaténées ; la première ligne ci-dessous aurait également pu être écrite "
"``word = 'Help' 'A'`` ; ceci ne fonctionne qu'avec deux chaînes littérales, pas "
"avec des expressions arbitraires ::"

# 81b99e3ed45148568543d7906b031fef
#: ../src/Doc/tutorial/introduction.rst:265
msgid ""
"Strings can be subscripted (indexed); like in C, the first character of a "
"string has subscript (index) 0.  There is no separate character type; a "
"character is simply a string of size one.  Like in Icon, substrings can be "
"specified with the *slice notation*: two indices separated by a colon. ::"
msgstr ""
"Les chaînes de caractères peuvent être indexées ; comme en C, le premier "
"caractè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. "
"Comme dans Icon, des sous-chaînes peuvent être spécifiées via une *notation par "
"tranches* : deux indices séparés par deux points ::"

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

#: ../src/Doc/tutorial/introduction.rst:285
msgid ""
"Unlike a C string, Python strings cannot be changed.  Assigning to an "
"indexed position in the string results in an error::"
msgstr ""
"À la différence des chaînes de caractères en C, les chaînes Python ne peuvent pas "
"être modifiées. Affecter une nouvelle valeur à un indice d'une chaîne produit une "
"erreur ::"

#: ../src/Doc/tutorial/introduction.rst:297
msgid ""
"However, creating a new string with the combined content is easy and "
"efficient::"
msgstr ""
"Par contre, créer une nouvelle chaîne avec le contenu combiné est simple et "
"efficace ::"

#: ../src/Doc/tutorial/introduction.rst:304
msgid ""
"Here's a useful invariant of slice operations: ``s[:i] + s[i:]`` equals "
"``s``. ::"
msgstr ""
"Voici un invariant utile des opérations par tranches : ``s[:i] + s[i:]`` est "
"égal à ``s`` ::"

#: ../src/Doc/tutorial/introduction.rst:312
msgid ""
"Degenerate slice indices are handled gracefully: an index that is too large "
"is replaced by the string size, an upper bound smaller than the lower bound "
"returns an empty string. ::"
msgstr ""
"Des indices de tranches erronés sont également gérés gracieusement : un indice "
"trop élevé est remplacé par la taille de la chaîne, un indice de fin plus petit "
"que l'indice de début retourne une chaîne vide ::"

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

#: ../src/Doc/tutorial/introduction.rst:334
msgid ""
"But note that -0 is really the same as 0, so it does not count from the "
"right! ::"
msgstr ""
"Mais notez bien que -0 est vraiment la même chose que 0, et n'effectue donc pas "
"son décompte à partir de la droite !"

#: ../src/Doc/tutorial/introduction.rst:340
msgid ""
"Out-of-range negative slice indices are truncated, but don't try this for "
"single-element (non-slice) indices::"
msgstr ""
"Des tranches avec des indices négatifs en dehors des valeurs autorisées sont "
"tronquées, mais n'essayez pas de les utiliser avec des indices pour des valeurs "
"isolées (hors tranches) ::"

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

#: ../src/Doc/tutorial/introduction.rst:361
msgid ""
"The first row of numbers gives the position of the indices 0...5 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...5 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."

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

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

# dc94a4264e3a4a0fa21b4f0848b59ea8
#: ../src/Doc/tutorial/introduction.rst:380
msgid ""
"Strings, and the Unicode strings described in the next section, are examples "
"of *sequence types*, and support the common operations supported by such "
"types."
msgstr ""
"Les chaînes de caractères, et les chaînes Unicode décrites dans la prochaine "
"section, sont des exemples de *types de séquences*, et supportent donc les "
"opérations classiques prises en charge par ces types."

# 0e3c9c88390d40f8b435ceca2e3e5fa2
#: ../src/Doc/tutorial/introduction.rst:385
msgid ""
"Both strings and Unicode strings support a large number of methods for basic "
"transformations and searching."
msgstr ""
"Aussi bien les chaînes de caractères que les chaînes Unicode supportent un "
"large éventail de méthodes de transformations basiques et de recherche."

#: ../src/Doc/tutorial/introduction.rst:389
msgid ""
"Information about string formatting with :meth:`str.format` is described "
"here."
msgstr ""
"Le formatage des chaînes avec la méthode :meth:`str.format` est décrit ici."

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

# e9f5c7de8cd043048a81c59a606bda57
#: ../src/Doc/tutorial/introduction.rst:400
msgid "Unicode Strings"
msgstr "Chaînes Unicode"

# ff4a88fc4dbf4203a1963c8e8042a016
#: ../src/Doc/tutorial/introduction.rst:405
msgid ""
"Starting with Python 2.0 a new data type for storing text data is available "
"to the programmer: the Unicode object. It can be used to store and "
"manipulate Unicode data (see http://www.unicode.org/) and integrates well "
"with the existing string objects, providing auto-conversions where necessary."
msgstr ""
"À partir de Python 2.0, un nouveau type permettant de stocker du texte est mis à "
"la disposition du programmeur : le type Unicode. Il peut être utilisé pour "
"stocker et manipuler des données Unicode (voir http://www.unicode.org/) et "
"s'intègre très bien avec les types de chaînes de caractères existant, en "
"fournissant une conversion automatique lorsque c'est nécessaire."

#: ../src/Doc/tutorial/introduction.rst:410
msgid ""
"Unicode has the advantage of providing one ordinal for every character in "
"every script used in modern and ancient texts. Previously, there were only "
"256 possible ordinals for script characters. Texts were typically bound to a "
"code page which mapped the ordinals to script characters. This lead to very "
"much confusion especially with respect to internationalization (usually "
"written as ``i18n`` --- ``'i'`` + 18 characters + ``'n'``) of software.  "
"Unicode solves these problems by defining one code page for all scripts."
msgstr ""
"Unicode a l'avantage de fournir une valeur ordinale pour chaque caractère d'un "
"script utilisé aussi bien dans d'anciens textes que dans des textes modernes. "
"Auparavant, il n'y avait que 256 valeurs ordinales possibles pour chaque "
"caractère. Chaque texte était typiquement associé à une page de codes qui "
"associait une valeur ordinale à chaque caractère. Ceci conduisait à une grande "
"confusion, notamment pour tout ce qui touchait à l'internationalisation (souvent "
"écrite ``i18n`` --- ``'i'`` + 18 caractères + ``'n'``) des logiciels. Unicode "
"résout ces problèmes en définissant une page de code unique pour tous les scripts."

# 9c768ff79bed4b06873ef02799f68dee
#: ../src/Doc/tutorial/introduction.rst:418
msgid ""
"Creating Unicode strings in Python is just as simple as creating normal "
"strings::"
msgstr ""
"Créer des chaînes Unicode en Python est aussi simple que de créer des chaînes de "
"caractères normales ::"

# 49929afe29c94cd38e866dcbb014004e
#: ../src/Doc/tutorial/introduction.rst:424
msgid ""
"The small ``'u'`` in front of the quote indicates that a Unicode string is "
"supposed to be created. If you want to include special characters in the "
"string, you can do so by using the Python *Unicode-Escape* encoding. The "
"following example shows how::"
msgstr ""
"Le petit ``'u'`` qui précède l'apostrophe indique que l'on veut créer une "
"chaîne Unicode. Si vous voulez intégrer des caractères spéciaux dans la chaîne, "
"vous pouvez le faire en utilisant l'encodage Python d'échappement des caractères "
"Unicode. Comme dans cet exemple ::"

#: ../src/Doc/tutorial/introduction.rst:432
msgid ""
"The escape sequence ``\\u0020`` indicates to insert the Unicode character "
"with the ordinal value 0x0020 (the space character) at the given position."
msgstr ""
"La séquence d'échappement ``\\u0020`` indique d'insérer le caractère Unicode "
"de valeur ordinale 0x0020 (un espace) à la position indiquée."

#: ../src/Doc/tutorial/introduction.rst:435
msgid ""
"Other characters are interpreted by using their respective ordinal values "
"directly as Unicode ordinals.  If you have literal strings in the standard "
"Latin-1 encoding that is used in many Western countries, you will find it "
"convenient that the lower 256 characters of Unicode are the same as the 256 "
"characters of Latin-1."
msgstr ""
"Les autres caractères sont interprétés en utilisant leurs valeurs ordinales "
"respectives directement comme des ordinaux Unicode. Si vous avez des chaînes "
"littérales dans l'encodage standard Latin-1 utilisé dans de nombreux pays "
"occidentaux, vous trouverez pratique que les 256 premiers caractères Unicode "
"soient les mêmes que ceux de l'encodage Latin-1."

# e704dbdcc7b84d5fa5187b18e3df045b
#: ../src/Doc/tutorial/introduction.rst:441
msgid ""
"For experts, there is also a raw mode just like the one for normal strings. "
"You have to prefix the opening quote with 'ur' to have Python use the *Raw-"
"Unicode-Escape* encoding. It will only apply the above ``\\uXXXX`` "
"conversion if there is an uneven number of backslashes in front of the small "
"'u'. ::"
msgstr ""
"Pour les experts, il existe également un mode \"brut\" identique à celui "
"disponible pour les chaînes de caractères. Vous devez préfixer la première "
"apostrophe avec 'ur' pour que Python utilise l'encodage *Unicode-Brut*. "
"Il n'appliquera la conversion ``\\uXXXX`` de l'exemple ci-dessous que s'il y a "
"un nombre impair d'antislashs devant le petit 'u' ::"

# f7d8ba88d48343f1bc5e81982b1faf00
#: ../src/Doc/tutorial/introduction.rst:452
msgid ""
"The raw mode is most useful when you have to enter lots of backslashes, as "
"can be necessary in regular expressions."
msgstr ""
"Le mode brut est le plus utile lorsque vous devez saisir de nombreux antislashs, "
"comme il peut être nécessaire de le faire dans des expressions rationnelles."

#: ../src/Doc/tutorial/introduction.rst:455
msgid ""
"Apart from these standard encodings, Python provides a whole set of other "
"ways of creating Unicode strings on the basis of a known encoding."
msgstr ""
"En dehors de ces encodages standards, Python fournit d'autres méthodes pour créer "
"des chaînes Unicode sur la base d'un encodage connu."

# 6b911ea5f8a24a2a8531621f77f2b074
#: ../src/Doc/tutorial/introduction.rst:460
msgid ""
"The built-in function :func:`unicode` provides access to all registered "
"Unicode codecs (COders and DECoders). Some of the more well known encodings "
"which these codecs can convert are *Latin-1*, *ASCII*, *UTF-8*, and "
"*UTF-16*. The latter two are variable-length encodings that store each "
"Unicode character in one or more bytes. The default encoding is normally set "
"to ASCII, which passes through characters in the range 0 to 127 and rejects "
"any other characters with an error. When a Unicode string is printed, "
"written to a file, or converted with :func:`str`, conversion takes place "
"using this default encoding. ::"
msgstr ""
"La primitive :func:`unicode` donne accès à tous les codecs (COdeurs et DECodeurs) "
"enregistrés. Certains des encodages les plus connus pris en charge par ces codecs "
"sont *Latin-1*, *ASCII*, *UTF-8* et *UTF-16*. Les deux derniers sont des encodages "
"à longueur variable qui stockent chaque caractère Unicode dans un ou plusieurs "
"octets. L'encodage par défaut est normalement défini en ASCII, qui gère les "
"caractères de valeur ordinale 0 à 127 et rejette tous les autres caractères avec "
"une erreur. Quand une chaîne Unicode est imprimée, écrite dans un fichier ou "
"convertie avec la fonction :func:`str`, une conversion s'effectue en utilisant "
"cet encodage par défaut ::"

# 8b0b7540567140749bbd4a088d41db0b
#: ../src/Doc/tutorial/introduction.rst:480
msgid ""
"To convert a Unicode string into an 8-bit string using a specific encoding, "
"Unicode objects provide an :func:`encode` method that takes one argument, "
"the name of the encoding.  Lowercase names for encodings are preferred. ::"
msgstr ""
"Pour convertir une chaîne Unicode en une chaîne encodée sur 8 bits en utilisant "
"un encodage spécifique, les objets Unicode fournissent une méthode :func:`encode` "
"qui prend pour argument le nom de l'encodage. Les noms d'encodages en minuscules "
"sont préférés ::"

# 88ffe7f4fb0340b290b1ce47aced804e
#: ../src/Doc/tutorial/introduction.rst:487
msgid ""
"If you have data in a specific encoding and want to produce a corresponding "
"Unicode string from it, you can use the :func:`unicode` function with the "
"encoding name as the second argument. ::"
msgstr ""
"Si vous avez une donnée dans un encodage spécifique et voulez générer la chaîne "
"Unicode correspondante, vous pouvez utiliser la fonction :func:`unicode` en "
"fournissant le nom de l'encodage comme second argument ::"

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

#: ../src/Doc/tutorial/introduction.rst:500
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.  List items need not "
"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 espaces placée entre crochets. Les "
"éléments d'une liste ne doivent pas obligatoirement être tous du même type ::"

#: ../src/Doc/tutorial/introduction.rst:509
msgid ""
"Like string indices, list indices start at 0, and lists can be sliced, "
"concatenated and so on::"
msgstr ""
"Comme les indices d'une chaîne de caractères, les indices des éléments d'une liste "
"commencent à 0, les listes peuvent être extraites par tranches, concaténées et "
"ainsi de suite ::"

#: ../src/Doc/tutorial/introduction.rst:525
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a shallow copy of the list *a*::"
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 *a* ::"

#: ../src/Doc/tutorial/introduction.rst:531
msgid ""
"Unlike strings, which are *immutable*, it is possible to change individual "
"elements of a list::"
msgstr ""
"Mais à la différence des listes qui sont *immuables*, il est possible de modifier "
"un élément d'une liste ::"

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

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

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

#: ../src/Doc/tutorial/introduction.rst:587
msgid ""
"Note that in the last example, ``p[1]`` and ``q`` really refer to the same "
"object!  We'll come back to *object semantics* later."
msgstr ""
"Notez que dans le dernier exemple, ``p[1]`` et ``q`` se réfèrent réellement au "
"même objet ! Nous reviendrons plus tard sur la *sémantique des objets*."

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

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

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

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

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

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

# 77dfda61249149ebbff3415dc7f626c0
#: ../src/Doc/tutorial/introduction.rst:640
msgid ""
"The :keyword:`print` statement writes the value of the expression(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 "
"expressions and strings.  Strings are printed without quotes, and a space is "
"inserted between items, so you can format things nicely, like this::"
msgstr ""
"L'instruction :keyword:`print` écrit la valeur de l'expression qui lui est "
"fournie. Ce n'est pas la même chose que d'écrire l'expression que vous voulez "
"écrire (comme nous l'avons fait dans l'exemple de la calculatrice), et diffère "
"dans la façon dont elle gère les expressions et chaînes de caractères multiples. "
"Les chaînes sont imprimées sans apostrophes et un espace est inséré entre les "
"éléments de telle sorte que vous pouvez facilement formater les choses, comme "
"ceci ::"

# f1fa0b0caa934963ad37b6df950d1d60
#: ../src/Doc/tutorial/introduction.rst:650
msgid "A trailing comma avoids the newline after the output::"
msgstr "Une virgule à la fin de l'instruction supprime le saut de ligne ::"

# 9af5f173627d4c51a46b129d40db499d
#: ../src/Doc/tutorial/introduction.rst:659
msgid ""
"Note that the interpreter inserts a newline before it prints the next prompt "
"if the last line was not completed."
msgstr ""
"Notez que l'interpréteur insère un saut de ligne avant d'afficher l'invite "
"suivante si la dernière ligne n'était pas complète."

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

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

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

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

#: ../src/Doc/tutorial/modules.rst:44
msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:49
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 ""

#: ../src/Doc/tutorial/modules.rst:60
msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:70
msgid "More on Modules"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:72
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 is imported somewhere. [#]_"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:76
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 ""

#: ../src/Doc/tutorial/modules.rst:83
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 ""

#: ../src/Doc/tutorial/modules.rst:88
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 ""

#: ../src/Doc/tutorial/modules.rst:95
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 ""

#: ../src/Doc/tutorial/modules.rst:98
msgid "There is even a variant to import all names that a module defines::"
msgstr ""

# a576f929fa4b4f03a5ecc568fbc39da4
#: ../src/Doc/tutorial/modules.rst:104
msgid ""
"This imports all names except those beginning with an underscore (``_``)."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:106
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 ""

# 43ceb255506f40879d48e04284318f2b
#: ../src/Doc/tutorial/modules.rst:112
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:`reload`, e.g. ``reload(modulename)``."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:121
msgid "Executing modules as scripts"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:123
msgid "When you run a Python module with ::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:127
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 ""

#: ../src/Doc/tutorial/modules.rst:135
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 ""

#: ../src/Doc/tutorial/modules.rst:142
msgid "If the module is imported, the code is not run::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:147
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 ""

#: ../src/Doc/tutorial/modules.rst:154
msgid "The Module Search Path"
msgstr ""

# 7eb1de98727b457bb47241fe0f9a3c7a
#: ../src/Doc/tutorial/modules.rst:158
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 ""

# 2cfb18e596454d35aba4942f36ffb217
#: ../src/Doc/tutorial/modules.rst:163
msgid "the directory containing the input script (or the current directory)."
msgstr ""

# 92b653933f904f2ba5db5eeb5106e97d
#: ../src/Doc/tutorial/modules.rst:164
msgid ""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
"shell variable :envvar:`PATH`)."
msgstr ""

# 5f64433feec849c99a5c0234fbe44b86
#: ../src/Doc/tutorial/modules.rst:166
msgid "the installation-dependent default."
msgstr ""

# 06804f6bce114936a931a03ac145ec9a
#: ../src/Doc/tutorial/modules.rst:168
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 ""

#: ../src/Doc/tutorial/modules.rst:177
msgid "\"Compiled\" Python files"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:179
msgid ""
"As an important speed-up of the start-up time for short programs that use a "
"lot of standard modules, if a file called :file:`spam.pyc` exists in the "
"directory where :file:`spam.py` is found, this is assumed to contain an "
"already-\"byte-compiled\" version of the module :mod:`spam`. The "
"modification time of the version of :file:`spam.py` used to create :file:"
"`spam.pyc` is recorded in :file:`spam.pyc`, and the :file:`.pyc` file is "
"ignored if these don't match."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:186
msgid ""
"Normally, you don't need to do anything to create the :file:`spam.pyc` file. "
"Whenever :file:`spam.py` is successfully compiled, an attempt is made to "
"write the compiled version to :file:`spam.pyc`.  It is not an error if this "
"attempt fails; if for any reason the file is not written completely, the "
"resulting :file:`spam.pyc` file will be recognized as invalid and thus "
"ignored later.  The contents of the :file:`spam.pyc` file are platform "
"independent, so a Python module directory can be shared by machines of "
"different architectures."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:194
msgid "Some tips for experts:"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:196
msgid ""
"When the Python interpreter is invoked with the :option:`-O` flag, optimized "
"code is generated and stored in :file:`.pyo` files.  The optimizer currently "
"doesn't help much; it only removes :keyword:`assert` statements.  When :"
"option:`-O` is used, *all* :term:`bytecode` is optimized; ``.pyc`` files are "
"ignored and ``.py`` files are compiled to optimized bytecode."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:202
msgid ""
"Passing two :option:`-O` flags to the Python interpreter (:option:`-OO`) "
"will cause the bytecode compiler to perform optimizations that could in some "
"rare cases result in malfunctioning programs.  Currently only ``__doc__`` "
"strings are removed from the bytecode, resulting in more compact :file:`."
"pyo` files.  Since some programs may rely on having these available, you "
"should only use this option if you know what you're doing."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:209
msgid ""
"A program doesn't run any faster when it is read from a :file:`.pyc` or :"
"file:`.pyo` file than when it is read from a :file:`.py` file; the only "
"thing that's faster about :file:`.pyc` or :file:`.pyo` files is the speed "
"with which they are loaded."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:214
msgid ""
"When a script is run by giving its name on the command line, the bytecode "
"for the script is never written to a :file:`.pyc` or :file:`.pyo` file.  "
"Thus, the startup time of a script may be reduced by moving most of its code "
"to a module and having a small bootstrap script that imports that module.  "
"It is also possible to name a :file:`.pyc` or :file:`.pyo` file directly on "
"the command line."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:221
msgid ""
"It is possible to have a file called :file:`spam.pyc` (or :file:`spam.pyo` "
"when :option:`-O` is used) without a file :file:`spam.py` for the same "
"module. This can be used to distribute a library of Python code in a form "
"that is moderately hard to reverse engineer."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:228
msgid ""
"The module :mod:`compileall` can create :file:`.pyc` files (or :file:`.pyo` "
"files when :option:`-O` is used) for all modules in a directory."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:235
msgid "Standard Modules"
msgstr ""

# 0572f328979e445b8f24801a89a1e2b0
#: ../src/Doc/tutorial/modules.rst:239
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 ""

#: ../src/Doc/tutorial/modules.rst:262
msgid ""
"These two variables are only defined if the interpreter is in interactive "
"mode."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:264
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 ""

#: ../src/Doc/tutorial/modules.rst:277
msgid "The :func:`dir` Function"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:279
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 ""

#: ../src/Doc/tutorial/modules.rst:297
msgid ""
"Without arguments, :func:`dir` lists the names you have defined currently::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:305
msgid ""
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr ""

# 38ddad117ec74e9885481c252bed3daf
#: ../src/Doc/tutorial/modules.rst:309
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:"
"`__builtin__`::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:344
msgid "Packages"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:346
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 ""

#: ../src/Doc/tutorial/modules.rst:354
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 ""

#: ../src/Doc/tutorial/modules.rst:389
msgid ""
"When importing the package, Python searches through the directories on ``sys."
"path`` looking for the package subdirectory."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:392
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 ""

#: ../src/Doc/tutorial/modules.rst:399
msgid ""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:404
msgid ""
"This loads the submodule :mod:`sound.effects.echo`.  It must be referenced "
"with its full name. ::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:409
msgid "An alternative way of importing the submodule is::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:413
msgid ""
"This also loads the submodule :mod:`echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:418
msgid ""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:422
msgid ""
"Again, this loads the submodule :mod:`echo`, but this makes its function :"
"func:`echofilter` directly available::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:427
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 ""

#: ../src/Doc/tutorial/modules.rst:434
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 ""

#: ../src/Doc/tutorial/modules.rst:443
msgid "Importing \\* From a Package"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:447
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 ""

#: ../src/Doc/tutorial/modules.rst:453
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:`sounds/"
"effects/__init__.py` could contain the following code::"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:465
msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`sound` package."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:468
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 ""

#: ../src/Doc/tutorial/modules.rst:481
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 ""

#: ../src/Doc/tutorial/modules.rst:486
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 ""

#: ../src/Doc/tutorial/modules.rst:490
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 ""

#: ../src/Doc/tutorial/modules.rst:497
msgid "Intra-package References"
msgstr ""

# 20ba5d3273454eefa50529336214baa5
#: ../src/Doc/tutorial/modules.rst:499
msgid ""
"The submodules often need to refer to each other.  For example, the :mod:"
"`surround` module might use the :mod:`echo` module.  In fact, such "
"references are so common that the :keyword:`import` statement first looks in "
"the containing package before looking in the standard module search path. "
"Thus, the :mod:`surround` module can simply use ``import echo`` or ``from "
"echo import echofilter``.  If the imported module is not found in the "
"current package (the package of which the current module is a submodule), "
"the :keyword:`import` statement looks for a top-level module with the given "
"name."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:508
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 ""

# 82c84536e5f94eb8ad4f365cde80af40
#: ../src/Doc/tutorial/modules.rst:514
msgid ""
"Starting with Python 2.5, in addition to the implicit relative imports "
"described above, you can write explicit relative imports with the ``from "
"module import name`` form of import statement. These explicit relative "
"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 ""

# 0a545e217ccb4074a3817733279c812b
#: ../src/Doc/tutorial/modules.rst:524
msgid ""
"Note that both explicit and implicit 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 should always use absolute imports."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:531
msgid "Packages in Multiple Directories"
msgstr ""

#: ../src/Doc/tutorial/modules.rst:533
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 ""

#: ../src/Doc/tutorial/modules.rst:539
msgid ""
"While this feature is not often needed, it can be used to extend the set of "
"modules found in a package."
msgstr ""

#: ../src/Doc/tutorial/modules.rst:545
msgid ""
"In fact function definitions are also 'statements' that are 'executed'; the "
"execution of a module-level function enters the function name in the "
"module's global symbol table."
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:5
msgid "Brief Tour of the Standard Library"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:11
msgid "Operating System Interface"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:13
msgid ""
"The :mod:`os` module provides dozens of functions for interacting with the "
"operating system::"
msgstr ""

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

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

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

#: ../src/Doc/tutorial/stdlib.rst:49
msgid "File Wildcards"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:51
msgid ""
"The :mod:`glob` module provides a function for making file lists from "
"directory wildcard searches::"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:62
msgid "Command Line Arguments"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:64
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 ""

#: ../src/Doc/tutorial/stdlib.rst:73
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 ""

#: ../src/Doc/tutorial/stdlib.rst:81
msgid "Error Output Redirection and Program Termination"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:83
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 ""

#: ../src/Doc/tutorial/stdlib.rst:90
msgid "The most direct way to terminate a script is to use ``sys.exit()``."
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:96
msgid "String Pattern Matching"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:98
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 ""

#: ../src/Doc/tutorial/stdlib.rst:108
msgid ""
"When only simple capabilities are needed, string methods are preferred "
"because they are easier to read and debug::"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:118
msgid "Mathematics"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:120
msgid ""
"The :mod:`math` module gives access to the underlying C library functions "
"for floating point math::"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:129
msgid "The :mod:`random` module provides tools for making random selections::"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:145
msgid "Internet Access"
msgstr ""

# 621033cc072a4a8da88740058de8f289
#: ../src/Doc/tutorial/stdlib.rst:147
msgid ""
"There are a number of modules for accessing the internet and processing "
"internet protocols. Two of the simplest are :mod:`urllib2` for retrieving "
"data from URLs and :mod:`smtplib` for sending mail::"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:168
msgid "(Note that the second example needs a mailserver running on localhost.)"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:174
msgid "Dates and Times"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:176
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 ""

#: ../src/Doc/tutorial/stdlib.rst:200
msgid "Data Compression"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:202
msgid ""
"Common data archiving and compression formats are directly supported by "
"modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`zipfile` and :"
"mod:`tarfile`. ::"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:222
msgid "Performance Measurement"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:224
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 ""

#: ../src/Doc/tutorial/stdlib.rst:228
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 ""

#: ../src/Doc/tutorial/stdlib.rst:238
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 ""

#: ../src/Doc/tutorial/stdlib.rst:246
msgid "Quality Control"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:248
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 ""

#: ../src/Doc/tutorial/stdlib.rst:252
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 ""

#: ../src/Doc/tutorial/stdlib.rst:270
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 ""

#: ../src/Doc/tutorial/stdlib.rst:290
msgid "Batteries Included"
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:292
msgid ""
"Python has a \"batteries included\" philosophy.  This is best seen through "
"the sophisticated and robust capabilities of its larger packages. For "
"example:"
msgstr ""

# 1f0e345bae7b4a83861dd3cfabcc8448
#: ../src/Doc/tutorial/stdlib.rst:295
msgid ""
"The :mod:`xmlrpclib` and :mod:`SimpleXMLRPCServer` 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 ""

#: ../src/Doc/tutorial/stdlib.rst:299
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 ""

#: ../src/Doc/tutorial/stdlib.rst:306
msgid ""
"The :mod:`xml.dom` and :mod:`xml.sax` packages provide robust support for "
"parsing this popular data interchange format. Likewise, the :mod:`csv` "
"module supports direct reads and writes in a common database format. "
"Together, these modules and packages greatly simplify data interchange "
"between Python applications and other tools."
msgstr ""

#: ../src/Doc/tutorial/stdlib.rst:312
msgid ""
"Internationalization is supported by a number of modules including :mod:"
"`gettext`, :mod:`locale`, and the :mod:`codecs` package."
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:5
msgid "Brief Tour of the Standard Library -- Part II"
msgstr ""

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

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

# 20922d986c434cb78ddac80e1a60633b
#: ../src/Doc/tutorial/stdlib2.rst:16
msgid ""
"The :mod:`repr` module provides a version of :func:`repr` customized for "
"abbreviated displays of large or deeply nested containers::"
msgstr ""

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

#: ../src/Doc/tutorial/stdlib2.rst:39
msgid ""
"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "
"width::"
msgstr ""

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

#: ../src/Doc/tutorial/stdlib2.rst:72
msgid "Templating"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:74
msgid ""
"The :mod:`string` module includes a versatile :class:`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 ""

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

#: ../src/Doc/tutorial/stdlib2.rst:88
msgid ""
"The :meth:`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:"
"`safe_substitute` method may be more appropriate --- it will leave "
"placeholders unchanged if data is missing::"
msgstr ""

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

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

#: ../src/Doc/tutorial/stdlib2.rst:133
msgid "Working with Binary Data Record Layouts"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:135
msgid ""
"The :mod:`struct` module provides :func:`pack` and :func:`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 ""

#: ../src/Doc/tutorial/stdlib2.rst:163
msgid "Multi-threading"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:165
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:170
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:193
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 ""

# 5b0b88c3eb2844fa903eb3e3ff72d79b
#: ../src/Doc/tutorial/stdlib2.rst:198
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:209
msgid "Logging"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:211
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 ""

# 5d44183c6fb0489091fbd795f42c8dab
#: ../src/Doc/tutorial/stdlib2.rst:221
msgid "This produces the following output:"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:229
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:"
"`DEBUG`, :const:`INFO`, :const:`WARNING`, :const:`ERROR`, and :const:"
"`CRITICAL`."
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:235
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:243
msgid "Weak References"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:245
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:249
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:284
msgid "Tools for Working with Lists"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:286
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:290
msgid ""
"The :mod:`array` module provides an :class:`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 ""

#: ../src/Doc/tutorial/stdlib2.rst:303
msgid ""
"The :mod:`collections` module provides a :class:`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 ""

#: ../src/Doc/tutorial/stdlib2.rst:324
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:334
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:350
msgid "Decimal Floating Point Arithmetic"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:352
msgid ""
"The :mod:`decimal` module offers a :class:`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 ""

#: ../src/Doc/tutorial/stdlib2.rst:356
msgid ""
"financial applications and other uses which require exact decimal "
"representation,"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:358
msgid "control over precision,"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:359
msgid "control over rounding to meet legal or regulatory requirements,"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:360
msgid "tracking of significant decimal places, or"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:361
msgid ""
"applications where the user expects the results to match calculations done "
"by hand."
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:364
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 ""

#: ../src/Doc/tutorial/stdlib2.rst:377
msgid ""
"The :class:`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 ""

#: ../src/Doc/tutorial/stdlib2.rst:382
msgid ""
"Exact representation enables the :class:`Decimal` class to perform modulo "
"calculations and equality tests that are unsuitable for binary floating "
"point::"
msgstr ""

#: ../src/Doc/tutorial/stdlib2.rst:395
msgid ""
"The :mod:`decimal` module provides arithmetic with as much precision as "
"needed::"
msgstr ""

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

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

#: ../src/Doc/tutorial/whatnow.rst:11
msgid ""
"This tutorial is part of Python's documentation set.   Some other documents "
"in the set are:"
msgstr ""

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

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

#: ../src/Doc/tutorial/whatnow.rst:24
msgid ""
":ref:`install-index` explains how to install external modules written by "
"other Python users."
msgstr ""

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

#: ../src/Doc/tutorial/whatnow.rst:31
msgid "More Python resources:"
msgstr ""

#: ../src/Doc/tutorial/whatnow.rst:33
msgid ""
"http://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 ""

#: ../src/Doc/tutorial/whatnow.rst:39
msgid "http://docs.python.org:  Fast access to Python's  documentation."
msgstr ""

#: ../src/Doc/tutorial/whatnow.rst:41
msgid ""
"http://pypi.python.org: 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 ""

#: ../src/Doc/tutorial/whatnow.rst:46
msgid ""
"http://aspn.activestate.com/ASPN/Python/Cookbook/: 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 ""

#: ../src/Doc/tutorial/whatnow.rst:51
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 around 120 postings a day (with peaks up to several hundred), asking "
"(and answering) questions, suggesting new features, and announcing new "
"modules. Before posting, be sure to check the list of `Frequently Asked "
"Questions <http://www.python.org/doc/faq/>`_ (also called the FAQ), or look "
"for it in the :file:`Misc/` directory of the Python source distribution.  "
"Mailing list archives are available at http://mail.python.org/pipermail/. "
"The FAQ answers many of the questions that come up again and again, and may "
"already contain the solution for your problem."
msgstr ""

#~ msgid "|version|"
#~ msgstr "|version|"

#~ msgid "|today|"
#~ msgstr "|today|"

#~ 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."

#~ msgid "Scopes and Namespaces Example"
#~ msgstr "Exemple de portées et d'espaces de noms"

#~ 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 ::"

#~ msgid ""
#~ "def scope_test():     def do_local():         spam = \"local spam\"     "
#~ "def do_nonlocal():         nonlocal spam         spam = \"nonlocal spam"
#~ "\"     def do_global():         global spam         spam = \"global spam"
#~ "\"      spam = \"test spam\"     do_local()     print(\"After local "
#~ "assignment:\", spam)     do_nonlocal()     print(\"After nonlocal "
#~ "assignment:\", spam)     do_global()     print(\"After global assignment:"
#~ "\", spam)  scope_test() print(\"In global scope:\", spam)"
#~ msgstr ""
#~ "def scope_test():     def do_local():         spam = \"local spam\"     "
#~ "def do_nonlocal():         nonlocal spam         spam = \"nonlocal spam"
#~ "\"     def do_global():         global spam         spam = \"global spam"
#~ "\"      spam = \"test spam\"     do_local()     print(\"After local "
#~ "assignment:\", spam)     do_nonlocal()     print(\"After nonlocal "
#~ "assignment:\", spam)     do_global()     print(\"After global assignment:"
#~ "\", spam)  scope_test() print(\"In global scope:\", spam)"

#~ msgid "The output of the example code is::"
#~ msgstr "Ce code donne le résultat suivant ::"

#~ msgid ""
#~ "After local assignment: test spam After nonlocal assignment: nonlocal "
#~ "spam After global assignment: nonlocal spam In global scope: global spam"
#~ msgstr ""
#~ "After local assignment: test spam After nonlocal assignment: nonlocal "
#~ "spam After global assignment: nonlocal spam In global scope: global spam"

#~ 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."

#~ 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`."

#~ msgid ""
#~ "class ClassName:     <statement-1>     .     .     .     <statement-N>"
#~ msgstr "class NomDeLaClasse: <déclaration-1>. . . <déclaration-N>"

#~ msgid ""
#~ "class MyClass:     \"\"\"A simple example class\"\"\"     i = 12345     "
#~ "def f(self):         return 'hello world'"
#~ msgstr ""
#~ "class MaClasse: \"\"\"Une simple classe d'exemple\"\"\" i = 12345 def f"
#~ "(self): return 'hello world'"

#~ msgid "x = MyClass()"
#~ msgstr "x = MaClasse()"

#~ msgid "def __init__(self):     self.data = []"
#~ msgstr "def __init__(self): self.data = []"

#~ msgid ""
#~ ">>> class Complex: ...     def __init__(self, realpart, "
#~ "imagpart): ...         self.r = realpart ...         self.i = "
#~ "imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)"
#~ msgstr ""
#~ ">>> class Complexe: ...     def __init__(self, partie_reelle, "
#~ "partie_imaginaire): ...         self.r = partie_reelle ...         self.i "
#~ "= partie_imaginaire ... >>> x = Complexe(3.0, -4.5) >>> x.r, x.i (3.0, "
#~ "-4.5)"

#~ msgid ""
#~ "x.counter = 1 while x.counter < 10:     x.counter = x.counter * 2 print(x."
#~ "counter) del x.counter"
#~ msgstr ""
#~ "x.compteur = 1 while x.compteur < 10:     x.compteur = x.compteur * 2 "
#~ "print(x.compteur) del x.compteur"

#, fuzzy
#~ msgid "xf = x.f while True:     print(xf())"
#~ msgstr "xf = x.f while True: print(xf())"

#~ msgid ""
#~ "# Function defined outside the class def f1(self, x, y):     return min"
#~ "(x, x+y)  class C:     f = f1     def g(self):         return 'hello "
#~ "world'     h = g"
#~ msgstr ""
#~ "# Function définie à l'extérieur d'une classe def f1(self, x, y): return "
#~ "min(x, x+y) class C: f = f1 def g(self): return 'bonjour tout le monde' h "
#~ "= g"

#~ msgid ""
#~ "class DerivedClassName(BaseClassName):     "
#~ "<statement-1>     .     .     .     <statement-N>"
#~ msgstr ""
#~ "class ClasseDerivee(ClasseDeBase): <déclaration-1> . . . <déclaration-N>"

#~ msgid "class DerivedClassName(modname.BaseClassName):"
#~ msgstr "class ClasseDerivee(nommodule.ClasseDeBase):"

#, fuzzy
#~ msgid ""
#~ "class DerivedClassName(Base1, Base2, Base3):     "
#~ "<statement-1>     .     .     .     <statement-N>"
#~ msgstr ""
#~ "class NomDeLaClasseDerivee(Base1, Base2, Base3): <instruction-1> . . . "
#~ "<instruction-N>"