# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2016-10-17 21:44+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../Doc/tutorial/appendix.rst:5 msgid "Appendix" msgstr "Annexe" #: ../Doc/tutorial/appendix.rst:11 ../Doc/tutorial/interpreter.rst:90 msgid "Interactive Mode" msgstr "Mode interactif" #: ../Doc/tutorial/appendix.rst:16 msgid "Error Handling" msgstr "Gestion des erreurs" #: ../Doc/tutorial/appendix.rst:18 msgid "" "When an error occurs, the interpreter prints an error message and a stack " "trace. In interactive mode, it then returns to the primary prompt; when " "input came from a file, it exits with a nonzero exit status after printing " "the stack trace. (Exceptions handled by an :keyword:`except` clause in a :" "keyword:`try` statement are not errors in this context.) Some errors are " "unconditionally fatal and cause an exit with a nonzero exit; this applies to " "internal inconsistencies and some cases of running out of memory. All error " "messages are written to the standard error stream; normal output from " "executed commands is written to standard output." msgstr "" "Quand une erreur se produit, l'interpréteur affiche un message d'erreur et " "le suivit de la pile. En mode interactif, il revient à l'invite de commande " "primaire; si l'entrée provient d'un fichier, l'interpréteur se termine avec " "un état de sortie non nul après avoir affiché le suivit de la pile. (Les " "exceptions gérées par une clause :keyword:`except` dans une instruction :" "keyword:`try` ne sont pas des erreurs dans ce contexte.) Certaines erreurs " "sont inconditionnellement fatales et cause une sortie avec un état non nul; " "les incohérences internes et, dans certains cas, les pénuries de mémoires, " "sont traitées de la sorte. Tous les messages d'erreur sont écrits sur la " "sortie d'erreur standard; les sorties normales issues des commandes " "exécutées sont écrites sur la sortie standard." #: ../Doc/tutorial/appendix.rst:28 msgid "" "Typing the interrupt character (usually :kbd:`Control-C` or :kbd:`Delete`) " "to the primary or secondary prompt cancels the input and returns to the " "primary prompt. [#]_ Typing an interrupt while a command is executing raises " "the :exc:`KeyboardInterrupt` exception, which may be handled by a :keyword:" "`try` statement." msgstr "" "Taper le caractère d'interruption (généralement :kbd:`Ctrl+C` ou :kbd:" "`Supprimer`) au niveau de l'invite de commande primaire annule l'entrée et " "revient à l'invite. [#]_ Saisir une interruption tandis qu'une commande " "s'exécute lève une exception :exc:`KeyboardInterrupt` qui peut être gérée " "par une instruction :keyword:`try`." #: ../Doc/tutorial/appendix.rst:38 msgid "Executable Python Scripts" msgstr "Scripts Python exécutables" #: ../Doc/tutorial/appendix.rst:40 msgid "" "On BSD'ish Unix systems, Python scripts can be made directly executable, " "like shell scripts, by putting the line ::" msgstr "" "Sur les systèmes Unix, un script Python peut être rendu directement " "exécutable comme un script shell en ajoutant la ligne : ::" #: ../Doc/tutorial/appendix.rst:45 msgid "" "(assuming that the interpreter is on the user's :envvar:`PATH`) at the " "beginning of the script and giving the file an executable mode. The ``#!`` " "must be the first two characters of the file. On some platforms, this first " "line must end with a Unix-style line ending (``'\\n'``), not a Windows " "(``'\\r\\n'``) line ending. Note that the hash, or pound, character, " "``'#'``, is used to start a comment in Python." msgstr "" "(en supposant que l'interpréteur est dans le :envvar:`PATH` de " "l'utilisateur) au début du script et en rendant le fichier exécutable. ``#!" "`` doivent être les deux premiers caractères du fichier. Sur certaines " "plateformes, cette première ligne doit finir avec une fin de ligne de type " "Unix (``'\\n'``) et pas de type Windows (``'\\r\\n'``). Notez que le " "caractère dièse, ``'#'``, est utilisé pour initier un commentaire en Python." #: ../Doc/tutorial/appendix.rst:52 msgid "" "The script can be given an executable mode, or permission, using the :" "program:`chmod` command." msgstr "" "Un script peut être rendu utilisable en utilisant la commande :program:" "`chmod`." #: ../Doc/tutorial/appendix.rst:59 msgid "" "On Windows systems, there is no notion of an \"executable mode\". The " "Python installer automatically associates ``.py`` files with ``python.exe`` " "so that a double-click on a Python file will run it as a script. The " "extension can also be ``.pyw``, in that case, the console window that " "normally appears is suppressed." msgstr "" "Sur les système windows il n'y a pas de \"mode executable\". L'installateur " "Python associe automatiquement les fichier en ``.py`` avec ``python.exe`` de " "telle sorte qu'un double clic sur un fichier Python le lance comme un " "script. L'extension peut aussi être ``.pyw``, dans ce cas, la console " "n'apparait pas." #: ../Doc/tutorial/appendix.rst:69 msgid "The Interactive Startup File" msgstr "La configuration du mode interactif" #: ../Doc/tutorial/appendix.rst:71 msgid "" "When you use Python interactively, it is frequently handy to have some " "standard commands executed every time the interpreter is started. You can " "do this by setting an environment variable named :envvar:`PYTHONSTARTUP` to " "the name of a file containing your start-up commands. This is similar to " "the :file:`.profile` feature of the Unix shells." msgstr "" "En mode interactif, il peut être pratique de faire exécuter quelques " "commandes au lancement de l'interprète. C'est possible en configurant la " "variable d'environnement :envvar:`PYTHONSTARTUP`\" avec le nom d'un fichier " "contenant les instructions à exécuter, à la même manière du :file:`.profile` " "dans un shell Unix." #: ../Doc/tutorial/appendix.rst:77 msgid "" "This file is only read in interactive sessions, not when Python reads " "commands from a script, and not when :file:`/dev/tty` is given as the " "explicit source of commands (which otherwise behaves like an interactive " "session). It is executed in the same namespace where interactive commands " "are executed, so that objects that it defines or imports can be used without " "qualification in the interactive session. You can also change the prompts " "``sys.ps1`` and ``sys.ps2`` in this file." msgstr "" "Ce fichier n'est lu qu'en mode interactif, pas quand Python lis les " "instructions depuis un fichier, ni quand :file:`/dev/tty` est donné " "explicitement comme fichier source (qui d'ailleurs se compterait comme une " "session interactive). Les instructions de ce fichier, sont exécutées dans le " "même espace de noms que vos commandes, donc les objets définis et modules " "importés peuvent être utilisées directement dans la session interactive. " "Dans ce fichier il est aussi possible de changer les prompts ``sys.ps1`` et " "``sys.ps2``." #: ../Doc/tutorial/appendix.rst:85 msgid "" "If you want to read an additional start-up file from the current directory, " "you can program this in the global start-up file using code like ``if os." "path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. If you " "want to use the startup file in a script, you must do this explicitly in the " "script::" msgstr "" "Si vous voulez exécuter d'autres fichiers dans le dossier courant, vous " "pouvez le programmer dans le fichier global, par exemple: ``if os.\"\"path." "isfile('.pythonrc.py'): exec(open('.pythonrc.py').read())``. Et si vous " "voulez exécuter le fichier depuis un script, vous devez le faire " "explicitement." #: ../Doc/tutorial/appendix.rst:102 msgid "The Customization Modules" msgstr "Les modules de Personnalisation" #: ../Doc/tutorial/appendix.rst:104 msgid "" "Python provides two hooks to let you customize it: :mod:`sitecustomize` and :" "mod:`usercustomize`. To see how it works, you need first to find the " "location of your user site-packages directory. Start Python and run this " "code::" msgstr "" "Python peut être personnalisé via les modules :mod:`sitecustomize` et :mod:" "`usercustomize`. Pour découvrir comment ils fonctionnent vous devez d'abord " "les trouver, ils sont dans un dossier appelé user site-packages. Démarrez " "Python et exécutez : code::" #: ../Doc/tutorial/appendix.rst:112 msgid "" "Now you can create a file named :file:`usercustomize.py` in that directory " "and put anything you want in it. It will affect every invocation of Python, " "unless it is started with the :option:`-s` option to disable the automatic " "import." msgstr "" "Vous pouvez maintenant y créer un fichier :file:`usercustomize.py` \" et y " "écrire ce que vous voulez. Il sera toujours pris en compte par Python peut " "importe le mode, sauf si il est démarré avec l'option :option:`-s`, qui " "désactive l'import automatique." #: ../Doc/tutorial/appendix.rst:116 msgid "" ":mod:`sitecustomize` works in the same way, but is typically created by an " "administrator of the computer in the global site-packages directory, and is " "imported before :mod:`usercustomize`. See the documentation of the :mod:" "`site` module for more details." msgstr "" ":mod:`sitecustomize` fonctionne de la même manière, mais plus typiquement " "créé par un administrateur et stocké dans le dossier site-packages global. " "Il est importé avant :mod:`usercustomize`. Pour plus de détails, consultez " "la documentation de :mod:`site`." #: ../Doc/tutorial/appendix.rst:123 ../Doc/tutorial/classes.rst:952 #: ../Doc/tutorial/controlflow.rst:759 ../Doc/tutorial/datastructures.rst:707 #: ../Doc/tutorial/interpreter.rst:162 ../Doc/tutorial/introduction.rst:529 #: ../Doc/tutorial/modules.rst:550 msgid "Footnotes" msgstr "Notes" #: ../Doc/tutorial/appendix.rst:124 msgid "A problem with the GNU Readline package may prevent this." msgstr "Un problème avec GNU Readline peut l'en empêcher." #: ../Doc/tutorial/appetite.rst:5 msgid "Whetting Your Appetite" msgstr "Mise en bouche" #: ../Doc/tutorial/appetite.rst:7 msgid "" "If you do much work on computers, eventually you find that there's some task " "you'd like to automate. For example, you may wish to perform a search-and-" "replace over a large number of text files, or rename and rearrange a bunch " "of photo files in a complicated way. Perhaps you'd like to write a small " "custom database, or a specialized GUI application, or a simple game." msgstr "" "Si vous faites beaucoup de travail sur ordinateur, vous finirez par vouloir " "automatiser certaines tâches. Par exemple vous pouvez avoir besoin " "d'effectuer une recherche et un remplacement sur un grand nombre de fichiers " "de texte, ou de renommer et réorganiser des photos d'une manière " "sophistiquée. Peut-être avez-vous besoin de créer une petite base de données " "ou une application graphique, ou un simple jeu." #: ../Doc/tutorial/appetite.rst:13 msgid "" "If you're a professional software developer, you may have to work with " "several C/C++/Java libraries but find the usual write/compile/test/re-" "compile cycle is too slow. Perhaps you're writing a test suite for such a " "library and find writing the testing code a tedious task. Or maybe you've " "written a program that could use an extension language, and you don't want " "to design and implement a whole new language for your application." msgstr "" "Si vous êtes un développeur professionnel, vous pouvez avoir besoin de " "travailler avec certaines bibliothèques C/C++/Java, mais vous trouvez que le " "cycle habituel écriture/compilation/test/recompilation est trop lourd. Peut-" "être écrivez-vous une suite de tests pour une telle bibliothèque et trouvez-" "vous que l'écriture du code de test est pénible. Ou bien vous avez écrit un " "logiciel qui a besoin d'être extensible grâce à un langage de script, mais " "vous ne voulez pas concevoir ni implémenter un nouveau langage pour votre " "application." #: ../Doc/tutorial/appetite.rst:20 msgid "Python is just the language for you." msgstr "Python est le langage parfait pour vous." #: ../Doc/tutorial/appetite.rst:22 msgid "" "You could write a Unix shell script or Windows batch files for some of these " "tasks, but shell scripts are best at moving around files and changing text " "data, not well-suited for GUI applications or games. You could write a C/C++/" "Java program, but it can take a lot of development time to get even a first-" "draft program. Python is simpler to use, available on Windows, Mac OS X, " "and Unix operating systems, and will help you get the job done more quickly." msgstr "" "Vous pouvez écrire un script shell Unix ou des fichiers batch Windows pour " "certaines de ces tâches. Les scripts shell sont appropriés pour déplacer des " "fichiers et modifier des données textuelles, mais pas pour une application " "ayant une interface graphique ni pour des jeux. Vous pouvez écrire un " "programme en C/C++/Java, mais cela peut prendre beaucoup de temps, ne serait-" "ce que pour avoir une première maquette. Python est plus facile à utiliser, " "il est disponible sous Windows, Mac OS X et Unix, et il vous aidera à " "terminer plus rapidement votre travail." #: ../Doc/tutorial/appetite.rst:29 msgid "" "Python is simple to use, but it is a real programming language, offering " "much more structure and support for large programs than shell scripts or " "batch files can offer. On the other hand, Python also offers much more " "error checking than C, and, being a *very-high-level language*, it has high-" "level data types built in, such as flexible arrays and dictionaries. " "Because of its more general data types Python is applicable to a much larger " "problem domain than Awk or even Perl, yet many things are at least as easy " "in Python as in those languages." msgstr "" "Python est facile à utiliser, mais c'est un vrai langage de programmation, " "offrant une bien meilleure structure et prise en charge des grands " "programmes que les scripts shell ou les fichiers batch. D'un autre coté, " "Python offre beaucoup plus de méthodes de vérification d'erreurs que le " "langage C et, étant un *langage de très haut niveau*, il possède nativement " "des types de données très évolués tels que des tableaux flexibles ou des " "dictionnaires. Grâce à ses types de données plus universels, Python est " "utilisable pour des domaines beaucoup plus variés que Awk ou même Perl. " "Pourtant, de nombreuses choses sont au moins aussi faciles en Python que " "dans ces langages." #: ../Doc/tutorial/appetite.rst:37 msgid "" "Python allows you to split your program into modules that can be reused in " "other Python programs. It comes with a large collection of standard modules " "that you can use as the basis of your programs --- or as examples to start " "learning to program in Python. Some of these modules provide things like " "file I/O, system calls, sockets, and even interfaces to graphical user " "interface toolkits like Tk." msgstr "" "Python vous permet de découper votre programme en modules qui peuvent être " "réutilisés dans d'autres programmes en Python. Il est fourni avec une vaste " "collection de modules standards que vous pouvez utiliser comme base de vos " "programmes, ou comme exemples pour apprendre à programmer. Certains de ces " "modules fournissent des services tels que les entrées/sorties, les appels " "système, les sockets, et même des accès aux outils comme Tk pour créer des " "interfaces graphiques." #: ../Doc/tutorial/appetite.rst:44 msgid "" "Python is an interpreted language, which can save you considerable time " "during program development because no compilation and linking is necessary. " "The interpreter can be used interactively, which makes it easy to experiment " "with features of the language, to write throw-away programs, or to test " "functions during bottom-up program development. It is also a handy desk " "calculator." msgstr "" "Python est un langage interprété, ce qui peut vous faire gagner un temps " "considérable pendant le développement du programme car aucune compilation ni " "édition de liens n'est nécessaire. L'interpréteur peut être utilisé de " "manière interactive, pour vous permettre d'expérimenter avec les " "fonctionnalités du langage, d'écrire des programmes jetables ou de tester " "des fonctions lors d'un développement incrémental. Il constitue aussi une " "calculatrice de bureau pratique." #: ../Doc/tutorial/appetite.rst:50 msgid "" "Python enables programs to be written compactly and readably. Programs " "written in Python are typically much shorter than equivalent C, C++, or " "Java programs, for several reasons:" msgstr "" "Python permet d'écrire des programmes compacts et lisibles. Les programmes " "écrits en Python sont généralement beaucoup plus court que l'équivalent en " "C, C++, ou Java, pour plusieurs raisons :" #: ../Doc/tutorial/appetite.rst:54 msgid "" "the high-level data types allow you to express complex operations in a " "single statement;" msgstr "" "les types de données de haut niveau vous permettent d'exprimer des " "opérations complexes en une seule instruction ;" #: ../Doc/tutorial/appetite.rst:57 msgid "" "statement grouping is done by indentation instead of beginning and ending " "brackets;" msgstr "" "les instructions sont regroupées entre elles grâce à l'indentation, plutôt " "que par l'utilisation d'accolades ;" #: ../Doc/tutorial/appetite.rst:60 msgid "no variable or argument declarations are necessary." msgstr "aucune déclaration de variable ou d'argument n'est nécessaire." #: ../Doc/tutorial/appetite.rst:62 msgid "" "Python is *extensible*: if you know how to program in C it is easy to add a " "new built-in function or module to the interpreter, either to perform " "critical operations at maximum speed, or to link Python programs to " "libraries that may only be available in binary form (such as a vendor-" "specific graphics library). Once you are really hooked, you can link the " "Python interpreter into an application written in C and use it as an " "extension or command language for that application." msgstr "" "Python est *extensible* : si vous savez écrire un programme en C, il est " "aisé d'ajouter à l'interpréteur une nouvelle fonction primitive ou un " "module, soit pour effectuer des opérations critiques à vitesse maximale, " "soit pour lier des programmes en Python à des bibliothèques disponibles " "uniquement sous forme binaire (par exemple des bibliothèques graphiques " "dédiées à un matériel). Une fois que vous êtes à l'aise avec ces principes, " "vous pouvez relier l'interpréteur Python à une application écrite en C et " "l'utiliser comme un langage d'extensions ou de commandes pour cette " "application." #: ../Doc/tutorial/appetite.rst:70 msgid "" "By the way, the language is named after the BBC show \"Monty Python's Flying " "Circus\" and has nothing to do with reptiles. Making references to Monty " "Python skits in documentation is not only allowed, it is encouraged!" msgstr "" "À ce sujet, le nom du langage provient de l'émission de la BBC « Monty " "Python's Flying Circus » et n'a rien à voir avec les reptiles. Faire " "référence aux sketchs des Monty Python dans de la documentation n'est pas " "seulement permis, c'est encouragé !" #: ../Doc/tutorial/appetite.rst:74 msgid "" "Now that you are all excited about Python, you'll want to examine it in some " "more detail. Since the best way to learn a language is to use it, the " "tutorial invites you to play with the Python interpreter as you read." msgstr "" "Votre soudain enthousiasme à propos de Python va vous pousser à l'examiner " "un peu plus en détail. Comme la meilleure façon d'apprendre un langage est " "de l'utiliser, le tutoriel vous invite à jouer avec l'interpréteur pendant " "la lecture." #: ../Doc/tutorial/appetite.rst:78 msgid "" "In the next chapter, the mechanics of using the interpreter are explained. " "This is rather mundane information, but essential for trying out the " "examples shown later." msgstr "" "Dans le prochain chapitre, nous allons expliquer comment utiliser " "l'interpréteur. Ce n'est pas la section la plus passionnante, mais c'est un " "passage obligé pour tester les exemples montrés plus loin." #: ../Doc/tutorial/appetite.rst:82 msgid "" "The rest of the tutorial introduces various features of the Python language " "and system through examples, beginning with simple expressions, statements " "and data types, through functions and modules, and finally touching upon " "advanced concepts like exceptions and user-defined classes." msgstr "" "Le reste du tutoriel présente diverses fonctionnalités du langage et du " "système Python au travers d'exemples, depuis les simples expressions, " "instructions ou types de données, jusqu'aux fonctions et modules, pour " "finalement aborder des concepts avancés comme les exceptions et les classes." #: ../Doc/tutorial/classes.rst:5 msgid "Classes" msgstr "Classes" #: ../Doc/tutorial/classes.rst:7 msgid "" "Compared with other programming languages, Python's class mechanism adds " "classes with a minimum of new syntax and semantics. It is a mixture of the " "class mechanisms found in C++ and Modula-3. Python classes provide all the " "standard features of Object Oriented Programming: the class inheritance " "mechanism allows multiple base classes, a derived class can override any " "methods of its base class or classes, and a method can call the method of a " "base class with the same name. Objects can contain arbitrary amounts and " "kinds of data. As is true for modules, classes partake of the dynamic " "nature of Python: they are created at runtime, and can be modified further " "after creation." msgstr "" "Le mécanisme des classes Python ajoute au langage la notion de classes avec " "un minimum de syntaxe et de sémantique nouvelles. C'est un mélange des " "mécanismes rencontrés dans C++ et Modula-3. De la même manière que pour les " "modules, les classes Python ne posent pas de barrière rigide entre leur " "définition et l'utilisateur, mais s'appuient sur le respect de l'utilisateur " "à ne pas causer d'effraction dans la définition. Cependant, les " "fonctionnalités les plus importantes des classes sont conservées avec toutes " "leur puissance : le mécanisme d'héritage autorise d'avoir plusieurs classes " "de base, une classe dérivée peut surcharger toutes les méthodes de sa (ou " "ses) classe(s) de base et une méthode peut faire appel à la méthode d'une " "classe de base portant le même nom. Les objets peuvent contenir un nombre " "arbitraire de données." #: ../Doc/tutorial/classes.rst:17 msgid "" "In C++ terminology, normally class members (including the data members) are " "*public* (except see below :ref:`tut-private`), and all member functions are " "*virtual*. As in Modula-3, there are no shorthands for referencing the " "object's members from its methods: the method function is declared with an " "explicit first argument representing the object, which is provided " "implicitly by the call. As in Smalltalk, classes themselves are objects. " "This provides semantics for importing and renaming. Unlike C++ and " "Modula-3, built-in types can be used as base classes for extension by the " "user. Also, like in C++, most built-in operators with special syntax " "(arithmetic operators, subscripting etc.) can be redefined for class " "instances." msgstr "" "Dans la terminologie C++, les membres des classes (y compris les données) " "sont *publics* (sauf exception, voir :ref:`tut-private`) et toutes les " "fonctions membres sont *virtuelles*. Comme avec Modulo-3, il n'y a aucune " "façon d'accéder aux membres d'un objet à partir de ses méthodes : une " "méthode est déclarée avec un premier argument explicite représentant " "l'objet, et cet argument est transmis de manière implicite lors de l'appel. " "Comme avec Smalltalk, les classes elles-mêmes sont des objets. Il existe " "ainsi une sémantique pour les importer et les renommer. Au contraire de C++ " "et Modulo-3, les types de base peuvent être utilisés comme classes de base " "pour que l'utilisateur puisse les étendre. Enfin, comme en C++, la plupart " "des opérateurs de base avec une syntaxe spéciale (opérateurs arithmétiques, " "sous-indiçage, etc.) peuvent être redéfinis pour les instances de classes." #: ../Doc/tutorial/classes.rst:28 msgid "" "(Lacking universally accepted terminology to talk about classes, I will make " "occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, " "since its object-oriented semantics are closer to those of Python than C++, " "but I expect that few readers have heard of it.)" msgstr "" "(Par manque d'une terminologie universellement acceptée pour parler des " "classes, nous ferons un usage occasionnel des termes de Smalltalk et C++. " "Nous voulions utiliser les termes de Modula-3 puisque sa sémantique orientée " "objet est plus proche de celle de Python que de C++, mais il est probable " "que seul un petit nombre de lecteurs soit susceptibles de les connaître.)" #: ../Doc/tutorial/classes.rst:37 msgid "A Word About Names and Objects" msgstr "Quelques mots au sujet des noms et objets" #: ../Doc/tutorial/classes.rst:39 msgid "" "Objects have individuality, and multiple names (in multiple scopes) can be " "bound to the same object. This is known as aliasing in other languages. " "This is usually not appreciated on a first glance at Python, and can be " "safely ignored when dealing with immutable basic types (numbers, strings, " "tuples). However, aliasing has a possibly surprising effect on the " "semantics of Python code involving mutable objects such as lists, " "dictionaries, and most other types. This is usually used to the benefit of " "the program, since aliases behave like pointers in some respects. For " "example, passing an object is cheap since only a pointer is passed by the " "implementation; and if a function modifies an object passed as an argument, " "the caller will see the change --- this eliminates the need for two " "different argument passing mechanisms as in Pascal." msgstr "" "Les objets possèdent une existence propre et plusieurs noms peuvent être " "utilisés (dans divers contextes) pour faire référence au même objet. Ceux-ci " "sont connus sous le nom d'alias dans d'autres langages. Ceci est " "habituellement peu apprécié lors d'un premier coup d'œil à Python et peut " "être ignoré lorsqu'on travaille avec des types de base non mutables " "(nombres, chaînes, tuples). Cependant, les alias ont éventuellement des " "effets surprenants sur la sémantique d'un code Python mettant en jeu des " "objets mutables comme les listes, les dictionnaires et la plupart des autres " "types. C'est généralement utilisé au bénéfice du programme car les alias se " "comportent, d'un certain point de vue, comme des pointeurs. Par exemple, " "transmettre un objet n'a aucun coût car c'est simplement un pointeur qui est " "transmis par l'implémentation ; et si une fonction modifie un objet passé en " "argument, le code à l'origine de l'appel verra le changement. Ceci élimine " "le besoin d'avoir deux mécanismes de transmission d'arguments comme en " "Pascal." #: ../Doc/tutorial/classes.rst:55 msgid "Python Scopes and Namespaces" msgstr "Portées et espaces de noms en Python" #: ../Doc/tutorial/classes.rst:57 msgid "" "Before introducing classes, I first have to tell you something about " "Python's scope rules. Class definitions play some neat tricks with " "namespaces, and you need to know how scopes and namespaces work to fully " "understand what's going on. Incidentally, knowledge about this subject is " "useful for any advanced Python programmer." msgstr "" "Avant de présenter les classes, nous devons parler un peu de la notion de " "portée en Python. Les définitions de classes font d'habiles manipulations " "avec les espaces de noms, et vous devez savoir comment les portées et les " "espaces de noms fonctionnent. Soit dit en passant, toute connaissance sur ce " "sujet est aussi utile aux développeurs Python expérimentés." #: ../Doc/tutorial/classes.rst:63 msgid "Let's begin with some definitions." msgstr "Tout d'abord, quelques définitions." #: ../Doc/tutorial/classes.rst:65 msgid "" "A *namespace* is a mapping from names to objects. Most namespaces are " "currently implemented as Python dictionaries, but that's normally not " "noticeable in any way (except for performance), and it may change in the " "future. Examples of namespaces are: the set of built-in names (containing " "functions such as :func:`abs`, and built-in exception names); the global " "names in a module; and the local names in a function invocation. In a sense " "the set of attributes of an object also form a namespace. The important " "thing to know about namespaces is that there is absolutely no relation " "between names in different namespaces; for instance, two different modules " "may both define a function ``maximize`` without confusion --- users of the " "modules must prefix it with the module name." msgstr "" "Un *espace de nom* est une table de correspondance entre des noms et des " "objets. La plupart des espaces de noms sont actuellement implémentés sous " "forme de dictionnaires Python, mais ceci n'est normalement pas visible (sauf " "pour les performances) et peut changer dans le futur. Comme exemples " "d'espaces de noms, nous pouvons citer les primitives (fonctions comme :func:" "`abs`, et les noms des exceptions de base) ; les noms globaux dans un " "module ; et les noms locaux lors d'un appel de fonction. D'une certaine " "manière, l'ensemble des attributs d'un objet forme lui-même un espace de " "noms. La chose importante à retenir à propos des espaces de noms est qu'il " "n'y a absolument aucun lien entre les noms de plusieurs espaces de noms ; " "par exemple, deux modules différents peuvent définir une fonction " "``maximize`` sans qu'il y ait de confusion. Les utilisateurs des modules " "doivent préfixer le nom de la fonction avec celui du module." #: ../Doc/tutorial/classes.rst:76 msgid "" "By the way, I use the word *attribute* for any name following a dot --- for " "example, in the expression ``z.real``, ``real`` is an attribute of the " "object ``z``. Strictly speaking, references to names in modules are " "attribute references: in the expression ``modname.funcname``, ``modname`` is " "a module object and ``funcname`` is an attribute of it. In this case there " "happens to be a straightforward mapping between the module's attributes and " "the global names defined in the module: they share the same namespace! [#]_" msgstr "" "À ce propos, nous utilisons le mot *attribut* pour tout nom suivant un " "point. Par exemple, dans l'expression ``z.real``, ``real`` est un attribut " "de l'objet ``z``. Rigoureusement parlant, les références à des noms dans des " "modules sont des références d'attributs : dans l'expression ``modname." "funcname``, ``modname`` est un objet module et ``funcname`` est un attribut " "de cet objet. Dans ces conditions, il existe une correspondance directe " "entre les attributs du module et les noms globaux définis dans le module : " "ils partagent le même espace de noms ! [#]_" #: ../Doc/tutorial/classes.rst:84 msgid "" "Attributes may be read-only or writable. In the latter case, assignment to " "attributes is possible. Module attributes are writable: you can write " "``modname.the_answer = 42``. Writable attributes may also be deleted with " "the :keyword:`del` statement. For example, ``del modname.the_answer`` will " "remove the attribute :attr:`the_answer` from the object named by ``modname``." msgstr "" "Les attributs peuvent être seulement lisibles ou aussi modifiables. S'ils " "sont modifiables, l'affectation à un attribut est possible. Les attributs de " "modules sont modifiables : vous pouvez écrire ``modname.the_answer = 42``. " "Les attributs modifiables peuvent aussi être effacés avec l'instruction :" "keyword:`del`. Par exemple, ``del modname.the_answer`` supprime l'attribut :" "attr:`the_answer` de l'objet nommé ``modname``." #: ../Doc/tutorial/classes.rst:90 msgid "" "Namespaces are created at different moments and have different lifetimes. " "The namespace containing the built-in names is created when the Python " "interpreter starts up, and is never deleted. The global namespace for a " "module is created when the module definition is read in; normally, module " "namespaces also last until the interpreter quits. The statements executed " "by the top-level invocation of the interpreter, either read from a script " "file or interactively, are considered part of a module called :mod:" "`__main__`, so they have their own global namespace. (The built-in names " "actually also live in a module; this is called :mod:`builtins`.)" msgstr "" "Les espaces de noms sont créés à différents moments et ont différentes " "durées de vie. L'espace de noms contenant les primitives est créé au " "démarrage de l'interpréteur Python et n'est jamais effacé. L'espace de nom " "global pour un module est créé lorsque la définition du module est lue. " "Habituellement, les espaces de noms des modules durent aussi jusqu'à l'arrêt " "de l'interpréteur. Les instructions exécutées par la première invocation de " "l'interpréteur, qu'ils soient lus depuis un fichier de script ou de manière " "interactive, sont considérés comme faisant partie d'un module appelé :mod:" "`__main__`, de façon qu'elles possèdent leur propre espace de noms. (les " "primitives vivent elles-mêmes dans un module, appelé :mod:`builtins`.)" #: ../Doc/tutorial/classes.rst:100 msgid "" "The local namespace for a function is created when the function is called, " "and deleted when the function returns or raises an exception that is not " "handled within the function. (Actually, forgetting would be a better way to " "describe what actually happens.) Of course, recursive invocations each have " "their own local namespace." msgstr "" "L'espace de noms local d'une fonction est créé lors de son appel, puis " "effacé lorsqu'elle renvoie un résultat ou lève une exception non prise en " "charge. (En fait, « oublié » serait une meilleure façon de décrire ce qui se " "passe réellement). Bien sûr, des invocations récursives ont chacune leur " "propre espace de noms." #: ../Doc/tutorial/classes.rst:106 msgid "" "A *scope* is a textual region of a Python program where a namespace is " "directly accessible. \"Directly accessible\" here means that an unqualified " "reference to a name attempts to find the name in the namespace." msgstr "" "Une *portée* est une zone textuelle d'un programme Python où un espace de " "noms est directement accessible. « Directement accessible » signifie ici " "qu'une référence non qualifée à un nom sera recherchée dans l'espace de noms." #: ../Doc/tutorial/classes.rst:110 msgid "" "Although scopes are determined statically, they are used dynamically. At any " "time during execution, there are at least three nested scopes whose " "namespaces are directly accessible:" msgstr "" "Bien que les portées soient déterminées de manière statique, elles sont " "utilisées de manière dynamique. À n'importe quel moment de l'exécution, il y " "a au minimum trois portées imbriquées dont les espaces de noms sont " "directement accessibles :" #: ../Doc/tutorial/classes.rst:114 msgid "the innermost scope, which is searched first, contains the local names" msgstr "" "La portée la plus au centre, celle qui est consultée en premier, contient " "les noms locaux" #: ../Doc/tutorial/classes.rst:115 msgid "" "the scopes of any enclosing functions, which are searched starting with the " "nearest enclosing scope, contains non-local, but also non-global names" msgstr "" "les portées des fonctions englobantes, qui sont consultées en commençant " "avec la portée englobante la plus proche, contiennent des noms non-locaux " "mais aussi non-globaux" #: ../Doc/tutorial/classes.rst:117 msgid "the next-to-last scope contains the current module's global names" msgstr "l'avant dernière portée contient les noms globaux du module courant" #: ../Doc/tutorial/classes.rst:118 msgid "" "the outermost scope (searched last) is the namespace containing built-in " "names" msgstr "" "la portée englobante, consultée en dernier, est l'espace de noms contenant " "les primitives" #: ../Doc/tutorial/classes.rst:120 msgid "" "If a name is declared global, then all references and assignments go " "directly to the middle scope containing the module's global names. To " "rebind variables found outside of the innermost scope, the :keyword:" "`nonlocal` statement can be used; if not declared nonlocal, those variables " "are read-only (an attempt to write to such a variable will simply create a " "*new* local variable in the innermost scope, leaving the identically named " "outer variable unchanged)." msgstr "" "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 locale, 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 dans la portée la plus locale, en laissant inchangée la variable du " "même nom dans sa portée d'origine)." #: ../Doc/tutorial/classes.rst:127 msgid "" "Usually, the local scope references the local names of the (textually) " "current function. Outside functions, the local scope references the same " "namespace as the global scope: the module's namespace. Class definitions " "place yet another namespace in the local scope." msgstr "" "Habituellement, la portée locale référence les noms locaux de la fonction " "courante. En dehors des fonctions, la portée locale référence le même espace " "de noms que la portée globale : l'espace de noms du module. Les définitions " "de classes créent un nouvel espace de noms dans la portée locale." #: ../Doc/tutorial/classes.rst:132 msgid "" "It is important to realize that scopes are determined textually: the global " "scope of a function defined in a module is that module's namespace, no " "matter from where or by what alias the function is called. On the other " "hand, the actual search for names is done dynamically, at run time --- " "however, the language definition is evolving towards static name resolution, " "at \"compile\" time, so don't rely on dynamic name resolution! (In fact, " "local variables are already determined statically.)" msgstr "" "Il est important de réaliser que les portées sont déterminées de manière " "textuelle : la portée globale d'une fonction définie dans un module est " "l'espace de nom de ce module, quel que soit la provenance de cet appel. Par " "contre, la recherche réelle des noms est faite dynamiquement au moment de " "l'exécution. Cependant la définition du langage est en train d'évoluer vers " "une résolution statique des noms au moment de la « compilation », donc sans " "se baser sur une résolution dynamique ! (En réalité, les variables locales " "sont déjà déterminées de manière statique)." #: ../Doc/tutorial/classes.rst:140 msgid "" "A special quirk of Python is that -- if no :keyword:`global` statement is in " "effect -- assignments to names always go into the innermost scope. " "Assignments do not copy data --- they just bind names to objects. The same " "is true for deletions: the statement ``del x`` removes the binding of ``x`` " "from the namespace referenced by the local scope. In fact, all operations " "that introduce new names use the local scope: in particular, :keyword:" "`import` statements and function definitions bind the module or function " "name in the local scope." msgstr "" "Une particularité de Python est que si aucune instruction :keyword:`global` " "n'est active, les affectations de noms vont toujours dans la portée la plus " "proche. Les affectations ne copient aucune donnée : elles se contentent de " "lier des noms à des objets. Ceci est également vrai pour l'effacement : " "l'instruction ``del x`` supprime la liaison de ``x`` dans l'espace de noms " "référencé par la portée locale. En réalité, toutes les opérations qui " "impliquent des nouveaux noms utilisent la portée locale : en particulier, " "les instructions :keyword:`import` et les définitions de fonctions " "effectuent une liaison du module ou du nom de fonction dans la portée locale." #: ../Doc/tutorial/classes.rst:148 msgid "" "The :keyword:`global` statement can be used to indicate that particular " "variables live in the global scope and should be rebound there; the :keyword:" "`nonlocal` statement indicates that particular variables live in an " "enclosing scope and should be rebound there." msgstr "" "L'instruction :keyword:`global` peut être utilisée pour indiquer que " "certaines variables existent dans la portée globale et doivent être reliées " "en local ; l'instruction :keyword:`nonlocal` indique que certaines variables " "existent dans une portée supérieure et doivent être reliées en local." #: ../Doc/tutorial/classes.rst:156 msgid "Scopes and Namespaces Example" msgstr "Exemple de portées et d'espaces de noms" #: ../Doc/tutorial/classes.rst:158 msgid "" "This is an example demonstrating how to reference the different scopes and " "namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect " "variable binding::" msgstr "" "Ceci est un exemple montrant comment utiliser les différentes portées et " "espaces de noms, et comment :keyword:`global` et :keyword:`nonlocal` " "modifient l'affectation de variable : ::" #: ../Doc/tutorial/classes.rst:185 msgid "The output of the example code is:" msgstr "Ce code donne le résultat suivant :" #: ../Doc/tutorial/classes.rst:194 msgid "" "Note how the *local* assignment (which is default) didn't change *scope_test*" "\\'s binding of *spam*. The :keyword:`nonlocal` assignment changed " "*scope_test*\\'s binding of *spam*, and the :keyword:`global` assignment " "changed the module-level binding." msgstr "" "Vous pouvez constater que l'affectation *locale* (qui est effectuée par " "défaut) n'a pas modifié la liaison de *spam* dans *scope_test*. " "L'affectation :keyword:`nonlocal` a changé la liaison de *spam* dans " "*scope_test* et l'affectation :keyword:`global` a changé la liaison au " "niveau du module." #: ../Doc/tutorial/classes.rst:199 msgid "" "You can also see that there was no previous binding for *spam* before the :" "keyword:`global` assignment." msgstr "" "Vous pouvez également voir qu'aucune liaison pour *spam* n'a été faite avant " "l'affectation :keyword:`global`." #: ../Doc/tutorial/classes.rst:206 msgid "A First Look at Classes" msgstr "Une première approche des classes" #: ../Doc/tutorial/classes.rst:208 msgid "" "Classes introduce a little bit of new syntax, three new object types, and " "some new semantics." msgstr "" "Le concept de classes introduit quelques nouveau éléments de syntaxe, trois " "nouveaux types d'objets ainsi que de nouveaux éléments de sémantique" #: ../Doc/tutorial/classes.rst:215 msgid "Class Definition Syntax" msgstr "Syntaxe de définition des classes" #: ../Doc/tutorial/classes.rst:217 msgid "The simplest form of class definition looks like this::" msgstr "La forme la plus simple de définition de classe ressemble à ceci : ::" #: ../Doc/tutorial/classes.rst:226 msgid "" "Class definitions, like function definitions (:keyword:`def` statements) " "must be executed before they have any effect. (You could conceivably place " "a class definition in a branch of an :keyword:`if` statement, or inside a " "function.)" msgstr "" "Les définitions de classes, comme les définitions de fonctions (définitions :" "keyword:`def`) doivent être exécutées avant d'avoir un effet. (Vous pouvez " "tout à fait placer une définition de classe dans une branche d'une " "instruction conditionnelle :keyword:`if` ou encore à l'intérieur d'une " "fonction.)" #: ../Doc/tutorial/classes.rst:230 msgid "" "In practice, the statements inside a class definition will usually be " "function definitions, but other statements are allowed, and sometimes useful " "--- we'll come back to this later. The function definitions inside a class " "normally have a peculiar form of argument list, dictated by the calling " "conventions for methods --- again, this is explained later." msgstr "" "Dans la pratique, les déclarations dans une définition de classe seront " "généralement des définitions de fonctions, mais d'autres déclarations sont " "permises, et parfois utiles --- Nous reviendrons sur ce point plus tard. Les " "définitions de fonction à l'intérieur d'une classe ont normalement une forme " "particulière de liste d'arguments, dictée par les conventions d'appel aux " "méthodes --- À nouveau, tout ceci sera expliqué plus tard." #: ../Doc/tutorial/classes.rst:236 msgid "" "When a class definition is entered, a new namespace is created, and used as " "the local scope --- thus, all assignments to local variables go into this " "new namespace. In particular, function definitions bind the name of the new " "function here." msgstr "" "Quand une classe est définie, un nouvel espace de noms est créé et utilisé " "comme portée locale --- Ainsi, toutes les affectations de variables locales " "entrent dans ce nouvel espace de noms. En particulier, les définitions de " "fonctions y lient le nom de la nouvelle fonction." #: ../Doc/tutorial/classes.rst:241 msgid "" "When a class definition is left normally (via the end), a *class object* is " "created. This is basically a wrapper around the contents of the namespace " "created by the class definition; we'll learn more about class objects in the " "next section. The original local scope (the one in effect just before the " "class definition was entered) is reinstated, and the class object is bound " "here to the class name given in the class definition header (:class:" "`ClassName` in the example)." msgstr "" "A la fin de la définition d'une classe, un *objet classe* est créé. C'est, " "pour simplifier, une encapsulation du contenu de l'espace de noms créé par " "la définition de classe. Nous reparlerons des objets classes dans la " "prochaine section. La portée locale initiale (celle qui prévaut avant le " "début de la définition de la classe) est réinstanciée, et l'objet de classe " "est lié ici au nom de classe donné dans l'en-tête de définition de classe (:" "class:`NomDeLaClasse` dans l'exemple)." #: ../Doc/tutorial/classes.rst:253 msgid "Class Objects" msgstr "Les objets classe" #: ../Doc/tutorial/classes.rst:255 msgid "" "Class objects support two kinds of operations: attribute references and " "instantiation." msgstr "" "Les objets classes prennent en charge deux types d'opérations : des " "références à des attributs et l'instanciation." #: ../Doc/tutorial/classes.rst:258 msgid "" "*Attribute references* use the standard syntax used for all attribute " "references in Python: ``obj.name``. Valid attribute names are all the names " "that were in the class's namespace when the class object was created. So, " "if the class definition looked like this::" msgstr "" "Les *références d'attributs* utilisent la syntaxe standard utilisée pour " "toutes les références d'attributs en Python : ``obj.nom``. Les noms " "d'attribut valides sont tous les noms qui se trouvaient dans l'espace de " "noms de la classe quand l'objet classe a été créé. Donc, si la définition de " "classe ressemble à ceci : ::" #: ../Doc/tutorial/classes.rst:270 msgid "" "then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, " "returning an integer and a function object, respectively. Class attributes " "can also be assigned to, so you can change the value of ``MyClass.i`` by " "assignment. :attr:`__doc__` is also a valid attribute, returning the " "docstring belonging to the class: ``\"A simple example class\"``." msgstr "" "alors ``MaClasse.i`` et ``MaClasse.f`` sont des références valides à des " "attributs, renvoyant respectivement un entier et un objet fonction. Les " "attributs de classes peuvent également être affectés, de sorte que vous " "pouvez modifier la valeur de ``MaClasse.i`` par affectation. :attr:`__doc__` " "est aussi un attribut valide, renvoyant la docstring appartenant à la " "classe : ``\"Une simple classe d'exemple\"``." #: ../Doc/tutorial/classes.rst:276 msgid "" "Class *instantiation* uses function notation. Just pretend that the class " "object is a parameterless function that returns a new instance of the class. " "For example (assuming the above class)::" msgstr "" "L'*instanciation* de classes utilise la notation des fonctions. Considérez " "simplement que l'objet classe est une fonction sans paramètre qui renvoie " "une nouvelle instance de la classe. Par exemple (en considérant la classe " "définie ci-dessus) ::" #: ../Doc/tutorial/classes.rst:282 msgid "" "creates a new *instance* of the class and assigns this object to the local " "variable ``x``." msgstr "" "crée une nouvelle *instance* de la classe et affecte cet objet à la variable " "locale ``x``." #: ../Doc/tutorial/classes.rst:285 msgid "" "The instantiation operation (\"calling\" a class object) creates an empty " "object. Many classes like to create objects with instances customized to a " "specific initial state. Therefore a class may define a special method named :" "meth:`__init__`, like this::" msgstr "" "L'opération d'instanciation (en \"appelant\" un objet classe) crée un objet " "vide. De nombreuses classes aiment créer des objets personnalisés avec des " "instances personnalisées en fonction d'un état initial spécifique. Ainsi une " "classe peut définir une méthode spéciale nommée: :meth:`__init__`, comme " "ceci : ::" #: ../Doc/tutorial/classes.rst:293 msgid "" "When a class defines an :meth:`__init__` method, class instantiation " "automatically invokes :meth:`__init__` for the newly-created class " "instance. So in this example, a new, initialized instance can be obtained " "by::" msgstr "" "Quand une classe définit une méthode :meth:`__init__`, l'instanciation de la " "classe appelle automatiquement :meth:`__init__` pour la nouvelle instance de " "la classe. Donc, dans cet exemple, l'initialisation d'une nouvelle instance " "peut être obtenue par : ::" #: ../Doc/tutorial/classes.rst:299 msgid "" "Of course, the :meth:`__init__` method may have arguments for greater " "flexibility. In that case, arguments given to the class instantiation " "operator are passed on to :meth:`__init__`. For example, ::" msgstr "" "Bien sûr, la méthode :meth:`__init__` peut avoir des arguments pour une plus " "grande flexibilité. Dans ce cas, les arguments donnés à l'opérateur " "d'instanciation de classe sont transmis à :meth:`__init__`. Par exemple, ::" #: ../Doc/tutorial/classes.rst:316 msgid "Instance Objects" msgstr "Objets instance" #: ../Doc/tutorial/classes.rst:318 msgid "" "Now what can we do with instance objects? The only operations understood by " "instance objects are attribute references. There are two kinds of valid " "attribute names, data attributes and methods." msgstr "" "Maintenant, que pouvons-nous faire avec des objets instance ? Les seules " "opérations comprises par les objets instances sont des références " "d'attributs. Il y a deux sortes de noms d'attributs valides, les attributs " "données et les méthodes." #: ../Doc/tutorial/classes.rst:322 msgid "" "*data attributes* correspond to \"instance variables\" in Smalltalk, and to " "\"data members\" in C++. Data attributes need not be declared; like local " "variables, they spring into existence when they are first assigned to. For " "example, if ``x`` is the instance of :class:`MyClass` created above, the " "following piece of code will print the value ``16``, without leaving a " "trace::" msgstr "" "Les *attributs données* correspondent à des \"variables d'instance\" en " "Smalltalk, et aux \"membres de données\" en C++. Les attributs données n'ont " "pas à être déclarés. Comme les variables locales, ils existent dès lors " "qu'ils sont attribués une première fois. Par exemple, si ``x`` est " "l'instance de :class:`MyClass` créée ci-dessus, le code suivant affiche la " "valeur ``16``, sans laisser de traces : ::" #: ../Doc/tutorial/classes.rst:334 msgid "" "The other kind of instance attribute reference is a *method*. A method is a " "function that \"belongs to\" an object. (In Python, the term method is not " "unique to class instances: other object types can have methods as well. For " "example, list objects have methods called append, insert, remove, sort, and " "so on. However, in the following discussion, we'll use the term method " "exclusively to mean methods of class instance objects, unless explicitly " "stated otherwise.)" msgstr "" "L'autre type de référence à un attribut d'instance est une *méthode*. Une " "méthode est une fonction qui \"appartient à\" un objet (en Python, le terme " "de méthode n'est pas unique aux instances de classes : d'autres types " "d'objets peuvent aussi avoir des méthodes. Par exemple, les objets listes " "ont des méthodes appelées append, insert, remove, sort, et ainsi de suite. " "Toutefois, dans la discussion qui suit, sauf indication contraire, nous " "allons utiliser le terme de méthode exclusivement en référence à des " "méthodes d'objets instances de classe)." #: ../Doc/tutorial/classes.rst:343 msgid "" "Valid method names of an instance object depend on its class. By " "definition, all attributes of a class that are function objects define " "corresponding methods of its instances. So in our example, ``x.f`` is a " "valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is " "not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as " "``MyClass.f`` --- it is a *method object*, not a function object." msgstr "" "Les noms de méthodes valides d'un objet instance dépendent de sa classe. Par " "définition, tous les attributs d'une classe qui sont des objets fonction " "définissent les méthodes correspondantes de ses instances. Donc, dans notre " "exemple, ``x.f`` est une méthode de référence valide, car ``MaClasse.f`` est " "une fonction, mais pas ``x.i`` car ``MaClasse.i`` n'en est pas une. " "Attention cependant, ``x.f`` n'est pas la même chose que ``MaClasse.f`` --- " "Il s'agit d'un *objet méthode*, pas d'un objet fonction." #: ../Doc/tutorial/classes.rst:354 msgid "Method Objects" msgstr "Les objets méthode" #: ../Doc/tutorial/classes.rst:356 msgid "Usually, a method is called right after it is bound::" msgstr "Le plus souvent, une méthode est appelée juste après avoir été liée::" #: ../Doc/tutorial/classes.rst:360 msgid "" "In the :class:`MyClass` example, this will return the string ``'hello " "world'``. However, it is not necessary to call a method right away: ``x.f`` " "is a method object, and can be stored away and called at a later time. For " "example::" msgstr "" "Dans l'exemple de la class :class:`MaClass`, cela va retourner la chaîne de " "caractères ``hello world``. Toutefois, il n'est pas nécessaire d'appeler la " "méthode directement: ``x.f`` est un objet méthode, il peut être gardé de " "coté et être appelé plus tard. Par exemple::" #: ../Doc/tutorial/classes.rst:368 msgid "will continue to print ``hello world`` until the end of time." msgstr "va afficher ``hello world`` jusqu'à la fin des temps." #: ../Doc/tutorial/classes.rst:370 msgid "" "What exactly happens when a method is called? You may have noticed that ``x." "f()`` was called without an argument above, even though the function " "definition for :meth:`f` specified an argument. What happened to the " "argument? Surely Python raises an exception when a function that requires an " "argument is called without any --- even if the argument isn't actually " "used..." msgstr "" "Que ce passe-t-il exactement quand une méthode est appelée ? Vous avez dû " "remarquer que ``x.f()`` a été appelée dans le code ci-dessus sans argument, " "alors que la définition de la méthode :meth:`f` spécifie bien qu'elle prend " "un argument. Qu'est-il arrivé à l'argument ? Python doit sûrement lever une " "exception lorsqu'une fonction qui requiert un argument est appelée sans -- " "même si l'argument n'est pas utilisé..." #: ../Doc/tutorial/classes.rst:376 msgid "" "Actually, you may have guessed the answer: the special thing about methods " "is that the object is passed as the first argument of the function. In our " "example, the call ``x.f()`` is exactly equivalent to ``MyClass.f(x)``. In " "general, calling a method with a list of *n* arguments is equivalent to " "calling the corresponding function with an argument list that is created by " "inserting the method's object before the first argument." msgstr "" "En fait, vous aurez peut-être deviné la réponse : la particularité des " "méthodes est que l'objet est passé comme premier argument de la fonction. " "Dans notre exemple, l'appel ``x.f ()`` est exactement équivalent à " "``MaClasse.f(x)``. En général, appeler une méthode avec une liste " "d'arguments *n* est équivalent à appeler la fonction correspondante avec " "cette liste d'arguments modulo l'insertion de l'objet de la méthode avant le " "premier argument." #: ../Doc/tutorial/classes.rst:383 msgid "" "If you still don't understand how methods work, a look at the implementation " "can perhaps clarify matters. When an instance attribute is referenced that " "isn't a data attribute, its class is searched. If the name denotes a valid " "class attribute that is a function object, a method object is created by " "packing (pointers to) the instance object and the function object just found " "together in an abstract object: this is the method object. When the method " "object is called with an argument list, a new argument list is constructed " "from the instance object and the argument list, and the function object is " "called with this new argument list." msgstr "" "Si vous ne comprenez toujours pas comment les méthodes fonctionnent, un coup " "d'œil à l'implémentation vous aidera peut être. Lorsque l'instance d'un " "attribut est référencé qui n'est pas un attribut donnée, sa classe est " "recherchée. Si le nom correspond à un attribut valide qui est une fonction, " "un objet méthode est créé en associant (via leurs pointeurs) l'objet " "instance et l'objet fonction trouvé ensemble dans un nouvel objet abstrait : " "c'est l'objet méthode. Lorsque l'objet méthode est appelé avec une liste " "d'arguments, une nouvelle liste d'arguments est construite à partir de " "l'objet méthode et de la liste des arguments. L'objet fonction est appelé " "avec cette nouvelle liste d'arguments." #: ../Doc/tutorial/classes.rst:397 msgid "Class and Instance Variables" msgstr "Classes et variables d'instance" #: ../Doc/tutorial/classes.rst:399 msgid "" "Generally speaking, instance variables are for data unique to each instance " "and class variables are for attributes and methods shared by all instances " "of the class::" msgstr "" "En général, les variables d'instance stockent des informations relatives à " "chaque instance alors que les variables de classe servent à stocker les " "attributs et méthodes communes à toutes les instances de la classe::" #: ../Doc/tutorial/classes.rst:421 msgid "" "As discussed in :ref:`tut-object`, shared data can have possibly surprising " "effects with involving :term:`mutable` objects such as lists and " "dictionaries. For example, the *tricks* list in the following code should " "not be used as a class variable because just a single list would be shared " "by all *Dog* instances::" msgstr "" "Comme vu dans :ref:`tut-object`, les données partagées :term:`modifiables " "` (tel que les listes, dictionnaires, etc...) peuvent avoir des " "effets surprenants. Part exemple, la liste *tricks* dans le code suivant ne " "devrait pas être une variable de classe, car jiate une seule liste serait " "partagées par toutes les instances de *Dog*::" #: ../Doc/tutorial/classes.rst:444 msgid "Correct design of the class should use an instance variable instead::" msgstr "" "Une conception correcte de la classe serait d'utiliser une variable " "d'instance à la place : :" #: ../Doc/tutorial/classes.rst:468 msgid "Random Remarks" msgstr "Remarques diverses" #: ../Doc/tutorial/classes.rst:472 msgid "" "Data attributes override method attributes with the same name; to avoid " "accidental name conflicts, which may cause hard-to-find bugs in large " "programs, it is wise to use some kind of convention that minimizes the " "chance of conflicts. Possible conventions include capitalizing method " "names, prefixing data attribute names with a small unique string (perhaps " "just an underscore), or using verbs for methods and nouns for data " "attributes." msgstr "" "Les attributs de données surchargent les méthodes avec le même nom ; pour " "éviter des conflits de nommage, qui peuvent causer des bugs difficiles à " "trouver dans de grands programmes, il est sage d'adopter certaines " "conventions qui minimisent les risques de conflits. Les conventions " "possibles comprennent la mise en majuscule des noms de méthodes, le préfixe " "des noms d'attributs de données par une chaîne courte et unique (parfois " "juste la caractère souligné), ou l'utilisation de verbes pour les méthodes " "et de noms pour les attributs de données." #: ../Doc/tutorial/classes.rst:479 msgid "" "Data attributes may be referenced by methods as well as by ordinary users " "(\"clients\") of an object. In other words, classes are not usable to " "implement pure abstract data types. In fact, nothing in Python makes it " "possible to enforce data hiding --- it is all based upon convention. (On " "the other hand, the Python implementation, written in C, can completely hide " "implementation details and control access to an object if necessary; this " "can be used by extensions to Python written in C.)" msgstr "" "Les attributs de données peuvent être référencés par des méthodes comme par " "des utilisateurs ordinaires (\"clients\") d'un objet. En d'autres termes, " "les classes ne sont pas utilisables pour implémenter des types de données " "purement abstraits. En fait, rien en Python ne rend possible d'imposer de " "masquer des données --- tout est basé sur des conventions (d'un autre coté, " "l'implémentation Python, écrite en C, peut complètement masquer les détails " "d'implémentation et contrôler l'accès à un objet si nécessaire ; ceci peut " "être utilisé par des extensions de Python écrites en C)." #: ../Doc/tutorial/classes.rst:487 msgid "" "Clients should use data attributes with care --- clients may mess up " "invariants maintained by the methods by stamping on their data attributes. " "Note that clients may add data attributes of their own to an instance object " "without affecting the validity of the methods, as long as name conflicts are " "avoided --- again, a naming convention can save a lot of headaches here." msgstr "" "Les clients doivent utiliser les attributs de données avec précaution --- " "ils pourraient mettre le désordre dans les invariants gérés par les méthodes " "avec leurs propres valeurs d'attributs. Remarquez que les clients peuvent " "ajouter leurs propres attributs de données à une instance d'objet sans " "altérer la validité des méthodes, pour autant que les noms n'entrent pas en " "conflit --- aussi, adopter une convention de nommage peut éviter bien des " "problèmes." #: ../Doc/tutorial/classes.rst:493 msgid "" "There is no shorthand for referencing data attributes (or other methods!) " "from within methods. I find that this actually increases the readability of " "methods: there is no chance of confusing local variables and instance " "variables when glancing through a method." msgstr "" "Il n'y a pas de notation abrégée pour référencer des attributs de données " "(ou d'autres méthodes !) depuis les méthodes. Nous pensons que ceci améliore " "en fait la lisibilité des méthodes : il n'y a aucune chance de confondre " "variables locales et variables d'instances quand on regarde le code d'une " "méthode." #: ../Doc/tutorial/classes.rst:498 msgid "" "Often, the first argument of a method is called ``self``. This is nothing " "more than a convention: the name ``self`` has absolutely no special meaning " "to Python. Note, however, that by not following the convention your code " "may be less readable to other Python programmers, and it is also conceivable " "that a *class browser* program might be written that relies upon such a " "convention." msgstr "" "Souvent, le premier argument d'une méthode est nommé ``self``. Ce n'est " "qu'une convention : le nom ``self`` n'a aucune signification particulière en " "Python. Notez cependant que si vous ne suivez pas cette convention, votre " "code risque d'être moins lisible pour d'autres programmeurs Python, et il " "est aussi possible qu'un programme qui fasse l'introspection de classes " "repose sur une telle convention." #: ../Doc/tutorial/classes.rst:504 msgid "" "Any function object that is a class attribute defines a method for instances " "of that class. It is not necessary that the function definition is " "textually enclosed in the class definition: assigning a function object to a " "local variable in the class is also ok. For example::" msgstr "" "Tout objet fonction qui est un attribut de classe définit une méthode pour " "des instances de cette classe. Il n'est pas nécessaire que le texte de " "définition de la fonction soit dans la définition de la classe : il est " "possible d'affecter un objet fonction à une variable locale de la classe. " "Par exemple : ::" #: ../Doc/tutorial/classes.rst:521 msgid "" "Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer " "to function objects, and consequently they are all methods of instances of :" "class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this " "practice usually only serves to confuse the reader of a program." msgstr "" "Maintenant, ``f``, ``g`` et ``h`` sont tous des attributs des classes :class:" "`C` faisant référence aux fonctions objets, et par conséquent sont toutes " "des méthodes des instances de :class:`C` --- ``h`` est exactement identique " "à ``g``. Remarquez qu'en pratique, ceci ne sert qu'à embrouiller le lecteur " "d'un programme." #: ../Doc/tutorial/classes.rst:526 msgid "" "Methods may call other methods by using method attributes of the ``self`` " "argument::" msgstr "" "Les méthodes peuvent appeler d'autres méthodes en utilisant des méthodes qui " "sont des attributs de l'argument ``self`` ::" #: ../Doc/tutorial/classes.rst:540 msgid "" "Methods may reference global names in the same way as ordinary functions. " "The global scope associated with a method is the module containing its " "definition. (A class is never used as a global scope.) While one rarely " "encounters a good reason for using global data in a method, there are many " "legitimate uses of the global scope: for one thing, functions and modules " "imported into the global scope can be used by methods, as well as functions " "and classes defined in it. Usually, the class containing the method is " "itself defined in this global scope, and in the next section we'll find some " "good reasons why a method would want to reference its own class." msgstr "" "Les méthodes peuvent faire référence à des noms globaux de la même manière " "que les fonctions. La portée globale associée à une méthode est le module " "contenant la définition de la classe (la classe elle même n'est jamais " "utilisée en tant que portée globale). Alors qu'on rencontre rarement une " "bonne raison d'utiliser des données globales dans une méthode, il y a de " "nombreuses utilisations légitimes d'une portée globale : par exemple, les " "fonctions et modules importés dans une portée globale peuvent être utilisés " "par des méthodes, de même que les fonctions et classes définies dans cette " "même portée. Habituellement, la classe contenant la méthode est elle même " "définie dans cette portée globale, et dans la section suivante, nous verrons " "de bonnes raisons pour qu'une méthode référence sa propre classe." #: ../Doc/tutorial/classes.rst:550 msgid "" "Each value is an object, and therefore has a *class* (also called its " "*type*). It is stored as ``object.__class__``." msgstr "" "Toute valeur est un objet, et a donc une *classe* (appelé aussi son *type*). " "Elle est stockée dans ``objet.__class__``." #: ../Doc/tutorial/classes.rst:557 msgid "Inheritance" msgstr "L'héritage" #: ../Doc/tutorial/classes.rst:559 msgid "" "Of course, a language feature would not be worthy of the name \"class\" " "without supporting inheritance. The syntax for a derived class definition " "looks like this::" msgstr "" "Bien sûr, ce terme de «classe» ne serait pas utilisé s'il n'y avait pas " "l'héritage. La syntaxe pour définir une sous-classe ressemble à ceci : ::" #: ../Doc/tutorial/classes.rst:570 msgid "" "The name :class:`BaseClassName` must be defined in a scope containing the " "derived class definition. In place of a base class name, other arbitrary " "expressions are also allowed. This can be useful, for example, when the " "base class is defined in another module::" msgstr "" "Le nom :class:`ClasseDeBase` doit être défini dans un espace contenant la " "définition de la classe dérivée. A la place du nom d'une classe de base, une " "expression est aussi autorisée. Ceci peut être utile, par exemple, lorsque " "la classe est définie dans un autre module : ::" #: ../Doc/tutorial/classes.rst:577 msgid "" "Execution of a derived class definition proceeds the same as for a base " "class. When the class object is constructed, the base class is remembered. " "This is used for resolving attribute references: if a requested attribute is " "not found in the class, the search proceeds to look in the base class. This " "rule is applied recursively if the base class itself is derived from some " "other class." msgstr "" "L'exécution d'une définition de classe dérivée se déroule comme pour une " "classe de base. Quand l'objet de la classe est construit, la classe de base " "est mémorisée. Elle est utilisée pour la résolution des références " "d'attributs : si un attribut n'est pas trouvé dans la classe, la recherche " "procède en regardant dans la classe de base. Cette règle est appliquée " "récursivement si la classe de base est elle-même dérivée d'une autre classe." #: ../Doc/tutorial/classes.rst:583 msgid "" "There's nothing special about instantiation of derived classes: " "``DerivedClassName()`` creates a new instance of the class. Method " "references are resolved as follows: the corresponding class attribute is " "searched, descending down the chain of base classes if necessary, and the " "method reference is valid if this yields a function object." msgstr "" "Il n'y a rien de particulier dans l'instantiation des classes dérivées : " "``DerivedClassName()`` crée une nouvelle instance de la classe. Les " "références aux méthodes sont résolues comme suit : l'attribut correspondant " "de la classe est recherché, en remontant la hiérarchie des classes de base " "si nécessaire, et la référence de méthode est valide si cela conduit à une " "fonction." #: ../Doc/tutorial/classes.rst:589 msgid "" "Derived classes may override methods of their base classes. Because methods " "have no special privileges when calling other methods of the same object, a " "method of a base class that calls another method defined in the same base " "class may end up calling a method of a derived class that overrides it. " "(For C++ programmers: all methods in Python are effectively ``virtual``.)" msgstr "" "Les classes dérivées peuvent surcharger des méthodes de leurs classes de " "base. Comme les méthodes n'ont aucun privilège particulier quand elles " "appellent d'autres méthodes d'un même objet, une méthode d'une classe de " "base qui appelle une autre méthode définie dans la même classe peut en fait " "appeler une méthode d'une classe dérivée qui la surcharge (pour les " "programmeurs C++ : toutes les méthodes de Python sont en effet ``virtual``)." #: ../Doc/tutorial/classes.rst:595 msgid "" "An overriding method in a derived class may in fact want to extend rather " "than simply replace the base class method of the same name. There is a " "simple way to call the base class method directly: just call ``BaseClassName." "methodname(self, arguments)``. This is occasionally useful to clients as " "well. (Note that this only works if the base class is accessible as " "``BaseClassName`` in the global scope.)" msgstr "" "Une méthode surchargée dans une classe dérivée peut en fait vouloir étendre " "plutôt que simplement remplacer la méthode du même nom de sa classe de base. " "Il y a une façon simple d'appeler la méthode de la classe de base " "directement : appelez simplement ``BaseClassName.methodname(self, " "arguments)``. Ceci est parfois utile également aux clients (notez bien que " "ceci ne fonctionne que si la classe de base est accessible en tant que " "``ClasseDeBase`` dans la portée globale)." #: ../Doc/tutorial/classes.rst:602 msgid "Python has two built-in functions that work with inheritance:" msgstr "Python a deux fonctions primitives qui gèrent l'héritage :" #: ../Doc/tutorial/classes.rst:604 msgid "" "Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` " "will be ``True`` only if ``obj.__class__`` is :class:`int` or some class " "derived from :class:`int`." msgstr "" "Utilisez :func:`isinstance` pour tester le type d'une instance : " "``isinstance(obj, int)`` renverra ``True`` seulement si ``obj.__class__`` " "est égal à :class:`int` ou à une autre classe dérivée de :class:`int`." #: ../Doc/tutorial/classes.rst:608 msgid "" "Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` " "is ``True`` since :class:`bool` is a subclass of :class:`int`. However, " "``issubclass(float, int)`` is ``False`` since :class:`float` is not a " "subclass of :class:`int`." msgstr "" "Utilisez :func:`issubclass` pour tester l'héritage d'une class : " "``issubclass(bool, int)`` renvoie ``True`` car la class :class:`bool` est " "une sous-classe de :class:`int`. Par contre, ``issubclass(float, int)`` " "renvoie ``False`` car :class:`float` n'est pas une sous-classe de :class:" "`int`." #: ../Doc/tutorial/classes.rst:618 msgid "Multiple Inheritance" msgstr "L'héritage multiple" #: ../Doc/tutorial/classes.rst:620 msgid "" "Python supports a form of multiple inheritance as well. A class definition " "with multiple base classes looks like this::" msgstr "" "Python gère également une forme d'héritage multiple. Une définition de " "classe ayant plusieurs classes de base ressemble à : ::" #: ../Doc/tutorial/classes.rst:630 msgid "" "For most purposes, in the simplest cases, you can think of the search for " "attributes inherited from a parent class as depth-first, left-to-right, not " "searching twice in the same class where there is an overlap in the " "hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, " "it is searched for in :class:`Base1`, then (recursively) in the base classes " "of :class:`Base1`, and if it was not found there, it was searched for in :" "class:`Base2`, and so on." msgstr "" "Dans la plupart des cas, vous pouvez imaginer la recherche d'attributs dans " "les classes parentes comme étant : le plus profond d'abord, de gauche à " "droite, sans chercher deux fois dans la même classe si elle apparaît " "plusieurs fois dans la hiérarchie. Ainsi, si un attribut n'est pas trouvé " "dans :class:`DerivedClassName`, il est recherché dans :class:`Base1`, puis " "(récursivement) dans les classes de base de :class:`Base1` ; s'il n'y est " "pas trouvé, il est recherché dans :class:`Base2` et ses classes de base, et " "ainsi de suite." #: ../Doc/tutorial/classes.rst:637 msgid "" "In fact, it is slightly more complex than that; the method resolution order " "changes dynamically to support cooperative calls to :func:`super`. This " "approach is known in some other multiple-inheritance languages as call-next-" "method and is more powerful than the super call found in single-inheritance " "languages." msgstr "" "Dans les faits, c'est un peu plus complexe que ça, l'ordre de la recherche " "(method resolution order, ou MRO) change dynamiquement pour gérer des appels " "coopératifs à :func:`super`. Cette approche est connue sous le nom de la " "\"méthode la plus proche\" (\"call-next-method\") dans d'autres langages " "supportant l'héritage multiple, et est plus puissante que l'appel à super " "trouve dans les langages à héritage simple." #: ../Doc/tutorial/classes.rst:643 msgid "" "Dynamic ordering is necessary because all cases of multiple inheritance " "exhibit one or more diamond relationships (where at least one of the parent " "classes can be accessed through multiple paths from the bottommost class). " "For example, all classes inherit from :class:`object`, so any case of " "multiple inheritance provides more than one path to reach :class:`object`. " "To keep the base classes from being accessed more than once, the dynamic " "algorithm linearizes the search order in a way that preserves the left-to-" "right ordering specified in each class, that calls each parent only once, " "and that is monotonic (meaning that a class can be subclassed without " "affecting the precedence order of its parents). Taken together, these " "properties make it possible to design reliable and extensible classes with " "multiple inheritance. For more detail, see https://www.python.org/download/" "releases/2.3/mro/." msgstr "" "L'ordre défini dynamiquement est nécessaire car tous les cas d'héritage " "multiple comportent une ou plusieurs relations en losange (où au moins une " "classe peut être accédée à partir de plusieurs chemins en pariant de la " "classe la plus base). Par exemple, puisque toutes les classes héritent de :" "class:`object`, tout héritage multiple ouvre plusieurs chemins pour " "atteindre :class:`object`. Pour qu'une classe de base ne soit pas appelée " "plusieurs fois, l'algorithme dynamique linéarise l'ordre de recherche d'une " "façon qui préserve l'ordre d'héritage, de lagauche vers la droite, spécifié " "dans chaque classe, qui appelle chaque classe parente une seule fois, qui " "est monotone (ce qui signifie qu'une classe peut être sous-classée sans " "affecter l'ordre d'héritage de ses parents). Prises ensemble, ces propriétés " "permettent de concevoir des classes de façon fiable et extensible dans un " "contexte d'héritage multiple. Pour plus de détail, consultez http://www." "python.org/download/releases/2.3/mro/." #: ../Doc/tutorial/classes.rst:660 msgid "Private Variables" msgstr "Variables privées" #: ../Doc/tutorial/classes.rst:662 msgid "" "\"Private\" instance variables that cannot be accessed except from inside an " "object don't exist in Python. However, there is a convention that is " "followed by most Python code: a name prefixed with an underscore (e.g. " "``_spam``) should be treated as a non-public part of the API (whether it is " "a function, a method or a data member). It should be considered an " "implementation detail and subject to change without notice." msgstr "" "Les membres \"privés\", qui ne peuvent être accédés en dehors d'un objet, " "n'existent pas en Python. Toutefois, il existe une convention respectée par " "la majorité du code Python : un nom préfixé par un tiret bas (comme " "``_spam``) doit être vu comme une partie non publique de l'API (qu'il " "s'agisse d'une fonction, d'une méthode ou d'une variable membre). Il doit " "être considéré comme un détail d'implémentation pouvant faire l'objet de " "modification futures sans préavis." #: ../Doc/tutorial/classes.rst:669 msgid "" "Since there is a valid use-case for class-private members (namely to avoid " "name clashes of names with names defined by subclasses), there is limited " "support for such a mechanism, called :dfn:`name mangling`. Any identifier " "of the form ``__spam`` (at least two leading underscores, at most one " "trailing underscore) is textually replaced with ``_classname__spam``, where " "``classname`` is the current class name with leading underscore(s) " "stripped. This mangling is done without regard to the syntactic position of " "the identifier, as long as it occurs within the definition of a class." msgstr "" "Dès lors qu'il y a un cas d'utilisation valable pour avoir des membres " "privés (notamment pour éviter des conflits avec des noms définis dans des " "sous-classes), il existe un support (certes limité) pour un tel mécanisme, " "appelé :dfn:`name mangling`. Tout identifiant sous la forme ``__spam`` (avec " "au moins deux underscores en tête, et au plus un à la fin) est remplacé " "textuellement par ``_classname__spam``, où ``classname`` est le nom de la " "classe sans le(s) premier(s) underscore(s). Ce \"bricolage\" est effectué " "sans tenir compte de la position syntaxique de l'identifiant, tant qu'il est " "présent dans la définition d'une classe." #: ../Doc/tutorial/classes.rst:678 msgid "" "Name mangling is helpful for letting subclasses override methods without " "breaking intraclass method calls. For example::" msgstr "" "Ce changement de nom est utile pour permettre à des sous-classes de " "surcharger des méthodes sans interrompre les appels de méthodes intra-" "classes. Par exemple : ::" #: ../Doc/tutorial/classes.rst:700 msgid "" "Note that the mangling rules are designed mostly to avoid accidents; it " "still is possible to access or modify a variable that is considered " "private. This can even be useful in special circumstances, such as in the " "debugger." msgstr "" "Notez que ces règles sont conçues avant tout pour éviter les accidents ; il " "reste possible d'accéder ou de modifier une variable considérée comme " "privée. Ceci peut même être utile dans certaines circonstances, comme au " "sein du débogueur." #: ../Doc/tutorial/classes.rst:704 msgid "" "Notice that code passed to ``exec()`` or ``eval()`` does not consider the " "classname of the invoking class to be the current class; this is similar to " "the effect of the ``global`` statement, the effect of which is likewise " "restricted to code that is byte-compiled together. The same restriction " "applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when " "referencing ``__dict__`` directly." msgstr "" "Notez que le code passé à ``exec()``, ``eval()`` ne considère pas le nom de " "la classe appelante comme étant la classe courante ; le même effet " "s'applique à la directive ``global``, dont l'effet est de la même façon " "restreint au code compilé dans le même ensemble de byte-code. Les mêmes " "restrictions s'appliquent à ``getattr()``, ``setattr()`` et ``delattr()``, " "ainsi qu'aux références directes à ``__dict__``." #: ../Doc/tutorial/classes.rst:715 msgid "Odds and Ends" msgstr "Trucs et astuces" #: ../Doc/tutorial/classes.rst:717 msgid "" "Sometimes it is useful to have a data type similar to the Pascal \"record\" " "or C \"struct\", bundling together a few named data items. An empty class " "definition will do nicely::" msgstr "" "Il est parfois utile d'avoir un type de donnée similaire au \"record\" du " "Pascal ou au \"struct\" du C, qui regroupent ensemble quelques attributs " "nommés. La définition d'une classe vide remplit parfaitement ce besoin : ::" #: ../Doc/tutorial/classes.rst:731 msgid "" "A piece of Python code that expects a particular abstract data type can " "often be passed a class that emulates the methods of that data type " "instead. For instance, if you have a function that formats some data from a " "file object, you can define a class with methods :meth:`read` and :meth:`!" "readline` that get the data from a string buffer instead, and pass it as an " "argument." msgstr "" "On peut souvent fournir, à du code Python qui s'attend à recevoir un type de " "donnée abstrait spécifique, une classe qui simule les méthodes de ce type. " "Par exemple, si vous avez une fonction qui formate des données extraites " "d'un objet fichier, vous pouvez définir une classe avec des méthodes :meth:" "`read` et :meth:`!readline` qui extrait ses données d'un tampon de chaînes " "de caractères à la place, et lui passer une instance comme argument." #: ../Doc/tutorial/classes.rst:742 msgid "" "Instance method objects have attributes, too: ``m.__self__`` is the instance " "object with the method :meth:`m`, and ``m.__func__`` is the function object " "corresponding to the method." msgstr "" "Les objets méthodes d'instances ont également des attributs : ``m.im_self`` " "est l'instance d'objet avec la méthode :meth:`m`, et ``m.im_func`` est " "l'objet fonction correspondant à la méthode." #: ../Doc/tutorial/classes.rst:750 msgid "Exceptions Are Classes Too" msgstr "Les exceptions sont aussi des classes" #: ../Doc/tutorial/classes.rst:752 msgid "" "User-defined exceptions are identified by classes as well. Using this " "mechanism it is possible to create extensible hierarchies of exceptions." msgstr "" "Les exceptions définies par l'utilisateur sont également définies par des " "classes. En utilisant ce mécanisme, il est possible de créer des hiérarchies " "d'exceptions extensibles." #: ../Doc/tutorial/classes.rst:755 msgid "" "There are two new valid (semantic) forms for the :keyword:`raise` statement::" msgstr "" "Il y a deux nouvelles formes (sémantiques) pour l'instruction :keyword:" "`raise` ::" #: ../Doc/tutorial/classes.rst:761 msgid "" "In the first form, ``Class`` must be an instance of :class:`type` or of a " "class derived from it. The first form is a shorthand for::" msgstr "" "Dans la première forme, ``Class`` doit être une instance de :class:`type` ou " "d'une classe dérivée. La seconde forme est un raccourci pour : ::" #: ../Doc/tutorial/classes.rst:766 msgid "" "A class in an :keyword:`except` clause is compatible with an exception if it " "is the same class or a base class thereof (but not the other way around --- " "an except clause listing a derived class is not compatible with a base " "class). For example, the following code will print B, C, D in that order::" msgstr "" "Une classe dans une clause :keyword:`except` est compatible avec une " "exception si elle est de la même classe ou d'une de ses classes dérivées " "(mais l'inverse n'est pas vrai --- une clause except spécifiant une classe " "dérivée n'est pas compatible avec une classe de base.) Par exemple, le code " "suivant imprimera B, C et D dans cet ordre : ::" #: ../Doc/tutorial/classes.rst:788 msgid "" "Note that if the except clauses were reversed (with ``except B`` first), it " "would have printed B, B, B --- the first matching except clause is triggered." msgstr "" "Notez que si les clauses except avaient été inversées (avec ``except B`` en " "premier), il aurait imprimé B, B, B --- la première clause except " "correspondante étant déclenchée." #: ../Doc/tutorial/classes.rst:791 msgid "" "When an error message is printed for an unhandled exception, the exception's " "class name is printed, then a colon and a space, and finally the instance " "converted to a string using the built-in function :func:`str`." msgstr "" "Quand un message d'erreur est imprimé pour une exception non traitée, la " "classe de l'exception est indiquée, suivie de deux points, d'un espace et de " "l'instance convertie en chaîne de caractères via la fonction :func:`str`." #: ../Doc/tutorial/classes.rst:799 msgid "Iterators" msgstr "Itérateurs" #: ../Doc/tutorial/classes.rst:801 msgid "" "By now you have probably noticed that most container objects can be looped " "over using a :keyword:`for` statement::" msgstr "" "Vous avez maintenant certainement remarqué que l'on peut itérer sur la " "plupart des objets conteneurs en utilisant une instruction :keyword:`for` ::" #: ../Doc/tutorial/classes.rst:815 msgid "" "This style of access is clear, concise, and convenient. The use of " "iterators pervades and unifies Python. Behind the scenes, the :keyword:" "`for` statement calls :func:`iter` on the container object. The function " "returns an iterator object that defines the method :meth:`~iterator." "__next__` which accesses elements in the container one at a time. When " "there are no more elements, :meth:`~iterator.__next__` raises a :exc:" "`StopIteration` exception which tells the :keyword:`for` loop to terminate. " "You can call the :meth:`~iterator.__next__` method using the :func:`next` " "built-in function; this example shows how it all works::" msgstr "" "Ce mode d'accès est simple, concis et pratique. L'utilisation d'itérateurs " "imprègne et unifie Python. En arrière plan, l'instruction :keyword:`for` " "appelle la fonction :func:`iter` sur l'objet conteneur. Cette fonction " "renvoie un itérateur qui définit la méthode :meth:`~iterator.__next__`, " "laquelle accèdeaux éléments du conteneur un par un. Lorsqu'il n'y a plus " "d'élément, :meth:`~iterator.__next__` lève une exception :exc:" "`StopIteration` qui indique à la boucle de l'instruction :keyword:`for` de " "se terminer. Vous pouvez appeller la méthode :meth:`~iterator.__next__` en " "utilisant la fonction native :func:`next`. Cet exemple montre comment tout " "cela fonctionne::" #: ../Doc/tutorial/classes.rst:840 msgid "" "Having seen the mechanics behind the iterator protocol, it is easy to add " "iterator behavior to your classes. Define an :meth:`__iter__` method which " "returns an object with a :meth:`~iterator.__next__` method. If the class " "defines :meth:`__next__`, then :meth:`__iter__` can just return ``self``::" msgstr "" "Une fois compris les mécanismes de gestion des itérateurs, il est simple " "d'ajouter ce comportement à vos classes. Définissez une méthode :meth:" "`__iter__`, qui retourne un objet disposant d'une méthode :meth:`~iterator." "__next__`. Sila classe définit elle-même la méthode :meth:`__next__`, alors :" "meth:`__iter__` peut simplement renvoyer ``self`` ::" #: ../Doc/tutorial/classes.rst:877 msgid "Generators" msgstr "Générateurs" #: ../Doc/tutorial/classes.rst:879 msgid "" ":term:`Generator`\\s are a simple and powerful tool for creating iterators. " "They are written like regular functions but use the :keyword:`yield` " "statement whenever they want to return data. Each time :func:`next` is " "called on it, the generator resumes where it left off (it remembers all the " "data values and which statement was last executed). An example shows that " "generators can be trivially easy to create::" msgstr "" "Les :term:`générateur`\\s sont des outils simples et puissants pour créer " "des itérateurs. Ils sont écrits comme des fonctions classiques mais " "utilisent l'instruction :keyword:`yield` lorsqu'ils veulent renvoyer des " "données. À chaque fois que :func:`next` est appelée, le générateur reprend " "son exécution là où il s'était arrété (en conservant tout son contexte " "d'exécution). Un exemple montre très bien combien les générateurs sont " "simples à créer : ::" #: ../Doc/tutorial/classes.rst:900 msgid "" "Anything that can be done with generators can also be done with class-based " "iterators as described in the previous section. What makes generators so " "compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods " "are created automatically." msgstr "" "Tout ce qui peut être fait avec des générateurs peut également être fait " "avec des itérateurs basés sur des classes, comme décrit dans le paragraphe " "précédent. Si qui fait que les générateurs sont si compacts est que les " "méthodes :meth:`__iter__` et :meth:`~generator.__next__` sont créées " "automatiquement." #: ../Doc/tutorial/classes.rst:905 msgid "" "Another key feature is that the local variables and execution state are " "automatically saved between calls. This made the function easier to write " "and much more clear than an approach using instance variables like ``self." "index`` and ``self.data``." msgstr "" "Une autre fonctionnalité clé est que les variables locales ainsi que le " "contexte d'exécution sont sauvegardés automatiquement entre les appels. Cela " "simplifie d'autant plus l'écriture de ces fonctions, et rend leur code " "beaucoup plus lisible qu'avec une approche utilisant des variables " "d'instance telles que ``self.index`` et ``self.data``." #: ../Doc/tutorial/classes.rst:910 msgid "" "In addition to automatic method creation and saving program state, when " "generators terminate, they automatically raise :exc:`StopIteration`. In " "combination, these features make it easy to create iterators with no more " "effort than writing a regular function." msgstr "" "En plus de la création automatique de méthodes et de la sauvegarde du " "contexte d'exécution, les générateurs lèvent automatiquement une exception :" "exc:`StopIteration` lorsqu'ils terminent leur exécution. Combinées, ces " "fonctionnalités rendent très simple la création d'itérateurs sans plus " "d'effort que l'écriture d'une fonction classique." #: ../Doc/tutorial/classes.rst:919 msgid "Generator Expressions" msgstr "Expressions et générateurs" #: ../Doc/tutorial/classes.rst:921 msgid "" "Some simple generators can be coded succinctly as expressions using a syntax " "similar to list comprehensions but with parentheses instead of brackets. " "These expressions are designed for situations where the generator is used " "right away by an enclosing function. Generator expressions are more compact " "but less versatile than full generator definitions and tend to be more " "memory friendly than equivalent list comprehensions." msgstr "" "Des générateurs simples peuvent être codés très rapidement avec des " "expressions utilisant la même syntaxe que les compréhensions de listes, mais " "en utilisant des parenthèses à la place des crochets. Ces expressions sont " "conçues pour des situations où le générateur est utilisé tout de suite dans " "une fonction. Ces expressions sont plus compactes mais moins souples que des " "définitions complètes de générateurs, et ont tendance à être plus économes " "en mémoire que leur équivalent en compréhension de listes." #: ../Doc/tutorial/classes.rst:928 msgid "Examples::" msgstr "Exemples : ::" #: ../Doc/tutorial/classes.rst:953 msgid "" "Except for one thing. Module objects have a secret read-only attribute " "called :attr:`~object.__dict__` which returns the dictionary used to " "implement the module's namespace; the name :attr:`~object.__dict__` is an " "attribute but not a global name. Obviously, using this violates the " "abstraction of namespace implementation, and should be restricted to things " "like post-mortem debuggers." msgstr "" "Sauf pour une chose. Les modules disposent d'un attribut secret en lecture " "seule appelé :attr:`~object.__dict__`, qui renvoie le dictionnaire utilisé " "pour implémenter l'espace de noms du module ; le nom :attr:`~object." "__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." #: ../Doc/tutorial/controlflow.rst:5 msgid "More Control Flow Tools" msgstr "D'autres outils de contrôle de flux" #: ../Doc/tutorial/controlflow.rst:7 msgid "" "Besides the :keyword:`while` statement just introduced, Python knows the " "usual control flow statements known from other languages, with some twists." msgstr "" "En plus de l'instruction :keyword:`while` qui vient d'être présentée, Python " "dispose des instructions de contrôle de flux classiques que l'on trouve dans " "d'autres langages, mais toujours avec ses propres tournures." #: ../Doc/tutorial/controlflow.rst:14 msgid ":keyword:`if` Statements" msgstr "L'instruction :keyword:`if`" #: ../Doc/tutorial/controlflow.rst:16 msgid "" "Perhaps the most well-known statement type is the :keyword:`if` statement. " "For example::" msgstr "" "L'instruction :keyword:`if` est sans doute la plus connue. Par exemple : ::" #: ../Doc/tutorial/controlflow.rst:33 msgid "" "There can be zero or more :keyword:`elif` parts, and the :keyword:`else` " "part is optional. The keyword ':keyword:`elif`' is short for 'else if', and " "is useful to avoid excessive indentation. An :keyword:`if` ... :keyword:" "`elif` ... :keyword:`elif` ... sequence is a substitute for the ``switch`` " "or ``case`` statements found in other languages." msgstr "" "Il peut y avoir un nombre quelconque de parties :keyword:`elif`, et la " "partie :keyword:`else` est facultative. Le mot clé ':keyword:`elif`' est un " "raccourci pour 'else if', mais permet de gagner un niveau d'indentation. Une " "séquence :keyword:`if` ... :keyword:`elif` ... :keyword:`elif` ... est par " "ailleurs équivalente aux instructions ``switch`` ou ``case`` disponibles " "dans d'autres langages." #: ../Doc/tutorial/controlflow.rst:43 msgid ":keyword:`for` Statements" msgstr "L'instruction :keyword:`for`" #: ../Doc/tutorial/controlflow.rst:48 msgid "" "The :keyword:`for` statement in Python differs a bit from what you may be " "used to in C or Pascal. Rather than always iterating over an arithmetic " "progression of numbers (like in Pascal), or giving the user the ability to " "define both the iteration step and halting condition (as C), Python's :" "keyword:`for` statement iterates over the items of any sequence (a list or a " "string), in the order that they appear in the sequence. For example (no pun " "intended):" msgstr "" "L'instruction :keyword:`for` que propose Python est un peu différente de " "celle que l'on peut trouver en C ou en Pascal. Au lieu de toujours itérer " "sur une suite arithmétique de nombres (comme en Pascal), ou de donner à " "l'utilisateur la possibilité de définir le pas d'itération et la condition " "de fin (comme en C), l'instruction :keyword:`for` en Python itère sur les " "éléments d'une séquence (qui peut être une liste, une chaîne de " "caractères...), dans l'ordre dans lequel ils apparaissent dans la séquence. " "Par exemple (sans jeu de mots) :" #: ../Doc/tutorial/controlflow.rst:69 msgid "" "If you need to modify the sequence you are iterating over while inside the " "loop (for example to duplicate selected items), it is recommended that you " "first make a copy. Iterating over a sequence does not implicitly make a " "copy. The slice notation makes this especially convenient::" msgstr "" "Si vous devez modifier la séquence sur laquelle s'effectue l'itération à " "l'intérieur de la boucle (par exemple pour dupliquer ou supprimer un " "élément), il est plus que recommandé de commencer par en faire une copie, " "celle-ci n'étant pas implicite. La notation \"par tranches\" rend cette " "opération particulièrement simple : ::" #: ../Doc/tutorial/controlflow.rst:81 msgid "" "With ``for w in words:``, the example would attempt to create an infinite " "list, inserting ``defenestrate`` over and over again." msgstr "" #: ../Doc/tutorial/controlflow.rst:88 msgid "The :func:`range` Function" msgstr "La fonction :func:`range`" #: ../Doc/tutorial/controlflow.rst:90 msgid "" "If you do need to iterate over a sequence of numbers, the built-in function :" "func:`range` comes in handy. It generates arithmetic progressions::" msgstr "" "Si vous devez itérer sur une suite de nombres, la fonction intégrée :func:" "`range` est faite pour cela. Elle génère des suites arithmétiques : :" #: ../Doc/tutorial/controlflow.rst:102 msgid "" "The given end point is never part of the generated sequence; ``range(10)`` " "generates 10 values, the legal indices for items of a sequence of length " "10. It is possible to let the range start at another number, or to specify " "a different increment (even negative; sometimes this is called the 'step')::" msgstr "" "Le dernier élément fourni en paramètre ne fait jamais partie de la liste " "générée ; ``range(10)`` génère une liste de 10 valeurs, dont les valeurs " "vont de 0 à 9. Il est possible de spécifier une valeur de début et/ou une " "valeur d'incrément différente(s) (y compris négative pour cette dernière, " "que l'on appelle également parfois le 'pas') ::" #: ../Doc/tutorial/controlflow.rst:116 msgid "" "To iterate over the indices of a sequence, you can combine :func:`range` " "and :func:`len` as follows::" msgstr "" "Pour itérer sur les indices d'une séquence, on peut combiner les fonctions :" "func:`range` et :func:`len` ::" #: ../Doc/tutorial/controlflow.rst:129 msgid "" "In most such cases, however, it is convenient to use the :func:`enumerate` " "function, see :ref:`tut-loopidioms`." msgstr "" "Cependant, dans la plupart des cas, il est plus pratique d'utiliser la " "fonction :func:`enumerate`. Voyez pour cela :ref:`tut-loopidioms`." #: ../Doc/tutorial/controlflow.rst:132 msgid "A strange thing happens if you just print a range::" msgstr "Une chose étrange se produit lorsqu'on affiche un range : :" #: ../Doc/tutorial/controlflow.rst:137 msgid "" "In many ways the object returned by :func:`range` behaves as if it is a " "list, but in fact it isn't. It is an object which returns the successive " "items of the desired sequence when you iterate over it, but it doesn't " "really make the list, thus saving space." msgstr "" "Les objets données par :func:`range` se comportent presque comme des listes, " "mais n'en sont pas. Ce sont des objets qui génèrent les éléments de la " "séquence au fur et à mesure de leur itération, économisant ainsi de l'espace." #: ../Doc/tutorial/controlflow.rst:142 msgid "" "We say such an object is *iterable*, that is, suitable as a target for " "functions and constructs that expect something from which they can obtain " "successive items until the supply is exhausted. We have seen that the :" "keyword:`for` statement is such an *iterator*. The function :func:`list` is " "another; it creates lists from iterables::" msgstr "" "On appelle de tels objets des *iterables*, c'est à dire des objets qui " "conviennent à des *iterateurs*, des fonctions ou constructions qui " "s'attendent à quelque-chose duquel ils peuvent tirer des éléments, " "successives successivement, jusqu'à épuisement. On a vu que l'instruction :" "keyword:`for` est un iterateur. La fonction :func:`list` en est un autre, " "qui créé des listes à partir d'iterables : ::" #: ../Doc/tutorial/controlflow.rst:152 msgid "" "Later we will see more functions that return iterables and take iterables as " "argument." msgstr "" "Plus loin nous verrons d'autre fonctions qui donnent des iterables ou en " "prennent en paramètre." #: ../Doc/tutorial/controlflow.rst:158 msgid "" ":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` " "Clauses on Loops" msgstr "" "Les instructions :keyword:`break` et :keyword:`continue`, et les clauses :" "keyword:`else` au sein des boucles" #: ../Doc/tutorial/controlflow.rst:160 msgid "" "The :keyword:`break` statement, like in C, breaks out of the smallest " "enclosing :keyword:`for` or :keyword:`while` loop." msgstr "" "L'instruction :keyword:`break`, comme en C, interrompt la boucle :keyword:" "`for` ou :keyword:`while` la plus imbriquée." #: ../Doc/tutorial/controlflow.rst:163 msgid "" "Loop statements may have an ``else`` clause; it is executed when the loop " "terminates through exhaustion of the list (with :keyword:`for`) or when the " "condition becomes false (with :keyword:`while`), but not when the loop is " "terminated by a :keyword:`break` statement. This is exemplified by the " "following loop, which searches for prime numbers::" msgstr "" "Les boucles peuvent également disposer d'une instruction ``else`` ; celle-ci " "est exécutée lorsqu'une boucle se termine alors que tous ses éléments ont " "été traités (dans le cas d'un :keyword:`for`) ou que la condition devient " "fausse (dans le cas d'un :keyword:`while`), mais pas lorsque la boucle est " "interrompue par une instruction :keyword:`break`. L'exemple suivant, qui " "effectue une recherche de nombres premiers, en est une démonstration : ::" #: ../Doc/tutorial/controlflow.rst:187 msgid "" "(Yes, this is the correct code. Look closely: the ``else`` clause belongs " "to the :keyword:`for` loop, **not** the :keyword:`if` statement.)" msgstr "" "(Oui, ce code est correct. Regardez attentivement : l'instruction ``else`` " "est rattachée à la boucle :keyword:`for`, et **non** à l'instruction :" "keyword:`if`.)" #: ../Doc/tutorial/controlflow.rst:190 msgid "" "When used with a loop, the ``else`` clause has more in common with the " "``else`` clause of a :keyword:`try` statement than it does that of :keyword:" "`if` statements: a :keyword:`try` statement's ``else`` clause runs when no " "exception occurs, and a loop's ``else`` clause runs when no ``break`` " "occurs. For more on the :keyword:`try` statement and exceptions, see :ref:" "`tut-handling`." msgstr "" "Lorsqu'elle utilisée dans une boucle, la clause ``else`` est donc plus " "proche de celle associée à une instruction :keyword:`try` que de celle " "associée à une instruction :keyword:`if` : la clause ``else`` d'une " "instruction :keyword:`try` s'exécute lorsqu'aucune exception n'est " "déclenchée, et celle d'une boucle lorsque aucun ``break`` n'intervient. Plus " "plus d'informations sur l'instruction :keyword:`try` et le traitement des " "exceptions, consultez :ref:`tut-handling`." #: ../Doc/tutorial/controlflow.rst:197 msgid "" "The :keyword:`continue` statement, also borrowed from C, continues with the " "next iteration of the loop::" msgstr "" "L'instruction :keyword:`continue`, également empruntée au C, fait passer la " "boucle à son itération suivante : ::" #: ../Doc/tutorial/controlflow.rst:217 msgid ":keyword:`pass` Statements" msgstr "L'instruction :keyword:`pass`" #: ../Doc/tutorial/controlflow.rst:219 msgid "" "The :keyword:`pass` statement does nothing. It can be used when a statement " "is required syntactically but the program requires no action. For example::" msgstr "" "L'instruction :keyword:`pass` ne fait rien. Elle peut être utilisée " "lorsqu'une instruction est nécessaire pour fournir une syntaxe correcte, " "mais qu'aucune action ne doit être effectuée. Par exemple : ::" #: ../Doc/tutorial/controlflow.rst:226 msgid "This is commonly used for creating minimal classes::" msgstr "" "On utilise couramment cette instruction pour créer des classes minimales : ::" #: ../Doc/tutorial/controlflow.rst:232 msgid "" "Another place :keyword:`pass` can be used is as a place-holder for a " "function or conditional body when you are working on new code, allowing you " "to keep thinking at a more abstract level. The :keyword:`pass` is silently " "ignored::" msgstr "" "Un autre cas d'utilisation du :keyword:`pass` est de réserver un espace en " "phase de développement pour une fonction ou un traitement conditionnel, vous " "permettant ainsi de construire votre code à un niveau plus abstrait. " "L'instruction :keyword:`pass` est alors ignorée silencieusement : ::" #: ../Doc/tutorial/controlflow.rst:243 msgid "Defining Functions" msgstr "Définir des fonctions" #: ../Doc/tutorial/controlflow.rst:245 msgid "" "We can create a function that writes the Fibonacci series to an arbitrary " "boundary::" msgstr "" "On peut créer une fonction qui écrit la suite de Fibonacci jusqu'à une " "limite imposée : ::" #: ../Doc/tutorial/controlflow.rst:265 msgid "" "The keyword :keyword:`def` introduces a function *definition*. It must be " "followed by the function name and the parenthesized list of formal " "parameters. The statements that form the body of the function start at the " "next line, and must be indented." msgstr "" "Le mot-clé :keyword:`def` introduit une *définition* de fonction. Il doit " "être suivi du nom de la fonction et d'une liste entre parenthèses de ses " "paramètres. L'instruction qui constitue le corps de la fonction débute à la " "ligne suivante, et doit être indentée." #: ../Doc/tutorial/controlflow.rst:270 msgid "" "The first statement of the function body can optionally be a string literal; " "this string literal is the function's documentation string, or :dfn:" "`docstring`. (More about docstrings can be found in the section :ref:`tut-" "docstrings`.) There are tools which use docstrings to automatically produce " "online or printed documentation, or to let the user interactively browse " "through code; it's good practice to include docstrings in code that you " "write, so make a habit of it." msgstr "" "La première instruction d'une fonction peut, de façon facultative, être une " "chaîne de caractères littérale ; cette chaîne de caractères sera alors la " "chaîne de documentation de la fonction, ou :dfn:`docstring` (consultez la " "section :ref:`tut-docstrings` pour en savoir plus). Il existe des outils qui " "utilisent ces chaînes de documentation pour générer automatiquement une " "documentation en ligne ou imprimée, ou pour permettre à l'utilisateur de " "naviguer de façon interactive dans le code ; prenez-en l'habitude, c'est une " "bonne habitude que de documenter le code que vous écrivez !" #: ../Doc/tutorial/controlflow.rst:277 msgid "" "The *execution* of a function introduces a new symbol table used for the " "local variables of the function. More precisely, all variable assignments " "in a function store the value in the local symbol table; whereas variable " "references first look in the local symbol table, then in the local symbol " "tables of enclosing functions, then in the global symbol table, and finally " "in the table of built-in names. Thus, global variables cannot be directly " "assigned a value within a function (unless named in a :keyword:`global` " "statement), although they may be referenced." msgstr "" "*L'exécution* d'une fonction introduit une nouvelle table de symboles " "utilisée par les variables locales de la fonction. Plus précisément, toutes " "les affectations de variables effectuées au sein d'une fonction stockent la " "valeur dans la table de symboles locale ; tandis que les références de " "variables sont recherchées dans la table de symboles locale, puis dans la " "table de symboles locale des fonctions englobantes, puis dans la table de " "symboles globale et finallement dans la table de noms des primitives. Par " "conséquent, il est impossible d'affecter une valeur à une variable globale " "(sauf en utilisant une instruction :keyword:`global`), bien qu'elles " "puissent être référencées." #: ../Doc/tutorial/controlflow.rst:286 msgid "" "The actual parameters (arguments) to a function call are introduced in the " "local symbol table of the called function when it is called; thus, arguments " "are passed using *call by value* (where the *value* is always an object " "*reference*, not the value of the object). [#]_ When a function calls " "another function, a new local symbol table is created for that call." msgstr "" "Les paramètres effectifs (arguments) d'une fonction sont introduits dans la " "table de symboles locale de la fonction appelée lorsqu'elle est appelée ; " "par conséquent, les passages de paramètres se font *par valeur*, la *valeur* " "étant toujours une *référence* à un objet, et non la valeur de l'objet lui-" "même. [#]_ Lorsqu'une fonction appelle une autre fonction, une nouvelle " "table de symboles locale est créée pour cet appel." #: ../Doc/tutorial/controlflow.rst:292 msgid "" "A function definition introduces the function name in the current symbol " "table. The value of the function name has a type that is recognized by the " "interpreter as a user-defined function. This value can be assigned to " "another name which can then also be used as a function. This serves as a " "general renaming mechanism::" msgstr "" "Une définition de fonction introduit le nom de la fonction dans la table de " "symboles courante. La valeur du nom de la fonction est un type qui est " "reconnu par l'interpréteur comme une fonction utilisateur. Cette valeur peut " "être affectée à un autre nom qui pourra alors être utilisé également comme " "une fonction. Ceci fournit un mécanisme de renommage général : ::" #: ../Doc/tutorial/controlflow.rst:304 msgid "" "Coming from other languages, you might object that ``fib`` is not a function " "but a procedure since it doesn't return a value. In fact, even functions " "without a :keyword:`return` statement do return a value, albeit a rather " "boring one. This value is called ``None`` (it's a built-in name). Writing " "the value ``None`` is normally suppressed by the interpreter if it would be " "the only value written. You can see it if you really want to using :func:" "`print`::" msgstr "" "Si vous venez d'autres langages, vous pouvez penser que ``fib`` n'est pas " "une fonction mais une procédure, puisqu'elle ne renvoie pas de résultat. En " "fait, même les fonctions sans instruction :keyword:`return` renvoient une " "valeur, quoique ennuyeuse. Cette valeur est appelée ``None`` (c'est le nom " "d'une primitive). Écrire la valeur ``None`` est normalement supprimé par " "l'interpréteur lorsqu'il s'agit de la seule value écrite. Vous pouvez le " "voir si vous y tenez vraiment en utilisant :func:`print` ::" #: ../Doc/tutorial/controlflow.rst:315 msgid "" "It is simple to write a function that returns a list of the numbers of the " "Fibonacci series, instead of printing it::" msgstr "" "Il est facile d'écrire une fonction qui renvoie une liste de la série de " "Fibonacci au lieu de l'imprimer : ::" #: ../Doc/tutorial/controlflow.rst:331 msgid "This example, as usual, demonstrates some new Python features:" msgstr "" "Cet exemple, comme d'habitude, illustre de nouvelles fonctionnalités de " "Python :" #: ../Doc/tutorial/controlflow.rst:333 msgid "" "The :keyword:`return` statement returns with a value from a function. :" "keyword:`return` without an expression argument returns ``None``. Falling " "off the end of a function also returns ``None``." msgstr "" "L'instruction :keyword:`return` provoque la sortie de la fonction en " "renvoyant une valeur. :keyword:`return` sans expression en paramètre renvoie " "``None``. Arriver à la fin d'une fonction renvoie également ``None``." #: ../Doc/tutorial/controlflow.rst:337 msgid "" "The statement ``result.append(a)`` calls a *method* of the list object " "``result``. A method is a function that 'belongs' to an object and is named " "``obj.methodname``, where ``obj`` is some object (this may be an " "expression), and ``methodname`` is the name of a method that is defined by " "the object's type. Different types define different methods. Methods of " "different types may have the same name without causing ambiguity. (It is " "possible to define your own object types and methods, using *classes*, see :" "ref:`tut-classes`) The method :meth:`append` shown in the example is defined " "for list objects; it adds a new element at the end of the list. In this " "example it is equivalent to ``result = result + [a]``, but more efficient." msgstr "" "L'instruction ``result.append(a)`` appelle une *méthode* de l'objet " "``result`` qui est une liste. Une méthode est une fonction qui 'appartient' " "à un objet et qui est nommée ``obj.methodname``, où ``obj`` est un objet (il " "peut également s'agir d'une expression), et ``methodname`` est le nom d'une " "méthode définie par le type de l'objet. Différents types définissent " "différentes méthodes. Des méthodes de différents types peuvent porter le " "même nom sans qu'il n'y ait d'ambigüité (vous pouvez définir vos propres " "types d'objets et leurs méthodes en utilisant des *classes*, voir :ref:`tut-" "classes`). La méthode :meth:`append` donnée dans cet exemple est définie " "pour les listes ; elles ajoute un nouvel élément à la fin de la liste. Dans " "cet exemple, elle est l'équivalent de ``result = result + [a]``, mais elle " "est plus efficace." #: ../Doc/tutorial/controlflow.rst:352 msgid "More on Defining Functions" msgstr "D'avantage sur la définition des fonctions" #: ../Doc/tutorial/controlflow.rst:354 msgid "" "It is also possible to define functions with a variable number of arguments. " "There are three forms, which can be combined." msgstr "" "Il est également possible de définir des fonctions avec un nombre variable " "d'arguments. Trois syntaxes peuvent être utilisées, éventuellement combinées." #: ../Doc/tutorial/controlflow.rst:361 msgid "Default Argument Values" msgstr "Valeur par défaut des arguments" #: ../Doc/tutorial/controlflow.rst:363 msgid "" "The most useful form is to specify a default value for one or more " "arguments. This creates a function that can be called with fewer arguments " "than it is defined to allow. For example::" msgstr "" "La forme la plus utile consiste à indiquer une valeur par défaut pour " "certains arguments. Ceci crée une fonction qui pourra être appelée avec " "moins d'arguments que ceux présents dans sa définition. Par exemple : ::" #: ../Doc/tutorial/controlflow.rst:379 msgid "This function can be called in several ways:" msgstr "Cette fonction peut être appelée de plusieurs façons :" #: ../Doc/tutorial/controlflow.rst:381 msgid "" "giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``" msgstr "" "en ne fournissant que les arguments obligatoires : ``ask_ok('Voulez-vous " "vraiment quitter ?')``" #: ../Doc/tutorial/controlflow.rst:383 msgid "" "giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', " "2)``" msgstr "" "en fournissant une partie des arguments facultatifs : ``ask_ok('OK pour " "écraser le fichier ?', 2)``" #: ../Doc/tutorial/controlflow.rst:385 msgid "" "or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come " "on, only yes or no!')``" msgstr "" "en fournissant tous les arguments : ``ask_ok('OK pour écraser le fichier ?', " "2, 'Allez, seulement oui ou non !')``" #: ../Doc/tutorial/controlflow.rst:388 msgid "" "This example also introduces the :keyword:`in` keyword. This tests whether " "or not a sequence contains a certain value." msgstr "" "Cet exemple présente également le mot-clé :keyword:`in`. Celui-ci permet de " "tester si une séquence contient une certaine valeur." #: ../Doc/tutorial/controlflow.rst:391 msgid "" "The default values are evaluated at the point of function definition in the " "*defining* scope, so that ::" msgstr "" "Les valeurs par défaut sont évaluées lors de la définition de la fonction " "dans la portée de *définition*, de telle sorte que : ::" #: ../Doc/tutorial/controlflow.rst:402 msgid "will print ``5``." msgstr "imprimera ``5``." #: ../Doc/tutorial/controlflow.rst:404 msgid "" "**Important warning:** The default value is evaluated only once. This makes " "a difference when the default is a mutable object such as a list, " "dictionary, or instances of most classes. For example, the following " "function accumulates the arguments passed to it on subsequent calls::" msgstr "" "**Avertissement important :** La valeur par défaut n'est évaluée qu'une " "seule fois. Ceci fait une différence lorsque cette valeur par défaut est un " "objet mutable tel qu'une liste, un dictionnaire ou des instances de la " "plupart des classes. Par exemple, la fonction suivante accumule les " "arguments qui lui sont passés au fil des appels successifs : ::" #: ../Doc/tutorial/controlflow.rst:417 msgid "This will print ::" msgstr "Ceci imprimera : ::" #: ../Doc/tutorial/controlflow.rst:423 msgid "" "If you don't want the default to be shared between subsequent calls, you can " "write the function like this instead::" msgstr "" "Si vous ne voulez pas que cette valeur par défaut soit partagée entre des " "appels successifs, vous pouvez écrire la fonction de cette façon : ::" #: ../Doc/tutorial/controlflow.rst:436 msgid "Keyword Arguments" msgstr "Les arguments nommés" #: ../Doc/tutorial/controlflow.rst:438 msgid "" "Functions can also be called using :term:`keyword arguments ` 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 ` sous la form ``kwarg=value``. Par " "exemple, la fonction suivante : ::" #: ../Doc/tutorial/controlflow.rst:447 msgid "" "accepts one required argument (``voltage``) and three optional arguments " "(``state``, ``action``, and ``type``). This function can be called in any " "of the following ways::" msgstr "" "accepte un argument obligatoire (``voltage``) et trois arguments facultatifs " "(``state``, ``action`` et ``type``). Cette fonction peut être appelée de " "n'importe laquelle des façons suivantes : ::" #: ../Doc/tutorial/controlflow.rst:458 msgid "but all the following calls would be invalid::" msgstr "mais tous les appels qui suivent sont incorrects : ::" #: ../Doc/tutorial/controlflow.rst:465 msgid "" "In a function call, keyword arguments must follow positional arguments. All " "the keyword arguments passed must match one of the arguments accepted by the " "function (e.g. ``actor`` is not a valid argument for the ``parrot`` " "function), and their order is not important. This also includes non-" "optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument " "may receive a value more than once. Here's an example that fails due to this " "restriction::" msgstr "" "Dans un appel de fonction, les arguments nommés doivent suivre les arguments " "positionnés. Tous les arguments nommés doivent correspondre à l'un des " "arguments acceptés par la fonction (par exemple, ``actor`` n'est pas un " "argument accepté par la fonction ``parrot``), mais leur ordre n'est pas " "important. Ceci inclut également les arguments facultatifs " "(``parrot(voltage=1000)`` est également correct). Aucun argument ne peut " "recevoir une valeur plus d'une fois, comme l'illustre cet exemple incorrect " "du fait de cette restriction : ::" #: ../Doc/tutorial/controlflow.rst:481 msgid "" "When a final formal parameter of the form ``**name`` is present, it receives " "a dictionary (see :ref:`typesmapping`) containing all keyword arguments " "except for those corresponding to a formal parameter. This may be combined " "with a formal parameter of the form ``*name`` (described in the next " "subsection) which receives a tuple containing the positional arguments " "beyond the formal parameter list. (``*name`` must occur before ``**name``.) " "For example, if we define a function like this::" msgstr "" "Quand un dernier paramètre formel est présent sous la forme ``**name``, il " "reçoit un dictionnaire (voir :ref:`typesmapping`) contenant tous les " "arguments nommés à l'exception de ceux correspondant à un paramètre formel. " "Ceci peut être combiné à un paramètre formel sous la forme ``*name`` (décrit " "dans la section suivante) qui lui reçoit un tuple contenant les arguments " "positionnés au-delà de la liste des paramètres formels (``*name`` doit être " "présent avant ``**name``). Par exemple, si vous définissez une fonction " "comme ceci :" #: ../Doc/tutorial/controlflow.rst:499 msgid "It could be called like this::" msgstr "Elle pourrait être appelée comme ceci : ::" #: ../Doc/tutorial/controlflow.rst:507 msgid "and of course it would print:" msgstr "" #: ../Doc/tutorial/controlflow.rst:520 msgid "" "Note that the list of keyword argument names is created by sorting the " "result of the keywords dictionary's ``keys()`` method before printing its " "contents; if this is not done, the order in which the arguments are printed " "is undefined." msgstr "" "Notez que la liste des arguments nommés est créée en triant les clés du " "dictionnaire extraites par la méthode ``keys()`` avant de les imprimer. Si " "celà n'est pas fait, l'ordre dans lequel les arguments sont imprimée n'est " "pas défini." #: ../Doc/tutorial/controlflow.rst:527 msgid "Arbitrary Argument Lists" msgstr "Listes d'arguments arbitraires" #: ../Doc/tutorial/controlflow.rst:532 msgid "" "Finally, the least frequently used option is to specify that a function can " "be called with an arbitrary number of arguments. These arguments will be " "wrapped up in a tuple (see :ref:`tut-tuples`). Before the variable number " "of arguments, zero or more normal arguments may occur. ::" msgstr "" "Pour terminer, l'option la moins fréquente consiste à indiquer qu'une " "fonction peut être appelée avec un nombre arbitraire d'arguments. Ces " "arguments sont intégrés dans un tuple (voir :ref:`tut-tuples`). Avant le " "nombre variable d'arguments, zéro arguments normaux ou plus peuvent " "apparaître : ::" #: ../Doc/tutorial/controlflow.rst:541 msgid "" "Normally, these ``variadic`` arguments will be last in the list of formal " "parameters, because they scoop up all remaining input arguments that are " "passed to the function. Any formal parameters which occur after the " "``*args`` parameter are 'keyword-only' arguments, meaning that they can only " "be used as keywords rather than positional arguments. ::" msgstr "" "Normalement, c'est arguments ``variadiques`` sont les derniers paramètres, " "parce qu'ils agrègent toutes les valeurs suivantes. Tout paramètre placé " "après le paramètre ``*arg`` ne pourront être utilisées que par leur nom." #: ../Doc/tutorial/controlflow.rst:558 msgid "Unpacking Argument Lists" msgstr "Séparation des listes d'arguments" #: ../Doc/tutorial/controlflow.rst:560 msgid "" "The reverse situation occurs when the arguments are already in a list or " "tuple but need to be unpacked for a function call requiring separate " "positional arguments. For instance, the built-in :func:`range` function " "expects separate *start* and *stop* arguments. If they are not available " "separately, write the function call with the ``*``\\ -operator to unpack " "the arguments out of a list or tuple::" msgstr "" "La situation inverse intervient lorsque les arguments sont déjà dans une " "liste ou un tuple mais doivent être séparés pour un appel de fonction " "nécessitant des arguments positionnés séparés. Par exemple, la primitive :" "func:`range` attend des arguments *start* et *stop* distincts. S'ils ne sont " "pas disponibles séparément, écrivez l'appel de fonction en utilisant " "l'opérateur ``*`` pour séparer les arguments présents dans une liste ou un " "tuple : ::" #: ../Doc/tutorial/controlflow.rst:576 msgid "" "In the same fashion, dictionaries can deliver keyword arguments with the " "``**``\\ -operator::" msgstr "" "De la même façon, les dictionnaires peuvent fournir des arguments nommés en " "utilisant l'opérateur ``**`` ::" #: ../Doc/tutorial/controlflow.rst:592 msgid "Lambda Expressions" msgstr "Fonctions anonymes" #: ../Doc/tutorial/controlflow.rst:594 msgid "" "Small anonymous functions can be created with the :keyword:`lambda` keyword. " "This function returns the sum of its two arguments: ``lambda a, b: a+b``. " "Lambda functions can be used wherever function objects are required. They " "are syntactically restricted to a single expression. Semantically, they are " "just syntactic sugar for a normal function definition. Like nested function " "definitions, lambda functions can reference variables from the containing " "scope::" msgstr "" "Avec le mot-clé :keyword:`lambda`, on peut créer de petites fonctions " "anonymes. Voilàune fonction qui renvoie la somme de ses deux arguments : " "``lambda a, b: a+b``. Les fonctions lambda peuvent être utilisées partout où " "un objet fonction est attendu. Elles sont syntaxiquement restreintes à une " "seule expression. Sémantiquement, elles ne sont qu'un sucre syntaxique pour " "une définition de fonction normale. Comme les fonctions imbriquées, les " "fonctions lambda peuvent référencer des variables de la portée " "englobante : ::" #: ../Doc/tutorial/controlflow.rst:611 msgid "" "The above example uses a lambda expression to return a function. Another " "use is to pass a small function as an argument::" msgstr "" "L'exemple précédent utilise une fonction anonyme pour renvoyer une fonction. " "Un aute usage typique est de donner une fonction minimaliste directement en " "temps que paramètre::" #: ../Doc/tutorial/controlflow.rst:623 msgid "Documentation Strings" msgstr "Chaînes de documentation" #: ../Doc/tutorial/controlflow.rst:630 msgid "" "Here are some conventions about the content and formatting of documentation " "strings." msgstr "" "Voici quelques conventions concernant le contenu et le format des chaînes de " "documentation." #: ../Doc/tutorial/controlflow.rst:633 msgid "" "The first line should always be a short, concise summary of the object's " "purpose. For brevity, it should not explicitly state the object's name or " "type, since these are available by other means (except if the name happens " "to be a verb describing a function's operation). This line should begin " "with a capital letter and end with a period." msgstr "" "La première ligne devrait toujours être courte, un résumé concis de " "l'utilité de l'objet. Pour être bref, nul besoin de rappeler le nom de " "l'objet ou son type, qui sont accessibles par d'autres moyens (sauf si le " "nom est un verbe qui décrit une opération). Cette ligne devrait commencer " "avec une majuscule et se terminer par un point." #: ../Doc/tutorial/controlflow.rst:639 msgid "" "If there are more lines in the documentation string, the second line should " "be blank, visually separating the summary from the rest of the description. " "The following lines should be one or more paragraphs describing the object's " "calling conventions, its side effects, etc." msgstr "" "Si il a d'autres lignes dans la chaîne de documentation, la seconde ligne " "devrait être vide, pour la séparer visuellement du reste de la description. " "Les autres lignes peuvent alors constituer un ou plusieurs paragraphes " "décrivant le mode d'utilisation de l'objet, ses effets de bord, etc." #: ../Doc/tutorial/controlflow.rst:644 msgid "" "The Python parser does not strip indentation from multi-line string literals " "in Python, so tools that process documentation have to strip indentation if " "desired. This is done using the following convention. The first non-blank " "line *after* the first line of the string determines the amount of " "indentation for the entire documentation string. (We can't use the first " "line since it is generally adjacent to the string's opening quotes so its " "indentation is not apparent in the string literal.) Whitespace \"equivalent" "\" to this indentation is then stripped from the start of all lines of the " "string. Lines that are indented less should not occur, but if they occur " "all their leading whitespace should be stripped. Equivalence of whitespace " "should be tested after expansion of tabs (to 8 spaces, normally)." msgstr "" "L'analyseur de code Python ne supprime pas l'indentation des chaînes de " "caractères littérales multi-lignes, donc les outils qui utilisent la " "documentation doivent si besoin faire cette opération eux-mêmes. La " "convention suivante s'applique : la première ligne non vide *après* la " "première détermine la profondeur d'indentation de l'ensemble de la chaîne de " "documentation (on ne peut pas utiliser la première ligne qui est " "généralement accolée aux guillemets d'ouverture de la chaîne de caractères " "et dont l'indentation n'est donc pas visible). Les espaces \"correspondant\" " "à cette profondeur d'indentation sont alors supprimés du début de chacune " "des lignes de la chaîne. Aucune ligne ne devrait présenter un niveau " "d'indentation inférieur mais si cela arrive, tous les espaces situés en " "début de ligne doivent être supprimés. L'équivalent des espaces doit être " "testé après expansion des tabulations (normalement remplacés par 4 espaces)." #: ../Doc/tutorial/controlflow.rst:656 msgid "Here is an example of a multi-line docstring::" msgstr "Voici un exemple de chaîne de documentation multi-lignes : ::" #: ../Doc/tutorial/controlflow.rst:674 msgid "Function Annotations" msgstr "Annotations de fonctions" #: ../Doc/tutorial/controlflow.rst:681 msgid "" ":ref:`Function annotations ` are completely optional metadata " "information about the types used by user-defined functions (see :pep:`484` " "for more information)." msgstr "" ":ref:`Function annotations ` sont des métadonnée optionnelles " "décrivant les types utilisées par une fonction définie par l'utilisateur " "(Voir la :pep:`484` pour plus d'informations)." #: ../Doc/tutorial/controlflow.rst:685 msgid "" "Annotations are stored in the :attr:`__annotations__` attribute of the " "function as a dictionary and have no effect on any other part of the " "function. Parameter annotations are defined by a colon after the parameter " "name, followed by an expression evaluating to the value of the annotation. " "Return annotations are defined by a literal ``->``, followed by an " "expression, between the parameter list and the colon denoting the end of " "the :keyword:`def` statement. The following example has a positional " "argument, a keyword argument, and the return value annotated::" msgstr "" "Les annotations sont stockées dans l'attribut :attr:`__annotations__` de la " "fonction, sous forme d'un dictionnaire, et n'ont aucun autre effet. Les " "annotations sur les paramètres sont définis par deux points (:) après le nom " "du paramètre suivi d'une expression donnant la valeur de l'annotation. Les " "annotations de retour sont définies par ``->`` suivi d'une expression, entre " "la liste des paramètres et les deux points de fin de l'instruction :keyword:" "`def`. L'exemple suivant a un paramètre positionnel, un paramètre nommé, et " "une valeur de retour annotée : ::" #: ../Doc/tutorial/controlflow.rst:707 msgid "Intermezzo: Coding Style" msgstr "Un style de codage : Intermezzo" #: ../Doc/tutorial/controlflow.rst:712 msgid "" "Now that you are about to write longer, more complex pieces of Python, it is " "a good time to talk about *coding style*. Most languages can be written (or " "more concise, *formatted*) in different styles; some are more readable than " "others. Making it easy for others to read your code is always a good idea, " "and adopting a nice coding style helps tremendously for that." msgstr "" "Maintenant que vous êtes prêt à écrire des programmes plus longs et plus " "complexes, il est temps de parler du *style de codage*. La plupart des " "langages peuvent être écrits (ou plutôt *formattés*) selon différents " "styles ; certains sont plus lisibles que d'autres. Rendre la lecture de " "votre code plus facile aux autres est toujours une bonne idée, et adopter un " "bon style de codage peut énormément vous y aider." #: ../Doc/tutorial/controlflow.rst:718 msgid "" "For Python, :pep:`8` has emerged as the style guide that most projects " "adhere to; it promotes a very readable and eye-pleasing coding style. Every " "Python developer should read it at some point; here are the most important " "points extracted for you:" msgstr "" "En Python, la :pep:`8` a émergé comme étant un guide auquel la plupart des " "projets adhèrent ; elle met en avant un style de codage très lisible et " "agréable à l'oeil. Chaque développeur Python devrait donc la lire et s'en " "inspirer autant que possible ; voici ses principaux points notables :" #: ../Doc/tutorial/controlflow.rst:723 msgid "Use 4-space indentation, and no tabs." msgstr "Utilisez des indentations de 4 espaces, et pas de tabulation." #: ../Doc/tutorial/controlflow.rst:725 msgid "" "4 spaces are a good compromise between small indentation (allows greater " "nesting depth) and large indentation (easier to read). Tabs introduce " "confusion, and are best left out." msgstr "" "4 espaces constituent un bon compromis entre une indentation courte (qui " "permet une profondeur d'imbrication plus importante) et une longue (qui rend " "le code plus facile à lire). Les tabulations introduisent de la confusion, " "et doivent être proscrites autant que possible." #: ../Doc/tutorial/controlflow.rst:729 msgid "Wrap lines so that they don't exceed 79 characters." msgstr "" "Faites des retours à la ligne, de telle sorte qu'elles n'excèdent pas 79 " "caractères." #: ../Doc/tutorial/controlflow.rst:731 msgid "" "This helps users with small displays and makes it possible to have several " "code files side-by-side on larger displays." msgstr "" "Ceci aide les utilisateurs ne disposant que de petits écrans, et permet sur " "de plus grands de disposer plusieurs fichiers côte à côte sans difficulté." #: ../Doc/tutorial/controlflow.rst:734 msgid "" "Use blank lines to separate functions and classes, and larger blocks of code " "inside functions." msgstr "" "Utilisez des lignes vides pour séparer les fonctions et les classes, ou pour " "scinder de gros blocs de code à l'intérieur de fonctions." #: ../Doc/tutorial/controlflow.rst:737 msgid "When possible, put comments on a line of their own." msgstr "" "Lorsque c'est possible, placez les commentaires sur leur propres lignes." #: ../Doc/tutorial/controlflow.rst:739 msgid "Use docstrings." msgstr "Utilisez les chaînes de documentation" #: ../Doc/tutorial/controlflow.rst:741 msgid "" "Use spaces around operators and after commas, but not directly inside " "bracketing constructs: ``a = f(1, 2) + g(3, 4)``." msgstr "" "Utilisez des espaces autour des opérateurs et après les virgules, mais pas " "directement à l'intérieur des parenthèses : ``a = f(1, 2) + g(3, 4)``." #: ../Doc/tutorial/controlflow.rst:744 msgid "" "Name your classes and functions consistently; the convention is to use " "``CamelCase`` for classes and ``lower_case_with_underscores`` for functions " "and methods. Always use ``self`` as the name for the first method argument " "(see :ref:`tut-firstclasses` for more on classes and methods)." msgstr "" "Nommez toujours vos classes et fonctions de la même manière ; la convention " "est d'utiliser une notation ``CamelCase`` pour les classes, et " "``minuscules_avec_trait_bas`` pour les fonctions et méthodes. Utilisez " "toujours ``self`` comme nom du premier argument des méthodes (voyez :ref:" "`tut-firstclasses` pour en savoir plus sur les classes et les méthodes)." #: ../Doc/tutorial/controlflow.rst:749 msgid "" "Don't use fancy encodings if your code is meant to be used in international " "environments. Python's default, UTF-8, or even plain ASCII work best in any " "case." msgstr "" "N'utilisez pas d'encodages exotiques dès lors que votre code est sensé être " "utilisé dans des environnements internationaux. Par défaut, Python travaille " "en UTF-8, ou sinon du simple ASCII fonctionne dans la plupart des cas." #: ../Doc/tutorial/controlflow.rst:753 msgid "" "Likewise, don't use non-ASCII characters in identifiers if there is only the " "slightest chance people speaking a different language will read or maintain " "the code." msgstr "" "De la même manière, n'utilisez que des caractères ASCII pour vos noms de " "variables si vous soupçonnez qu'un personne parlant une autre langue lira ou " "devra modifier votre code." #: ../Doc/tutorial/controlflow.rst:760 msgid "" "Actually, *call by object reference* would be a better description, since if " "a mutable object is passed, the caller will see any changes the callee makes " "to it (items inserted into a list)." msgstr "" "En fait, *appels par référence d'objets* serait sans doute une desciption " "plus juste, dans la mesure où si un objet mutable est passé en argument, " "l'appelant verra toutes les modifications qui lui auront été apportées par " "l'appelé (insertion d'éléments dans une liste...)." #: ../Doc/tutorial/datastructures.rst:5 msgid "Data Structures" msgstr "Structures de données" #: ../Doc/tutorial/datastructures.rst:7 msgid "" "This chapter describes some things you've learned about already in more " "detail, and adds some new things as well." msgstr "" "Ce chapitre reprend plus en détail quelques point déjà décrits précédemment, " "et introduit également de nouvelles notions." #: ../Doc/tutorial/datastructures.rst:13 msgid "More on Lists" msgstr "Compléments sur les listes" #: ../Doc/tutorial/datastructures.rst:15 msgid "" "The list data type has some more methods. Here are all of the methods of " "list objects:" msgstr "" "Le type liste dispose de méthodes supplémentaires. Voici la liste complète " "des méthodes des objets de type liste :" #: ../Doc/tutorial/datastructures.rst:22 msgid "" "Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``." msgstr "" "Ajoute un élément à la fin de la liste. Equivalent à ``a[len(a):] = [x]``." #: ../Doc/tutorial/datastructures.rst:28 msgid "" "Extend the list by appending all the items in the given list. Equivalent to " "``a[len(a):] = L``." msgstr "" "Étend la liste en y ajoutant tous les éléments de la liste fournie." "Équivalent à ``a[len(a):] = L``." #: ../Doc/tutorial/datastructures.rst:35 msgid "" "Insert an item at a given position. The first argument is the index of the " "element before which to insert, so ``a.insert(0, x)`` inserts at the front " "of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``." msgstr "" "Insère un élément à la position indiquée. Le premier argument est la " "position de l'élément courant avant lequel l'insertion doit s'effectuer, " "donc ``a.insert(0, x)`` insère l'élément en tête de la liste, et ``a." "insert(len(a), x)`` est équivalent à ``a.append(x)``." #: ../Doc/tutorial/datastructures.rst:43 msgid "" "Remove the first item from the list whose value is *x*. It is an error if " "there is no such item." msgstr "" "Supprime de la liste le premier élément dont la valeur est *x*. Une " "exception est levée s'il existe aucun élément avec cette valeur." #: ../Doc/tutorial/datastructures.rst:50 msgid "" "Remove the item at the given position in the list, and return it. If no " "index is specified, ``a.pop()`` removes and returns the last item in the " "list. (The square brackets around the *i* in the method signature denote " "that the parameter is optional, not that you should type square brackets at " "that position. You will see this notation frequently in the Python Library " "Reference.)" msgstr "" "Enlève de la liste l'élément situé à la position indiquée, et le retourne. " "Si aucune position n'est indiqué, ``a.pop()`` enlève et retourne le dernier " "élément de la liste (les crochets autour du *i* dans la signature de la " "méthode indiquent bien que ce paramètre est facultatif, et non que vous " "devez placer des crochets dans votre code ! Vous retrouverez cette notation " "fréquemment dans le Guide de Référence de la Bibliothèque Python)." #: ../Doc/tutorial/datastructures.rst:60 msgid "Remove all items from the list. Equivalent to ``del a[:]``." msgstr "Supprime tous les éléments de la liste, équivalent à ``del a[:]``." #: ../Doc/tutorial/datastructures.rst:66 msgid "" "Return the index in the list of the first item whose value is *x*. It is an " "error if there is no such item." msgstr "" "Retourne la position du premier élément de la liste ayant la valeur *x*. Une " "exception est levée s'il n'existe aucun élément avec cette valeur." #: ../Doc/tutorial/datastructures.rst:73 msgid "Return the number of times *x* appears in the list." msgstr "Retourne le nombre d'éléments ayant la valeur *x* dans la liste." #: ../Doc/tutorial/datastructures.rst:79 msgid "" "Sort the items of the list in place (the arguments can be used for sort " "customization, see :func:`sorted` for their explanation)." msgstr "" "Trie les éléments sur place, (les arguments peuvent personaliser le tri, " "voir :func:`sorted` pour leur explication)." #: ../Doc/tutorial/datastructures.rst:86 msgid "Reverse the elements of the list in place." msgstr "Inverse l'ordre des éléments de la liste, sur place." #: ../Doc/tutorial/datastructures.rst:92 msgid "Return a shallow copy of the list. Equivalent to ``a[:]``." msgstr "Renvoie une copie superficielle de la liste. Équivalent à ``a[:]``." #: ../Doc/tutorial/datastructures.rst:95 msgid "An example that uses most of the list methods::" msgstr "L'exemple suivant utilise la plupart des méthodes des listes : ::" #: ../Doc/tutorial/datastructures.rst:120 msgid "" "You might have noticed that methods like ``insert``, ``remove`` or ``sort`` " "that only modify the list have no return value printed -- they return the " "default ``None``. [1]_ This is a design principle for all mutable data " "structures in Python." msgstr "" "Vous avez probablement remarqué que les méthodes tel que ``insert``, " "``remove`` ou ``sort``, qui ne font que modifier la liste, ne renvoient pas " "de valeur mais ``None``. [1]_ C'est un principe respecté par toutes les " "structures de données variables en Python." #: ../Doc/tutorial/datastructures.rst:129 msgid "Using Lists as Stacks" msgstr "Utiliser les listes comme des piles" #: ../Doc/tutorial/datastructures.rst:134 msgid "" "The list methods make it very easy to use a list as a stack, where the last " "element added is the first element retrieved (\"last-in, first-out\"). To " "add an item to the top of the stack, use :meth:`append`. To retrieve an " "item from the top of the stack, use :meth:`pop` without an explicit index. " "For example::" msgstr "" "Les méthodes des listes rendent très facile leur utilisation comme des " "piles, où le dernier élément ajouté est le premier récupéré (\"dernier " "entré, premier sorti\", ou LIFO pour \"last-in, first-out\"). Pour ajouter " "un élément sur la pile, utilisez la méthode :meth:`append`. Pour récupérer " "l'objet au sommet de la pile, utilisez la méthode :meth:`pop`, sans " "indicateur de position. Par exemple : ::" #: ../Doc/tutorial/datastructures.rst:159 msgid "Using Lists as Queues" msgstr "Utiliser les listes comme des files" #: ../Doc/tutorial/datastructures.rst:163 msgid "" "It is also possible to use a list as a queue, where the first element added " "is the first element retrieved (\"first-in, first-out\"); however, lists are " "not efficient for this purpose. While appends and pops from the end of list " "are fast, doing inserts or pops from the beginning of a list is slow " "(because all of the other elements have to be shifted by one)." msgstr "" "Il est également possible d'utiliser une liste comme une file, où le premier " "élément ajouté est le premier récupéré (\"premier entré, premier sorti\", ou " "FIFO pour \"first-in, first-out\") ; touefois, les listes ne sont pas très " "efficaces pour ce type de traitement. Alors que les ajouts et suppressions " "en fin de liste sont rapides, les opérations d'insertions ou de retraits en " "début de liste sont lentes (car tous les autres éléments doivent être " "décalés d'une position)." #: ../Doc/tutorial/datastructures.rst:169 msgid "" "To implement a queue, use :class:`collections.deque` which was designed to " "have fast appends and pops from both ends. For example::" msgstr "" "Pour implémenter une file, utilisez donc la classe :class:`collections." "deque` qui a été conçue pour fournir des opérations d'ajouts et de retraits " "rapides aux deux extrémités. Par exemple : ::" #: ../Doc/tutorial/datastructures.rst:187 msgid "List Comprehensions" msgstr "Compréhensions de listes" #: ../Doc/tutorial/datastructures.rst:189 msgid "" "List comprehensions provide a concise way to create lists. Common " "applications are to make new lists where each element is the result of some " "operations applied to each member of another sequence or iterable, or to " "create a subsequence of those elements that satisfy a certain condition." msgstr "" "Les compréhensions de listes fournissent un moyen de construire des listes " "de manière très concice. Une application classique est la construction de " "nouvelles listes où chaque élément est le résultat d'une opération appliquée " "à chaque élément d'une autre séquence, ou de créer une sous-séquence des " "éléments satisfaisant une condition spécifique." #: ../Doc/tutorial/datastructures.rst:194 msgid "For example, assume we want to create a list of squares, like::" msgstr "" "Par exemple, supposons que l'on veuille créer une liste de carrés, comme : ::" #: ../Doc/tutorial/datastructures.rst:203 msgid "" "Note that this creates (or overwrites) a variable named ``x`` that still " "exists after the loop completes. We can calculate the list of squares " "without any side effects using::" msgstr "" "Notez que cela créé (ou écrase) une variable nommée ``x`` qui existe " "toujours après l'exécution de la boucle. On peut calculer une liste de " "carrés sans effet de bord, avec : ::" #: ../Doc/tutorial/datastructures.rst:209 msgid "or, equivalently::" msgstr "ou : ::" #: ../Doc/tutorial/datastructures.rst:213 msgid "which is more concise and readable." msgstr "qui est plus court et lisible." #: ../Doc/tutorial/datastructures.rst:215 msgid "" "A list comprehension consists of brackets containing an expression followed " "by a :keyword:`for` clause, then zero or more :keyword:`for` or :keyword:" "`if` clauses. The result will be a new list resulting from evaluating the " "expression in the context of the :keyword:`for` and :keyword:`if` clauses " "which follow it. For example, this listcomp combines the elements of two " "lists if they are not equal::" msgstr "" "Une compréhension de liste consiste en crochets contenant une expression " "suivie par une clause :keyword:`for`, puis par zéro ou plus clauses :keyword:" "`for` ou :keyword:`if`. Le résultat sera une nouvelle liste résultat de " "l'évaluation de l'expression dans le contexte des clauses :keyword:`for` et :" "keyword:`if` qui la suivent. Par exemple, cette compréhension de liste " "combine les éléments de deux listes s'ils ne sont pas égaux : ::" #: ../Doc/tutorial/datastructures.rst:225 msgid "and it's equivalent to::" msgstr "et c'est équivaent à : ::" #: ../Doc/tutorial/datastructures.rst:236 msgid "" "Note how the order of the :keyword:`for` and :keyword:`if` statements is the " "same in both these snippets." msgstr "" "Notez que l'ordre des instructions :keyword:`for` et :keyword:`if` est le " "même dans ces différents extraits de code." #: ../Doc/tutorial/datastructures.rst:239 msgid "" "If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), " "it must be parenthesized. ::" msgstr "" "Si l'expression est un tuple (c'est à dire ``(x, y)`` dans cet exemple), " "elle doit être entourée par des parenthèses : ::" #: ../Doc/tutorial/datastructures.rst:270 msgid "" "List comprehensions can contain complex expressions and nested functions::" msgstr "" "Les compréhensions de listes peuvent contenir des expressions complexes et " "des fonctions imbriquées : ::" #: ../Doc/tutorial/datastructures.rst:277 msgid "Nested List Comprehensions" msgstr "Compréhensions de listes imbriquées" #: ../Doc/tutorial/datastructures.rst:279 msgid "" "The initial expression in a list comprehension can be any arbitrary " "expression, including another list comprehension." msgstr "" "La première expression dans une compréhension de liste peut être n'importe " "quelle expression, y compris une autre compréhension de liste." #: ../Doc/tutorial/datastructures.rst:282 msgid "" "Consider the following example of a 3x4 matrix implemented as a list of 3 " "lists of length 4::" msgstr "" "Voyez l'exemple suivant d'une matrice de 3x4, implémentée sous la forme de 3 " "listes de 4 éléments : ::" #: ../Doc/tutorial/datastructures.rst:291 msgid "The following list comprehension will transpose rows and columns::" msgstr "" "Cette compréhension de liste va transposer les lignes et les colonnes : ::" #: ../Doc/tutorial/datastructures.rst:296 msgid "" "As we saw in the previous section, the nested listcomp is evaluated in the " "context of the :keyword:`for` that follows it, so this example is equivalent " "to::" msgstr "" "Comme on l'a vu dans la section précédente, la compréhension de liste " "imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui " "la suit, donc cet exemple est équivalent à : ::" #: ../Doc/tutorial/datastructures.rst:307 msgid "which, in turn, is the same as::" msgstr "lequel à son tour est équivalent à : ::" #: ../Doc/tutorial/datastructures.rst:320 msgid "" "In the real world, you should prefer built-in functions to complex flow " "statements. The :func:`zip` function would do a great job for this use case::" msgstr "" "Dans des cas concrets, il est toujours préférable d'utiliser des fonctions " "natives plutôt que des instructions de contrôle de flux complexes. La " "fonction :func:`zip` ferait dans ce cas un excellent travail : ::" #: ../Doc/tutorial/datastructures.rst:326 msgid "" "See :ref:`tut-unpacking-arguments` for details on the asterisk in this line." msgstr "" "Voyez :ref:`tut-unpacking-arguments` pour plus de détails sur cette ligne." #: ../Doc/tutorial/datastructures.rst:331 msgid "The :keyword:`del` statement" msgstr "L'instruction :keyword:`del`" #: ../Doc/tutorial/datastructures.rst:333 msgid "" "There is a way to remove an item from a list given its index instead of its " "value: the :keyword:`del` statement. This differs from the :meth:`pop` " "method which returns a value. The :keyword:`del` statement can also be used " "to remove slices from a list or clear the entire list (which we did earlier " "by assignment of an empty list to the slice). For example::" msgstr "" "Il existe un moyen de retirer un élément d'une liste à partir de sa position " "au lieu de sa valeur : l'instruction :keyword:`del`. Elle diffère de la " "méthode :meth:`pop` qui, elle, renvoie une valeur. L'instruction :keyword:" "`del` peut également être utilisée pour supprimer des tranches d'une liste " "ou la vider complètement (ce que nous avions fait auparavent en affectant " "une liste vide à la tranche). Par exemple : ::" #: ../Doc/tutorial/datastructures.rst:350 msgid ":keyword:`del` can also be used to delete entire variables::" msgstr "" ":keyword:`del` peut aussi être utilisée pour supprimer des variables : ::" #: ../Doc/tutorial/datastructures.rst:354 msgid "" "Referencing the name ``a`` hereafter is an error (at least until another " "value is assigned to it). We'll find other uses for :keyword:`del` later." msgstr "" "À partir de là, référencer le nom ``a`` est une erreur (au moins jusqu'à ce " "qu'une autre valeur lui soit affectée). Vous trouverez d'autres utilisations " "de la fonction :keyword:`del` plus tard." #: ../Doc/tutorial/datastructures.rst:361 msgid "Tuples and Sequences" msgstr "Tuples et séquences" #: ../Doc/tutorial/datastructures.rst:363 msgid "" "We saw that lists and strings have many common properties, such as indexing " "and slicing operations. They are two examples of *sequence* data types " "(see :ref:`typesseq`). Since Python is an evolving language, other sequence " "data types may be added. There is also another standard sequence data type: " "the *tuple*." msgstr "" "Nous avons vu que les listes et les chaînes de caractères ont beaucoup de " "propriétés en commun, comme l'indexation et les opérations sur des tranches. " "Ce sont deux exemple de *séquences* (voir :ref:`typesseq`). Comme Python est " "un langage en constante évolution, d'autres types de séquences y seront peut-" "être ajoutés. Il existe également un autre type standard de séquence : le " "*tuple*." #: ../Doc/tutorial/datastructures.rst:369 msgid "" "A tuple consists of a number of values separated by commas, for instance::" msgstr "" "Un tuple consiste en différentes valeurs séparées par des virgules, comme " "par exemple : ::" #: ../Doc/tutorial/datastructures.rst:391 msgid "" "As you see, on output tuples are always enclosed in parentheses, so that " "nested tuples are interpreted correctly; they may be input with or without " "surrounding parentheses, although often parentheses are necessary anyway (if " "the tuple is part of a larger expression). It is not possible to assign to " "the individual items of a tuple, however it is possible to create tuples " "which contain mutable objects, such as lists." msgstr "" "Comme vous pouvez le voir, à l'affichage les tuples sont toujours encadrés " "par des parenthèses, de façon à ce que des tuples imbriqués soient " "interprétés correctement ; ils peuvent être entrés avec ou sans parenthèses, " "même si celles-ci sont souvent nécessaires (notamment lorsqu'un tuple fait " "partie d'une expression plus longue). Il n'est pas possible d'affecter de " "valeur à un élément d'un tuple ; par contre, il est possible de créer des " "tuples contenant des objets mutables, comme des listes." #: ../Doc/tutorial/datastructures.rst:398 msgid "" "Though tuples may seem similar to lists, they are often used in different " "situations and for different purposes. Tuples are :term:`immutable`, and " "usually contain a heterogeneous sequence of elements that are accessed via " "unpacking (see later in this section) or indexing (or even by attribute in " "the case of :func:`namedtuples `). 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:`immuable`\\s 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 `). Les listes sont souvent :term:`mutables `, et " "contiennent des éléments homogènes qui sont accédés par itération sur la " "liste." #: ../Doc/tutorial/datastructures.rst:406 msgid "" "A special problem is the construction of tuples containing 0 or 1 items: the " "syntax has some extra quirks to accommodate these. Empty tuples are " "constructed by an empty pair of parentheses; a tuple with one item is " "constructed by following a value with a comma (it is not sufficient to " "enclose a single value in parentheses). Ugly, but effective. For example::" msgstr "" "Un problème spécifique est la construction de tuples ne contenant aucun ou " "un seul élément : la syntaxe a quelques tournures spécifiques pour s'en " "accomoder. Les tuples vides sont construits par une paire de parenthèses " "vides ; un tuple avec un seul élément est construit en faisant suivre la " "valeur par une virgule (il n'est pas suffisant de placer cette valeur entre " "parenthèses). Pas très joli, mais efficace. Par exemple : ::" #: ../Doc/tutorial/datastructures.rst:421 msgid "" "The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple " "packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed " "together in a tuple. The reverse operation is also possible::" msgstr "" "L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple d'un *emballage " "de tuple* : les valeurs ``12345``, ``54321`` et ``hello !`` sont emballées " "ensemble dans un tuple. L'opération inverse est aussi possible : ::" #: ../Doc/tutorial/datastructures.rst:427 msgid "" "This is called, appropriately enough, *sequence unpacking* and works for any " "sequence on the right-hand side. Sequence unpacking requires that there are " "as many variables on the left side of the equals sign as there are elements " "in the sequence. Note that multiple assignment is really just a combination " "of tuple packing and sequence unpacking." msgstr "" "Ceci est appelé, de façon plus ou moins appropriée, un *déballage de " "séquence* et fonctionne pour toute séquence placée à droite de l'expression. " "Ce déballage requiert autant de variables dans la partie gauche qu'il y a " "d'éléments dans la séquence. Notez également que cette affectation multiple " "est juste une combinaison entre un emballage de tuple et un déballage de " "séquence." #: ../Doc/tutorial/datastructures.rst:437 msgid "Sets" msgstr "Les ensembles" #: ../Doc/tutorial/datastructures.rst:439 msgid "" "Python also includes a data type for *sets*. A set is an unordered " "collection with no duplicate elements. Basic uses include membership " "testing and eliminating duplicate entries. Set objects also support " "mathematical operations like union, intersection, difference, and symmetric " "difference." msgstr "" "Python fournit également un type de donnée pour les *ensembles*. Un ensemble " "est une collection non ordonnée sans élément dupliqué. Des utilisations " "basiques concernent par exemple des tests d'appartenance ou des suppressons " "de doublons. Les ensembles supportent également les opérations mathématiques " "comme les unions, intersections, différences et différences symétriques." #: ../Doc/tutorial/datastructures.rst:444 msgid "" "Curly braces or the :func:`set` function can be used to create sets. Note: " "to create an empty set you have to use ``set()``, not ``{}``; the latter " "creates an empty dictionary, a data structure that we discuss in the next " "section." msgstr "" "Des accolades, ou la fonction :func:`set` peuvent être utilisés pour créer " "des ensembles. Notez que pour créer un ensemble vide, ``{}`` ne " "fonctionne pas, cela créé un dictionnaire vide. Utilisez plutôt ``set()``." #: ../Doc/tutorial/datastructures.rst:448 msgid "Here is a brief demonstration::" msgstr "Voici une brève démonstration : ::" #: ../Doc/tutorial/datastructures.rst:473 msgid "" "Similarly to :ref:`list comprehensions `, set comprehensions " "are also supported::" msgstr "" "Tout comme les :ref:`comprehensions de listes `, il est " "possibled'écrire des comprehensions d'ensembles : ::" #: ../Doc/tutorial/datastructures.rst:484 msgid "Dictionaries" msgstr "Dictionnaires" #: ../Doc/tutorial/datastructures.rst:486 msgid "" "Another useful data type built into Python is the *dictionary* (see :ref:" "`typesmapping`). Dictionaries are sometimes found in other languages as " "\"associative memories\" or \"associative arrays\". Unlike sequences, which " "are indexed by a range of numbers, dictionaries are indexed by *keys*, which " "can be any immutable type; strings and numbers can always be keys. Tuples " "can be used as keys if they contain only strings, numbers, or tuples; if a " "tuple contains any mutable object either directly or indirectly, it cannot " "be used as a key. You can't use lists as keys, since lists can be modified " "in place using index assignments, slice assignments, or methods like :meth:" "`append` and :meth:`extend`." msgstr "" "Un autre type de donnée très utile, natif dans Python, est le *dictionnaire* " "(voir :ref:`typesmapping`). Ces dictionnaires sont parfois présents dans " "d'autres langages sous le nom de \"mémoires associatives\" ou de \"tableaux " "associatifs\". À la différence des séquences, qui sont indexées par des " "nombres, les dictionnaires sont indexés par des *clés*, qui peuvent être de " "n'importe quel type immuable ; les chaînes de caractères et les nombres " "peuvent toujours être des clés. Des tuples peuvent être utilisés comme clés " "s'ils ne contiennent que des chaînes, des nombres ou des tuples ; si un " "tuple contient un objet mutable, de façon directe ou indirecte, il ne peut " "pas être utilisé comme une clé. Vous ne pouvez pas utiliser des listes comme " "clés, car les listes peuvent être modifiées en place en utilisant des " "affectations par position, par tranches ou via des méthodes comme :meth:" "`append` ou :meth:`extend`." #: ../Doc/tutorial/datastructures.rst:497 msgid "" "It is best to think of a dictionary as an unordered set of *key: value* " "pairs, with the requirement that the keys are unique (within one " "dictionary). A pair of braces creates an empty dictionary: ``{}``. Placing a " "comma-separated list of key:value pairs within the braces adds initial key:" "value pairs to the dictionary; this is also the way dictionaries are written " "on output." msgstr "" "Le plus simple est de considérer les dictionnaires comme des ensembles non " "ordonnés de paires *clé: valeur*, les clés devant être uniques (au sein d'un " "dictionnaire). Une paire d'accolades crée un dictionnaire vide : ``{}``. " "Placer une liste de paires clé:valeur séparées par des virgules à " "l'intérieur des accolades ajoute les valeurs correspondantes au " "dictionnaire ; c'est également de cette façon que les dictionnaires sont " "affichés en sortie." #: ../Doc/tutorial/datastructures.rst:503 msgid "" "The main operations on a dictionary are storing a value with some key and " "extracting the value given the key. It is also possible to delete a key:" "value pair with ``del``. If you store using a key that is already in use, " "the old value associated with that key is forgotten. It is an error to " "extract a value using a non-existent key." msgstr "" "Les principales opérations effectuées sur un dictionnaire consistent à " "stocker une valeur pour une clé et à extraire la valeur correspondant à une " "clé. Il est également possible de supprimer une paire clé:valeur avec " "``del``. Si vous stockez une valeur pour une clé qui est déjà utilisée, " "l'ancienne valeur associée à cette clé est perdue. Si vous tentez d'extraire " "une valeur associée à une clé qui n'existe pas, une exception est levée." #: ../Doc/tutorial/datastructures.rst:509 msgid "" "Performing ``list(d.keys())`` on a dictionary returns a list of all the keys " "used in the dictionary, in arbitrary order (if you want it sorted, just use " "``sorted(d.keys())`` instead). [2]_ To check whether a single key is in the " "dictionary, use the :keyword:`in` keyword." msgstr "" "Exécuter ``list(d.keys())`` sur un dictionnaire ``d`` retourne une liste de " "toutes lesclés utilisées dans le dictionnaire, dans un ordre arbitraire (si " "vous voulez qu'elles soient triées, utilisez ``sorted(d.keys())``). [2]_ " "Pour tester si une clé est dans le dictionnaire, utilisez le mot-clé :" "keyword:`in`." #: ../Doc/tutorial/datastructures.rst:514 msgid "Here is a small example using a dictionary::" msgstr "Voici un petit exemple utilisant un dictionnaire : ::" #: ../Doc/tutorial/datastructures.rst:535 msgid "" "The :func:`dict` constructor builds dictionaries directly from sequences of " "key-value pairs::" msgstr "" "Le constructeur :func:`dict` fabrique un dictionnaire directement à partir " "d'une liste de paires clé-valeur stockées sous la forme de tuples : ::" #: ../Doc/tutorial/datastructures.rst:541 msgid "" "In addition, dict comprehensions can be used to create dictionaries from " "arbitrary key and value expressions::" msgstr "" "De plus, il est possible de créer des dictionnaires par compréhension depuis " "un jeu de clef et valeurs : ::" #: ../Doc/tutorial/datastructures.rst:547 msgid "" "When the keys are simple strings, it is sometimes easier to specify pairs " "using keyword arguments::" msgstr "" "Lorsque les clés sont de simples chaînes de caractères, il est parfois plus " "facile de spécifier les paires en utilisant des paramètres nommés : ::" #: ../Doc/tutorial/datastructures.rst:557 msgid "Looping Techniques" msgstr "Techniques de boucles" #: ../Doc/tutorial/datastructures.rst:559 msgid "" "When looping through dictionaries, the key and corresponding value can be " "retrieved at the same time using the :meth:`items` method. ::" msgstr "" "Lorsque vous faites une boucle sur un dictionnaire, les clés et leurs " "valeurs peuvent être récupérées en même temps en utilisant la méthode :meth:" "`items` ::" #: ../Doc/tutorial/datastructures.rst:569 msgid "" "When looping through a sequence, the position index and corresponding value " "can be retrieved at the same time using the :func:`enumerate` function. ::" msgstr "" "Lorsque vous itérez sur une séquence, la position et la valeur " "correspondante peuvent être récupérées en même temps en utilisant la " "fonction :func:`enumerate`." #: ../Doc/tutorial/datastructures.rst:579 msgid "" "To loop over two or more sequences at the same time, the entries can be " "paired with the :func:`zip` function. ::" msgstr "" "Pour faire des boucles sur deux séquences ou plus en même temps, les " "éléments peuvent être associés par la fonction :func:`zip` ::" #: ../Doc/tutorial/datastructures.rst:591 msgid "" "To loop over a sequence in reverse, first specify the sequence in a forward " "direction and then call the :func:`reversed` function. ::" msgstr "" "Pour faire une boucle sur une séquence inversée, commencez par créer la " "séquence dans son ordre normal, puis appliquez la fonction :func:" "`reversed` ::" #: ../Doc/tutorial/datastructures.rst:603 msgid "" "To loop over a sequence in sorted order, use the :func:`sorted` function " "which returns a new sorted list while leaving the source unaltered. ::" msgstr "" "Pour faire une boucle sur une séquence triée, utilisez la fonction :func:" "`sorted`, qui renvoie une nouvelle liste triée sans altérer la source : ::" #: ../Doc/tutorial/datastructures.rst:615 msgid "" "It is sometimes tempting to change a list while you are looping over it; " "however, it is often simpler and safer to create a new list instead. ::" msgstr "" "Il est parfois tentant de changer une liste pendant son itération, " "cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste " "à la place. ::" #: ../Doc/tutorial/datastructures.rst:632 msgid "More on Conditions" msgstr "Plus d'informations sur les conditions" #: ../Doc/tutorial/datastructures.rst:634 msgid "" "The conditions used in ``while`` and ``if`` statements can contain any " "operators, not just comparisons." msgstr "" "Les conditions utilisées dans une instruction ``while`` ou ``if`` peuvent " "contenir n'importe quel opérateur, pas seulement des comparaisons." #: ../Doc/tutorial/datastructures.rst:637 msgid "" "The comparison operators ``in`` and ``not in`` check whether a value occurs " "(does not occur) in a sequence. The operators ``is`` and ``is not`` compare " "whether two objects are really the same object; this only matters for " "mutable objects like lists. All comparison operators have the same " "priority, which is lower than that of all numerical operators." msgstr "" "Les opérateurs de comparaison ``in`` et ``not in`` testent si une valeur est " "présente ou non dans une séquence. Les opérateurs ``is`` et ``is not`` " "testent si deux objets sont vraiment le même objet ; ceci n'est important " "que pour des objets mutables comme des listes. Tous les opérateurs de " "comparaison ont la même priorité, qui est plus faible que celle des " "opérateurs numériques." #: ../Doc/tutorial/datastructures.rst:643 msgid "" "Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` " "is less than ``b`` and moreover ``b`` equals ``c``." msgstr "" "Les comparaison peuvent être enchaînées. Par exemple, ``a < b == c`` teste " "si ``a`` est inférieur ou égal à ``b`` et par ailleurs si ``b`` est égal à " "``c``." #: ../Doc/tutorial/datastructures.rst:646 msgid "" "Comparisons may be combined using the Boolean operators ``and`` and ``or``, " "and the outcome of a comparison (or of any other Boolean expression) may be " "negated with ``not``. These have lower priorities than comparison " "operators; between them, ``not`` has the highest priority and ``or`` the " "lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or " "C``. As always, parentheses can be used to express the desired composition." msgstr "" "Les comparaisons peuvent être combinées en utilisant les opérateurs booléens " "``and`` et ``or``, le résultat d'une comparaison (ou de toute expression " "booléenne) pouvant être inversé avec ``not``. Ces opérateurs ont une " "priorité inférieure à celle des opérateurs de comparaison ; entre eux, " "``not`` a la priorité la plus élevée et ``or`` la plus faible, de telle " "sorte que ``A and not B or C`` est équivalent à ``(A and (not B)) or C``. " "Comme toujours, des parenthèses peuvent être utilisées pour exprimer " "l'instruction désirée." #: ../Doc/tutorial/datastructures.rst:653 msgid "" "The Boolean operators ``and`` and ``or`` are so-called *short-circuit* " "operators: their arguments are evaluated from left to right, and evaluation " "stops as soon as the outcome is determined. For example, if ``A`` and ``C`` " "are true but ``B`` is false, ``A and B and C`` does not evaluate the " "expression ``C``. When used as a general value and not as a Boolean, the " "return value of a short-circuit operator is the last evaluated argument." msgstr "" "Les opérateurs booléens ``and`` et ``or`` sont appelés opérateurs *en " "circuit court* : leurs arguments sont évalués de la gauche vers la droite, " "et l'évaluation s'arrête dès que le résultat est déterminé. Par exemple, si " "``A`` et ``C`` sont vrais et ``B`` est faux, ``A and B and C`` n'évalue pas " "l'expression ``C``. Lorsqu'elle est utilisée en tant que valeur et non en " "tant que booléen, la valeur de retour d'un opérateur en circuit court est " "celle du dernier argument évalué." #: ../Doc/tutorial/datastructures.rst:660 msgid "" "It is possible to assign the result of a comparison or other Boolean " "expression to a variable. For example, ::" msgstr "" "Il est possible d'affecter le résultat d'une comparaison ou d'une autre " "expression booléenne à une variable. Par exemple : ::" #: ../Doc/tutorial/datastructures.rst:668 msgid "" "Note that in Python, unlike C, assignment cannot occur inside expressions. C " "programmers may grumble about this, but it avoids a common class of problems " "encountered in C programs: typing ``=`` in an expression when ``==`` was " "intended." msgstr "" "Notez qu'en Python, à la différence du C, des affectations ne peuvent pas " "intervenir à l'intérieur d'expressions. Les programmeurs C râleront peut-" "être après cela, mais cela évite des erreurs fréquentes que l'on rencontre " "en C, lorsque l'expression ``=`` est placée alors qu'une expression ``==`` " "était attendue." #: ../Doc/tutorial/datastructures.rst:677 msgid "Comparing Sequences and Other Types" msgstr "Comparer des séquences avec d'autres types" #: ../Doc/tutorial/datastructures.rst:679 msgid "" "Sequence objects may be compared to other objects with the same sequence " "type. The comparison uses *lexicographical* ordering: first the first two " "items are compared, and if they differ this determines the outcome of the " "comparison; if they are equal, the next two items are compared, and so on, " "until either sequence is exhausted. If two items to be compared are " "themselves sequences of the same type, the lexicographical comparison is " "carried out recursively. If all items of two sequences compare equal, the " "sequences are considered equal. If one sequence is an initial sub-sequence " "of the other, the shorter sequence is the smaller (lesser) one. " "Lexicographical ordering for strings uses the Unicode code point number to " "order individual characters. Some examples of comparisons between sequences " "of the same type::" msgstr "" "Des séquences peuvent être comparées avec d'autres séquences du même type. " "La comparaison utilise un ordre *lexicographique* : les deux premiers " "éléments de chaque séquence sont comparés, et s'ils diffèrent cela détermine " "le résultat de la comparaison ; s'ils sont égaux, les deux éléments suivants " "sont comparés à leur tour, et ainsi de suite jusqu'à ce que l'une des " "séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des " "séquences du même type, alors la comparaison lexicographique est effectuée " "récursivement. Si tous les éléments des deux séquences sont égaux, les deux " "séquences sont alors considérées comme égales. Si une séquence est une sous-" "séquence de l'autre, la séquence la plus courte est celle dont la valeur est " "inférieure. La comparaison lexicographique des chaînes de caractères utilise " "le code Unicode des caractères. Voici quelques exemples de comparaisons " "entre séquences de même type : ::" #: ../Doc/tutorial/datastructures.rst:699 msgid "" "Note that comparing objects of different types with ``<`` or ``>`` is legal " "provided that the objects have appropriate comparison methods. For example, " "mixed numeric types are compared according to their numeric value, so 0 " "equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, " "the interpreter will raise a :exc:`TypeError` exception." msgstr "" "Comparer des objets de type différents avec ``<`` ou ``>`` est autorisé si " "les objets ont des méthodes de comparaison appropriées. Par exemple, les " "types numériques sont comparées via leur valeur numérique, donc 0 est égal à " "0,0, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, " "l'interpréteur lancera une exception :exc:`TypeError`." #: ../Doc/tutorial/datastructures.rst:708 msgid "" "Other languages may return the mutated object, which allows method chaining, " "such as ``d->insert(\"a\")->remove(\"b\")->sort();``." msgstr "" "D'autres langages pourraient renvoie l'objet modifié, qui permet de chaîner " "les méthodes, tel que : ``d->insert(\"a\")->remove(\"b\")->sort();``." #: ../Doc/tutorial/datastructures.rst:711 msgid "" "Calling ``d.keys()`` will return a :dfn:`dictionary view` object. It " "supports operations like membership test and iteration, but its contents are " "not independent of the original dictionary -- it is only a *view*." msgstr "" "Appeler ``d.keys()`` renvoie un objet :dfn:`dictionary view`, qui gère les " "opérations du type test d'appartenance (``in``) et l'itération. Mais son " "contenu n'est pas indépendant du dictionnaire d'origine, c'est une simple " "*vue*." #: ../Doc/tutorial/errors.rst:5 msgid "Errors and Exceptions" msgstr "Erreurs et exceptions" #: ../Doc/tutorial/errors.rst:7 msgid "" "Until now error messages haven't been more than mentioned, but if you have " "tried out the examples you have probably seen some. There are (at least) " "two distinguishable kinds of errors: *syntax errors* and *exceptions*." msgstr "" "Jusqu'à maintenant, les messages d'erreurs ont seulement été mentionnés, " "mais si vous avez essayé les exemples vous avez certainement vu plus que " "cela. En fait, il y a au moins deux types d'erreurs à distinguer : les " "*erreurs de syntaxe* et les *exceptions*." #: ../Doc/tutorial/errors.rst:15 msgid "Syntax Errors" msgstr "Les erreurs de syntaxe" #: ../Doc/tutorial/errors.rst:17 msgid "" "Syntax errors, also known as parsing errors, are perhaps the most common " "kind of complaint you get while you are still learning Python::" msgstr "" "Les erreurs de syntaxe, qui sont des erreurs d'analyse du code, sont peut-" "être celles que vous rencontrez le plus souvent lorsque vous êtes encore en " "phase d'apprentissage de Python : ::" #: ../Doc/tutorial/errors.rst:26 msgid "" "The parser repeats the offending line and displays a little 'arrow' pointing " "at the earliest point in the line where the error was detected. The error " "is caused by (or at least detected at) the token *preceding* the arrow: in " "the example, the error is detected at the function :func:`print`, since a " "colon (``':'``) is missing before it. File name and line number are printed " "so you know where to look in case the input came from a script." msgstr "" "L'analyseur répère la ligne incriminée et affiche une petite 'flèche' " "pointant vers le premier endroit de la ligne où l'erreur a été détectée. " "L'erreur est causée (ou, au moins, a été détectée comme telle) par le " "symbole placé *avant* la flèche. Dans cet exemple la flèche est sur la " "fonction :func:`print` car il manque deux points (``':'``) justeavant. Le " "nom de fichier et le numéro de ligne sont affichés pour vous permettre de " "localiser facilement l'erreur lorsque le code provient d'un script." #: ../Doc/tutorial/errors.rst:37 msgid "Exceptions" msgstr "Les exceptions" #: ../Doc/tutorial/errors.rst:39 msgid "" "Even if a statement or expression is syntactically correct, it may cause an " "error when an attempt is made to execute it. Errors detected during " "execution are called *exceptions* and are not unconditionally fatal: you " "will soon learn how to handle them in Python programs. Most exceptions are " "not handled by programs, however, and result in error messages as shown " "here::" msgstr "" "Même si une instruction ou une expression est syntaxiquement correcte, elle " "peut générer une erreur lors de son exécution. Les erreurs détectées durant " "l'exécution son appelées des *exceptions* et ne sont pas toujours fatales : " "vous apprendrez bientôt comment les traîter dans vos programmes. La plupart " "des exceptions toutefois ne sont pas prises en charge par les programmes, ce " "qui génère des messages d'erreurs comme celui-ci : ::" #: ../Doc/tutorial/errors.rst:58 msgid "" "The last line of the error message indicates what happened. Exceptions come " "in different types, and the type is printed as part of the message: the " "types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:" "`TypeError`. The string printed as the exception type is the name of the " "built-in exception that occurred. This is true for all built-in exceptions, " "but need not be true for user-defined exceptions (although it is a useful " "convention). Standard exception names are built-in identifiers (not reserved " "keywords)." msgstr "" "La dernière ligne du message d'erreur indique la cause de l'erreur. Les " "exceptions peuvent être de différents types, et ce type est indiqué dans le " "message : les types indiqués dans l'exemple sont :exc:`ZeroDivisionError`, :" "exc:`NameError` et :exc:`TypeError`. Le texte affiché comme type de " "l'exception est le nom de l'exception native qui a été déclenchée. Ceci est " "vrai pour toutes les exceptions natives, mais n'est pas une obligation pour " "les exceptions définies par l'utilisateur (même si c'est une convention bien " "pratique). Les noms des exceptions standards sont des identifiants natifs " "(pas des mots réservés)." #: ../Doc/tutorial/errors.rst:66 msgid "" "The rest of the line provides detail based on the type of exception and what " "caused it." msgstr "" "Le reste de la ligne fournit plus de détails en fonction du type de " "l'exception et de ce qui l'a causé." #: ../Doc/tutorial/errors.rst:69 msgid "" "The preceding part of the error message shows the context where the " "exception happened, in the form of a stack traceback. In general it contains " "a stack traceback listing source lines; however, it will not display lines " "read from standard input." msgstr "" "La partie précédente du message d'erreur montre le contexte dans lequel " "s'est produite l'exception, sous la forme d'une trace de pile d'exécution. " "En général, celle-ci contient les lignes du code source ; toutefois, les " "lignes lues à partir de l'entrée standard ne seront pas affichées." #: ../Doc/tutorial/errors.rst:74 msgid "" ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings." msgstr "" "Vous trouverez dans :ref:`bltin-exceptions` la liste des exceptions natives " "et leur signification." #: ../Doc/tutorial/errors.rst:80 msgid "Handling Exceptions" msgstr "Gestion des exceptions" #: ../Doc/tutorial/errors.rst:82 msgid "" "It is possible to write programs that handle selected exceptions. Look at " "the following example, which asks the user for input until a valid integer " "has been entered, but allows the user to interrupt the program (using :kbd:" "`Control-C` or whatever the operating system supports); note that a user-" "generated interruption is signalled by raising the :exc:`KeyboardInterrupt` " "exception. ::" msgstr "" "Il est possible d'écrire des programmes qui prennent en charge certaines " "exceptions. Regardez l'exemple suivant, qui demande une saisie à " "l'utilisateur jusqu'à ce qu'un entier valide ait été entré, mais permet à " "l'utilisateur d'interrompre le programme (en utilisant :kbd:`Control-C` ou " "un autre raccourci que le système supporte) ; notez qu'une interruption " "générée par l'utilisateur est signalée en levant l'exception :exc:" "`KeyboardInterrupt`." #: ../Doc/tutorial/errors.rst:96 msgid "The :keyword:`try` statement works as follows." msgstr "L'instruction :keyword:`try` fonctionne comme ceci." #: ../Doc/tutorial/errors.rst:98 msgid "" "First, the *try clause* (the statement(s) between the :keyword:`try` and :" "keyword:`except` keywords) is executed." msgstr "" "Premièrement, la *clause try* (instruction(s) placée(s) entre les mots-clés :" "keyword:`try` et :keyword:`except`) est exécutée." #: ../Doc/tutorial/errors.rst:101 msgid "" "If no exception occurs, the *except clause* is skipped and execution of the :" "keyword:`try` statement is finished." msgstr "" "Si aucune exception n'intervient, la *clause except* est sautée et " "l'exécution de l'instruction :keyword:`try` est terminée." #: ../Doc/tutorial/errors.rst:104 msgid "" "If an exception occurs during execution of the try clause, the rest of the " "clause is skipped. Then if its type matches the exception named after the :" "keyword:`except` keyword, the except clause is executed, and then execution " "continues after the :keyword:`try` statement." msgstr "" "Si une exception intervient pendant l'exécution de la clause 'try', le reste " "de cette clause est sauté. Si son type correspond à un nom d'exception " "indiqué après le mot-clé :keyword:`except`, la clause 'except' " "correspondante est exécutée, puis l'exécution continue après l'instruction :" "keyword:`try`." #: ../Doc/tutorial/errors.rst:109 msgid "" "If an exception occurs which does not match the exception named in the " "except clause, it is passed on to outer :keyword:`try` statements; if no " "handler is found, it is an *unhandled exception* and execution stops with a " "message as shown above." msgstr "" "Si une exception intervient qui ne corresponde à aucune exception mentionnée " "dans la clause 'except', elle est transmise à l'instruction :keyword:`try` " "de niveau supérieur ; si aucun gestionnaire d'exception n'est trouvé, il " "s'agit d'une *exception non gérée* et l'exécution s'arrête avec un message " "comme indiqué ci-dessus." #: ../Doc/tutorial/errors.rst:114 msgid "" "A :keyword:`try` statement may have more than one except clause, to specify " "handlers for different exceptions. At most one handler will be executed. " "Handlers only handle exceptions that occur in the corresponding try clause, " "not in other handlers of the same :keyword:`try` statement. An except " "clause may name multiple exceptions as a parenthesized tuple, for example::" msgstr "" "Une instruction :keyword:`try` peut comporter plusieurs clauses except, pour " "permettre la prise en charge de différentes exceptions. Mais un seul " "gestionnaire, au plus, sera exécuté. Les gestionnaires ne prennent en charge " "que les exceptions qui interviennent dans la clause try correspondante, pas " "dans d'autres gestionnaires de la même instruction :keyword:`try`. Mais une " "même clause except peut citer plusieurs exceptions sous la forme d'un tuple " "entre parenthèses, comme dans cet exemple : ::" #: ../Doc/tutorial/errors.rst:123 msgid "" "The last except clause may omit the exception name(s), to serve as a " "wildcard. Use this with extreme caution, since it is easy to mask a real " "programming error in this way! It can also be used to print an error " "message and then re-raise the exception (allowing a caller to handle the " "exception as well)::" msgstr "" "La dernière clause except peut omettre le(s) nom(s) d'exception(s), pour " "servir de joker. C'est toutefois à utiliser avec beaucoup de précautions, " "car il est très facile de masquer une vraie erreur de programmation par ce " "biais. Elle peut aussi être utilisée pour afficher un message d'erreur avant " "de re-lever l'exception (en permettant à un appelant de prendre également en " "charge l'exception) ::" #: ../Doc/tutorial/errors.rst:142 msgid "" "The :keyword:`try` ... :keyword:`except` statement has an optional *else " "clause*, which, when present, must follow all except clauses. It is useful " "for code that must be executed if the try clause does not raise an " "exception. For example::" msgstr "" "L'instruction :keyword:`try` ... :keyword:`except` a également une *clause " "else* optionnelle qui, lorsqu'elle est présente, doit suivre toutes les " "clauses except. Elle est utile pour du code qui doit être exécuté " "lorsqu'aucune exception n'a été levée par la clause try. Par exemple : ::" #: ../Doc/tutorial/errors.rst:156 msgid "" "The use of the :keyword:`else` clause is better than adding additional code " "to the :keyword:`try` clause because it avoids accidentally catching an " "exception that wasn't raised by the code being protected by the :keyword:" "`try` ... :keyword:`except` statement." msgstr "" "Il vaut mieux utiliser la clause :keyword:`else`, plutôt que d'ajouter du " "code à la clause :keyword:`try`, car cela évite de capturer accidentellement " "une exception qui n'a pas été levée par le code initialement protégé par " "l'instruction :keyword:`try` ... :keyword:`except`." #: ../Doc/tutorial/errors.rst:161 msgid "" "When an exception occurs, it may have an associated value, also known as the " "exception's *argument*. The presence and type of the argument depend on the " "exception type." msgstr "" "Quand une exception intervient, une valeur peut lui être associée, que l'on " "appelle également *l'argument* de l'exception. La présence de cet argument " "et son type dépendent du type de l'exception." #: ../Doc/tutorial/errors.rst:165 msgid "" "The except clause may specify a variable after the exception name. The " "variable is bound to an exception instance with the arguments stored in " "``instance.args``. For convenience, the exception instance defines :meth:" "`__str__` so the arguments can be printed directly without having to " "reference ``.args``. One may also instantiate an exception first before " "raising it and add any attributes to it as desired. ::" msgstr "" "La clause except peut spécifier un nom de variable après le nom de " "l'exception. Cette variable est liée à une instance d'exception avec les " "arguments stockés dans ``instance.args``. Pour plus de commodité, l'instance " "de l'exception définit la méthode :meth:`__str__` afin que les arguments " "puissent être affichés directement sans avoir à référencer ``.args``. Il est " "possible de construire une exception, y ajouter ses attributs, puis la " "lancer plus tard. ::" #: ../Doc/tutorial/errors.rst:189 msgid "" "If an exception has arguments, they are printed as the last part ('detail') " "of the message for unhandled exceptions." msgstr "" "Si une exception a un argument, il est affiché dans la dernière partie " "('detail') du message des exceptions non gérées." #: ../Doc/tutorial/errors.rst:192 msgid "" "Exception handlers don't just handle exceptions if they occur immediately in " "the try clause, but also if they occur inside functions that are called " "(even indirectly) in the try clause. For example::" msgstr "" "Les gestionnaires d'exceptions n'interceptent pas que les exceptions qui " "sont levées immédiatement dans leur clause try, mais aussi celles qui sont " "levées au sein de fonctions appelées (parfois indirectement) dans la clause " "try. Par exemple : ::" #: ../Doc/tutorial/errors.rst:210 msgid "Raising Exceptions" msgstr "Déclencher des exceptions" #: ../Doc/tutorial/errors.rst:212 msgid "" "The :keyword:`raise` statement allows the programmer to force a specified " "exception to occur. For example::" msgstr "" "L'instruction :keyword:`raise` permet au programmeur de déclencher une " "exception spécifique. Par exemple : ::" #: ../Doc/tutorial/errors.rst:220 msgid "" "The sole argument to :keyword:`raise` indicates the exception to be raised. " "This must be either an exception instance or an exception class (a class " "that derives from :class:`Exception`)." msgstr "" "Le seul argument à :keyword:`raise` indique l'exception à déclencher. Cela " "peut être soit une instance d'exception, soit une classe d'exception (une " "classe dérivée de :class:`Exception`)." #: ../Doc/tutorial/errors.rst:224 msgid "" "If you need to determine whether an exception was raised but don't intend to " "handle it, a simpler form of the :keyword:`raise` statement allows you to re-" "raise the exception::" msgstr "" "Si vous devez savoir qu'une exception a été levée mais sans intention de la " "prendre en charge, une forme plus simple de l'instruction :keyword:`raise` " "permet de re-déclencher l'exception : ::" #: ../Doc/tutorial/errors.rst:243 msgid "User-defined Exceptions" msgstr "Exceptions définies par l'utilisateur" #: ../Doc/tutorial/errors.rst:245 msgid "" "Programs may name their own exceptions by creating a new exception class " "(see :ref:`tut-classes` for more about Python classes). Exceptions should " "typically be derived from the :exc:`Exception` class, either directly or " "indirectly." msgstr "" #: ../Doc/tutorial/errors.rst:249 msgid "" "Exception classes can be defined which do anything any other class can do, " "but are usually kept simple, often only offering a number of attributes that " "allow information about the error to be extracted by handlers for the " "exception. When creating a module that can raise several distinct errors, a " "common practice is to create a base class for exceptions defined by that " "module, and subclass that to create specific exception classes for different " "error conditions::" msgstr "" "Les classes d'exceptions peuvent être définies pour faire tout ce qu'une " "autre classe peut faire. Mais elles sont le plus souvent assez simples, " "n'offrant que les attributs permettant aux gestionnaires de ces exceptions " "d'extraire les informations relatives à l'erreur qui s'est produite. Lorsque " "l'on crée un module qui peut déclencher plusieurs types d'erreurs distincts, " "une pratique courante est de créer une classe de base pour l'ensemble des " "exceptions définies dans ce module, et de créer des sous-classes spécifiques " "d'exceptions pour les différentes conditions d'erreurs : ::" #: ../Doc/tutorial/errors.rst:287 msgid "" "Most exceptions are defined with names that end in \"Error,\" similar to the " "naming of the standard exceptions." msgstr "" "La plupart des exceptions sont définies avec des noms qui se terminent par " "\"Error\", comme pour les exceptions standards." #: ../Doc/tutorial/errors.rst:290 msgid "" "Many standard modules define their own exceptions to report errors that may " "occur in functions they define. More information on classes is presented in " "chapter :ref:`tut-classes`." msgstr "" "La plupart des modules standards définissent leurs propres exceptions pour " "décrire les erreurs que l'on peut rencontrer dans les fonctions qu'ils " "définissent. Plus d'informations sur les classes sont présentées dans le " "chapitre :ref:`tut-classes`." #: ../Doc/tutorial/errors.rst:298 msgid "Defining Clean-up Actions" msgstr "Définition d'actions de nettoyage" #: ../Doc/tutorial/errors.rst:300 msgid "" "The :keyword:`try` statement has another optional clause which is intended " "to define clean-up actions that must be executed under all circumstances. " "For example::" msgstr "" "L'instruction :keyword:`try` a une autre clause optionnelle qui est destinée " "à définir des actions de nettoyage devant être exécutées dans certaines " "circonstances. Par exemple : ::" #: ../Doc/tutorial/errors.rst:314 msgid "" "A *finally clause* is always executed before leaving the :keyword:`try` " "statement, whether an exception has occurred or not. When an exception has " "occurred in the :keyword:`try` clause and has not been handled by an :" "keyword:`except` clause (or it has occurred in an :keyword:`except` or :" "keyword:`else` clause), it is re-raised after the :keyword:`finally` clause " "has been executed. The :keyword:`finally` clause is also executed \"on the " "way out\" when any other clause of the :keyword:`try` statement is left via " "a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement. A " "more complicated example::" msgstr "" "Une *clause finally* est toujours exécutée avant de quitter l'instruction :" "keyword:`try`, qu'une exception ait été déclenchée ou non. Quand " "uneexception a été déclenchée dans la clause :keyword:`try` et n'a pas été " "prise en charge par une clause :keyword:`except` (ou si elle a été " "déclenchée dans une clause :keyword:`except` ou :keyword:`else`), elle est " "re-déclenchée après l'exécution de la clause :keyword:`finally`. La clause :" "keyword:`finally` est également exécutée \"à la sortie\" quand " "n'importequelle autre clause de l'instruction :keyword:`try` est abandonnée " "par une instruction :keyword:`break`, :keyword:`continue` ou :keyword:" "`return`. Voici un exemple plus compliqué : ::" #: ../Doc/tutorial/errors.rst:347 msgid "" "As you can see, the :keyword:`finally` clause is executed in any event. " "The :exc:`TypeError` raised by dividing two strings is not handled by the :" "keyword:`except` clause and therefore re-raised after the :keyword:`finally` " "clause has been executed." msgstr "" "Comme vous pouvez le voir, la clause :keyword:`finally` est exécutée dans " "tous les cas. L'exception de type :exc:`TypeError` déclenchée en divisant " "deux chaînes de caractères n'est pas prise en charge par la clause :keyword:" "`except` et est donc re-déclenchée après que la clause :keyword:`finally` " "ait été exécutée." #: ../Doc/tutorial/errors.rst:352 msgid "" "In real world applications, the :keyword:`finally` clause is useful for " "releasing external resources (such as files or network connections), " "regardless of whether the use of the resource was successful." msgstr "" "Dans les vraies applicatons, la clause :keyword:`finally` est notamment " "utile pour libérer des ressources externes (telles que des fichiers ou des " "connections réseau), que l'utilisation de ces ressources ait réussi ou non." #: ../Doc/tutorial/errors.rst:360 msgid "Predefined Clean-up Actions" msgstr "Actions de nettoyage prédéfinies" #: ../Doc/tutorial/errors.rst:362 msgid "" "Some objects define standard clean-up actions to be undertaken when the " "object is no longer needed, regardless of whether or not the operation using " "the object succeeded or failed. Look at the following example, which tries " "to open a file and print its contents to the screen. ::" msgstr "" "Certains objets définissent des actions de nettoyage standards qui doivent " "être exécutées lorsque l'objet n'est plus nécessaire, indépendamment du fait " "que l'opération ayant utilisé l'objet ait réussi ou non. Regardez l'exemple " "suivant, qui tente d'ouvrir un fichier et d'afficher son contenu à " "l'écran : ::" #: ../Doc/tutorial/errors.rst:370 msgid "" "The problem with this code is that it leaves the file open for an " "indeterminate amount of time after this part of the code has finished " "executing. This is not an issue in simple scripts, but can be a problem for " "larger applications. The :keyword:`with` statement allows objects like files " "to be used in a way that ensures they are always cleaned up promptly and " "correctly. ::" msgstr "" "Le problème avec ce code est qu'il laisse le fichier ouvert pendant une " "durée indéterminée après que le code ait fini de s'exécuter. Ce n'est pas un " "problème avec des scripts simples, mais peut l'être au sein d'applications " "plus conséquentes. L'instruction :keyword:`with` permet d'utiliser certains " "objets comme des fichiers d'une façon qui assure qu'ils seront toujours " "nettoyés rapidement et correctement. ::" #: ../Doc/tutorial/errors.rst:380 msgid "" "After the statement is executed, the file *f* is always closed, even if a " "problem was encountered while processing the lines. Objects which, like " "files, provide predefined clean-up actions will indicate this in their " "documentation." msgstr "" "Dès que l'instruction est exécutée, le fichier *f* est toujours fermé, même " "si un problème est survenu pendant l'exécution de ces lignes. D'autres " "objets qui, comme pour les fichiers, fournissent des actions de nettoyage " "prédéfinies l'indiquent dans leur documentation." #: ../Doc/tutorial/floatingpoint.rst:9 msgid "Floating Point Arithmetic: Issues and Limitations" msgstr "Arithmétique en Nombre à Virgule Flottante : Problèmes et Limites" #: ../Doc/tutorial/floatingpoint.rst:14 msgid "" "Floating-point numbers are represented in computer hardware as base 2 " "(binary) fractions. For example, the decimal fraction ::" msgstr "" "Les nombres à virgule flottante sont représentés, au niveau matériel, en " "fractions de nombres binaires (base 2). Par exemple, la fraction " "décimale : ::" #: ../Doc/tutorial/floatingpoint.rst:19 msgid "" "has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::" msgstr "" "a la valeur 1/10 + 2/100 + 5/1000, et de la même manière, la fraction " "binaire : ::" #: ../Doc/tutorial/floatingpoint.rst:23 msgid "" "has value 0/2 + 0/4 + 1/8. These two fractions have identical values, the " "only real difference being that the first is written in base 10 fractional " "notation, and the second in base 2." msgstr "" "a la valeur 0/2 + 0/4 + 1/8. Ces deux fractions ont une valeur identique, la " "seule différence est que la première est une fraction décimale, la seconde " "binaire." #: ../Doc/tutorial/floatingpoint.rst:27 msgid "" "Unfortunately, most decimal fractions cannot be represented exactly as " "binary fractions. A consequence is that, in general, the decimal floating-" "point numbers you enter are only approximated by the binary floating-point " "numbers actually stored in the machine." msgstr "" "Malheureusement, la plupart des fractions décimales n'ont pas de " "représentation exacte en fractions binaires. Par conséquent, en général, les " "nombres à virgule flottante que vous donnez sont seulement approximés en " "fraction binaire pour être stocké dans la machine." #: ../Doc/tutorial/floatingpoint.rst:32 msgid "" "The problem is easier to understand at first in base 10. Consider the " "fraction 1/3. You can approximate that as a base 10 fraction::" msgstr "" "Le problème est plus simple à aborder en base 10. Prenons par exemple, la " "fraction 1/3. Vous pouvez l'approximer en une fraction décimale::" #: ../Doc/tutorial/floatingpoint.rst:37 ../Doc/tutorial/floatingpoint.rst:41 msgid "or, better, ::" msgstr "ou, mieux, ::" #: ../Doc/tutorial/floatingpoint.rst:45 msgid "" "and so on. No matter how many digits you're willing to write down, the " "result will never be exactly 1/3, but will be an increasingly better " "approximation of 1/3." msgstr "" "etc... Peu importe le nombre de décimales que vous écrirez, le résultat ne " "sera jamais exactement 1/3, mais une estimation s'en approchant toujours " "mieux." #: ../Doc/tutorial/floatingpoint.rst:49 msgid "" "In the same way, no matter how many base 2 digits you're willing to use, the " "decimal value 0.1 cannot be represented exactly as a base 2 fraction. In " "base 2, 1/10 is the infinitely repeating fraction ::" msgstr "" "De la même manière, peu importe combien de décimales en base 2 vous " "utiliserez, la valeur décimale 0.1 ne peut être représentée exactement en " "fraction binaire. En base 2, 1/10 est le nombre périodique suivant : ::" #: ../Doc/tutorial/floatingpoint.rst:55 msgid "" "Stop at any finite number of bits, and you get an approximation. On most " "machines today, floats are approximated using a binary fraction with the " "numerator using the first 53 bits starting with the most significant bit and " "with the denominator as a power of two. In the case of 1/10, the binary " "fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly " "equal to the true value of 1/10." msgstr "" "En se limitant à une quantité finie de bits, on ne peut obtenir qu'une " "approximation. Sur la majorité des machines aujourd'hui, les nombres à " "virgule flottante sont approximés par une fraction binaire avec les 53 " "premiers bits comme numérateur et une puissance de deux au dénominateur. " "Dans le cas de 1/10, la fraction binaire est ``3602879701896397 / 2 ** 55`` " "qui est proche mais pas exactement 1/10." #: ../Doc/tutorial/floatingpoint.rst:62 msgid "" "Many users are not aware of the approximation because of the way values are " "displayed. Python only prints a decimal approximation to the true decimal " "value of the binary approximation stored by the machine. On most machines, " "if Python were to print the true decimal value of the binary approximation " "stored for 0.1, it would have to display ::" msgstr "" "Il est facile d'oublier que la valeur stockée est une approximation de la " "fraction décimale d'origine, du fait de la manière dont les flottants sont " "affichés dans l'interpréteur. Python n'affiche qu'une approximation décimale " "de la valeur stockée en binaire. Si Python devait afficher la vraie valeur " "décimale de l'approximation binaire stockée pour 0,1, il afficherait : ::" #: ../Doc/tutorial/floatingpoint.rst:71 msgid "" "That is more digits than most people find useful, so Python keeps the number " "of digits manageable by displaying a rounded value instead ::" msgstr "" "C'est bien plus de décimales que nécessaire, donc Python affiche une valeur " "arrondie afin d'améliorer la lisibilité : ::" #: ../Doc/tutorial/floatingpoint.rst:77 msgid "" "Just remember, even though the printed result looks like the exact value of " "1/10, the actual stored value is the nearest representable binary fraction." msgstr "" "Il faut se rappeler, bien que la valeur affichée ressemble à la valeur " "exacte de 1/10, que la valeur stockée est la représentation la plus proche " "en fraction binaire." #: ../Doc/tutorial/floatingpoint.rst:80 msgid "" "Interestingly, there are many different decimal numbers that share the same " "nearest approximate binary fraction. For example, the numbers ``0.1`` and " "``0.10000000000000001`` and " "``0.1000000000000000055511151231257827021181583404541015625`` are all " "approximated by ``3602879701896397 / 2 ** 55``. Since all of these decimal " "values share the same approximation, any one of them could be displayed " "while still preserving the invariant ``eval(repr(x)) == x``." msgstr "" "Il existe beaucoup de nombres décimaux qui partagent une même approximation " "en fraction binaire. Par exemple, ``0.1``, ``0.10000000000000001``, et " "``0.1000000000000000055511151231257827021181583404541015625`` ont tous pour " "approximation ``3602879701896397 / 2 ** 55``. Puisques toutes ces valeurs " "décimales partagent la même approximation, chacune peut être affichée tout " "en respectant ``eval(repr(x)) == x``." #: ../Doc/tutorial/floatingpoint.rst:88 msgid "" "Historically, the Python prompt and built-in :func:`repr` function would " "choose the one with 17 significant digits, ``0.10000000000000001``. " "Starting with Python 3.1, Python (on most systems) is now able to choose the " "shortest of these and simply display ``0.1``." msgstr "" "Historiquement, le mode interactif de Python et la primitive :func:`repr` " "auraient choisi la version avec 17 décimales significatives, " "``0.10000000000000001``. Python, depuis la version 3.1 (sur la majorité des " "systèmes) est maintenant capable de choisir la plus courte représentation et " "n'afficher que ``0.1``." #: ../Doc/tutorial/floatingpoint.rst:93 msgid "" "Note that this is in the very nature of binary floating-point: this is not a " "bug in Python, and it is not a bug in your code either. You'll see the same " "kind of thing in all languages that support your hardware's floating-point " "arithmetic (although some languages may not *display* the difference by " "default, or in all output modes)." msgstr "" "Ce comportement est inhérent au comportement des nombres à virgule " "flottante : ce n'est pas un bug dans Python, et ce n'est pas non plus un bug " "dans votre code. Vous verrez le même type de comportement dans tous les " "autres langages utilisant le support matériel pour le calcul des nombres à " "virgules flottante (bien que certains langages ne rendent pas visible la " "différence par défaut, ou pas dans tous les modes d'affichage)." #: ../Doc/tutorial/floatingpoint.rst:99 msgid "" "For more pleasant output, you may wish to use string formatting to produce a " "limited number of significant digits::" msgstr "" "Pour obtenir un affichage plus plaisant, les fonctions de formatage de " "chaînes de caractères peuvent limiter le nombre de décimales significatives " "affichées::" #: ../Doc/tutorial/floatingpoint.rst:111 msgid "" "It's important to realize that this is, in a real sense, an illusion: you're " "simply rounding the *display* of the true machine value." msgstr "" "Il est important de comprendre qu'en réalité, c'est une illusion : Python " "arrondit simplement, la vraie valeur stockée, à *l'affichage*." #: ../Doc/tutorial/floatingpoint.rst:114 msgid "" "One illusion may beget another. For example, since 0.1 is not exactly 1/10, " "summing three values of 0.1 may not yield exactly 0.3, either::" msgstr "" "Une autre conséquence du fait que 0,1 n'est pas exactement stocké 1/10 est " "que la somme de trois valeurs de 0,1 ne donne pas 0,3 non plus : ::" #: ../Doc/tutorial/floatingpoint.rst:120 msgid "" "Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 " "cannot get any closer to the exact value of 3/10, then pre-rounding with :" "func:`round` function cannot help::" msgstr "" "Aussi, puisque 0,1 ne peut pas être stocké avec une représentation plus " "proche de sa valeur exacte 1/10, comme 0,3 qui ne peut pas être plus proche " "de sa valeur exacte 3/10, arrondir avec la fonction :func:`round` n'aide en " "rien : ::" #: ../Doc/tutorial/floatingpoint.rst:127 msgid "" "Though the numbers cannot be made closer to their intended exact values, " "the :func:`round` function can be useful for post-rounding so that results " "with inexact values become comparable to one another::" msgstr "" "Bien que les nombres ne peuvent se rapprocher plus de la valeur qu'on attend " "qu'ils aient, la fonction :func:`round` peut être utile à posteriori pour " "arrondir deux valeurs inexactes et les rendre comparables : ::" #: ../Doc/tutorial/floatingpoint.rst:134 msgid "" "Binary floating-point arithmetic holds many surprises like this. The " "problem with \"0.1\" is explained in precise detail below, in the " "\"Representation Error\" section. See `The Perils of Floating Point `_ 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 `_ pour une liste plus " "complète de ce genre de surprises." #: ../Doc/tutorial/floatingpoint.rst:139 msgid "" "As that says near the end, \"there are no easy answers.\" Still, don't be " "unduly wary of floating-point! The errors in Python float operations are " "inherited from the floating-point hardware, and on most machines are on the " "order of no more than 1 part in 2\\*\\*53 per operation. That's more than " "adequate for most tasks, but you do need to keep in mind that it's not " "decimal arithmetic and that every float operation can suffer a new rounding " "error." msgstr "" "Il est vrai qu'il n'existe pas de réponse simple, cependant ne vous méfiez " "pas trop des nombres à virtule flottante ! Les erreurs, en Python, dans les " "opérations de nombres à virgule flottante sont dues au matériel sous-jacent, " "et sur la plupart des machines ne sont pas plus importantes que 1 sur 2\\*" "\\*53 par opération. C'est plus que nécessaire pour la plupart des tâches, " "mais vous devez garder à l'esprit que ce ne sont pas des opérations " "décimales, et que chaque opération sur des nombres à virgule flottante peut " "souffrir d'une nouvelle erreur." #: ../Doc/tutorial/floatingpoint.rst:146 msgid "" "While pathological cases do exist, for most casual use of floating-point " "arithmetic you'll see the result you expect in the end if you simply round " "the display of your final results to the number of decimal digits you " "expect. :func:`str` usually suffices, and for finer control see the :meth:" "`str.format` method's format specifiers in :ref:`formatstrings`." msgstr "" "Bien que des cas pathologiques existent, pour la plupart des cas " "d'utilisations courants vous obtiendrez le résultat attendu à la fin et en " "arrondissant simplement au nombre de décimales désirées à l'affichage avec :" "func:`str`. Pour un contrôle fin sur la manière dont les décimales sont " "affichées, consultez dans :ref:`formatstrings` les spécifications de " "formattage de la méthode :meth:`str.format`." #: ../Doc/tutorial/floatingpoint.rst:152 msgid "" "For use cases which require exact decimal representation, try using the :mod:" "`decimal` module which implements decimal arithmetic suitable for accounting " "applications and high-precision applications." msgstr "" "Pour les cas requérant une représentation décimale exacte, le module :mod:" "`decimal` peut être utile, il implémente l'arithmétique décimale et peut " "donc être un choix adapté pour des applications nécessitant une grande " "précision." #: ../Doc/tutorial/floatingpoint.rst:156 msgid "" "Another form of exact arithmetic is supported by the :mod:`fractions` module " "which implements arithmetic based on rational numbers (so the numbers like " "1/3 can be represented exactly)." msgstr "" "Une autre forme d'arithmétique exacte est implémentée dans le module :mod:" "`fractions` qui se base sur les nombre rationnels (donc 1/3 peut y être " "représenté exactement)." #: ../Doc/tutorial/floatingpoint.rst:160 msgid "" "If you are a heavy user of floating point operations you should take a look " "at the Numerical Python package and many other packages for mathematical and " "statistical operations supplied by the SciPy project. See ." msgstr "" "Si vous êtes un utilisateur intensif des opérations sur les nombres à " "virgule flottante, vous devriez regarder le paquet *Numerical Python* et une " "série d'autres paquets pour les opérations statistiques et mathématiques " "fournis par le projet SciPy. Voir ." #: ../Doc/tutorial/floatingpoint.rst:164 msgid "" "Python provides tools that may help on those rare occasions when you really " "*do* want to know the exact value of a float. The :meth:`float." "as_integer_ratio` method expresses the value of a float as a fraction::" msgstr "" "Python fournit des outils qui peuvent être utils dans les rares occasions ou " "vous voulez réellement connaître la valeur exacte d'un nombre à virgule " "flottante. La méthode :meth:`float.as_integer_ratio` donne la valeur du " "nombre sous forme de fraction : ::" #: ../Doc/tutorial/floatingpoint.rst:173 msgid "" "Since the ratio is exact, it can be used to losslessly recreate the original " "value::" msgstr "" "Puisque le ratio est exact, il peut être utilisé pour recréer la valeur " "originale dans perte : ::" #: ../Doc/tutorial/floatingpoint.rst:179 msgid "" "The :meth:`float.hex` method expresses a float in hexadecimal (base 16), " "again giving the exact value stored by your computer::" msgstr "" "La méthode :meth:`float.hex` donne le nombre en hexadécimal (base 16), " "donnant ici aussi la valeur exacte stockée par la machine : ::" #: ../Doc/tutorial/floatingpoint.rst:185 msgid "" "This precise hexadecimal representation can be used to reconstruct the float " "value exactly::" msgstr "" "Cette représentation hexadécimale petit être utilisée pour reconstruire, " "sans approximation, le *float* ::" #: ../Doc/tutorial/floatingpoint.rst:191 msgid "" "Since the representation is exact, it is useful for reliably porting values " "across different versions of Python (platform independence) and exchanging " "data with other languages that support the same format (such as Java and " "C99)." msgstr "" "Puisque cette représentation est exacte, elle est pratique pour échanger des " "valeurs entre différentes version de Python (indépendamment de la machine) " "ou d'autres langages qui comprennent ce format (tel que Java et C99)." #: ../Doc/tutorial/floatingpoint.rst:195 msgid "" "Another helpful tool is the :func:`math.fsum` function which helps mitigate " "loss-of-precision during summation. It tracks \"lost digits\" as values are " "added onto a running total. That can make a difference in overall accuracy " "so that the errors do not accumulate to the point where they affect the " "final total:" msgstr "" "Une autre fonction utile est :func:`math.fsum`, qui aide à diminuer les " "pertes de précision lors des additions. Elle surveille les *décimales " "perdues* au fur et à mesure que les valeurs sont ajoutées au total. Cela " "peut faire une différence au niveau de la précision globale car cela empêche " "les erreurs de s'accumuler jusqu'au point ou le résultat final est affecté:" #: ../Doc/tutorial/floatingpoint.rst:209 msgid "Representation Error" msgstr "Erreurs de représentation" #: ../Doc/tutorial/floatingpoint.rst:211 msgid "" "This section explains the \"0.1\" example in detail, and shows how you can " "perform an exact analysis of cases like this yourself. Basic familiarity " "with binary floating-point representation is assumed." msgstr "" "Cette section explique en détail l'exemple du \"0.1\", et montre comment " "vous pouvez effectuer une analyse exacte de ce type de cas par vous-même. Il " "est supposé que vous êtes déjà familier de la représentation binaire des " "nombres flottants." #: ../Doc/tutorial/floatingpoint.rst:215 msgid "" ":dfn:`Representation error` refers to the fact that some (most, actually) " "decimal fractions cannot be represented exactly as binary (base 2) " "fractions. This is the chief reason why Python (or Perl, C, C++, Java, " "Fortran, and many others) often won't display the exact decimal number you " "expect." msgstr "" "Le terme :dfn:`Representation error` signifie que la plupart des fractions " "décimales ne peuvent être représentées exactement en binaire. C'est la " "principale raison pour laquelle Python (ou Perl, C, C++, Java, Fortran, et " "beuacoup d'autres) n'affiche habituellement pas le résultat exact en décimal." #: ../Doc/tutorial/floatingpoint.rst:220 msgid "" "Why is that? 1/10 is not exactly representable as a binary fraction. Almost " "all machines today (November 2000) use IEEE-754 floating point arithmetic, " "and almost all platforms map Python floats to IEEE-754 \"double precision" "\". 754 doubles contain 53 bits of precision, so on input the computer " "strives to convert 0.1 to the closest fraction it can of the form *J*/2**\\ " "*N* where *J* is an integer containing exactly 53 bits. Rewriting ::" msgstr "" "Pourquoi ? 1/10 n'est pas représentable de manière exacte en fractions " "binaires. Cependant, toutes les machines d'aujourd'hui (Juillet 2010) " "suivent la norme IEEE-754 en ce qui concerne l'arithmétique des nombres à " "virgule flottante. et la plupart des plateformes utilisent un \"IEEE-754 " "double precision\" pour représenter les floats de Python. Les \"IEEE-754 " "double precision\" utilisent 53 bits de précision, donc a la lecture " "l'ordinateur essaie de convertir 0,1 dans la fraction la plus proche " "possible de la forme *J*/2**\\ *N* avec *J* un nombre entier d'exactement 53 " "bits. Réecrire : ::" #: ../Doc/tutorial/floatingpoint.rst:229 msgid "as ::" msgstr "en : ::" #: ../Doc/tutorial/floatingpoint.rst:233 msgid "" "and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< " "2**53``), the best value for *N* is 56::" msgstr "" "en se rappelant que *J* fait exactement 53 bits (donc ``>= 2**52`` mais ``< " "2**53``), la meilleur valeur possible pour *N* est 56::" #: ../Doc/tutorial/floatingpoint.rst:239 msgid "" "That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits. " "The best possible value for *J* is then that quotient rounded::" msgstr "" "Donc 56 est la seule valeur possible pour *N* qui laisse exactement 53 bits " "pour *J*. La meilleure valeur possible pour *J* est donc ce quotient, " "arrondi::" #: ../Doc/tutorial/floatingpoint.rst:246 msgid "" "Since the remainder is more than half of 10, the best approximation is " "obtained by rounding up::" msgstr "" "Puisque la retenue est plus grande que la moitié de 10, la meilleure " "approximation est obtenue en arrondissant par le haut:" #: ../Doc/tutorial/floatingpoint.rst:252 msgid "" "Therefore the best possible approximation to 1/10 in 754 double precision " "is::" msgstr "" "Par conséquent la meilleure approximation possible pour 1/10 en \"IEEE-754 " "double precision\" est cette au desus de 2\\*\\*56, soit : ::" #: ../Doc/tutorial/floatingpoint.rst:256 msgid "" "Dividing both the numerator and denominator by two reduces the fraction to::" msgstr "" "Diviser le numérateur et le dénominateur par deux réduit la fraction à : ::" #: ../Doc/tutorial/floatingpoint.rst:260 msgid "" "Note that since we rounded up, this is actually a little bit larger than " "1/10; if we had not rounded up, the quotient would have been a little bit " "smaller than 1/10. But in no case can it be *exactly* 1/10!" msgstr "" "Notez que puisque l'arrondi a été fait vers le haut, le résultat est en " "réalité légèrement plus grand que 1/10; si nous n'avions pas arrondi par le " "haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun " "cas il ne vaut *exactement* 1/10 !" #: ../Doc/tutorial/floatingpoint.rst:264 msgid "" "So the computer never \"sees\" 1/10: what it sees is the exact fraction " "given above, the best 754 double approximation it can get::" msgstr "" "Donc l'ordinateur ne \"voit\" jamais 1/10: ce qu'il voit est la fraction " "exacte donnée ci-dessus, la meilleure approximation utilisant les nombres à " "virgule flottante double précision de l'\"IEEE-754\"" #: ../Doc/tutorial/floatingpoint.rst:270 msgid "" "If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 " "decimal digits::" msgstr "" "Si on multiplie cette fraction par 10\\*\\*30, on peut observer les valeurs " "de ses 55 décimales de poid fort::" #: ../Doc/tutorial/floatingpoint.rst:276 msgid "" "meaning that the exact number stored in the computer is equal to the decimal " "value 0.1000000000000000055511151231257827021181583404541015625. Instead of " "displaying the full decimal value, many languages (including older versions " "of Python), round the result to 17 significant digits::" msgstr "" "la valeur stockée dans l'ordinateur est donc égale à " "0,1000000000000000055511151231257827021181583404541015625. Au lieu " "d'afficher toutes les décimales, beaucoup de langages (dont les vieilles " "version de Python) arrondissent le résultat à la 17eme décimale " "significative." #: ../Doc/tutorial/floatingpoint.rst:284 msgid "" "The :mod:`fractions` and :mod:`decimal` modules make these calculations " "easy::" msgstr "" "Les modules :mod:`fractions` et :mod:`decimal` rendent simples ces " "calculs : ::" #: ../Doc/tutorial/index.rst:5 msgid "The Python Tutorial" msgstr "Le tutoriel python" #: ../Doc/tutorial/index.rst:7 msgid "" "Python is an easy to learn, powerful programming language. It has efficient " "high-level data structures and a simple but effective approach to object-" "oriented programming. Python's elegant syntax and dynamic typing, together " "with its interpreted nature, make it an ideal language for scripting and " "rapid application development in many areas on most platforms." msgstr "" "Python est un langage de programmation puissant et facile à apprendre. Il " "dispose de structures de données de haut niveau et d'une approche de la " "programmation orientée objet simple mais efficace. Parce que sa syntaxe est " "élégante, que son typage est dynamique et qu'il est interprété, Python est " "un langage idéal pour l'écriture de scripts et le développement rapide " "d'applications dans de nombreux domaines et sur de nombreuses plateformes." #: ../Doc/tutorial/index.rst:13 msgid "" "The Python interpreter and the extensive standard library are freely " "available in source or binary form for all major platforms from the Python " "Web site, https://www.python.org/, and may be freely distributed. The same " "site also contains distributions of and pointers to many free third party " "Python modules, programs and tools, and additional documentation." msgstr "" "L'interpréteur Python et sa vaste bibliothèque standard sont disponibles " "librement, sous forme de sources ou de binaires, pour toutes les plateformes " "majeures, depuis le site Internet http://www.python.org/ et peuvent être " "librement redistribués. Le même site distribue et contient des liens vers " "des modules, des programmes et des outils tiers ainsi que vers de la " "documentation supplémentaire." #: ../Doc/tutorial/index.rst:19 msgid "" "The Python interpreter is easily extended with new functions and data types " "implemented in C or C++ (or other languages callable from C). Python is also " "suitable as an extension language for customizable applications." msgstr "" "L'interpréteur Python peut être facilement étendu par de nouvelles fonctions " "et types de données implémentés en C ou C++ (ou tout autre langage appelable " "depuis le C). Python est également adapté comme langage d'extension pour " "personnaliser des applications." #: ../Doc/tutorial/index.rst:23 msgid "" "This tutorial introduces the reader informally to the basic concepts and " "features of the Python language and system. It helps to have a Python " "interpreter handy for hands-on experience, but all examples are self-" "contained, so the tutorial can be read off-line as well." msgstr "" "Ce tutoriel introduit au lecteur, de façon informelle, les concepts de base " "ainsi que les fonctionnalités du langage Python et de son écosystème. Il " "aide à prendre en main l'interpréteur Python pour une utilisation sur des " "cas pratiques. Les exemples étant indépendants, le tutoriel est adapté à une " "lecture hors ligne." #: ../Doc/tutorial/index.rst:28 msgid "" "For a description of standard objects and modules, see :ref:`library-" "index`. :ref:`reference-index` gives a more formal definition of the " "language. To write extensions in C or C++, read :ref:`extending-index` and :" "ref:`c-api-index`. There are also several books covering Python in depth." msgstr "" "Pour une description des objets et modules de la bibliothèque standard, " "voyez :ref:`library-index`. :ref:`reference-index` présente une définition " "plus formelle du langage. Pour écrire des extensions en C ou en C++, lisez :" "ref:`extending-index` et :ref:`c-api-index`. Des livres sont également " "disponibles qui couvrent Python dans le détail." #: ../Doc/tutorial/index.rst:33 msgid "" "This tutorial does not attempt to be comprehensive and cover every single " "feature, or even every commonly used feature. Instead, it introduces many of " "Python's most noteworthy features, and will give you a good idea of the " "language's flavor and style. After reading it, you will be able to read and " "write Python modules and programs, and you will be ready to learn more about " "the various Python library modules described in :ref:`library-index`." msgstr "" "L'ambition de ce tutoriel n'est pas d'être exhaustif et de couvrir chaque " "fonctionnalités, ni même toutes les fonctionnalités les plus utilisées. Il " "cherche, par contre, à introduire plusieurs des fonctionnalités les plus " "notables et à vous donner une bonne idée de la saveur et du style du " "langage. Après l'avoir lu, vous serez capable de lire et d'écrire des " "modules et des programmes Python et vous serez prêts à en apprendre " "d'avantage sur les modules de la bibliothèque Python décrits dans :ref:" "`library-index`." #: ../Doc/tutorial/index.rst:40 msgid "The :ref:`glossary` is also worth going through." msgstr "Pensez aussi à consulter le :ref:`glossary`." #: ../Doc/tutorial/inputoutput.rst:5 msgid "Input and Output" msgstr "Les entrées/sorties" #: ../Doc/tutorial/inputoutput.rst:7 msgid "" "There are several ways to present the output of a program; data can be " "printed in a human-readable form, or written to a file for future use. This " "chapter will discuss some of the possibilities." msgstr "" "Il existe bien des moyens de présenter les sorties d'un programmes ; les " "données peuvent être imprimées sous une forme lisible par un être humain, ou " "sauvegardées dans un fichier pour une utilisation future. Ce chapitre " "présentera donc diverses possibilités." #: ../Doc/tutorial/inputoutput.rst:15 msgid "Fancier Output Formatting" msgstr "Formatage de données" #: ../Doc/tutorial/inputoutput.rst:17 msgid "" "So far we've encountered two ways of writing values: *expression statements* " "and the :func:`print` function. (A third way is using the :meth:`write` " "method of file objects; the standard output file can be referenced as ``sys." "stdout``. See the Library Reference for more information on this.)" msgstr "" "Jusque là, nous avons rencontré deux moyens d'écrire des données : les " "*déclarations d'expressions* et la fonction :func:`print`. (Une troisième " "méthode consiste à utiliser la méthode :meth:`write` des fichiers, le " "fichier de sortie standard peut être référence en tant que ``sys.stdout``. " "Voyez le Guide de Référence de la Bibliothèque Standard pour en savoir plus.)" #: ../Doc/tutorial/inputoutput.rst:22 msgid "" "Often you'll want more control over the formatting of your output than " "simply printing space-separated values. There are two ways to format your " "output; the first way is to do all the string handling yourself; using " "string slicing and concatenation operations you can create any layout you " "can imagine. The string type has some methods that perform useful " "operations for padding strings to a given column width; these will be " "discussed shortly. The second way is to use :ref:`formatted string literals " "`, or the :meth:`str.format` method." msgstr "" #: ../Doc/tutorial/inputoutput.rst:31 msgid "" "The :mod:`string` module contains a :class:`~string.Template` class which " "offers yet another way to substitute values into strings." msgstr "" "Le module :mod:`string` contient une classe :class:`~string.Template` qui " "offre encore une autre façon de remplacer des valeurs au sein de chaînes de " "caractères." #: ../Doc/tutorial/inputoutput.rst:34 msgid "" "One question remains, of course: how do you convert values to strings? " "Luckily, Python has ways to convert any value to a string: pass it to the :" "func:`repr` or :func:`str` functions." msgstr "" "Mais une question demeure, bien sûr : comment convertir des valeurs en " "chaînes de caractères ? Heureusement, Python fournit plusieurs moyens de " "convertir n'importe quelle valeur en chaîne : les fonctions :func:`repr` et :" "func:`str`." #: ../Doc/tutorial/inputoutput.rst:38 msgid "" "The :func:`str` function is meant to return representations of values which " "are fairly human-readable, while :func:`repr` is meant to generate " "representations which can be read by the interpreter (or will force a :exc:" "`SyntaxError` if there is no equivalent syntax). For objects which don't " "have a particular representation for human consumption, :func:`str` will " "return the same value as :func:`repr`. Many values, such as numbers or " "structures like lists and dictionaries, have the same representation using " "either function. Strings, in particular, have two distinct representations." msgstr "" "La fonction :func:`str` est destinée à renvoyer des représentations de " "valeurs qui soient lisibles par un être humain, alors que la fonction :func:" "`repr` est destinée à générer des représentations qui puissent être lues par " "l'interpréteur (ou forceront une :exc:`SyntaxError` s'il n'existe aucune " "syntaxe équivalente). Pour les objets qui n'ont pas de représentation " "humaine spécifique, :func:`str` renverra la même valeur que :func:`repr`. " "Beaucoup de valeurs, comme les nombres ou les structures telles que les " "listes ou les dictionnaires, ont la même représentation en utilisant les " "deux fonctions. Les chaînes de caractères et les nombres à virgule " "flottante, en revanche, ont deux représentations distinctes." #: ../Doc/tutorial/inputoutput.rst:47 ../Doc/tutorial/introduction.rst:22 msgid "Some examples::" msgstr "Quelques exemples : ::" #: ../Doc/tutorial/inputoutput.rst:70 msgid "Here are two ways to write a table of squares and cubes::" msgstr "Voici deux façons d'écrire une table de carrés et de cubes : ::" #: ../Doc/tutorial/inputoutput.rst:102 msgid "" "(Note that in the first example, one space between each column was added by " "the way :func:`print` works: it always adds spaces between its arguments.)" msgstr "" "(Notez que dans ce premier exemple, un espace entre chaque colonne a été " "ajouté par la façon dont fonctionne :func:`print`, qui ajoute toujours des " "espaces entre ses paramètres.)" #: ../Doc/tutorial/inputoutput.rst:105 msgid "" "This example demonstrates the :meth:`str.rjust` method of string objects, " "which right-justifies a string in a field of a given width by padding it " "with spaces on the left. There are similar methods :meth:`str.ljust` and :" "meth:`str.center`. These methods do not write anything, they just return a " "new string. If the input string is too long, they don't truncate it, but " "return it unchanged; this will mess up your column lay-out but that's " "usually better than the alternative, which would be lying about a value. " "(If you really want truncation you can always add a slice operation, as in " "``x.ljust(n)[:n]``.)" msgstr "" "Cet exemple démontre l'utilisation de la méthode :meth:`str.rjust` des " "chaînes de caractères, qui fait une justification à droite d'une chaîne dans " "un champ d'une largeur donnée en ajoutant des espaces sur la gauche. Il " "existe des méthodes similaires :meth:`str.ljust` et :meth:`str.center`. Ces " "méthodes n'écrivent rien, elles retournent simplement une nouvelle chaîne. " "Si la chaîne passée en paramètre est trop longue, elle n'est pas tronquée " "mais renvoyée sans modification ; ce qui peut déranger votre mise en page " "mais est souvent préférable à l'alternative, qui pourrait mentir sur une " "valeur (et si vous voulez vraiment tronquer vos valeurs, vous pouvez " "toujours utiliser une tranche, comme dans ``x.ljust(n)[:n]``)." #: ../Doc/tutorial/inputoutput.rst:115 msgid "" "There is another method, :meth:`str.zfill`, which pads a numeric string on " "the left with zeros. It understands about plus and minus signs::" msgstr "" "Il existe une autre méthode, :meth:`str.zfill`, qui comble une chaîne " "numérique à gauche avec des zéros. Elle comprend les signes plus et " "moins : ::" #: ../Doc/tutorial/inputoutput.rst:125 msgid "Basic usage of the :meth:`str.format` method looks like this::" msgstr "" "L'utilisation de base de la méthode :meth:`str.format` ressemble à cela : ::" #: ../Doc/tutorial/inputoutput.rst:130 msgid "" "The brackets and characters within them (called format fields) are replaced " "with the objects passed into the :meth:`str.format` method. A number in the " "brackets can be used to refer to the position of the object passed into the :" "meth:`str.format` method. ::" msgstr "" "Les accolades et les caractères qu'ils contiennent (appelés les champs de " "formatage) sont remplacés par les objets passés en paramètres à la méthode :" "meth:`str.format`. Un nombre entre accolades se réfère à la position de " "l'objet passé à la méthode :meth:`str.format`. ::" #: ../Doc/tutorial/inputoutput.rst:140 msgid "" "If keyword arguments are used in the :meth:`str.format` method, their values " "are referred to by using the name of the argument. ::" msgstr "" "Si des arguments nommés sont utilisés dans la méthode :meth:`str.format`, " "leurs valeurs sont utilisées en se basant sur le nom des arguments : ::" #: ../Doc/tutorial/inputoutput.rst:147 msgid "Positional and keyword arguments can be arbitrarily combined::" msgstr "" "Les arguments positionnés et nommés peuvent être combinés arbitrairement : ::" #: ../Doc/tutorial/inputoutput.rst:153 msgid "" "``'!a'`` (apply :func:`ascii`), ``'!s'`` (apply :func:`str`) and ``'!r'`` " "(apply :func:`repr`) can be used to convert the value before it is " "formatted::" msgstr "" "``'!a'`` (appliquer :func:`ascii`), ``'!s'`` (appliquer :func:`str`) et ``'!" "r'`` (appliquer :func:`repr`)peuvent être utilisées pour convertir les " "valeurs avant leur formatage : ::" #: ../Doc/tutorial/inputoutput.rst:162 msgid "" "An optional ``':'`` and format specifier can follow the field name. This " "allows greater control over how the value is formatted. The following " "example rounds Pi to three places after the decimal." msgstr "" "Des caractères ``':'`` suivis d'une spécification de formatage peuvent " "suivre le nom du champ. Ceci offre un niveau de contrôle plus fin sur la " "façon dont les valeurs sont formatées. L'exemple suivant arrondit Pi à trois " "décimales : ::" #: ../Doc/tutorial/inputoutput.rst:170 msgid "" "Passing an integer after the ``':'`` will cause that field to be a minimum " "number of characters wide. This is useful for making tables pretty. ::" msgstr "" "Indiquer un entier après le ``':'`` indique la largeur minimale de ce champ " "en nombre de caractères. C'est utile pour faire de jolis tableaux : ::" #: ../Doc/tutorial/inputoutput.rst:181 msgid "" "If you have a really long format string that you don't want to split up, it " "would be nice if you could reference the variables to be formatted by name " "instead of by position. This can be done by simply passing the dict and " "using square brackets ``'[]'`` to access the keys ::" msgstr "" "Si vous avez vraiment une longue chaîne de formatage que vous ne voulez pas " "découper, ce serait bien de pouvoir référencer les variables à formater par " "leur nom plutôt que par leur position. Cela peut être fait simplement en " "passant un dictionnaire et en utilisant des crochets ``'[]'`` pour accéder " "aux clés : ::" #: ../Doc/tutorial/inputoutput.rst:191 msgid "" "This could also be done by passing the table as keyword arguments with the " "'**' notation. ::" msgstr "" "On pourrait également faire ça en passant le tableau comme des arguments " "nommés en utilisant la notation '**' ::" #: ../Doc/tutorial/inputoutput.rst:198 msgid "" "This is particularly useful in combination with the built-in function :func:" "`vars`, which returns a dictionary containing all local variables." msgstr "" "C'est particulièrement utile en combinaison avec la fonction native :func:" "`vars`, qui retourne un dictionnaire contenant toutes les variables locales." #: ../Doc/tutorial/inputoutput.rst:201 msgid "" "For a complete overview of string formatting with :meth:`str.format`, see :" "ref:`formatstrings`." msgstr "" "Pour avoir une vue complète du formatage des chaînes de caractères avec la " "méthode :meth:`str.format`, voyez : :ref:`formatstrings`." #: ../Doc/tutorial/inputoutput.rst:206 msgid "Old string formatting" msgstr "Anciennes méthodes de formatage de chaînes" #: ../Doc/tutorial/inputoutput.rst:208 msgid "" "The ``%`` operator can also be used for string formatting. It interprets the " "left argument much like a :c:func:`sprintf`\\ -style format string to be " "applied to the right argument, and returns the string resulting from this " "formatting operation. For example::" msgstr "" "L'opérateur ``%`` peut aussi être utilisé pour formater des chaînes. Il " "interprète l'argument de gauche un peu comme une chaîne de formatage d'une " "fonction :c:func:`sprintf` à appliquer à l'argument de droite, et retourne " "la chaîne résultant de cette opération de formatage. Par exemple : ::" #: ../Doc/tutorial/inputoutput.rst:217 msgid "" "More information can be found in the :ref:`old-string-formatting` section." msgstr "" "Vous trouverez plus d'informations dans la section :ref:`old-string-" "formatting`." #: ../Doc/tutorial/inputoutput.rst:223 msgid "Reading and Writing Files" msgstr "Lecture et écriture de fichiers" #: ../Doc/tutorial/inputoutput.rst:229 msgid "" ":func:`open` returns a :term:`file object`, and is most commonly used with " "two arguments: ``open(filename, mode)``." msgstr "" ":func:`open` retourne un :term:`objet fichier`, et est le plus souvent " "utilisé avecdeux arguments : ``open(filename, mode)``." #: ../Doc/tutorial/inputoutput.rst:241 msgid "" "The first argument is a string containing the filename. The second argument " "is another string containing a few characters describing the way in which " "the file will be used. *mode* can be ``'r'`` when the file will only be " "read, ``'w'`` for only writing (an existing file with the same name will be " "erased), and ``'a'`` opens the file for appending; any data written to the " "file is automatically added to the end. ``'r+'`` opens the file for both " "reading and writing. The *mode* argument is optional; ``'r'`` will be " "assumed if it's omitted." msgstr "" "Le premier argument est une chaîne contenant le nom du fichier. Le second " "argument est une autre chaîne contenant quelques caractères décrivant la " "façon dont le fichier sera utilisé. *mode* peut être ``'r'`` quand le " "fichier ne sera accédé qu'en lecture, ``'w'`` en écriture seulement (un " "fichier existant portant le même nom sera alors écrasé), et ``'a'`` ouvre le " "fichier en mode ajout (toute donnée écrite dans le fichier est " "automatiquement ajoutée à la fin). ``'r+'`` ouvre le fichier en mode lecture/" "écriture. L'argument *mode* est optionnel ; sa valeur par défaut est ``'r'``." #: ../Doc/tutorial/inputoutput.rst:250 msgid "" "Normally, files are opened in :dfn:`text mode`, that means, you read and " "write strings from and to the file, which are encoded in a specific " "encoding. If encoding is not specified, the default is platform dependent " "(see :func:`open`). ``'b'`` appended to the mode opens the file in :dfn:" "`binary mode`: now the data is read and written in the form of bytes " "objects. This mode should be used for all files that don't contain text." msgstr "" "Normalement, les fichiers sont ouverts en :dfn:`mode texte`, c'est à dire " "que vous lisez et écrivez des chaînes de caractères depuis et dans ce " "fichier, qui y sont encodées avec un encodage donné. Si aucun encodage n'est " "spécifié, l'encodage par défaut dépendra de la plateforme (voir :func:" "`open`). ``'b'`` collé à la fin du mode indique que le fichier doit être " "ouvert en :dfn:`mode binaire` c'est à dire que les données sont lues et " "écrites sous formes d'octets. Ce mode est à utiliser pour les fichiers " "contenant autre chose que du texte." #: ../Doc/tutorial/inputoutput.rst:257 msgid "" "In text mode, the default when reading is to convert platform-specific line " "endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``. When " "writing in text mode, the default is to convert occurrences of ``\\n`` back " "to platform-specific line endings. This behind-the-scenes modification to " "file data is fine for text files, but will corrupt binary data like that in :" "file:`JPEG` or :file:`EXE` files. Be very careful to use binary mode when " "reading and writing such files." msgstr "" "En mode texte, le comportement par défaut, à la lecture, est de convertir " "les fin de lignes spécifiques à la plateforme (``\\n`` sur Unix, ``\\r\\n`` " "sur windows etc...) en simples ``\\n``. Lors de l'écriture, le comprennent " "par défaut est d'appliquer l'opération contraire : les ``\\n`` sont " "convertis dans leur équivalent sur la plateforme courante. Ces modifications " "effectuées automatiquement sont normales pour du texte mais détérioreraient " "des données binaires comme un fichier :file:`JPEG` ou :file:`EXE`. Soyez " "particulièrement attentifs à ouvrir ces fichiers binaires en mode binaire." #: ../Doc/tutorial/inputoutput.rst:269 msgid "Methods of File Objects" msgstr "Méthodes des objets fichiers" #: ../Doc/tutorial/inputoutput.rst:271 msgid "" "The rest of the examples in this section will assume that a file object " "called ``f`` has already been created." msgstr "" "Les derniers exemples de cette section supposeront qu'un objet fichier " "appelé ``f`` a déjà été créé." #: ../Doc/tutorial/inputoutput.rst:274 msgid "" "To read a file's contents, call ``f.read(size)``, which reads some quantity " "of data and returns it as a string (in text mode) or bytes object (in binary " "mode). *size* is an optional numeric argument. When *size* is omitted or " "negative, the entire contents of the file will be read and returned; it's " "your problem if the file is twice as large as your machine's memory. " "Otherwise, at most *size* bytes are read and returned. If the end of the " "file has been reached, ``f.read()`` will return an empty string (``''``). ::" msgstr "" "Pour lire le contenu d'un fichier, appelez ``f.read(size)``, qui lit une " "certaine quantité de données et les donne sous la forme d'une chaîne (en " "mode texte) ou dans un objet *bytes* (en mode binaire). *size* est un " "argument numérique optionnel. Quand *size* est omis ou négatif, le contenu " "entier du fichier est lu et donné, c'est votre problème si le fichier est " "deux fois plus gros que la mémoire de votre machine. Sinon, un maximum de " "*size* octets sont lus et rendus. Lorsque la fin du fichier est atteinte, " "``f.read()`` renvoie une chaîne vide (``''``). ::" #: ../Doc/tutorial/inputoutput.rst:288 msgid "" "``f.readline()`` reads a single line from the file; a newline character (``" "\\n``) is left at the end of the string, and is only omitted on the last " "line of the file if the file doesn't end in a newline. This makes the " "return value unambiguous; if ``f.readline()`` returns an empty string, the " "end of the file has been reached, while a blank line is represented by " "``'\\n'``, a string containing only a single newline. ::" msgstr "" "``f.readline()`` lit une seule ligne du fichier ; un caractère de fin de " "ligne (``\\n``) est laissé à la fin de la chaîne, et n'est omis que sur la " "dernière ligne du fichier si celui-ci ne se termine pas un caractère de fin " "de ligne. Ceci permet de rendre la valeur de retour non ambigüe : si ``f." "readline()`` retourne une chaîne vide, c'est que la fin du fichier a été " "atteinte, alors qu'une ligne vide est représentée par ``'\\n'``, une chaîne " "de caractères ne contenant qu'une fin de ligne. ::" #: ../Doc/tutorial/inputoutput.rst:302 msgid "" "For reading lines from a file, you can loop over the file object. This is " "memory efficient, fast, and leads to simple code::" msgstr "" "Une autre approche de lecture des lignes est de faire une boucle sur l'objet " "fichier. Cela est plus efficace en terme de gestion mémoire, plus rapide, et " "donne un code plus simple : ::" #: ../Doc/tutorial/inputoutput.rst:311 msgid "" "If you want to read all the lines of a file in a list you can also use " "``list(f)`` or ``f.readlines()``." msgstr "" "Pour lire toutes les lignes d'un fichier, il est aussi possible d'utiliser " "``list(f)`` ou ``f.readlines()``." #: ../Doc/tutorial/inputoutput.rst:314 msgid "" "``f.write(string)`` writes the contents of *string* to the file, returning " "the number of characters written. ::" msgstr "" "``f.write(string)`` écrit le contenu de *string* dans le fichier, et renvoie " "le nombre de caractères écrits. ::" #: ../Doc/tutorial/inputoutput.rst:320 msgid "" "Other types of objects need to be converted -- either to a string (in text " "mode) or a bytes object (in binary mode) -- before writing them::" msgstr "" "D'autres types doivent être convertis, soit en une chaîne (en mode texte) ou " "un objet *bytes* (en mode binaire), avant de les écrire : ::" #: ../Doc/tutorial/inputoutput.rst:328 msgid "" "``f.tell()`` returns an integer giving the file object's current position in " "the file represented as number of bytes from the beginning of the file when " "in binary mode and an opaque number when in text mode." msgstr "" "``f.tell()`` retourne un entier indiquant la position actuelle dans le " "fichier, mesurée en octets à partir du début du fichier, lorsque le fichier " "est ouvert en mode binaire, ou un nombre obscure en mode texte." #: ../Doc/tutorial/inputoutput.rst:332 msgid "" "To change the file object's position, use ``f.seek(offset, from_what)``. " "The position is computed from adding *offset* to a reference point; the " "reference point is selected by the *from_what* argument. A *from_what* " "value of 0 measures from the beginning of the file, 1 uses the current file " "position, and 2 uses the end of the file as the reference point. " "*from_what* can be omitted and defaults to 0, using the beginning of the " "file as the reference point. ::" msgstr "" "Pour modifier la position dans le fichier, utilisez ``f.seek(offset, " "from_what)``. Laposition est calculée en ajoutant *offset* à un point de " "référence ; ce point de référence est sélectionné par l'argument " "*from_what* : 0 pour le début du fichier, 1 pour la position actuelle, et 2 " "pour la fin du fichier. *from_what* peut être omis et sa valeur par défaut " "est 0, utilisant le début du fichier comme point de référence : ::" #: ../Doc/tutorial/inputoutput.rst:351 msgid "" "In text files (those opened without a ``b`` in the mode string), only seeks " "relative to the beginning of the file are allowed (the exception being " "seeking to the very file end with ``seek(0, 2)``) and the only valid " "*offset* values are those returned from the ``f.tell()``, or zero. Any other " "*offset* value produces undefined behaviour." msgstr "" "Sur un fichier en mode texte (ceux ouverts sans ``b`` dans le mode), seuls " "les changements de position relatifs au début du fichier sont autorisés " "(sauf une exception : se rendre à la fin du fichier avec ``seek(0, 2)``) et " "les seuls valeurs possible pour le paramètre *offset* sont les valeurs " "renvoyées par ``f.tell()``, ou zéro. Toute autre valeur pour le paramètre " "*offset* engendrera un comportement indéfini." #: ../Doc/tutorial/inputoutput.rst:358 msgid "" "When you're done with a file, call ``f.close()`` to close it and free up any " "system resources taken up by the open file. After calling ``f.close()``, " "attempts to use the file object will automatically fail. ::" msgstr "" "Quand vous avez terminé d'utiliser un fichier, appeler ``f.close()`` pour le " "fermer et libérer toutes les ressources système qu'il a pu utiliser. Après " "l'appel de ``f.close()``, toute tentative d'utilisation de l'objet fichier " "échouera systématiquement : ::" #: ../Doc/tutorial/inputoutput.rst:368 msgid "" "It is good practice to use the :keyword:`with` keyword when dealing with " "file objects. This has the advantage that the file is properly closed after " "its suite finishes, even if an exception is raised on the way. It is also " "much shorter than writing equivalent :keyword:`try`\\ -\\ :keyword:`finally` " "blocks::" msgstr "" "C'est une bonne pratique d'utiliser le mot-clé :keyword:`with` lorsque vous " "traitez des fichiers. Ceci procure l'avantage de toujours fermer " "correctement le fichier, même si une exception a été déclenchée. C'est aussi " "beaucoup plus court que d'utiliser l'équivalent avec des blocs :keyword:`try`" "\\ - \\ :keyword:`finally` ::" #: ../Doc/tutorial/inputoutput.rst:378 msgid "" "File objects have some additional methods, such as :meth:`~file.isatty` and :" "meth:`~file.truncate` which are less frequently used; consult the Library " "Reference for a complete guide to file objects." msgstr "" "Les fichiers disposent de méthodes supplémentaires, telles que :meth:`~file." "isatty` et :meth:`~file.truncate` qui sont moins souvent utilisées ; " "consultez la Référence de la Bibliothèque Standard pour avoir un guide " "complet des objets fichiers." #: ../Doc/tutorial/inputoutput.rst:386 msgid "Saving structured data with :mod:`json`" msgstr "Sauvegarder des données structurées avec le module :mod:`json`" #: ../Doc/tutorial/inputoutput.rst:390 msgid "" "Strings can easily be written to and read from a file. Numbers take a bit " "more effort, since the :meth:`read` method only returns strings, which will " "have to be passed to a function like :func:`int`, which takes a string like " "``'123'`` and returns its numeric value 123. When you want to save more " "complex data types like nested lists and dictionaries, parsing and " "serializing by hand becomes complicated." msgstr "" "Les chaînes de caractères peuvent facilement être écrites dans un fichier et " "relues. Les nombres nécessitent un peu plus d'efforts, car la méthode :meth:" "`read` ne retourne que des chaînes, qui doivent donc être passées à une " "fonction comme :func:`int`, qui prend une chaîne comme ``'123'`` en entrée " "et retourne sa valeur numérique 123. Mais dès que vous voulez enregistrer " "des types de données plus complexes comme des listes, des dictionnaires ou " "des instances de classes, les choses se compliquent beaucoup plus." #: ../Doc/tutorial/inputoutput.rst:397 msgid "" "Rather than having users constantly writing and debugging code to save " "complicated data types to files, Python allows you to use the popular data " "interchange format called `JSON (JavaScript Object Notation) `_. The standard module called :mod:`json` can take Python data " "hierarchies, and convert them to string representations; this process is " "called :dfn:`serializing`. Reconstructing the data from the string " "representation is called :dfn:`deserializing`. Between serializing and " "deserializing, the string representing the object may have been stored in a " "file or data, or sent over a network connection to some distant machine." msgstr "" "Plutôt que de passer son temps à écrire et déboguer du code permettant de " "sauvegarder des types de données compliquées, Python permet d'utiliser `JSON " "(JavaScript Object Notation) `_, un format répandu de " "représentation et d'échange de données. Le module standard appellé :mod:" "`json` peut transformer des hiérarchies de données Python en leur " "représentation sous forme de chaîne de caractère. Ce processus est nommé :" "dfn:`sérialiser`. Reconstruire les données à partir de leur représentation " "sous forme de chaîne est appelé :dfn:`déserialiser`. Entre sa serialisation " "et sa déserialisation, la chaîne représentant les données peuvent avoir été " "stockées ou transmises à une autre machine." #: ../Doc/tutorial/inputoutput.rst:408 msgid "" "The JSON format is commonly used by modern applications to allow for data " "exchange. Many programmers are already familiar with it, which makes it a " "good choice for interoperability." msgstr "" "Le format JSON se retrouve communément dans les applications modernes pour " "échanger des données. Beaucoup de développeurs sont déjà familier avec le " "JSON, en faisant un format de prédilection pour l'interopérabilité." #: ../Doc/tutorial/inputoutput.rst:412 msgid "" "If you have an object ``x``, you can view its JSON string representation " "with a simple line of code::" msgstr "" "Si vous avez un objet ``x``, vous pouvez simplement voir sa représentation " "JSON ::" #: ../Doc/tutorial/inputoutput.rst:418 msgid "" "Another variant of the :func:`~json.dumps` function, called :func:`~json." "dump`, simply serializes the object to a :term:`text file`. So if ``f`` is " "a :term:`text file` object opened for writing, we can do this::" msgstr "" "Une variation de la fonction :func:`~json.dumps`, nommée :func:`~json.dump`, " "sérialise simplement l'objet donné vers un :term:`fichier texte `. Donc si ``f`` est un :term:`fichier texte ` ouvert en " "écriture, il devient possible de faire : ::" #: ../Doc/tutorial/inputoutput.rst:424 msgid "" "To decode the object again, if ``f`` is a :term:`text file` object which has " "been opened for reading::" msgstr "" "Pour reconstruire l'objet, si ``f`` est cette fois un :term:`fichier texte` " "ouverten lecture : ::" #: ../Doc/tutorial/inputoutput.rst:429 msgid "" "This simple serialization technique can handle lists and dictionaries, but " "serializing arbitrary class instances in JSON requires a bit of extra " "effort. The reference for the :mod:`json` module contains an explanation of " "this." msgstr "" "Cette méthode de serialisation peut sérialiser des listes et des " "dictionnaires, mais sérialiser d'autres types de données nécessité un peu " "plus de travail. La documentation du module :mod:`json` explique comment " "faire." #: ../Doc/tutorial/inputoutput.rst:435 msgid ":mod:`pickle` - the pickle module" msgstr "Le module :mod:`pickle`" #: ../Doc/tutorial/inputoutput.rst:437 msgid "" "Contrary to :ref:`JSON `, *pickle* is a protocol which allows the " "serialization of arbitrarily complex Python objects. As such, it is " "specific to Python and cannot be used to communicate with applications " "written in other languages. It is also insecure by default: deserializing " "pickle data coming from an untrusted source can execute arbitrary code, if " "the data was crafted by a skilled attacker." msgstr "" "À l'inverse de :ref:`JSON `, *pickle* est un protocole permettant " "la serialisation d'objets Python arbitrairement complexes. Il est donc " "spécifique à Python et ne peut être utilisé pour communiquer avec d'autres " "langages. Il n'est aussi pas sans failles : desérialiser des données au " "format pickle provenant d'une source malveillante et particulièrement habile " "pourrait mener exécuter du code arbitraire." #: ../Doc/tutorial/interactive.rst:5 msgid "Interactive Input Editing and History Substitution" msgstr "Édition interactive des entrées et substitution d'historique" #: ../Doc/tutorial/interactive.rst:7 msgid "" "Some versions of the Python interpreter support editing of the current input " "line and history substitution, similar to facilities found in the Korn shell " "and the GNU Bash shell. This is implemented using the `GNU Readline`_ " "library, which supports various styles of editing. This library has its own " "documentation which we won't duplicate here." msgstr "" "Certaines versions de l'interpréteur Python prennent en charge l'édition de " "la ligne d'entrée courante et la substitution d'historique, similaires aux " "facilités que l'on trouve dans le shell Korn et dans le shell GNU Bash. " "C'est implémenté en utilisant la bibliothèque `GNU Readline`_, qui supporte " "plusieurs styles d'édition. La bibliothèque a sa propre documentation qui ne " "va pas être dupliquée ici." #: ../Doc/tutorial/interactive.rst:17 msgid "Tab Completion and History Editing" msgstr "Complément Automatique et édition de l'historique" #: ../Doc/tutorial/interactive.rst:19 msgid "" "Completion of variable and module names is :ref:`automatically enabled " "` at interpreter startup so that the :kbd:`Tab` key " "invokes the completion function; it looks at Python statement names, the " "current local variables, and the available module names. For dotted " "expressions such as ``string.a``, it will evaluate the expression up to the " "final ``'.'`` and then suggest completions from the attributes of the " "resulting object. Note that this may execute application-defined code if an " "object with a :meth:`__getattr__` method is part of the expression. The " "default configuration also saves your history into a file named :file:`." "python_history` in your user directory. The history will be available again " "during the next interactive interpreter session." msgstr "" "La complétion de variables et de noms de modules est :ref:`automatiquement " "activé ` lors du démarrage de l'interpréteur, tel que la " "touche :kbd:`Tab` invoque la fonction de complétion, donc taper la touche :" "kbd:`Tab` deux fois de suite suggère les options disponibles ; la recherche " "s'effectue dans les noms d'instructions Python, les noms des variables " "locales et les noms de modules disponibles. Pour les expressions pointées " "telles que ``string.a``, l'expression est évaluée jusqu'au dernier ``'.'`` " "avant de suggérer les options disponibles à partir des attributs de l'objet " "résultant de cette évaluation. Notez bien que ceci peut exécuter une partie " "du code de l'application si un objet disposant d'une méthode :meth:" "`__getattr__` fait partie de l'expression. La configuration par défaut " "sauvegarde l'historique dans un fichier nommé :file:`.python_history` dans " "votre dossier d'utilisateur. L'historique sera à nouveau disponible lors de " "la prochaine session interactive." #: ../Doc/tutorial/interactive.rst:36 msgid "Alternatives to the Interactive Interpreter" msgstr "Alternatives à l'interpréteur interactif" #: ../Doc/tutorial/interactive.rst:38 msgid "" "This facility is an enormous step forward compared to earlier versions of " "the interpreter; however, some wishes are left: It would be nice if the " "proper indentation were suggested on continuation lines (the parser knows if " "an indent token is required next). The completion mechanism might use the " "interpreter's symbol table. A command to check (or even suggest) matching " "parentheses, quotes, etc., would also be useful." msgstr "" "Cette facilité constitue un énorme pas en avant comparé aux versions " "précédentes de l'interpréteur ; toutefois, certains souhaits sont laissés de " "côté : ce serait bien si une indentation correcte était proposée sur les " "lignes de continuation (l'analyseur sait si une indentation doit suivre). Le " "mécanisme de complétion devrait utiliser la table de symboles de " "l'interpréteur. Une commande pour vérifier (ou même suggérer) les " "correspondances de parenthèses, de guillemets..., serait également utile." #: ../Doc/tutorial/interactive.rst:45 msgid "" "One alternative enhanced interactive interpreter that has been around for " "quite some time is IPython_, which features tab completion, object " "exploration and advanced history management. It can also be thoroughly " "customized and embedded into other applications. Another similar enhanced " "interactive environment is bpython_." msgstr "" "Une alternative améliorée de l'interpréteur interactif qui a été développée " "depuis maintenant quelques temps est IPython_, qui fournit la complétude, " "l'exploration d'objets et une gestion avancée de l'historique. Il peut " "également être personnalisé en profondeur et embarqué dans d'autres " "applications. Un autre environnement interactif amélioré similaire est " "bpython_." #: ../Doc/tutorial/interpreter.rst:5 msgid "Using the Python Interpreter" msgstr "Utiliser l'interpréteur Python" #: ../Doc/tutorial/interpreter.rst:11 msgid "Invoking the Interpreter" msgstr "Invoquer l'interpréteur" #: ../Doc/tutorial/interpreter.rst:13 msgid "" "The Python interpreter is usually installed as :file:`/usr/local/bin/" "python3.6` on those machines where it is available; putting :file:`/usr/" "local/bin` in your Unix shell's search path makes it possible to start it by " "typing the command:" msgstr "" #: ../Doc/tutorial/interpreter.rst:21 msgid "" "to the shell. [#]_ Since the choice of the directory where the interpreter " "lives is an installation option, other places are possible; check with your " "local Python guru or system administrator. (E.g., :file:`/usr/local/python` " "is a popular alternative location.)" msgstr "" "dans le shell. [#]_ Le choix du répertoire où se trouve l'interpréteur étant " "uneoption d'installation, d'autres chemins sont possibles; voyez avec votre " "guru Python local ou votre administrateur système. (Par exemple, :file:`/usr/" "local/python` est une localisation courante.)" #: ../Doc/tutorial/interpreter.rst:26 msgid "" "On Windows machines, the Python installation is usually placed in :file:`C:\\" "\\Python36`, though you can change this when you're running the installer. " "To add this directory to your path, you can type the following command into " "the command prompt in a DOS box::" msgstr "" #: ../Doc/tutorial/interpreter.rst:33 msgid "" "Typing an end-of-file character (:kbd:`Control-D` on Unix, :kbd:`Control-Z` " "on Windows) at the primary prompt causes the interpreter to exit with a zero " "exit status. If that doesn't work, you can exit the interpreter by typing " "the following command: ``quit()``." msgstr "" "Taper un caractère de fin de fichier (:kbd:`Ctrl-D` sous Unix, :kbd:`Ctrl-Z` " "sous Windows) suive à une invite de commande primaire provoque la fermeture " "de l'interpréteur avec un statut d'erreur nul. Si cela ne fonctionne pas, " "vous pouvez fermer l'interpréteur en tapant la commande ``quit()``." #: ../Doc/tutorial/interpreter.rst:38 msgid "" "The interpreter's line-editing features include interactive editing, history " "substitution and code completion on systems that support readline. Perhaps " "the quickest check to see whether command line editing is supported is " "typing :kbd:`Control-P` to the first Python prompt you get. If it beeps, " "you have command line editing; see Appendix :ref:`tut-interacting` for an " "introduction to the keys. If nothing appears to happen, or if ``^P`` is " "echoed, command line editing isn't available; you'll only be able to use " "backspace to remove characters from the current line." msgstr "" "Les fonctionnalités d'édition de l'interpréteur comprennent l'édition " "interactive, la substitution depuis l'historique, et la complétion, sur les " "systèmes qui gèrent readline. Le moyen le plus rapide de tester si l'édition " "de la ligne decommande est gérée est peut-être de taper :kbd:`Control-P` " "suite au premier invite de commande que vous rencontrez. Si cela bip, vous " "disposez de l'édition de la ligne de commande; voyez l'appendice :ref:`tut-" "interacting` pour une introduction aux touches. Si rien ne semble se " "produire ou si ``^P`` s'affiche, l'édition de la ligne de commande n'est pas " "disponible; vous serez seulement en mesure d'utiliser la touche retour " "arrière pour supprimer des caractères de la ligne courante." #: ../Doc/tutorial/interpreter.rst:47 msgid "" "The interpreter operates somewhat like the Unix shell: when called with " "standard input connected to a tty device, it reads and executes commands " "interactively; when called with a file name argument or with a file as " "standard input, it reads and executes a *script* from that file." msgstr "" "L'interpréteur opère de façon similaire au shell Unix : lorsqu'il est appelé " "avec l'entrée standard connectée à un périphérique tty, il lit et exécute " "les commandes de façon interactive; lorsqu'il est appelé avec un nom de " "fichier en argument ou avec un fichier comme entrée standard, il lit et " "exécute un *script* depuis ce fichier." #: ../Doc/tutorial/interpreter.rst:52 msgid "" "A second way of starting the interpreter is ``python -c command [arg] ...``, " "which executes the statement(s) in *command*, analogous to the shell's :" "option:`-c` option. Since Python statements often contain spaces or other " "characters that are special to the shell, it is usually advised to quote " "*command* in its entirety with single quotes." msgstr "" "Une autre façon de lancer l'interpréteur est ``python -c commande [arg] ..." "``. Cela exécute les instructions de *commande* de façon analogue à " "l'option :option:`-c` du shell. Parce que les instructions Python " "contiennent souvent des espaces et d'autres caractères spéciaux pour le " "shell, il est généralement conseillé de mettre *commande* entre guillemets " "simples." #: ../Doc/tutorial/interpreter.rst:58 msgid "" "Some Python modules are also useful as scripts. These can be invoked using " "``python -m module [arg] ...``, which executes the source file for *module* " "as if you had spelled out its full name on the command line." msgstr "" "Certains modules Python sont aussi utiles en tant que scripts. Ils peuvent " "être appelé avec ``python -m module [arg] ...`` qui exécute le fichier " "source de *module* comme si vous aviez tapé son nom complet dans la ligne de " "commande." #: ../Doc/tutorial/interpreter.rst:62 msgid "" "When a script file is used, it is sometimes useful to be able to run the " "script and enter interactive mode afterwards. This can be done by passing :" "option:`-i` before the script." msgstr "" "Quand un fichier de script est utilisé, il est parfois utile de pouvoir " "lancer le script puis d'entrer dans le mode interactif après coup. Cela est " "possible en passant :option:`-i` avant le script." #: ../Doc/tutorial/interpreter.rst:66 msgid "All command line options are described in :ref:`using-on-general`." msgstr "" "Tous les paramètres utilisables en ligne de commande sont documentés dans :" "ref:`using-on-general`." #: ../Doc/tutorial/interpreter.rst:72 msgid "Argument Passing" msgstr "Passage d'arguments" #: ../Doc/tutorial/interpreter.rst:74 msgid "" "When known to the interpreter, the script name and additional arguments " "thereafter are turned into a list of strings and assigned to the ``argv`` " "variable in the ``sys`` module. You can access this list by executing " "``import sys``. The length of the list is at least one; when no script and " "no arguments are given, ``sys.argv[0]`` is an empty string. When the script " "name is given as ``'-'`` (meaning standard input), ``sys.argv[0]`` is set " "to ``'-'``. When :option:`-c` *command* is used, ``sys.argv[0]`` is set to " "``'-c'``. When :option:`-m` *module* is used, ``sys.argv[0]`` is set to " "the full name of the located module. Options found after :option:`-c` " "*command* or :option:`-m` *module* are not consumed by the Python " "interpreter's option processing but left in ``sys.argv`` for the command or " "module to handle." msgstr "" "Lorsqu'ils sont connus de l'interpréteur, le nom du script et les arguments " "additionnels sont représentés sous forme d'une liste assignée à la variable " "``argv`` du module ``sys``. Vous pouvez y accéder en exécutant ``import " "sys``. La liste contient au minimum un élément; quand aucun script ni aucun " "arguments ne sont donnés, ``sys.argv[0]`` est une chaine vide. Quand ``'-'`` " "(qui représente l'entrée standard) est passé comme nom de script, ``sys." "argv[0]`` contient ``'-'``. Quand :option:`-c` *commande* est utilisé, ``sys." "argv[0]`` contient ``'-c'``. Enfin, quand :option:`-m` *module* est utilisé, " "le nom complet du module est assigné à ``sys.argv[0]``. Les options trouvées " "après :option:`-c` *commande* ou :option:`-m` *module* ne sont pas lues " "comme options de l'interpréteur Python mais laissées dans ``sys.argv`` pour " "être utilisée par le module ou la commande." #: ../Doc/tutorial/interpreter.rst:92 msgid "" "When commands are read from a tty, the interpreter is said to be in " "*interactive mode*. In this mode it prompts for the next command with the " "*primary prompt*, usually three greater-than signs (``>>>``); for " "continuation lines it prompts with the *secondary prompt*, by default three " "dots (``...``). The interpreter prints a welcome message stating its version " "number and a copyright notice before printing the first prompt:" msgstr "" #: ../Doc/tutorial/interpreter.rst:109 msgid "" "Continuation lines are needed when entering a multi-line construct. As an " "example, take a look at this :keyword:`if` statement::" msgstr "" "Les lignes de continuation sont nécessaires pour entrer une construction " "multi-lignes. Par exemple, regardez cette instruction :keyword:`if` ::" #: ../Doc/tutorial/interpreter.rst:119 msgid "For more on interactive mode, see :ref:`tut-interac`." msgstr "" "Pour plus d'informations sur le mode interactif, voir :ref:`tut-interac`." #: ../Doc/tutorial/interpreter.rst:125 msgid "The Interpreter and Its Environment" msgstr "L'interpréteur et son environnement" #: ../Doc/tutorial/interpreter.rst:131 msgid "Source Code Encoding" msgstr "Encodage du code source" #: ../Doc/tutorial/interpreter.rst:133 msgid "" "By default, Python source files are treated as encoded in UTF-8. In that " "encoding, characters of most languages in the world can be used " "simultaneously in string literals, identifiers and comments --- although the " "standard library only uses ASCII characters for identifiers, a convention " "that any portable code should follow. To display all these characters " "properly, your editor must recognize that the file is UTF-8, and it must use " "a font that supports all the characters in the file." msgstr "" "Par défaut Python considère que ses fichiers source sont encodés en UTF-8. " "Dans cet encodage, les caractères de la plupart des langues peuvent être " "utilisés ensemble dans les chaînes de caractères, identifiants, et " "commentaires, bien que la bibliothèque standard n'utilise que des caractères " "ASCII dans ses identifiants, une bonne habitude que tout code portable " "devrait suivre. Pour afficher correctement tous ces caractères, votre " "éditeur doit reconnaître que le fichier est en UTF-8, et utiliser une fonte " "de caractère qui comprend tous les caractères utilisés dans le fichier." #: ../Doc/tutorial/interpreter.rst:141 msgid "" "It is also possible to specify a different encoding for source files. In " "order to do this, put one more special comment line right after the ``#!`` " "line to define the source file encoding::" msgstr "" "Il est possible d'utiliser un autre encodage dans un fichier source Python. " "La meilleure façon de faire est de placer un commentaire spécial " "supplémentaire juste après le ``#!`` pour définir l'encodage du fichier " "source::" #: ../Doc/tutorial/interpreter.rst:147 msgid "" "With that declaration, everything in the source file will be treated as " "having the encoding *encoding* instead of UTF-8. The list of possible " "encodings can be found in the Python Library Reference, in the section on :" "mod:`codecs`." msgstr "" "Avec cette déclaration, tous les caractères du fichier source sont traités " "comme étant dans l'encodage *encoding* au lieu d'UTF-8. La liste des " "encodages disponibles peut être trouvée dans la référence de la bibliothèque " "Python dans la partie à propos de :mod:`codecs`." #: ../Doc/tutorial/interpreter.rst:151 msgid "" "For example, if your editor of choice does not support UTF-8 encoded files " "and insists on using some other encoding, say Windows-1252, you can write::" msgstr "" "Par exemple, si votre éditeur de gère pas l'UTF-8 et insiste pour utiliser " "un autre encodage, disons Windows-1252, vous pouvez écrire : ::" #: ../Doc/tutorial/interpreter.rst:156 msgid "" "and still use all characters in the Windows-1252 character set in the source " "files. The special encoding comment must be in the *first or second* line " "within the file." msgstr "" "et continuer d'utiliser tous les caractères de Windows-1252 dans votre code. " "Ce commentaire spécial spécifiant l'encodage doit être à *la première ou " "deuxième* ligne du fichier." #: ../Doc/tutorial/interpreter.rst:163 msgid "" "On Unix, the Python 3.x interpreter is by default not installed with the " "executable named ``python``, so that it does not conflict with a " "simultaneously installed Python 2.x executable." msgstr "" "Sur Unix, l'interpréteur Python 3.x n'est pas, par défaut, installé sous le " "nom de ``python`` pour ne pas entrer en conflit avec une éventuelle " "installation de Python 2.x." #: ../Doc/tutorial/introduction.rst:5 msgid "An Informal Introduction to Python" msgstr "Introduction informelle à Python" #: ../Doc/tutorial/introduction.rst:7 msgid "" "In the following examples, input and output are distinguished by the " "presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the " "example, you must type everything after the prompt, when the prompt appears; " "lines that do not begin with a prompt are output from the interpreter. Note " "that a secondary prompt on a line by itself in an example means you must " "type a blank line; this is used to end a multi-line command." msgstr "" "Dans les exemples qui suivent, les entrées et sorties se distinguent par la " "présence ou l'absence d'invite (:term:`>>>` et :term:`...`) : pour " "reproduire les exemples, vous devez taper tout ce qui est après l'invite, au " "moment où celle-ci apparaît ; les lignes qui n'affichent pas d'invite sont " "les sorties de l'interpréteur. Notez qu'une invite secondaire affichée seule " "sur une ligne dans un exemple indique que vous devez entrer une ligne vide ; " "ceci est utilisé pour terminer une commande multi-lignes." #: ../Doc/tutorial/introduction.rst:14 msgid "" "Many of the examples in this manual, even those entered at the interactive " "prompt, include comments. Comments in Python start with the hash character, " "``#``, and extend to the end of the physical line. A comment may appear at " "the start of a line or following whitespace or code, but not within a string " "literal. A hash character within a string literal is just a hash character. " "Since comments are to clarify code and are not interpreted by Python, they " "may be omitted when typing in examples." msgstr "" "Beaucoup d'exemples de ce manuel, même ceux saisis à l'invite de " "l'interpréteur, incluent des commentaires. Les commentaires en Python " "commencent avec un caractère dièse, ``#``, et s'étendent jusqu'à la fin de " "la ligne. Un commentaire peut apparaître au début d'une ligne ou à la suite " "d'un espace ou de code, mais pas à l'intérieur d'une chaîne de caractères " "littérale. Un caractère dièse à l'intérieur d'une chaîne de caractères est " "juste un caractère dièse. Comme les commentaires ne servent qu'à expliquer " "le code et ne sont pas interprétés par Python, ils peuvent être ignorés " "lorsque vous tapez les exemples." #: ../Doc/tutorial/introduction.rst:33 msgid "Using Python as a Calculator" msgstr "Utiliser Python comme une calculatrice" #: ../Doc/tutorial/introduction.rst:35 msgid "" "Let's try some simple Python commands. Start the interpreter and wait for " "the primary prompt, ``>>>``. (It shouldn't take long.)" msgstr "" "Essayons quelques commandes Python simples. Démarrez l'interpréteur et " "attendez l'invite primaire, ``>>>``. Ça ne devrait pas être long." #: ../Doc/tutorial/introduction.rst:42 msgid "Numbers" msgstr "Les nombres" #: ../Doc/tutorial/introduction.rst:44 msgid "" "The interpreter acts as a simple calculator: you can type an expression at " "it and it will write the value. Expression syntax is straightforward: the " "operators ``+``, ``-``, ``*`` and ``/`` work just like in most other " "languages (for example, Pascal or C); parentheses (``()``) can be used for " "grouping. For example::" msgstr "" "L'interpréteur agit comme une simple calculatrice : vous pouvez lui entrer " "une expression et il vous affiche la valeur. La syntaxe des expressions est " "simple : les opérateurs ``+``, ``-``, ``*`` et ``/`` fonctionnent comme dans " "la plupart des langages (par exemple, Pascal ou C) ; les parenthèses peuvent " "être utilisées pour faire des regroupements. Par exemple : ::" #: ../Doc/tutorial/introduction.rst:59 msgid "" "The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the " "ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:" "`float`. We will see more about numeric types later in the tutorial." msgstr "" "Les nombre entiers (comme ``2``, ``4``, ``20``) sont de type :class:`int`, " "alors que les décimaux (comme ``5.0``, ``1.6``) sont de type :class:`float`. " "Plus de détails sont données sur les types numériques plus loin dans ce " "tutoriel." #: ../Doc/tutorial/introduction.rst:63 msgid "" "Division (``/``) always returns a float. To do :term:`floor division` and " "get an integer result (discarding any fractional result) you can use the ``//" "`` operator; to calculate the remainder you can use ``%``::" msgstr "" "Les divisions (``/``) donnent toujours des :class:`float`. Utilisez " "l'opérateur ``//`` pour effectuer des divisions entières, et donc obtenir un " "résultat entier. Pour obtenir le reste de cette division entière, utilisez " "l'opérateur ``%`` ::" #: ../Doc/tutorial/introduction.rst:77 msgid "" "With Python, it is possible to use the ``**`` operator to calculate powers " "[#]_::" msgstr "" "Avec Python il est possible de calculer des puissances avec l'opérateur " "``**`` [#]_ ::" #: ../Doc/tutorial/introduction.rst:84 msgid "" "The equal sign (``=``) is used to assign a value to a variable. Afterwards, " "no result is displayed before the next interactive prompt::" msgstr "" "Le signe égal (``=``) est utilisé pour affecter une valeur à une variable. " "Après cela, aucun résultat n'est affiché avant l'invite suivante : ::" #: ../Doc/tutorial/introduction.rst:92 msgid "" "If a variable is not \"defined\" (assigned a value), trying to use it will " "give you an error::" msgstr "" "Si une variable n'est pas \"définie\" (si aucune valeur ne lui a été " "affecté), l'utiliser engendrera une erreur : ::" #: ../Doc/tutorial/introduction.rst:100 msgid "" "There is full support for floating point; operators with mixed type operands " "convert the integer operand to floating point::" msgstr "" "Il y a un support complet des nombres à virgule flottante ; les opérateurs " "avec des types d'opérandes mélangés convertissent l'opérande entier en " "virgule flottante : ::" #: ../Doc/tutorial/introduction.rst:108 msgid "" "In interactive mode, the last printed expression is assigned to the variable " "``_``. This means that when you are using Python as a desk calculator, it " "is somewhat easier to continue calculations, for example::" msgstr "" "En mode interactif, la dernière expression affichée est affectée à la " "variable ``_``. Ce qui signifie que lorsque vous utilisez Python comme " "calculatrice, il est parfois plus simple de continuer des calculs, par " "exemple : ::" #: ../Doc/tutorial/introduction.rst:121 msgid "" "This variable should be treated as read-only by the user. Don't explicitly " "assign a value to it --- you would create an independent local variable with " "the same name masking the built-in variable with its magic behavior." msgstr "" "Cette variable doit être considérée comme une variable en lecture seule par " "l'utilisateur. Ne lui affectez pas de valeur explicitement --- vous créeriez " "ainsi une variable locale indépendante avec le même nom qui masquerait la " "variable native et son fonctionnement magique." #: ../Doc/tutorial/introduction.rst:125 msgid "" "In addition to :class:`int` and :class:`float`, Python supports other types " "of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions." "Fraction`. Python also has built-in support for :ref:`complex numbers " "`, and uses the ``j`` or ``J`` suffix to indicate the " "imaginary part (e.g. ``3+5j``)." msgstr "" "En plus des :class:`int` et des :class:`float`, il existe les :class:" "`~decimal.Decimal` et les :class:`~fractions.Fraction`. Python gère aussi " "les :ref:`nombre complexes `, en utilisant le suffixe ``j`` ou " "``J`` pour indiquer la partie imaginaire (tel que: ``3+5j``)." #: ../Doc/tutorial/introduction.rst:135 msgid "Strings" msgstr "Les chaînes de caractères" #: ../Doc/tutorial/introduction.rst:137 msgid "" "Besides numbers, Python can also manipulate strings, which can be expressed " "in several ways. They can be enclosed in single quotes (``'...'``) or " "double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used " "to escape quotes::" msgstr "" "Au delà des nombres, Python peut aussi manipuler des chaînes de caractères, " "qui peuvent être exprimés de différentes manières. Elles peuvent être " "écrites entre guillemets simples (``'...'``) ou entre guillemets (``\"..." "\"``) sans distinction [#]_. ``\\`` peut être utilisé pour protéger un " "guillemet : ::" #: ../Doc/tutorial/introduction.rst:155 msgid "" "In the interactive interpreter, the output string is enclosed in quotes and " "special characters are escaped with backslashes. While this might sometimes " "look different from the input (the enclosing quotes could change), the two " "strings are equivalent. The string is enclosed in double quotes if the " "string contains a single quote and no double quotes, otherwise it is " "enclosed in single quotes. The :func:`print` function produces a more " "readable output, by omitting the enclosing quotes and by printing escaped " "and special characters::" msgstr "" "En mode interactif, l'interpréteur affiche les chaînes de caractères entre " "guillemets et en protégant les guillemets et autres caractères spéciaux avec " "des antislash. Bien que cela puisse paraître différent de ce qui a été donné " "(les guillemets peuvent changer) La chaîne est affichée entre guillemets si " "elle contient un guillemet simple mais aucun guillemet, sinon elle est " "affichée entreguillemets simples. La fonction :func:`print` affiche les " "chaînes de manière plus lisible, en retirant les guillemets et en affichant " "les caractères spéciaux qui étaient protégées par un antislash : ::" #: ../Doc/tutorial/introduction.rst:175 msgid "" "If you don't want characters prefaced by ``\\`` to be interpreted as special " "characters, you can use *raw strings* by adding an ``r`` before the first " "quote::" msgstr "" "Pour éviter que les caractères précédées d'un ``\\`` ne soient interprétés " "comme étant spéciaux, utilisez les *chaînes brutes* (*raw strings*) en " "préfixant la chaîne d'un ``r`` ::" #: ../Doc/tutorial/introduction.rst:185 msgid "" "String literals can span multiple lines. One way is using triple-quotes: ``" "\"\"\"...\"\"\"`` or ``'''...'''``. End of lines are automatically included " "in the string, but it's possible to prevent this by adding a ``\\`` at the " "end of the line. The following example::" msgstr "" "Les chaînes de caractères peuvent s'étendre sur plusieurs lignes. On peut " "utiliser les triples guillemets, simples ou doubles: ``'''...'''`` ou ``" "\"\"\"...\"\"\"``. Les retours à la ligne sont automatiquement inclus, mais " "on peut l'en empêcher en ajoutant ``\\`` à la fin de la ligne. L'exemple " "suivant : ::" #: ../Doc/tutorial/introduction.rst:196 msgid "" "produces the following output (note that the initial newline is not " "included):" msgstr "" "produit l'affichage suivant (notez que le premier retour à la ligne n'est " "pas inclus) :" #: ../Doc/tutorial/introduction.rst:204 msgid "" "Strings can be concatenated (glued together) with the ``+`` operator, and " "repeated with ``*``::" msgstr "" "Les chaines peuvent être concaténées (collées ensemble) avec l'opérateur ``" "+``, et répétées avec l'opérateur ``*``::" #: ../Doc/tutorial/introduction.rst:211 msgid "" "Two or more *string literals* (i.e. the ones enclosed between quotes) next " "to each other are automatically concatenated. ::" msgstr "" "Plusieurs chaînes de caractères, écrites littéralement (c'est à dire entre " "guillemets), côte à côte, sont automatiquement concaténées. ::" #: ../Doc/tutorial/introduction.rst:217 msgid "" "This only works with two literals though, not with variables or expressions::" msgstr "" "Cela ne fonctionne cependant qu'avec les chaînes littérales, pas les " "variables ni les expressions : ::" #: ../Doc/tutorial/introduction.rst:227 msgid "" "If you want to concatenate variables or a variable and a literal, use ``+``::" msgstr "" "Pour concaténer des variables, ou des variables avec des chaînes littérales, " "utilisez l'opérateur ``+``::" #: ../Doc/tutorial/introduction.rst:232 msgid "" "This feature is particularly useful when you want to break long strings::" msgstr "" "Cette fonctionnalité est surtout intéressante pour couper des chaînes trop " "longues : ::" #: ../Doc/tutorial/introduction.rst:239 msgid "" "Strings can be *indexed* (subscripted), with the first character having " "index 0. There is no separate character type; a character is simply a string " "of size one::" msgstr "" "Les chaînes de caractères peuvent être indexées (accéder aux caractères par " "leur position), le premiercaractère d'une chaîne est à la position 0. Il " "n'existe pas de type distinct pour les caractères, un caractère est " "simplement une chaîne de longueur 1 ::" #: ../Doc/tutorial/introduction.rst:249 msgid "" "Indices may also be negative numbers, to start counting from the right::" msgstr "" "Les indices peuvent également être négatifs, pour effectuer un décompte en " "partant de la droite. Par exemple : ::" #: ../Doc/tutorial/introduction.rst:258 msgid "Note that since -0 is the same as 0, negative indices start from -1." msgstr "Notez que puisque -0 égal 0, les indices négatifs commencent par -1." #: ../Doc/tutorial/introduction.rst:260 msgid "" "In addition to indexing, *slicing* is also supported. While indexing is " "used to obtain individual characters, *slicing* allows you to obtain " "substring::" msgstr "" "En plus d'accéder à un élément par son indice, il est aussi possible de " "*trancher* une liste. Accéder à une chaîne par un indice permet d'obtenir un " "caractère, alors que la *trancher* permet d'obtenir une sous-chaïne : ::" #: ../Doc/tutorial/introduction.rst:268 msgid "" "Note how the start is always included, and the end always excluded. This " "makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::" msgstr "" "Notez que le début est toujours inclus et la fin toujours exclue. Cela " "assure que ``s[:i] + s[i:]`` est toujours égal à ``s`` ::" #: ../Doc/tutorial/introduction.rst:276 msgid "" "Slice indices have useful defaults; an omitted first index defaults to zero, " "an omitted second index defaults to the size of the string being sliced. ::" msgstr "" "Les indices par tranches ont des valeurs par défaut utiles ; le premier " "indice lorsqu'il est omis équivaut à zéro, le second à la taille de la " "chaîne de caractères : ::" #: ../Doc/tutorial/introduction.rst:286 msgid "" "One way to remember how slices work is to think of the indices as pointing " "*between* characters, with the left edge of the first character numbered 0. " "Then the right edge of the last character of a string of *n* characters has " "index *n*, for example::" msgstr "" "Une façon de mémoriser la façon dont les tranches fonctionnent est de penser " "que les indices pointent *entre* les caractères, le côté gauche du premier " "caractère ayant la position 0. Le côté droit du dernier caractère d'une " "chaîne de *n* caractères a alors pour indice *n*, par exemple : ::" #: ../Doc/tutorial/introduction.rst:297 msgid "" "The first row of numbers gives the position of the indices 0...6 in the " "string; the second row gives the corresponding negative indices. The slice " "from *i* to *j* consists of all characters between the edges labeled *i* and " "*j*, respectively." msgstr "" "La première ligne de nombres donne la position des indices 0...6 dans la " "chaîne ; la deuxième ligne donne l'indice négatif correspondant. La tranche " "de *i* à *j* est constituée de tous les caractères situés entre les bords " "libellés *i* et *j*, respectivement." #: ../Doc/tutorial/introduction.rst:302 msgid "" "For non-negative indices, the length of a slice is the difference of the " "indices, if both are within bounds. For example, the length of " "``word[1:3]`` is 2." msgstr "" "Pour des indices non négatifs, la longueur d'une tranche est la différence " "entre ces indices, si les deux sont entre les bornes. Par exemple, la longue " "de ``word[1:3]`` est 2." #: ../Doc/tutorial/introduction.rst:306 msgid "Attempting to use an index that is too large will result in an error::" msgstr "Utiliser un indice trop grand générera une erreur : ::" #: ../Doc/tutorial/introduction.rst:313 msgid "" "However, out of range slice indexes are handled gracefully when used for " "slicing::" msgstr "" "Cependant, les indices hors bornes sont gérés silencieusement lorsqu'ils " "sont utilisés dans des tranches : ::" #: ../Doc/tutorial/introduction.rst:321 msgid "" "Python strings cannot be changed --- they are :term:`immutable`. Therefore, " "assigning to an indexed position in the string results in an error::" msgstr "" "Les chaînes de caractères, en Python ne peuvent pas être modifiées, on dit " "quelles sont :term:`immutable`. Affecter une nouvelle valeur à un indice " "dans une chaîne produit une erreur : ::" #: ../Doc/tutorial/introduction.rst:331 msgid "If you need a different string, you should create a new one::" msgstr "" "Si vous avez besoin d'une chaîne différente, vous devez en créer une " "autre : ::" #: ../Doc/tutorial/introduction.rst:338 msgid "The built-in function :func:`len` returns the length of a string::" msgstr "La fonction native :func:`len` renvoie la longueur d'une chaîne : ::" #: ../Doc/tutorial/introduction.rst:349 msgid ":ref:`textseq`" msgstr ":ref:`textseq`" #: ../Doc/tutorial/introduction.rst:348 msgid "" "Strings are examples of *sequence types*, and support the common operations " "supported by such types." msgstr "" "Les chaînes de caractères sont des exemples de *types séquences*, et " "supportent donc lesopérations classiques prises en charge par ces types." #: ../Doc/tutorial/introduction.rst:353 msgid ":ref:`string-methods`" msgstr ":ref:`string-methods`" #: ../Doc/tutorial/introduction.rst:352 msgid "" "Strings support a large number of methods for basic transformations and " "searching." msgstr "" "Les chaînes de caractères supportent un large éventail de méthodes de " "transformations basiques et de recherche." #: ../Doc/tutorial/introduction.rst:356 msgid ":ref:`f-strings`" msgstr "" #: ../Doc/tutorial/introduction.rst:356 msgid "String literals that have embedded expressions." msgstr "" #: ../Doc/tutorial/introduction.rst:359 msgid ":ref:`formatstrings`" msgstr ":ref:`formatstrings`" #: ../Doc/tutorial/introduction.rst:359 msgid "Information about string formatting with :meth:`str.format`." msgstr "" "Informations sur le formatage des chaînes avec la méthode :meth:`str.format`." #: ../Doc/tutorial/introduction.rst:362 msgid ":ref:`old-string-formatting`" msgstr ":ref:`old-string-formatting`" #: ../Doc/tutorial/introduction.rst:362 msgid "" "The old formatting operations invoked when strings and Unicode strings are " "the left operand of the ``%`` operator are described in more detail here." msgstr "" "Les anciennes opérations de formatage appelées lorsque les chaînes de " "caractères et les chaînes Unicode sont les opérandes placés à gauche de " "l'opérateur ``%`` sont décrites plus en détail ici." #: ../Doc/tutorial/introduction.rst:369 msgid "Lists" msgstr "Les listes" #: ../Doc/tutorial/introduction.rst:371 msgid "" "Python knows a number of *compound* data types, used to group together other " "values. The most versatile is the *list*, which can be written as a list of " "comma-separated values (items) between square brackets. Lists might contain " "items of different types, but usually the items all have the same type. ::" msgstr "" "Python connaît différents types de données *combinés*, utilisés pour " "regrouper plusieurs valeurs. La plus souple est la *liste*, qui peut être " "écrite comme une suite de valeurs (éléments) séparés par des virgules placée " "entre crochets. Les éléments d'une liste ne sont pas obligatoirement tous du " "même type, bien qu'à l'usage ce soit souvent le cas. ::" #: ../Doc/tutorial/introduction.rst:380 msgid "" "Like strings (and all other built-in :term:`sequence` type), lists can be " "indexed and sliced::" msgstr "" "Comme les chaînes de caractères (et toute autre types de :term:`sequence`), " "les listes peuvent être indicées et découpées : ::" #: ../Doc/tutorial/introduction.rst:390 msgid "" "All slice operations return a new list containing the requested elements. " "This means that the following slice returns a new (shallow) copy of the " "list::" msgstr "" "Toutes les opérations par tranches renvoient une nouvelle liste contenant " "les éléments demandés. Ce qui signifie que l'opération suivante renvoie une " "copie superficielle de la liste : ::" #: ../Doc/tutorial/introduction.rst:396 msgid "Lists also support operations like concatenation::" msgstr "Les listes gèrent aussi les opérations comme les concaténations : ::" #: ../Doc/tutorial/introduction.rst:401 msgid "" "Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` " "type, i.e. it is possible to change their content::" msgstr "" "Mais à la différence des listes qui sont :term:`immuable`\\s, les listes " "sont :term:`mutable`\\s : il est possible de changer leur contenu : ::" #: ../Doc/tutorial/introduction.rst:411 msgid "" "You can also add new items at the end of the list, by using the :meth:`~list." "append` *method* (we will see more about methods later)::" msgstr "" "Il est aussi possible d'ajouter de nouveaux éléments à la fin d'une liste " "avec la méthode :meth:`~list.append`. (Les méthodes seront abordées plus " "tard) ::" #: ../Doc/tutorial/introduction.rst:419 msgid "" "Assignment to slices is also possible, and this can even change the size of " "the list or clear it entirely::" msgstr "" "Des affectations de tranches sont également possibles, ce qui peut même " "modifier la taille de la liste ou la vider complètement : ::" #: ../Doc/tutorial/introduction.rst:438 msgid "The built-in function :func:`len` also applies to lists::" msgstr "La primitive :func:`len` s'applique aussi aux listes : ::" #: ../Doc/tutorial/introduction.rst:444 msgid "" "It is possible to nest lists (create lists containing other lists), for " "example::" msgstr "" "Il est possible d'imbriquer des listes (de créer des listes contenant " "d'autres listes), par exemple : ::" #: ../Doc/tutorial/introduction.rst:460 msgid "First Steps Towards Programming" msgstr "Premiers pas vers la programmation" #: ../Doc/tutorial/introduction.rst:462 msgid "" "Of course, we can use Python for more complicated tasks than adding two and " "two together. For instance, we can write an initial sub-sequence of the " "*Fibonacci* series as follows::" msgstr "" "Bien entendu, on peut utiliser Python pour des tâches plus compliquées que " "d'additionner deux et deux. Par exemple, on peut écrire une sous-séquence " "initiale de la suite de Fibonacci comme ceci : ::" #: ../Doc/tutorial/introduction.rst:480 msgid "This example introduces several new features." msgstr "Cet exemple introduit plusieurs nouvelles fonctionnalités." #: ../Doc/tutorial/introduction.rst:482 msgid "" "The first line contains a *multiple assignment*: the variables ``a`` and " "``b`` simultaneously get the new values 0 and 1. On the last line this is " "used again, demonstrating that the expressions on the right-hand side are " "all evaluated first before any of the assignments take place. The right-" "hand side expressions are evaluated from the left to the right." msgstr "" "La première ligne contient une *affectation multiple* : les variables ``a`` " "et ``b`` se voient affecter simultanément leurs nouvelles valeurs 0 et 1. " "Cette méthode est encore utilisée à la dernière ligne, pour démontrer que " "les expressions sur la partie droite de l'affectation sont toutes évaluées " "avant que les affectations ne soient effectuées. Ces expressions en partie " "droite sont toujours évaluées de la gauche vers la droite." #: ../Doc/tutorial/introduction.rst:488 msgid "" "The :keyword:`while` loop executes as long as the condition (here: ``b < " "10``) remains true. In Python, like in C, any non-zero integer value is " "true; zero is false. The condition may also be a string or list value, in " "fact any sequence; anything with a non-zero length is true, empty sequences " "are false. The test used in the example is a simple comparison. The " "standard comparison operators are written the same as in C: ``<`` (less " "than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal " "to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)." msgstr "" "La boucle :keyword:`while` s'exécute tant que la condition (ici : ``b < " "10``) reste vraie. En Python, comme en C, tout entier différent de zéro est " "vrai et zéro est faux. La condition peut aussi être une chaîne de " "caractères, une liste, ou en fait toute séquence ; une séquence avec une " "valeur non nulle est vraie, une séquence vide est fausse. Le test utilisé " "dans l'exemple est une simple comparaison. Les opérateurs de comparaison " "standards sont écrits comme en C : ``<`` (inférieur), ``>`` (supérieur), " "``==`` (égal), ``<=`` (inférieur ou égal), ``>=`` (supérieur ou égal) et ``!" "=`` (non égal)." #: ../Doc/tutorial/introduction.rst:497 msgid "" "The *body* of the loop is *indented*: indentation is Python's way of " "grouping statements. At the interactive prompt, you have to type a tab or " "space(s) for each indented line. In practice you will prepare more " "complicated input for Python with a text editor; all decent text editors " "have an auto-indent facility. When a compound statement is entered " "interactively, it must be followed by a blank line to indicate completion " "(since the parser cannot guess when you have typed the last line). Note " "that each line within a basic block must be indented by the same amount." msgstr "" "Le *corps* de la boucle est *indenté* : l'indentation est la méthode " "utilisée par Python pour regrouper des instructions. En mode interactif, " "vous devez saisir une tabulation ou des espaces pour chaque ligne indentée. " "En pratique, vous aurez intérêt à utiliser un éditeur de texte pour les " "saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom " "disposent d'une fonction d'auto-indentation. Lorsqu'une expression composée " "est saisie en mode interactif, elle doit être suivie d'une ligne vide pour " "indiquer qu'elle est terminée (car l'analyseur ne peut pas deviner que vous " "venez de saisir la dernière ligne). Notez bien que toutes les lignes à " "l'intérieur d'un bloc doivent être indentées au même niveau." #: ../Doc/tutorial/introduction.rst:506 msgid "" "The :func:`print` function writes the value of the argument(s) it is given. " "It differs from just writing the expression you want to write (as we did " "earlier in the calculator examples) in the way it handles multiple " "arguments, floating point quantities, and strings. Strings are printed " "without quotes, and a space is inserted between items, so you can format " "things nicely, like this::" msgstr "" "La fonction :func:`print` écrit les valeur des paramètres qui lui sont " "fournis. Ce n'est pas la même chose que d'écrire l'expression que vousvoulez " "afficher (comme nous l'avons fait dans l'exemple de la calculatrice), dû à " "la manière de ``print`` de gérer les paramètres multiples, les nombres " "décimaux, et les chaînes. Les chaînes sont affichées sans apostrophes et " "unespace est inséré entre les éléments de telle sorte que vous pouvez " "facilement formater les choses, comme ceci : ::" #: ../Doc/tutorial/introduction.rst:517 msgid "" "The keyword argument *end* can be used to avoid the newline after the " "output, or end the output with a different string::" msgstr "" "Le paramètre nommé *end* peut servir pour enlever le retour à la ligne, ou " "terminer la ligne par une autre chaîne : ::" #: ../Doc/tutorial/introduction.rst:530 msgid "" "Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted " "as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you " "can use ``(-3)**2``." msgstr "" "Puisque ``**`` est prioritaire sur ``-``, ``-3 ** 2`` sera interprété ``-(3 " "** 2)`` et vaudra donc ``-9``. Pour éviter cela et obtenir ``9``, utilisez " "des parenthèses : ``(-3) ** 2``." #: ../Doc/tutorial/introduction.rst:534 msgid "" "Unlike other languages, special characters such as ``\\n`` have the same " "meaning with both single (``'...'``) and double (``\"...\"``) quotes. The " "only difference between the two is that within single quotes you don't need " "to escape ``\"`` (but you have to escape ``\\'``) and vice versa." msgstr "" "Contrairement à d'autres langages, les caractères spéciaux comme ``\\n`` ont " "la même signification entre guillemets (`\"...\"`) ou guillemets simples " "(`'...'`). La seule différence est que dans une chaîne entre guillemets il " "n'est pas nécessaire de protéger les guillemets simples et vice-versa." #: ../Doc/tutorial/modules.rst:5 msgid "Modules" msgstr "Modules" #: ../Doc/tutorial/modules.rst:7 msgid "" "If you quit from the Python interpreter and enter it again, the definitions " "you have made (functions and variables) are lost. Therefore, if you want to " "write a somewhat longer program, you are better off using a text editor to " "prepare the input for the interpreter and running it with that file as input " "instead. This is known as creating a *script*. As your program gets " "longer, you may want to split it into several files for easier maintenance. " "You may also want to use a handy function that you've written in several " "programs without copying its definition into each program." msgstr "" "Lorsque vous quittez et entrez à nouveau dans l'interpréteur Python, tout ce " "que vous avez déclaré dans la session précédente est perdu. Afin de rédiger " "des programmes plus longs, vous devriez utiliser un éditeur de texte, " "préparer votre code dans un fichier, et exécuter Python avec ce fichier en " "paramètre. Ça s'appelle créé un *script*. Lorsque votre programme deviendra " "plus long encore, vous pourrez séparer votre code dans plusieurs fichiers, " "et vous trouverez aussi pratique de réutiliser des fonctions écrites pour un " "programme dans un autre sans avoir à les copier." #: ../Doc/tutorial/modules.rst:16 msgid "" "To support this, Python has a way to put definitions in a file and use them " "in a script or in an interactive instance of the interpreter. Such a file is " "called a *module*; definitions from a module can be *imported* into other " "modules or into the *main* module (the collection of variables that you have " "access to in a script executed at the top level and in calculator mode)." msgstr "" "Pour gérer ça, Python à un moyen de rédiger des définitions dans un fichier " "et les utiliser dans un script ou une session interactive. Un tel fichier " "est appelé un *module*, et les définitions d'un module peuvent être " "importées dans un autre module ou dans le module *main* (qui est le module " "qui contiens vous variables et définitions lors de l'exécution d'un script " "ou en mode interactif)." #: ../Doc/tutorial/modules.rst:22 msgid "" "A module is a file containing Python definitions and statements. The file " "name is the module name with the suffix :file:`.py` appended. Within a " "module, the module's name (as a string) is available as the value of the " "global variable ``__name__``. For instance, use your favorite text editor " "to create a file called :file:`fibo.py` in the current directory with the " "following contents::" msgstr "" "Un module est un fichier contenant des définitions et des instructions. Son " "nom de fichier est le même que son nom, suffixé de :file:`.py`. À " "l'intérieur d'un module, son propre nom est accessible dans la variable " "``__name__``. Par exemple, prenez votre éditeur favori et créez un fichier :" "file:`fibo.py` contenant : ::" #: ../Doc/tutorial/modules.rst:45 msgid "" "Now enter the Python interpreter and import this module with the following " "command::" msgstr "" "Maintenant, en étant dans le même dossier, ouvrez un interpréteur et " "importez le module en tapant : ::" #: ../Doc/tutorial/modules.rst:50 msgid "" "This does not enter the names of the functions defined in ``fibo`` directly " "in the current symbol table; it only enters the module name ``fibo`` there. " "Using the module name you can access the functions::" msgstr "" "Cela n'importe pas les noms des fonctions définies dans ``fibo`` directement " "dans la table des symboles courante, mais y ajoute simplement ``fibo``. Vous " "pouvez donc appeler les fonctions via le nom du module : ::" #: ../Doc/tutorial/modules.rst:61 msgid "" "If you intend to use a function often you can assign it to a local name::" msgstr "" "Si vous avez l'intention d'utiliser une fonction souvent, il est possible de " "lui assigner un nom local : ::" #: ../Doc/tutorial/modules.rst:71 msgid "More on Modules" msgstr "Les modules en détails" #: ../Doc/tutorial/modules.rst:73 msgid "" "A module can contain executable statements as well as function definitions. " "These statements are intended to initialize the module. They are executed " "only the *first* time the module name is encountered in an import statement. " "[#]_ (They are also run if the file is executed as a script.)" msgstr "" "Un module peut contenir aussi bien des instructions que des déclarations de " "fonctions. C'est instructions permettent d'initialiser le module, et ne sont " "donc exécutées que la première fois que le nom d'un module est trouvé dans " "un ``import``. [#]_ (Elles sont aussi exécutées lorsque le fichier est " "exécuté en temps que script.)" #: ../Doc/tutorial/modules.rst:78 msgid "" "Each module has its own private symbol table, which is used as the global " "symbol table by all functions defined in the module. Thus, the author of a " "module can use global variables in the module without worrying about " "accidental clashes with a user's global variables. On the other hand, if you " "know what you are doing you can touch a module's global variables with the " "same notation used to refer to its functions, ``modname.itemname``." msgstr "" "Chaque module a sa propre table de symboles, utilisée comme table de " "symboles globaux par toutes les fonctions définies par le module. Ainsi " "l'auteur d'un module peut utiliser des variables globales dans un module " "sans se soucier de collisions de noms avec des globales définies par " "l'utilisateur du module. D'un autre côté, si vous savez ce que vous faites, " "vous pouvez modifier une variable globale d'un module avec la même notation " "que pour accéder aux fonctions : ``modname.itemname``." #: ../Doc/tutorial/modules.rst:85 msgid "" "Modules can import other modules. It is customary but not required to place " "all :keyword:`import` statements at the beginning of a module (or script, " "for that matter). The imported module names are placed in the importing " "module's global symbol table." msgstr "" "Des modules peuvent importer d'autres modules. Il est habituel mais pas " "obligatoire de ranger tous les :keyword:`import` au début du module (ou du " "script). Les noms des module importés sont insérés dans la table des " "symboles globaux du module qui importe." #: ../Doc/tutorial/modules.rst:90 msgid "" "There is a variant of the :keyword:`import` statement that imports names " "from a module directly into the importing module's symbol table. For " "example::" msgstr "" "Il existe une variation à l'instruction :keyword:`import` qui importe les " "noms d'un module directement dans la table de symboles du module qui " "l'importe, par exemple : ::" #: ../Doc/tutorial/modules.rst:97 msgid "" "This does not introduce the module name from which the imports are taken in " "the local symbol table (so in the example, ``fibo`` is not defined)." msgstr "" "Cela n'insère pas le nom du module depuis lequel les définitions sont " "récupérées dans la table locale de symboles (dans cet exemple, ``fibo`` " "n'est pas défini)." #: ../Doc/tutorial/modules.rst:100 msgid "There is even a variant to import all names that a module defines::" msgstr "" "Il existe même une variation permettant d'importer tous les noms qu'un " "module définit : ::" #: ../Doc/tutorial/modules.rst:106 msgid "" "This imports all names except those beginning with an underscore (``_``). In " "most cases Python programmers do not use this facility since it introduces " "an unknown set of names into the interpreter, possibly hiding some things " "you have already defined." msgstr "" "Tous les noms ne commencant pas par un tiret bas (``_``) sont importés. Dans " "la grande majorité des cas, les développeurs n'utilisent pas cette syntaxe " "puisqu'en important un ensemble indéfini de noms, des noms déjà définis " "peuvent se retrouver cachés." #: ../Doc/tutorial/modules.rst:111 msgid "" "Note that in general the practice of importing ``*`` from a module or " "package is frowned upon, since it often causes poorly readable code. " "However, it is okay to use it to save typing in interactive sessions." msgstr "" "Notez qu'en général, importer ``*`` d'un module ou d'un paquet est " "déconseillé, en général ça engendre du code difficilement lisible. " "Cependant, c'est acceptable de l'utiliser pour gagner quelques secondes en " "mode interactif." #: ../Doc/tutorial/modules.rst:117 msgid "" "For efficiency reasons, each module is only imported once per interpreter " "session. Therefore, if you change your modules, you must restart the " "interpreter -- or, if it's just one module you want to test interactively, " "use :func:`importlib.reload`, e.g. ``import importlib; importlib." "reload(modulename)``." msgstr "" "Pour des raisons de performance, chaque module n'est importé qu'une fois par " "session. Si vous changez le code d'un module vous devez donc redémarrer " "l'interpréteur afin d'en voir l'impact. Ou le re-importer explicitement en " "utilisant :func:`importlib.reload`, par exemple : ``import importlib; " "importlib.reload(modulename)``." #: ../Doc/tutorial/modules.rst:127 msgid "Executing modules as scripts" msgstr "Exécuter des modules comme des scripts" #: ../Doc/tutorial/modules.rst:129 msgid "When you run a Python module with ::" msgstr "Lorsque vous exécutez un module Python avec : ::" #: ../Doc/tutorial/modules.rst:133 msgid "" "the code in the module will be executed, just as if you imported it, but " "with the ``__name__`` set to ``\"__main__\"``. That means that by adding " "this code at the end of your module::" msgstr "" "le code du module sera exécuté comme si vous l'aviez importé, mais son " "``__name__`` vaudra ``\"__main__\"``. Donc en ajoutant ces lignes à la fin " "du module : ::" #: ../Doc/tutorial/modules.rst:141 msgid "" "you can make the file usable as a script as well as an importable module, " "because the code that parses the command line only runs if the module is " "executed as the \"main\" file:" msgstr "" #: ../Doc/tutorial/modules.rst:150 msgid "If the module is imported, the code is not run::" msgstr "Si le fichier est importé, le code n'est pas exécuté : ::" #: ../Doc/tutorial/modules.rst:155 msgid "" "This is often used either to provide a convenient user interface to a " "module, or for testing purposes (running the module as a script executes a " "test suite)." msgstr "" "C'est typiquement utilisé soit pour proposer une interface utilisateur pour " "un module, soit pour lancer les tests sur le module (où exécuter le module " "en temps que script lance les tests)." #: ../Doc/tutorial/modules.rst:162 msgid "The Module Search Path" msgstr "Les dossiers de recherche de modules" #: ../Doc/tutorial/modules.rst:166 msgid "" "When a module named :mod:`spam` is imported, the interpreter first searches " "for a built-in module with that name. If not found, it then searches for a " "file named :file:`spam.py` in a list of directories given by the variable :" "data:`sys.path`. :data:`sys.path` is initialized from these locations:" msgstr "" "Lorsqu'un module nommé par exemple :mod:`spam` est importé, il est d'abord " "recherché parmis les modules natifs, puis s'il n'y est pas trouvé, " "l'interpréteur va chercher un fichier nommé :file:`spam.py` dans une liste " "de dossiers donnés par la variable :data:`sys.path`, :data:`sys.path` est " "initialisée par défaut à : ::" #: ../Doc/tutorial/modules.rst:171 msgid "" "The directory containing the input script (or the current directory when no " "file is specified)." msgstr "" "Le dossier contenant le script courant (ou le dossier courant si aucun " "script n'est donné)." #: ../Doc/tutorial/modules.rst:173 msgid "" ":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the " "shell variable :envvar:`PATH`)." msgstr "" ":envvar:`PYTHONPATH` (une liste de dossiers, utilisant la même syntaxe que " "la variable shell :envvar:`PATH`)." #: ../Doc/tutorial/modules.rst:175 msgid "The installation-dependent default." msgstr "La valeur par défaut, dépendante de l'installation." #: ../Doc/tutorial/modules.rst:178 msgid "" "On file systems which support symlinks, the directory containing the input " "script is calculated after the symlink is followed. In other words the " "directory containing the symlink is **not** added to the module search path." msgstr "" "Sur les systèmes qui gèrent les liens symboliques, le dossier contenant le " "script courant est résolu après avoir suivi le lien sublimer du script. " "Autrement dit le dossier contenant le lien symbolique n'est **pas** ajouté " "au dossiers de recherche de modules." #: ../Doc/tutorial/modules.rst:182 msgid "" "After initialization, Python programs can modify :data:`sys.path`. The " "directory containing the script being run is placed at the beginning of the " "search path, ahead of the standard library path. This means that scripts in " "that directory will be loaded instead of modules of the same name in the " "library directory. This is an error unless the replacement is intended. See " "section :ref:`tut-standardmodules` for more information." msgstr "" "Après leur initialisation, les programmes Python peuvent modifier leur :data:" "`sys.path`. Le dossier contenant le script courant est placé au début de la " "liste des dossiers à rechercher, avant les dossiers de bibliothèques, Cela " "signifie qu'un module dans ce dossier, ayant le même nom qu'un module, sera " "chargé à sa place. C'est une erreur typique, à moins que ce soit voulu. " "Voir :ref:`tut-standardmodules` pour plus d'informations." #: ../Doc/tutorial/modules.rst:193 msgid "\"Compiled\" Python files" msgstr "Fichiers Python \"compilés\"" #: ../Doc/tutorial/modules.rst:195 msgid "" "To speed up loading modules, Python caches the compiled version of each " "module in the ``__pycache__`` directory under the name :file:`module." "{version}.pyc`, where the version encodes the format of the compiled file; " "it generally contains the Python version number. For example, in CPython " "release 3.3 the compiled version of spam.py would be cached as ``__pycache__/" "spam.cpython-33.pyc``. This naming convention allows compiled modules from " "different releases and different versions of Python to coexist." msgstr "" "Pour accélérer le chargement des modules, Python cache une version compilée " "de chaque module, dans un fichier nommé :file:`module(version).pyc` (ou " "*version* représente le format du fichier compilé, typiquement une version " "de Python) dans le dossier ``__pycache__``. Par exemple avec CPython 3.3 la " "version compilée de spam.py serait ``__pycache__/spam.cpython-33.pyc``. " "Cette règle de nommage permet à des versions compilées par des versions de " "Python différentes de coexister." #: ../Doc/tutorial/modules.rst:203 msgid "" "Python checks the modification date of the source against the compiled " "version to see if it's out of date and needs to be recompiled. This is a " "completely automatic process. Also, the compiled modules are platform-" "independent, so the same library can be shared among systems with different " "architectures." msgstr "" "Python compare les dates de modification du fichier source et de sa version " "compilée pour voir si le module doit être recompilé. Ce processus est " "entièrement automatique, et les versions compilées sont indépendantes de la " "plateforme, et peuvent donc être partagées entre des systèmes d'architecture " "différente." #: ../Doc/tutorial/modules.rst:208 msgid "" "Python does not check the cache in two circumstances. First, it always " "recompiles and does not store the result for the module that's loaded " "directly from the command line. Second, it does not check the cache if " "there is no source module. To support a non-source (compiled only) " "distribution, the compiled module must be in the source directory, and there " "must not be a source module." msgstr "" "Il existe deux circonstances pour lesquelles Python ne vérifie pas le " "cache : Le premier cas lorsque le module est donné par la ligne de commande " "(cas où le module est toujours recompilé, sans même cacher sa version " "compilée), le second cas est lorsque le module n'a pas de source dans ce cas " "Python n'essaye pas de charger la version compilée. Pour gérer un module " "sans source (seulement compilé) le module compilé doit être dans le dossier " "source et sa source ne doit pas être présente." #: ../Doc/tutorial/modules.rst:215 msgid "Some tips for experts:" msgstr "Astuces pour les experts :" #: ../Doc/tutorial/modules.rst:217 msgid "" "You can use the :option:`-O` or :option:`-OO` switches on the Python command " "to reduce the size of a compiled module. The ``-O`` switch removes assert " "statements, the ``-OO`` switch removes both assert statements and __doc__ " "strings. Since some programs may rely on having these available, you should " "only use this option if you know what you're doing. \"Optimized\" modules " "have an ``opt-`` tag and are usually smaller. Future releases may change " "the effects of optimization." msgstr "" "Vous pouvez utiliser les options :option:`-O` ou :option:`-OO` lors de " "l'appel à Python pour réduire la taille des modules compilés. L'option ``-" "O`` supprime les instructions ``assert``, et l'option ``-OO`` supprime aussi " "les documentations ``__doc__``. Cependant, puisque certains programmes ont " "besoin de ces ``__doc__``, vous ne devriez utiliser ``-OO`` que si vous " "savez ce que vous faites. Les modules \"optimisés\" sont marqués d'un ``opt-" "`` et sont généralement plus petits. Les versions futures de Python " "pourraient changer les effets de l'optimisation." #: ../Doc/tutorial/modules.rst:225 msgid "" "A program doesn't run any faster when it is read from a ``.pyc`` file than " "when it is read from a ``.py`` file; the only thing that's faster about ``." "pyc`` files is the speed with which they are loaded." msgstr "" "Un programme ne s'exécute pas plus vite lorsqu'il est lu depuis un ``.pyc``, " "il est cependant chargé plus vite puisque le ``.pyc`` est plut petit que le " "``.py``." #: ../Doc/tutorial/modules.rst:229 msgid "" "The module :mod:`compileall` can create .pyc files for all modules in a " "directory." msgstr "" "Le module :mod:`compileall` peut créer des fichiers ``.pyc`` pour tous les " "modules d'un dossier." #: ../Doc/tutorial/modules.rst:232 msgid "" "There is more detail on this process, including a flow chart of the " "decisions, in PEP 3147." msgstr "" "Voilà plus de détails sur le processus, ainsi qu'un organigramme des " "decisions, dans la PEP 3147." #: ../Doc/tutorial/modules.rst:239 msgid "Standard Modules" msgstr "Modules standards" #: ../Doc/tutorial/modules.rst:243 msgid "" "Python comes with a library of standard modules, described in a separate " "document, the Python Library Reference (\"Library Reference\" hereafter). " "Some modules are built into the interpreter; these provide access to " "operations that are not part of the core of the language but are " "nevertheless built in, either for efficiency or to provide access to " "operating system primitives such as system calls. The set of such modules " "is a configuration option which also depends on the underlying platform. " "For example, the :mod:`winreg` module is only provided on Windows systems. " "One particular module deserves some attention: :mod:`sys`, which is built " "into every Python interpreter. The variables ``sys.ps1`` and ``sys.ps2`` " "define the strings used as primary and secondary prompts::" msgstr "" "Python est accompagné d'une bibliothèque de modules standards, décrits dans " "la documentation de la Bibliothèque Python, plus loin. Certains modules sont " "intégrés dans l'interpréteur, ils exposent des outils qui ne font pas partie " "du langage, mais qui font tout de même partie de l'interpréteur, soit pour " "le côté pratique, soit pour exposer des outils essentiels tels que l'accès " "aux appels systems. La composition de ces modules est configurable à la " "compilation, et dépend aussi de la plateforme ciblée. Par exemple, le " "module :mod:`winreg` n'est proposé que sur les systèmes Windows. Un module " "mérite une attention particulière, le module :mod:`sys`, qui est présent " "dans tous les interpréteurs Python. Les variables ``sys.ps1`` et ``sys.ps2`` " "définissent les chaînes d'invites principales et secondaires : ::" #: ../Doc/tutorial/modules.rst:266 msgid "" "These two variables are only defined if the interpreter is in interactive " "mode." msgstr "" "Ces deux variables ne sont définies que si l'interpréteur est en mode " "interactif." #: ../Doc/tutorial/modules.rst:268 msgid "" "The variable ``sys.path`` is a list of strings that determines the " "interpreter's search path for modules. It is initialized to a default path " "taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in " "default if :envvar:`PYTHONPATH` is not set. You can modify it using " "standard list operations::" msgstr "" "La variable ``sys.path`` est une liste de chaînes qui détermine les chemins " "de recherche de modules pour l'interpréteur. Il est initialisé à un chemin " "par défaut pris de la variable d'environnement :envvar:`PYTHONPATH`, ou " "d'une valeur par défaut interne si :envvar:`PYTHONPATH` n'est pas définie. " "``sys.path`` est modifiable en utilisant les opérations habituelles des " "listes : ::" #: ../Doc/tutorial/modules.rst:281 msgid "The :func:`dir` Function" msgstr "La fonction :func:`dir`" #: ../Doc/tutorial/modules.rst:283 msgid "" "The built-in function :func:`dir` is used to find out which names a module " "defines. It returns a sorted list of strings::" msgstr "" "La fonction interne :func:`dir` est utilisée pour trouver quels noms sont " "définies par un module. Elle donne une liste triée de chaînes :;" #: ../Doc/tutorial/modules.rst:308 msgid "" "Without arguments, :func:`dir` lists the names you have defined currently::" msgstr "Sans paramètres, :func:`dir` listes les noms actuellement définis : ::" #: ../Doc/tutorial/modules.rst:316 msgid "" "Note that it lists all types of names: variables, modules, functions, etc." msgstr "" "Notez qu'elle liste tout types de noms : les variables, fonctions, modules, " "etc." #: ../Doc/tutorial/modules.rst:320 msgid "" ":func:`dir` does not list the names of built-in functions and variables. If " "you want a list of those, they are defined in the standard module :mod:" "`builtins`::" msgstr "" ":func:`dir` ne liste ni les fonctions primitives ni les variables internes. " "Si vous voulez les lister, ils sont définis dans le module :mod:`builtins` ::" #: ../Doc/tutorial/modules.rst:359 msgid "Packages" msgstr "Les paquets" #: ../Doc/tutorial/modules.rst:361 msgid "" "Packages are a way of structuring Python's module namespace by using " "\"dotted module names\". For example, the module name :mod:`A.B` designates " "a submodule named ``B`` in a package named ``A``. Just like the use of " "modules saves the authors of different modules from having to worry about " "each other's global variable names, the use of dotted module names saves the " "authors of multi-module packages like NumPy or the Python Imaging Library " "from having to worry about each other's module names." msgstr "" "Les paquets sont un moyen de structurer les espaces de noms des modules " "Python en utilisant une notations \"pointée\". Par exemple, le nom de " "module :mod:`A.B` désigne le sous-module ``B`` du paquet ``A``. De la même " "manière que l'utilisation des modules évite aux auteurs de différents " "modules d'avoir à se soucier des noms de variables globales des autres, " "l'utilisation des noms de modules avec des points évite aux auteurs de " "paquets contenant plusieurs modules tel que NumPy ou \"Python Image Library" "\" d'avoir à se soucier des noms des modules des autres." #: ../Doc/tutorial/modules.rst:369 msgid "" "Suppose you want to design a collection of modules (a \"package\") for the " "uniform handling of sound files and sound data. There are many different " "sound file formats (usually recognized by their extension, for example: :" "file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and " "maintain a growing collection of modules for the conversion between the " "various file formats. There are also many different operations you might " "want to perform on sound data (such as mixing, adding echo, applying an " "equalizer function, creating an artificial stereo effect), so in addition " "you will be writing a never-ending stream of modules to perform these " "operations. Here's a possible structure for your package (expressed in " "terms of a hierarchical filesystem):" msgstr "" "Imaginez que vous voulez constuire une collections de modules (un \"paquet" "\") pour gérer uniformément les fichiers contenant du son et des données " "sonores. Il existe un grand nombre de formats de fichiers pour stocker du " "son (généralement repérés par leur extension, par exemple :file:`.wav`, :" "file:`.aiff`, :file:`.au`), vous aurez donc envie de créer et maintenir un " "nombre croissant de modules pour gérer la conversion entre tous ces formats. " "Il existe aussi tout une floppée d'opérations que vous voudriez pouvoir " "faire sur du son (mixer, ajouter de l'écho, égaliser, ajouter un effet " "stéréo articifiel), donc, en plus des modules de conversion, vous allez " "écrire un nombre illimité de modules permettant d'effectuer ces opérations. " "Voici une structure possible pour votre paquet (exprimée comme un système de " "fichier, hierarchiquement) :" #: ../Doc/tutorial/modules.rst:406 msgid "" "When importing the package, Python searches through the directories on ``sys." "path`` looking for the package subdirectory." msgstr "" "Lorsqu'il importe des paquets, Python cherche dans chaque dossiers de ``sys." "path``, à la recherche du dossier du paquet." #: ../Doc/tutorial/modules.rst:409 msgid "" "The :file:`__init__.py` files are required to make Python treat the " "directories as containing packages; this is done to prevent directories with " "a common name, such as ``string``, from unintentionally hiding valid modules " "that occur later on the module search path. In the simplest case, :file:" "`__init__.py` can just be an empty file, but it can also execute " "initialization code for the package or set the ``__all__`` variable, " "described later." msgstr "" "Les fichiers :file:`__init__.py` sont nécessaires pour que Python considère " "les dossiers comme contenant des paquets, ça évite des dossiers ayant des " "noms courants comme ``string`` de cacher des modules qui auraient été " "trouvés plus loin dans les dossiers de recherche. Dans le plus simple des " "cas, :file:`__init__.py` peut être vide, mais il peut exécuter du code " "d'initialisation pour son paquet ou configurer la variable ``__all__`` " "(documentée plus loin)." #: ../Doc/tutorial/modules.rst:416 msgid "" "Users of the package can import individual modules from the package, for " "example::" msgstr "" "Les utilisateurs d'un module peuvent importer ses modules individuellement, " "par exemple : ::" #: ../Doc/tutorial/modules.rst:421 msgid "" "This loads the submodule :mod:`sound.effects.echo`. It must be referenced " "with its full name. ::" msgstr "" "Chargera le sous-module :mod:`sound.effects.echo`. Il dit être référencé par " "son nom complet. ::" #: ../Doc/tutorial/modules.rst:426 msgid "An alternative way of importing the submodule is::" msgstr "Une autre manière d'importer des sous-modules est : ::" #: ../Doc/tutorial/modules.rst:430 msgid "" "This also loads the submodule :mod:`echo`, and makes it available without " "its package prefix, so it can be used as follows::" msgstr "" "Chargera aussi le sous-module :mod:`echo`, et le rendra disponible dans le " "préfixe du paquet, il peut donc être utilisé comme ça : ::" #: ../Doc/tutorial/modules.rst:435 msgid "" "Yet another variation is to import the desired function or variable " "directly::" msgstr "" "Une autre méthode consisterait à importer la fonction ou variable désirée " "directement : ::" #: ../Doc/tutorial/modules.rst:439 msgid "" "Again, this loads the submodule :mod:`echo`, but this makes its function :" "func:`echofilter` directly available::" msgstr "" "Le sous-module :mod:`echo` est toujours chargé, mais ici la fonction :func:" "`echofilter` est disponible directement : ::" #: ../Doc/tutorial/modules.rst:444 msgid "" "Note that when using ``from package import item``, the item can be either a " "submodule (or subpackage) of the package, or some other name defined in the " "package, like a function, class or variable. The ``import`` statement first " "tests whether the item is defined in the package; if not, it assumes it is a " "module and attempts to load it. If it fails to find it, an :exc:" "`ImportError` exception is raised." msgstr "" "Notez que lorsque vous utilisez ``from package import item``, ``item`` peut " "aussi bien être un sous-module, un sous-paquet, ou simplement un nom déclaré " "dans le paquet (une variable, une fonction ou une classe). L'instruction " "``import`` cherche en premier si ``item`` est définit dans le paquet, s'il " "ne l'est pas, elle cherche à charger un module, et si elle n'y arrive pas, " "une exception :exc:`ImportError` est levée." #: ../Doc/tutorial/modules.rst:451 msgid "" "Contrarily, when using syntax like ``import item.subitem.subsubitem``, each " "item except for the last must be a package; the last item can be a module or " "a package but can't be a class or function or variable defined in the " "previous item." msgstr "" "Au contraire, en utilisant la syntaxe ``import item.item.subitement." "subsubitem``, chaque ``item`` sauf le dernier doivent être des paquets. Le " "dernier ``item`` peut être un module ou un paquet, mais ne peut être ni une " "fonction, ni une classe, ni une variable défini dans l'élément précédent." #: ../Doc/tutorial/modules.rst:460 msgid "Importing \\* From a Package" msgstr "Importer \\* depuis un paquet" #: ../Doc/tutorial/modules.rst:464 msgid "" "Now what happens when the user writes ``from sound.effects import *``? " "Ideally, one would hope that this somehow goes out to the filesystem, finds " "which submodules are present in the package, and imports them all. This " "could take a long time and importing sub-modules might have unwanted side-" "effects that should only happen when the sub-module is explicitly imported." msgstr "" "Qu'arrive-il lorsqu'un utilisateur écrit ``from sound.effects import *`` ? " "Dans l'idéal on pourrait espérer que ça irait chercher tous les sous-modules " "du paquet sur le système de fichiers, et qu'ils seraient tous importés. Ça " "pourrait être long, et importer certains sous-modules pourrait avoir des " "effets secondaires indésirables, du moins, désirés seulement lorsque le sous " "module est importé explicitement." #: ../Doc/tutorial/modules.rst:470 msgid "" "The only solution is for the package author to provide an explicit index of " "the package. The :keyword:`import` statement uses the following convention: " "if a package's :file:`__init__.py` code defines a list named ``__all__``, it " "is taken to be the list of module names that should be imported when ``from " "package import *`` is encountered. It is up to the package author to keep " "this list up-to-date when a new version of the package is released. Package " "authors may also decide not to support it, if they don't see a use for " "importing \\* from their package. For example, the file :file:`sound/" "effects/__init__.py` could contain the following code::" msgstr "" "La seule solution, pour l'auteur du paquet, est de fournir un index " "explicite du contenu du paquet. L'instruction :keyword:`import` utilise la " "convention suivante: Si le fichier :file:`__init__.py` du paquet définit une " "liste nommée ``__all__``, cette liste sera utilisée comme liste des noms de " "modules devant être importés lorsque ``from package import *`` est utilisé. " "C'est le rôle de l'auteur du paquet de maintenir cette liste à jour lorsque " "de nouvelles version du paquet sont publiées. Un auteur de paquet peut aussi " "décider de ne pas autoriser d'importer ``*`` de leur paquet. Par exemple, le " "fichier :file:`sound/effects/__init__.py` peut contenir le code suivant : ::" #: ../Doc/tutorial/modules.rst:482 msgid "" "This would mean that ``from sound.effects import *`` would import the three " "named submodules of the :mod:`sound` package." msgstr "" "Cela signifierai que ``from sound.effects import *`` importait les trois " "sous-modules du paquet :mod:`sound`." #: ../Doc/tutorial/modules.rst:485 msgid "" "If ``__all__`` is not defined, the statement ``from sound.effects import *`` " "does *not* import all submodules from the package :mod:`sound.effects` into " "the current namespace; it only ensures that the package :mod:`sound.effects` " "has been imported (possibly running any initialization code in :file:" "`__init__.py`) and then imports whatever names are defined in the package. " "This includes any names defined (and submodules explicitly loaded) by :file:" "`__init__.py`. It also includes any submodules of the package that were " "explicitly loaded by previous :keyword:`import` statements. Consider this " "code::" msgstr "" "Si ``__all__`` n'est pas défini, l'instruction ``from sound.effects import " "*`` n'importera *pas* tous les sous-modules du paquet :mod:`sound.effects` " "dans l'espace de nom courant, mais s'assurera seulement que le paquet :mod:" "`sound.effects` à été importé (que tout le code du fichier :file:`__init__." "py` à été executé) et importe ensuite n'importe quels noms définis dans le " "paquet. Cela inclu tous les noms définis (et sous modules chargés " "explicitement) par :file:`__init__.py`. Elle inclu aussi tous les sous-" "modules du paquet ayant été chargés explicitement par une instruction :" "keyword:`import`. Typiquement : ::" #: ../Doc/tutorial/modules.rst:498 msgid "" "In this example, the :mod:`echo` and :mod:`surround` modules are imported in " "the current namespace because they are defined in the :mod:`sound.effects` " "package when the ``from...import`` statement is executed. (This also works " "when ``__all__`` is defined.)" msgstr "" "Dans cet exemple, les modules :mod:`echo` et :mod:`surround` sont importés " "dans l'espace de noms courant lorsque ``from...import`` est exécuté, parce " "qu'ils sont définis dans le paquet :mod:`sound.effects`. (Cela fonctionne " "lorsque ``__all__`` est défini.)" #: ../Doc/tutorial/modules.rst:503 msgid "" "Although certain modules are designed to export only names that follow " "certain patterns when you use ``import *``, it is still considered bad " "practise in production code." msgstr "" "Bien que certains modules ont été pensés pour n'exporter que les noms " "respectant une certaine structure lorsque ``import *`` est utilisé, ``import " "*`` reste considéré comme une mauvaise pratique." #: ../Doc/tutorial/modules.rst:507 msgid "" "Remember, there is nothing wrong with using ``from Package import " "specific_submodule``! In fact, this is the recommended notation unless the " "importing module needs to use submodules with the same name from different " "packages." msgstr "" "Rappelez-vous qu'il n'y a rien de mauvais à utiliser ``from Package import " "specific_submodule`` ! C'est d'ailleurs la manière recommandée à moins que " "le module qui fait les imports ai besoin de sous-modules ayant le même nom " "mais provenant se paquets différents." #: ../Doc/tutorial/modules.rst:514 msgid "Intra-package References" msgstr "Références internes dans un paquet" #: ../Doc/tutorial/modules.rst:516 msgid "" "When packages are structured into subpackages (as with the :mod:`sound` " "package in the example), you can use absolute imports to refer to submodules " "of siblings packages. For example, if the module :mod:`sound.filters." "vocoder` needs to use the :mod:`echo` module in the :mod:`sound.effects` " "package, it can use ``from sound.effects import echo``." msgstr "" "Lorsque les paquets sont organisés en sous-paquets (comme le paquet :mod:" "`sound` par exemple), vous pouvez utiliser des imports absolus pour cibler " "des paquets voisins. Par exemple, si le module :mod:`sound.filters.vocoder` " "a besoin du module :mod:`echo` du paquet :mod:`sound.effects`, il peut " "utiliser ``from sound.effects import echo``." #: ../Doc/tutorial/modules.rst:522 msgid "" "You can also write relative imports, with the ``from module import name`` " "form of import statement. These imports use leading dots to indicate the " "current and parent packages involved in the relative import. From the :mod:" "`surround` module for example, you might use::" msgstr "" "Il est aussi possible d'écrire des imports relatifs de la forme ``from " "module import name``. Ces imports sont préfixés par des points pour indiquer " "leur origine (paquet courant ou parent). Depuis le module :mod:`surround`, " "par exemple vous pourriez faire : ::" #: ../Doc/tutorial/modules.rst:531 msgid "" "Note that relative imports are based on the name of the current module. " "Since the name of the main module is always ``\"__main__\"``, modules " "intended for use as the main module of a Python application must always use " "absolute imports." msgstr "" "Notez que les imports relatifs se fient au nom du module actuel. Puisque le " "nom du module principal est toujours ``\"__main__\"``, les modules utilisés " "par le module principal d'une application ne peuvent être importées que par " "des imports absolus." #: ../Doc/tutorial/modules.rst:537 msgid "Packages in Multiple Directories" msgstr "Paquets dans plusieurs dossiers" #: ../Doc/tutorial/modules.rst:539 msgid "" "Packages support one more special attribute, :attr:`__path__`. This is " "initialized to be a list containing the name of the directory holding the " "package's :file:`__init__.py` before the code in that file is executed. " "This variable can be modified; doing so affects future searches for modules " "and subpackages contained in the package." msgstr "" "Les paquets exposent un attribut supplémentaire, :attr:`__path__`, contenant " "une liste, initialisée avant l'exécution du fichier :file:`__init__.py`, " "contenant le nom de son dossier dans le système de fichier. Cette liste peut " "être modifiée, altérant ainsi les futures recherches de modules et sous-" "paquets contenus dans le paquet." #: ../Doc/tutorial/modules.rst:545 msgid "" "While this feature is not often needed, it can be used to extend the set of " "modules found in a package." msgstr "" "Bien que cette fonctionnalité ne soit que rarement utile, elle peut servir à " "élargir la liste des modules trouvés dans un paquet." #: ../Doc/tutorial/modules.rst:551 msgid "" "In fact function definitions are also 'statements' that are 'executed'; the " "execution of a module-level function definition enters the function name in " "the module's global symbol table." msgstr "" "En réalité, la déclaration d'une fonction est elle même une instruction, " "sont l'exécution enregistre le nom de la fonction dans la table des symboles " "globaux du module." #: ../Doc/tutorial/stdlib.rst:5 msgid "Brief Tour of the Standard Library" msgstr "Survol de la Bibliothèque Standard" #: ../Doc/tutorial/stdlib.rst:11 msgid "Operating System Interface" msgstr "Interface avec le Système d'Exploitation" #: ../Doc/tutorial/stdlib.rst:13 msgid "" "The :mod:`os` module provides dozens of functions for interacting with the " "operating system::" msgstr "" "Le modules :mod:`os` propose pléthore fonctions pour interagir avec le " "système d'exploitation : ::" #: ../Doc/tutorial/stdlib.rst:23 msgid "" "Be sure to use the ``import os`` style instead of ``from os import *``. " "This will keep :func:`os.open` from shadowing the built-in :func:`open` " "function which operates much differently." msgstr "" "Mais, encore une fois, préférez ``import os``, à ``from os import *``, sans " "quoi :func:`os.open` cacherait la primitive :func:`open`, qui fonctionne " "différemment." #: ../Doc/tutorial/stdlib.rst:29 msgid "" "The built-in :func:`dir` and :func:`help` functions are useful as " "interactive aids for working with large modules like :mod:`os`::" msgstr "" "Les primitives :func:`dir` et :func:`help` sont des outils utiles lorsque " "vous travaillez en mode interactif avez des gros modules comme :mod:`os` ::" #: ../Doc/tutorial/stdlib.rst:38 msgid "" "For daily file and directory management tasks, the :mod:`shutil` module " "provides a higher level interface that is easier to use::" msgstr "" "Pour la gestion des fichiers et dossiers, le module :mod:`shutil` expose une " "interface plus abstraite et plus facile à utiliser : ::" #: ../Doc/tutorial/stdlib.rst:51 msgid "File Wildcards" msgstr "Jokers sur les noms de Fichiers" #: ../Doc/tutorial/stdlib.rst:53 msgid "" "The :mod:`glob` module provides a function for making file lists from " "directory wildcard searches::" msgstr "" "Le module :mod:`glob` fournit une fonction pour construire des listes de " "fichiers à partir de motifs : ::" #: ../Doc/tutorial/stdlib.rst:64 msgid "Command Line Arguments" msgstr "Paramètres en ligne de Commande" #: ../Doc/tutorial/stdlib.rst:66 msgid "" "Common utility scripts often need to process command line arguments. These " "arguments are stored in the :mod:`sys` module's *argv* attribute as a list. " "For instance the following output results from running ``python demo.py one " "two three`` at the command line::" msgstr "" "Typiquement, les outils en ligne de commande ont besoin de lire les " "paramètres qui leur sont donnés. Ces paramètres sont stockés dans la " "variable ``argv`` dans le module :mod:`sys` sous forme de liste. Par " "exemple, l'affichage suivant vient de l'exécution de ``python demo.py one " "two three`` depuis la ligne de commande : ::" #: ../Doc/tutorial/stdlib.rst:75 msgid "" "The :mod:`getopt` module processes *sys.argv* using the conventions of the " "Unix :func:`getopt` function. More powerful and flexible command line " "processing is provided by the :mod:`argparse` module." msgstr "" "Le module :mod:`getopt` comprend *sys.argv* en utilisant les conventions " "habituelles de la fonction Unix :func:`getopt`. Des outils de compréhension " "des paramètres de la ligne de commande plus flexibles et avancés sont " "disponibles dnas le module :mod:`argparse`." #: ../Doc/tutorial/stdlib.rst:83 msgid "Error Output Redirection and Program Termination" msgstr "Redirection de la sortie d'erreur et fin d'exécution" #: ../Doc/tutorial/stdlib.rst:85 msgid "" "The :mod:`sys` module also has attributes for *stdin*, *stdout*, and " "*stderr*. The latter is useful for emitting warnings and error messages to " "make them visible even when *stdout* has been redirected::" msgstr "" "Le module :mod:`sys` à aussi des attributs pour *stdin*, *stdout*, et " "*stderr*. Ce dernier est utile pour émettre des messages d'avertissement ou " "d'erreur qui restent visibles même si *stdout* est redirigé : ::" #: ../Doc/tutorial/stdlib.rst:92 msgid "The most direct way to terminate a script is to use ``sys.exit()``." msgstr "" "Le moyen le plus direct de terminer un script est d'utiliser ``sys.exit()``." #: ../Doc/tutorial/stdlib.rst:98 msgid "String Pattern Matching" msgstr "Recherche de motifs dans les Chaînes" #: ../Doc/tutorial/stdlib.rst:100 msgid "" "The :mod:`re` module provides regular expression tools for advanced string " "processing. For complex matching and manipulation, regular expressions offer " "succinct, optimized solutions::" msgstr "" "Le module :mod:`re` fournit des outils basés sur les expressions " "rationnelles permettant des opérations complexes sur les chaînes. C'est une " "solution optimisée, utilisant une syntaxe consise, pour rechercher des " "motifs complexes, ou effectuer des remplacements complexes dans les " "chaînes : ::" #: ../Doc/tutorial/stdlib.rst:110 msgid "" "When only simple capabilities are needed, string methods are preferred " "because they are easier to read and debug::" msgstr "" "Lorsque les opérations sont simples, il est préférable d'utiliser les " "méthodes des chaînes, elles sont plus lisibles et plus facile à débugger : ::" #: ../Doc/tutorial/stdlib.rst:120 msgid "Mathematics" msgstr "Mathématiques" #: ../Doc/tutorial/stdlib.rst:122 msgid "" "The :mod:`math` module gives access to the underlying C library functions " "for floating point math::" msgstr "" "Le module :mod:`math` expose des fonctions d'opération sur les \"float* de " "la bibliothèque C ::" #: ../Doc/tutorial/stdlib.rst:131 msgid "The :mod:`random` module provides tools for making random selections::" msgstr "" "Le module :mod:`random` offre des outils pour faire des sélections " "aléatoires : ::" #: ../Doc/tutorial/stdlib.rst:143 msgid "" "The :mod:`statistics` module calculates basic statistical properties (the " "mean, median, variance, etc.) of numeric data::" msgstr "" "Le module :mod:`statistics` permet de calculer des valeurs statistiques " "basiques (la moyenne, la médiane, la variance, ...) ::" #: ../Doc/tutorial/stdlib.rst:155 msgid "" "The SciPy project has many other modules for numerical " "computations." msgstr "" "Le projet SciPy contient beaucoup d'autres modules " "autour des calculs numériques." #: ../Doc/tutorial/stdlib.rst:161 msgid "Internet Access" msgstr "Accès à internet" #: ../Doc/tutorial/stdlib.rst:163 msgid "" "There are a number of modules for accessing the internet and processing " "internet protocols. Two of the simplest are :mod:`urllib.request` for " "retrieving data from URLs and :mod:`smtplib` for sending mail::" msgstr "" "Il existe tout un tat de modules permettant d'accéder à internet et gérer " "des protocoles utilisés sur internet. Les deux plus simples sont :mod:" "`urllib.request`, qui permet de télécharger à partir d'une URL, et :mod:" "`smtplib` pour envoyer des emails : ::" #: ../Doc/tutorial/stdlib.rst:186 msgid "(Note that the second example needs a mailserver running on localhost.)" msgstr "" "(Notez que le deuxième exemple a besoin d'un serveur mail tournant " "localement.)" #: ../Doc/tutorial/stdlib.rst:192 msgid "Dates and Times" msgstr "Dates et heures" #: ../Doc/tutorial/stdlib.rst:194 msgid "" "The :mod:`datetime` module supplies classes for manipulating dates and times " "in both simple and complex ways. While date and time arithmetic is " "supported, the focus of the implementation is on efficient member extraction " "for output formatting and manipulation. The module also supports objects " "that are timezone aware. ::" msgstr "" "Les module :mod:`datetime` propose des classes pour manipuler les dates et " "les heures, que le besoin soit simple ou compliqué. Bien que faire des " "calculs de dates est possible, l'implémentation à être optimisée pour " "l'accès aux propriétés, le formatage et la manipulation. Le module gère " "aussi les objets conscients des fuseaux horaires : ::" #: ../Doc/tutorial/stdlib.rst:218 msgid "Data Compression" msgstr "Compression de donnée" #: ../Doc/tutorial/stdlib.rst:220 msgid "" "Common data archiving and compression formats are directly supported by " "modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :mod:" "`zipfile` and :mod:`tarfile`. ::" msgstr "" "Les formats d'archivage et de compression les plus communs sont directement " "gérés par les modules :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :" "mod:`zipfile`, et :mod:`tarfile` ::" #: ../Doc/tutorial/stdlib.rst:240 msgid "Performance Measurement" msgstr "Mesure des Performances" #: ../Doc/tutorial/stdlib.rst:242 msgid "" "Some Python users develop a deep interest in knowing the relative " "performance of different approaches to the same problem. Python provides a " "measurement tool that answers those questions immediately." msgstr "" "Certains utilisateurs de Python développent un intérêt profond des " "performances de différentes approches d'un même problème. Python propose un " "outil de mesure répondant simplement à ces questions." #: ../Doc/tutorial/stdlib.rst:246 msgid "" "For example, it may be tempting to use the tuple packing and unpacking " "feature instead of the traditional approach to swapping arguments. The :mod:" "`timeit` module quickly demonstrates a modest performance advantage::" msgstr "" "Par exemple, pour échanger deux variables, il peut être tentant d'utiliser " "l'empaquetage et le dépaquetage de tuples plutôt que la méthode " "traditionnelle. Le module :mod:`timeit` montre simplement laquelle est la " "plus efficace : ::" #: ../Doc/tutorial/stdlib.rst:256 msgid "" "In contrast to :mod:`timeit`'s fine level of granularity, the :mod:`profile` " "and :mod:`pstats` modules provide tools for identifying time critical " "sections in larger blocks of code." msgstr "" "En opposition à :mod:`timeit` et sa granularité fine, :mod:`profile` et :mod:" "`pstats` fournissent des outils permettant d'identifier les parties les plus " "gourmandes en temps d'exécution dans des volumes de code plus grands." #: ../Doc/tutorial/stdlib.rst:264 msgid "Quality Control" msgstr "Contrôle Qualité" #: ../Doc/tutorial/stdlib.rst:266 msgid "" "One approach for developing high quality software is to write tests for each " "function as it is developed and to run those tests frequently during the " "development process." msgstr "" "Une approche possible pour développer des application de très bonne qualité " "est d'écrire des tests pour chaque fonction au fur et à mesure de son " "développement, et d'exécuter ces tests fréquemment lors du processus de " "développement." #: ../Doc/tutorial/stdlib.rst:270 msgid "" "The :mod:`doctest` module provides a tool for scanning a module and " "validating tests embedded in a program's docstrings. Test construction is " "as simple as cutting-and-pasting a typical call along with its results into " "the docstring. This improves the documentation by providing the user with an " "example and it allows the doctest module to make sure the code remains true " "to the documentation::" msgstr "" "Le module :mod:`doctest` permet de chercher des tests dans les chaînes de " "documentation. Un tests ressemble à un simple copié-collé d'un appel et son " "résultat depuis le mode interactif. Cela améliore la documentation en " "fournissant des exemples tout en prouvant qu'ils sont justes : ::" #: ../Doc/tutorial/stdlib.rst:288 msgid "" "The :mod:`unittest` module is not as effortless as the :mod:`doctest` " "module, but it allows a more comprehensive set of tests to be maintained in " "a separate file::" msgstr "" "Le module :mod:`unittest` est plus lourd que le module :mod:`doctest`, mais " "il permet de construire un jeu de tests plus complet, maintenable, et " "compréhensible dans un fichier séparé : ::" #: ../Doc/tutorial/stdlib.rst:310 msgid "Batteries Included" msgstr "Piles Fournies" #: ../Doc/tutorial/stdlib.rst:312 msgid "" "Python has a \"batteries included\" philosophy. This is best seen through " "the sophisticated and robust capabilities of its larger packages. For " "example:" msgstr "" "Python respecte la philosophie \"piles fournies\". C'est plus évident en " "regardant les capacités sophistiquées et solides de ses plus gros paquets. " "Par exemple:" #: ../Doc/tutorial/stdlib.rst:315 msgid "" "The :mod:`xmlrpc.client` and :mod:`xmlrpc.server` modules make implementing " "remote procedure calls into an almost trivial task. Despite the modules " "names, no direct knowledge or handling of XML is needed." msgstr "" "Les modules :mod:`xmlrpc.client` et :mod:`xmlrpc.server` permettent " "d'appeler des fonctions à distance quasiment sans effort. En dépit du nom " "des modules, aucune connaissance du XML n'est nécessaire." #: ../Doc/tutorial/stdlib.rst:319 msgid "" "The :mod:`email` package is a library for managing email messages, including " "MIME and other RFC 2822-based message documents. Unlike :mod:`smtplib` and :" "mod:`poplib` which actually send and receive messages, the email package has " "a complete toolset for building or decoding complex message structures " "(including attachments) and for implementing internet encoding and header " "protocols." msgstr "" "Le paquet :mod:`email` est une bibliothèque pour gérer les messages " "electroniques, incluant les MIME et autre encodages basés sur la RFC 2822. " "Contrairement à :mod:`smtplib` et :mod:`poplib`, qui envoient et reçoivent " "des messages, le paquet email est une boite à outils pour construire, lire " "des structures de messages complexes (comprenant des pièces jointes), ou " "implémenter des encodages et protocoles." #: ../Doc/tutorial/stdlib.rst:326 msgid "" "The :mod:`json` package provides robust support for parsing this popular " "data interchange format. The :mod:`csv` module supports direct reading and " "writing of files in Comma-Separated Value format, commonly supported by " "databases and spreadsheets. XML processing is supported by the :mod:`xml." "etree.ElementTree`, :mod:`xml.dom` and :mod:`xml.sax` packages. Together, " "these modules and packages greatly simplify data interchange between Python " "applications and other tools." msgstr "" "Le paquet :mod:`json` permet de lire et d'écrire du JSON, format d'encodage " "de donnée répandu. Le module :mod:`csv` gère la lecture et l'écriture de " "données stockés sous forme de valeurs séparés par des virgules dans des " "fichiers (Coma-Separated Values), typique des base de donnée et feuiles de " "calculs. Pour la lecture du XML, utilisez les paquet :mod:`xml.etree." "ElementTree`, :mod:`xml.dom` et :mod:`xml.sax`. Réunis, ces modules et " "paquets simplifient grandement l'échange de données entre les applications " "Python et les autres outils." #: ../Doc/tutorial/stdlib.rst:335 msgid "" "The :mod:`sqlite3` module is a wrapper for the SQLite database library, " "providing a persistent database that can be updated and accessed using " "slightly nonstandard SQL syntax." msgstr "" "Le module :mod:`sqlite3` est une abstraction de la bibliothèque SQLite, " "permettant de manipuler une base de donnée persistante, accédée et manipulée " "en utilisant une syntaxe SQL quasi standard." #: ../Doc/tutorial/stdlib.rst:339 msgid "" "Internationalization is supported by a number of modules including :mod:" "`gettext`, :mod:`locale`, and the :mod:`codecs` package." msgstr "" "L'internationalisation est possible grâce à moulte paquets, comme :mod:" "`gettext`, :mod:`locale`, ou :mod:`codecs`." #: ../Doc/tutorial/stdlib2.rst:5 msgid "Brief Tour of the Standard Library -- Part II" msgstr "Rapide tour de la Bibliothèque Standard -- Deuxième partie" #: ../Doc/tutorial/stdlib2.rst:7 msgid "" "This second tour covers more advanced modules that support professional " "programming needs. These modules rarely occur in small scripts." msgstr "" "Cette seconde visite vous fera découvrir des modules d'un usage plus " "professionnel. Ces modules sont rarement nécessaires dans de petits scripts." #: ../Doc/tutorial/stdlib2.rst:14 msgid "Output Formatting" msgstr "Formatage" #: ../Doc/tutorial/stdlib2.rst:16 msgid "" "The :mod:`reprlib` module provides a version of :func:`repr` customized for " "abbreviated displays of large or deeply nested containers::" msgstr "" "Le module :mod:`reprlib` est une variante de la fonction :func:`repr`, " "spécialisée dans l'affichage concis de conteneurs volumineux ou fortement " "imbriqués : ::" #: ../Doc/tutorial/stdlib2.rst:23 msgid "" "The :mod:`pprint` module offers more sophisticated control over printing " "both built-in and user defined objects in a way that is readable by the " "interpreter. When the result is longer than one line, the \"pretty printer\" " "adds line breaks and indentation to more clearly reveal data structure::" msgstr "" "Le module :mod:`pprint` propose un contrôle plus fin de l'affichage des " "objets, aussi bien primitifs que définis par l'utilisateur, et souvent " "lisible part l'interpréteur. Lorsque le résultat fait plus d'une ligne, il " "est séparé sur plusieurs lignes et indenté pour rendre la structure plus " "visible : ::" #: ../Doc/tutorial/stdlib2.rst:39 msgid "" "The :mod:`textwrap` module formats paragraphs of text to fit a given screen " "width::" msgstr "" "Le module :mod:`textwrap` formatte des paragraphes de texte pour tenir sur " "un écran d'une largeur donnée : ::" #: ../Doc/tutorial/stdlib2.rst:53 msgid "" "The :mod:`locale` module accesses a database of culture specific data " "formats. The grouping attribute of locale's format function provides a " "direct way of formatting numbers with group separators::" msgstr "" "Le module :mod:`locale` offre une base de donnée de formats de donnée " "spécifique à chaque région. L'attribut ``grouping`` de la fonction de " "formattage permet de formater directement des nombres avec un séparateur : ::" #: ../Doc/tutorial/stdlib2.rst:72 msgid "Templating" msgstr "Gabarits (Templates)" #: ../Doc/tutorial/stdlib2.rst:74 msgid "" "The :mod:`string` module includes a versatile :class:`~string.Template` " "class with a simplified syntax suitable for editing by end-users. This " "allows users to customize their applications without having to alter the " "application." msgstr "" "Le module :mod:`string` contiens une classe fort polyvalente : :class:" "`~string.Template` permettant d'écrire des gabarits (dits \"templates\") " "avec une syntaxe simple, si simple qu'elle est compréhensible par des non-" "développeurs. Cela permet donc à vous utilisateurs de personnaliser leur " "application sans la modifier." #: ../Doc/tutorial/stdlib2.rst:78 msgid "" "The format uses placeholder names formed by ``$`` with valid Python " "identifiers (alphanumeric characters and underscores). Surrounding the " "placeholder with braces allows it to be followed by more alphanumeric " "letters with no intervening spaces. Writing ``$$`` creates a single escaped " "``$``::" msgstr "" "Le format est constitué de marqueurs formés d'un ``$`` suivi d'un " "identifiant Python valide (caractères alphanumériques et tirets-bas). " "Entourer le marqueur d'accolades permet de lui coller d'autres caractères " "alphanumériques sans intercaler un espace. Écrire ``$$`` créé un simple ``" "$``." #: ../Doc/tutorial/stdlib2.rst:88 msgid "" "The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` when " "a placeholder is not supplied in a dictionary or a keyword argument. For " "mail-merge style applications, user supplied data may be incomplete and the :" "meth:`~string.Template.safe_substitute` method may be more appropriate --- " "it will leave placeholders unchanged if data is missing::" msgstr "" "La méthode :meth:`~string.Template.substitute` lève une exception :exc:" "`KeyError` lorsqu'un marqueur n'a pas été fourni, ni dans un dictionnaire, " "ni sous forme d'un paramètre nommé. Dans certains cas, lorsque la donnée à " "appliquer n'est connur que partiellement, la méthode :meth:`~string.Template." "safe_substitute` est plus appropriée car elle laissera tel quel les " "marqueurs manquants : ::" #: ../Doc/tutorial/stdlib2.rst:103 msgid "" "Template subclasses can specify a custom delimiter. For example, a batch " "renaming utility for a photo browser may elect to use percent signs for " "placeholders such as the current date, image sequence number, or file " "format::" msgstr "" "Les classes filles de ``Template`` peuvent définir leur propre délimiteur. " "Typiquement, un script de renommage de photos par lots peut choisir le " "symbole pourcent comme marqueur pour, par exemple, la date actuelle, le " "numéro de l'image, ou son format : ::" #: ../Doc/tutorial/stdlib2.rst:125 msgid "" "Another application for templating is separating program logic from the " "details of multiple output formats. This makes it possible to substitute " "custom templates for XML files, plain text reports, and HTML web reports." msgstr "" "Un autre usage des templates est de séparer la logique métier dub côté et " "les détails spécifiques à chaque format de sortie. Il est possible de " "générer de cette manière des fichiers XML, texte, HTML, ..." #: ../Doc/tutorial/stdlib2.rst:133 msgid "Working with Binary Data Record Layouts" msgstr "Travailler avec des données binaires" #: ../Doc/tutorial/stdlib2.rst:135 msgid "" "The :mod:`struct` module provides :func:`~struct.pack` and :func:`~struct." "unpack` functions for working with variable length binary record formats. " "The following example shows how to loop through header information in a ZIP " "file without using the :mod:`zipfile` module. Pack codes ``\"H\"`` and ``\"I" "\"`` represent two and four byte unsigned numbers respectively. The ``\"<" "\"`` indicates that they are standard size and in little-endian byte order::" msgstr "" "Le module :mod:`struct` expose les fonctions :func:`~struct.pack` et :func:" "`~struct.unpack` permettant de travailler avec des données binaires. " "L'exemple suivant montre comment parcourir une entête de fichier ZIP sans " "recourir au module :mod:`zipfile`. Les marqueurs ``\"H\"`` et ``\"I\"`` " "représentent des nombres entiers non signés, stockés respectivement sur deux " "et quatre octets. Le ``\"<\"`` indique qu'ils ont une taille standard et " "dans le style petit-boutiste." #: ../Doc/tutorial/stdlib2.rst:166 msgid "Multi-threading" msgstr "Threads" #: ../Doc/tutorial/stdlib2.rst:168 msgid "" "Threading is a technique for decoupling tasks which are not sequentially " "dependent. Threads can be used to improve the responsiveness of " "applications that accept user input while other tasks run in the " "background. A related use case is running I/O in parallel with computations " "in another thread." msgstr "" "Des tâches indépendantes peuvent être exécutées simultanément (on parle de " "concourrance), en utilisant des threads.Les threads peuvent améliorer la " "réactivité d'une application qui accepterait d'interagir avec l'utilisateur " "pendant que d'autres traitements sont exécutés en arrière plan. Un autre " "usage typique est de séparer sur deux threads distincts les I/O (entrées / " "sorties) et le calcul." #: ../Doc/tutorial/stdlib2.rst:173 msgid "" "The following code shows how the high level :mod:`threading` module can run " "tasks in background while the main program continues to run::" msgstr "" "Le code suivant donne un exemple d'usage du module :mod:`threading` " "exécutant des tâches en arrière plan pendant que le programme principal " "continue de s'exécuter : ::" #: ../Doc/tutorial/stdlib2.rst:197 msgid "" "The principal challenge of multi-threaded applications is coordinating " "threads that share data or other resources. To that end, the threading " "module provides a number of synchronization primitives including locks, " "events, condition variables, and semaphores." msgstr "" "Le challenge principal des applications multi tâches est la coordination " "entre les threads qui partagent des données ou des ressources. Pour ce " "faire, le module ``threading`` expose quelques outils dédiés à la " "synchronisation comme les verrous (locks), événement (events), variables " "conditionnelles (condition variables), et les sémaphores." #: ../Doc/tutorial/stdlib2.rst:202 msgid "" "While those tools are powerful, minor design errors can result in problems " "that are difficult to reproduce. So, the preferred approach to task " "coordination is to concentrate all access to a resource in a single thread " "and then use the :mod:`queue` module to feed that thread with requests from " "other threads. Applications using :class:`~queue.Queue` objects for inter-" "thread communication and coordination are easier to design, more readable, " "and more reliable." msgstr "" "Bien que ces outils soient puissants, des erreurs de conceptions peuvent " "engendrer des problèmes difficiles à reproduire. Donc, l'approche favorite " "pour coordonner des tâches est de restreindre l'accès d'une ressource à un " "seul thread, et d'utiliser le module :mod:`queue` pour alimenter ce thread " "de requêtes venant d'autres threads. Les applications utilisant des :class:" "`~queue.Queue` pour leurs communication et coordination entre threads sont " "plus simples à concevoir, plus lisible, et plus fiables." #: ../Doc/tutorial/stdlib2.rst:213 msgid "Logging" msgstr "Journalisation" #: ../Doc/tutorial/stdlib2.rst:215 msgid "" "The :mod:`logging` module offers a full featured and flexible logging " "system. At its simplest, log messages are sent to a file or to ``sys." "stderr``::" msgstr "" "Le module :mod:`logging` est un système de journalisation complet. Dans son " "utilisation la plus élémentaire, les messages sont simplement envoyés dans " "un fichier ou sur ``sys.stderr`` ::" #: ../Doc/tutorial/stdlib2.rst:225 msgid "This produces the following output:" msgstr "Produisant l'affichage suivant :" #: ../Doc/tutorial/stdlib2.rst:233 msgid "" "By default, informational and debugging messages are suppressed and the " "output is sent to standard error. Other output options include routing " "messages through email, datagrams, sockets, or to an HTTP Server. New " "filters can select different routing based on message priority: :const:" "`~logging.DEBUG`, :const:`~logging.INFO`, :const:`~logging.WARNING`, :const:" "`~logging.ERROR`, and :const:`~logging.CRITICAL`." msgstr "" "Par défaut, les messages d'information et de débogage sont ignorés, les " "autres écrites sur la sortie standard. Il est aussi possible d'envoyer les " "messages par email, datagrammes, sur des sockets, ou postés sur un serveur " "HTTP. Les nouveaux filtres permettent d'utiliser des sorties différentes en " "fonction de la priorité du message : :const:`~logging.DEBUG`, :const:" "`~logging.INFO`, :const:`~logging.WARNING`, :const:`~logging.ERROR`, et :" "const:`~logging.CRITICAL`." #: ../Doc/tutorial/stdlib2.rst:240 msgid "" "The logging system can be configured directly from Python or can be loaded " "from a user editable configuration file for customized logging without " "altering the application." msgstr "" "depuis un fichier de configuration, permettant de personnaliser le log sans " "modifier l'application." #: ../Doc/tutorial/stdlib2.rst:248 msgid "Weak References" msgstr "Références faibles" #: ../Doc/tutorial/stdlib2.rst:250 msgid "" "Python does automatic memory management (reference counting for most objects " "and :term:`garbage collection` to eliminate cycles). The memory is freed " "shortly after the last reference to it has been eliminated." msgstr "" "Python gère lui même la mémoire (par comptage de référence pour la majorité " "des objets, et en utilisant un :term:`ramasse-miettes`\\s (garbage " "collector) pour éliminer les cycles). La mémoire est libérée rapidement " "lorsque sa dernière référence est perdue." #: ../Doc/tutorial/stdlib2.rst:254 msgid "" "This approach works fine for most applications but occasionally there is a " "need to track objects only as long as they are being used by something else. " "Unfortunately, just tracking them creates a reference that makes them " "permanent. The :mod:`weakref` module provides tools for tracking objects " "without creating a reference. When the object is no longer needed, it is " "automatically removed from a weakref table and a callback is triggered for " "weakref objects. Typical applications include caching objects that are " "expensive to create::" msgstr "" "Cette approche fonctionne bien pour la majorité des applications, mais, " "parfois, il est nécessaire de surveiller un objet seulement durant son " "utilisation par quelque chose d'autre. Malheureusement, le simple fait de le " "suivre crée une référence, qui rend l'objet permanent. Le module :mod:" "`weakref` expose des outils pour suivre les objets sans pour autant créer " "une référence. Lorsqu'un objet n'est pas utilisé, il est automatiquement " "supprimé du tableau des références faibles, et une fonction de rappel " "(callback) est appelée. Un exemple typique est le cache d'objets coûteux à " "créer : ::" #: ../Doc/tutorial/stdlib2.rst:289 msgid "Tools for Working with Lists" msgstr "Outils pour travailler avec des listes" #: ../Doc/tutorial/stdlib2.rst:291 msgid "" "Many data structure needs can be met with the built-in list type. However, " "sometimes there is a need for alternative implementations with different " "performance trade-offs." msgstr "" "Beaucoup de structures de données peuvent être représentés avec des listes " "natives. Cependant, parfois, d'autres besoins émergent, pour des structures " "ayant des caractéristiques différentes, typiquement en terme de performance." #: ../Doc/tutorial/stdlib2.rst:295 msgid "" "The :mod:`array` module provides an :class:`~array.array()` object that is " "like a list that stores only homogeneous data and stores it more compactly. " "The following example shows an array of numbers stored as two byte unsigned " "binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry " "for regular lists of Python int objects::" msgstr "" "Le module :mod:`array` fournit un objet :class:`~array.array()`, ne " "permettant de stocker que des listes homogènes, mais d'une manière plus " "compacte. L'exemple suivant montre une liste de nombres, stockés chacun sur " "deux octets non signés (marqueur ``\"H\"``) plutôt que d'utiliser 16 octets " "comme l'aurais fait une liste classique : ::" #: ../Doc/tutorial/stdlib2.rst:308 msgid "" "The :mod:`collections` module provides a :class:`~collections.deque()` " "object that is like a list with faster appends and pops from the left side " "but slower lookups in the middle. These objects are well suited for " "implementing queues and breadth first tree searches::" msgstr "" "Le module :mod:`collections` fournit la classe :class:`~collections." "deque()`, qui ressemble à une liste, mais plus rapide à insérer ou sortir " "des éléments par la gauche, et plus lente pour accéder aux éléments du " "milieu. C'est objets sont particulièrement adaptés pour construire des " "queues ou des algorithme de parcours d'arbre en largeur : ::" #: ../Doc/tutorial/stdlib2.rst:329 msgid "" "In addition to alternative list implementations, the library also offers " "other tools such as the :mod:`bisect` module with functions for manipulating " "sorted lists::" msgstr "" "Au delà de fournir des implémentations de listes alternatives, la " "bibliothèque fournit des outils tels que :mod:`bisect`, un module contenant " "des fonctions de manipulation de listes triées : ::" #: ../Doc/tutorial/stdlib2.rst:339 msgid "" "The :mod:`heapq` module provides functions for implementing heaps based on " "regular lists. The lowest valued entry is always kept at position zero. " "This is useful for applications which repeatedly access the smallest element " "but do not want to run a full list sort::" msgstr "" "Le module :mod:`heapq`, permettant d'implémenter des tas (heaps) à partir de " "simple listes. La valeur la plus faible est toujours à la première position " "(indice 0). C'est utile dans les cas où l'application souvent besoin de " "trouver l'élément le plus petit sans trier entièrement la liste : ::" #: ../Doc/tutorial/stdlib2.rst:355 msgid "Decimal Floating Point Arithmetic" msgstr "Arithmétique décimale à Virgule Flottante" #: ../Doc/tutorial/stdlib2.rst:357 msgid "" "The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for " "decimal floating point arithmetic. Compared to the built-in :class:`float` " "implementation of binary floating point, the class is especially helpful for" msgstr "" "Le module :mod:`decimal` expose la classe :class:`~decimal.Decimal`, " "spécialisée dans le calcul de nombres décimaux représentés en virgule " "flottante. Par rapport à la classe native :class:`float`, elle est " "particulièrement utile pour" #: ../Doc/tutorial/stdlib2.rst:361 msgid "" "financial applications and other uses which require exact decimal " "representation," msgstr "" "les application traitant de finance est autres usages nécessitant une " "représentation décimale exacte," #: ../Doc/tutorial/stdlib2.rst:363 msgid "control over precision," msgstr "contrôle sur la précision, " #: ../Doc/tutorial/stdlib2.rst:364 msgid "control over rounding to meet legal or regulatory requirements," msgstr "" "contrôle sur les arrondis pour correspondre aux obligations légales ou du " "régulateur," #: ../Doc/tutorial/stdlib2.rst:365 msgid "tracking of significant decimal places, or" msgstr "suivre les décimales significatives, ou" #: ../Doc/tutorial/stdlib2.rst:366 msgid "" "applications where the user expects the results to match calculations done " "by hand." msgstr "" "les applications avec lesquelles l'utilisateur attend des résultats " "identiques aux calculs faits à la main." #: ../Doc/tutorial/stdlib2.rst:369 msgid "" "For example, calculating a 5% tax on a 70 cent phone charge gives different " "results in decimal floating point and binary floating point. The difference " "becomes significant if the results are rounded to the nearest cent::" msgstr "" "Par exemple, calculer 5% de taxe sur une facture de 70 centimes donne un " "résultat différent en nombre a virgule flottantes binaires et décimales. La " "différence devient significative lorsqu'on arrondit le résultat au centime " "près : ::" #: ../Doc/tutorial/stdlib2.rst:379 msgid "" "The :class:`~decimal.Decimal` result keeps a trailing zero, automatically " "inferring four place significance from multiplicands with two place " "significance. Decimal reproduces mathematics as done by hand and avoids " "issues that can arise when binary floating point cannot exactly represent " "decimal quantities." msgstr "" "Le résultat d'un calcul donné par :class:`~decimal.Decimal` conserve les " "zéro non-significatifs. La classe conserve automatiquement quatre décimales " "significatives pour des opérandes à deux décimales significatives. La classe " "``Decimal`` imite les mathématiques tels qu'elles pourraient être effectuées " "à la main, évitant les problèmes typique de l'arithmétique binaire à virgule " "flottante qui n'est pas capable de représenter exactement certaines " "quantités décimales." #: ../Doc/tutorial/stdlib2.rst:385 msgid "" "Exact representation enables the :class:`~decimal.Decimal` class to perform " "modulo calculations and equality tests that are unsuitable for binary " "floating point::" msgstr "" "La représentation exacte de la classe :class:`~decimal.Decimal` lui permet " "de faire des calculs du modulo ou des tests d'égalité qui ne seraient pas " "possibles avec des virgules flottantes binaires : ::" #: ../Doc/tutorial/stdlib2.rst:399 msgid "" "The :mod:`decimal` module provides arithmetic with as much precision as " "needed::" msgstr "" "Le module :mod:`decimal` permet de faire des calculs avec autant de " "précision que nécessaire : ::" #: ../Doc/tutorial/venv.rst:6 msgid "Virtual Environments and Packages" msgstr "Environnements virtuels et Paquets" #: ../Doc/tutorial/venv.rst:9 msgid "Introduction" msgstr "Introduction" #: ../Doc/tutorial/venv.rst:11 msgid "" "Python applications will often use packages and modules that don't come as " "part of the standard library. Applications will sometimes need a specific " "version of a library, because the application may require that a particular " "bug has been fixed or the application may be written using an obsolete " "version of the library's interface." msgstr "" "Les programmes Python utilisent souvent des paquets et modules qui ne font " "pas partie de la bibliothèque standard. Ils nécessitent aussi, parfois, une " "version spécifique de la bibliothèque, nécessitant par exemple qu'un certain " "bug ai été corrigé, ou encore que le programme à été implémenté en utilisant " "une version obsolète de l'interface de la bibliothèque." #: ../Doc/tutorial/venv.rst:17 msgid "" "This means it may not be possible for one Python installation to meet the " "requirements of every application. If application A needs version 1.0 of a " "particular module but application B needs version 2.0, then the requirements " "are in conflict and installing either version 1.0 or 2.0 will leave one " "application unable to run." msgstr "" "Cela signifie qu'il n'est pas forcément possible, pour une installation de " "Python, de couvrir tous les besoins de toutes les applications. Basiquement, " "si une application A dépend de la version 1.0 d'un module et qu'une " "application B dépend de la version 2.0, il y a conflit, et installer la " "version 1.0 ou 2.0 laissera une des deux application incapable de " "fonctionner." #: ../Doc/tutorial/venv.rst:23 msgid "" "The solution for this problem is to create a :term:`virtual environment`, a " "self-contained directory tree that contains a Python installation for a " "particular version of Python, plus a number of additional packages." msgstr "" #: ../Doc/tutorial/venv.rst:27 msgid "" "Different applications can then use different virtual environments. To " "resolve the earlier example of conflicting requirements, application A can " "have its own virtual environment with version 1.0 installed while " "application B has another virtual environment with version 2.0. If " "application B requires a library be upgraded to version 3.0, this will not " "affect application A's environment." msgstr "" #: ../Doc/tutorial/venv.rst:36 msgid "Creating Virtual Environments" msgstr "Création d'Environnements Virtuels" #: ../Doc/tutorial/venv.rst:38 msgid "" "The module used to create and manage virtual environments is called :mod:" "`venv`. :mod:`venv` will usually install the most recent version of Python " "that you have available. If you have multiple versions of Python on your " "system, you can select a specific Python version by running ``python3`` or " "whichever version you want." msgstr "" #: ../Doc/tutorial/venv.rst:44 msgid "" "To create a virtual environment, decide upon a directory where you want to " "place it, and run the :mod:`venv` module as a script with the directory " "path::" msgstr "" #: ../Doc/tutorial/venv.rst:49 msgid "" "This will create the ``tutorial-env`` directory if it doesn't exist, and " "also create directories inside it containing a copy of the Python " "interpreter, the standard library, and various supporting files." msgstr "" "Cela créera le dossier ``tutorial-env`` (s'il n'existe pas) et des sous " "dossiers contenant une copie de l'interpréteur Python, de la bibliothèque " "standard, et quelques autres fichiers utiles." #: ../Doc/tutorial/venv.rst:53 msgid "Once you've created a virtual environment, you may activate it." msgstr "" #: ../Doc/tutorial/venv.rst:55 msgid "On Windows, run::" msgstr "Sur windows, lancez : ::" #: ../Doc/tutorial/venv.rst:59 msgid "On Unix or MacOS, run::" msgstr "Sur Unix et MacOS, lancez : ::" #: ../Doc/tutorial/venv.rst:63 msgid "" "(This script is written for the bash shell. If you use the :program:`csh` " "or :program:`fish` shells, there are alternate ``activate.csh`` and " "``activate.fish`` scripts you should use instead.)" msgstr "" "(Ce script est écrit pour le shell :program:`bash`, si vous utilisez :" "program:`csh` ou :program:`fish`, utilisez les variantes ``activate.csh`` ou " "``activate.fish``.)" #: ../Doc/tutorial/venv.rst:68 msgid "" "Activating the virtual environment will change your shell's prompt to show " "what virtual environment you're using, and modify the environment so that " "running ``python`` will get you that particular version and installation of " "Python. For example:" msgstr "" #: ../Doc/tutorial/venv.rst:87 msgid "Managing Packages with pip" msgstr "Gérer les Paquets avec pip" #: ../Doc/tutorial/venv.rst:89 msgid "" "You can install, upgrade, and remove packages using a program called :" "program:`pip`. By default ``pip`` will install packages from the Python " "Package Index, . You can browse the Python " "Package Index by going to it in your web browser, or you can use ``pip``'s " "limited search feature:" msgstr "" #: ../Doc/tutorial/venv.rst:105 msgid "" "``pip`` has a number of subcommands: \"search\", \"install\", \"uninstall\", " "\"freeze\", etc. (Consult the :ref:`installing-index` guide for complete " "documentation for ``pip``.)" msgstr "" "``pip`` a plusieurs sous commandes : \"search\", \"install\", \" uninstall" "\", \"freeze\", etc... (Consultez le guide :ref:`installing-index` contenant " "une documentation exhaustive sur ``pip``.)" #: ../Doc/tutorial/venv.rst:109 msgid "" "You can install the latest version of a package by specifying a package's " "name:" msgstr "" #: ../Doc/tutorial/venv.rst:120 msgid "" "You can also install a specific version of a package by giving the package " "name followed by ``==`` and the version number:" msgstr "" #: ../Doc/tutorial/venv.rst:131 msgid "" "If you re-run this command, ``pip`` will notice that the requested version " "is already installed and do nothing. You can supply a different version " "number to get that version, or you can run ``pip install --upgrade`` to " "upgrade the package to the latest version:" msgstr "" #: ../Doc/tutorial/venv.rst:146 msgid "" "``pip uninstall`` followed by one or more package names will remove the " "packages from the virtual environment." msgstr "" "``pip uninstall`` suivi d'un ou plusieurs noms de paquets les supprimera de " "votre virtualenv." #: ../Doc/tutorial/venv.rst:149 msgid "``pip show`` will display information about a particular package:" msgstr "" #: ../Doc/tutorial/venv.rst:166 msgid "" "``pip list`` will display all of the packages installed in the virtual " "environment:" msgstr "" #: ../Doc/tutorial/venv.rst:178 msgid "" "``pip freeze`` will produce a similar list of the installed packages, but " "the output uses the format that ``pip install`` expects. A common convention " "is to put this list in a ``requirements.txt`` file:" msgstr "" #: ../Doc/tutorial/venv.rst:190 msgid "" "The ``requirements.txt`` can then be committed to version control and " "shipped as part of an application. Users can then install all the necessary " "packages with ``install -r``:" msgstr "" #: ../Doc/tutorial/venv.rst:207 msgid "" "``pip`` has many more options. Consult the :ref:`installing-index` guide " "for complete documentation for ``pip``. When you've written a package and " "want to make it available on the Python Package Index, consult the :ref:" "`distributing-index` guide." msgstr "" "``pip`` a beaucoup d'autres options, documentées dans le guide :ref:" "`installing-index`. Lorsque vous aurez écrit un paquet, si vous voulez le " "rendre disponible sur PyPI, lisez le guide :ref:`distributing-index`." #: ../Doc/tutorial/whatnow.rst:5 msgid "What Now?" msgstr "Et Maintenant ?" #: ../Doc/tutorial/whatnow.rst:7 msgid "" "Reading this tutorial has probably reinforced your interest in using Python " "--- you should be eager to apply Python to solving your real-world problems. " "Where should you go to learn more?" msgstr "" "Lire ce tutoriel a probablement renforcé votre intérêt pour Python, en der " "l'utiliser pour résoudre des vrais problèmes. Ou devriez vous aller pour en " "apprendre plus ?" #: ../Doc/tutorial/whatnow.rst:11 msgid "" "This tutorial is part of Python's documentation set. Some other documents " "in the set are:" msgstr "" "Ce tutoriel fait partie de la documentation de Python, mais la documentation " "de Python est vaste : ::" #: ../Doc/tutorial/whatnow.rst:14 msgid ":ref:`library-index`:" msgstr ":ref:`library-index`:" #: ../Doc/tutorial/whatnow.rst:16 msgid "" "You should browse through this manual, which gives complete (though terse) " "reference material about types, functions, and the modules in the standard " "library. The standard Python distribution includes a *lot* of additional " "code. There are modules to read Unix mailboxes, retrieve documents via HTTP, " "generate random numbers, parse command-line options, write CGI programs, " "compress data, and many other tasks. Skimming through the Library Reference " "will give you an idea of what's available." msgstr "" "Vous devriez naviguer dans le manuel, il est une référence complète, (et " "donc laconique...) sur les types, fonctions, et modules de la bibliothèque " "standard. La distribution standard de Python inclus *énormément* de code " "supplémentaire. Il existe des modules pour lire des emails, récupérer des " "documents via HTTP, générer des nombres aléatoires, analyser les paramètres " "de la ligne de commande, écrire des programmes CGI, compresser de la donnée, " "et plein d'autres tâches. Vous balader dans la documentation de la " "bibliothèque vous donnera une idée de ce qui est disponnible." #: ../Doc/tutorial/whatnow.rst:24 msgid "" ":ref:`installing-index` explains how to install additional modules written " "by other Python users." msgstr "" ":ref:`installing-index` explique comment installer des paquets écrits par " "d'autres utilisateurs de Python." #: ../Doc/tutorial/whatnow.rst:27 msgid "" ":ref:`reference-index`: A detailed explanation of Python's syntax and " "semantics. It's heavy reading, but is useful as a complete guide to the " "language itself." msgstr "" ":ref:`reference-index`: Une explication détaillée de la syntaxe et " "sémantique de Python. C'est une lecture fastidieuse, mais qui a sa place " "dans une documentation exhaustive." #: ../Doc/tutorial/whatnow.rst:31 msgid "More Python resources:" msgstr "D'autres ressources:" #: ../Doc/tutorial/whatnow.rst:33 msgid "" "https://www.python.org: The major Python Web site. It contains code, " "documentation, and pointers to Python-related pages around the Web. This " "Web site is mirrored in various places around the world, such as Europe, " "Japan, and Australia; a mirror may be faster than the main site, depending " "on your geographical location." msgstr "" "https://www.python.org: C'est le site principal pour Python, il y contient " "du code, de la documentation, des liens vers d'autres sites à propos de " "Python tout autour d'internet. Il est répliqué dans différents endroits " "autours du globe, comme en Europe, au Japon, et en Australie, ces répliques " "peuvent dans certains cas être plus rapides que le site principal, tout " "dépend d'où vous vous situez." #: ../Doc/tutorial/whatnow.rst:39 msgid "https://docs.python.org: Fast access to Python's documentation." msgstr "" "https://docs.python.org: Un accès rapide à la documentation de Python en " "anglais. (La traduction en français, vous y êtes, est ici: http://www.afpy." "org/doc/python)" #: ../Doc/tutorial/whatnow.rst:41 msgid "" "https://pypi.python.org/pypi: The Python Package Index, previously also " "nicknamed the Cheese Shop, is an index of user-created Python modules that " "are available for download. Once you begin releasing code, you can register " "it here so that others can find it." msgstr "" "https://pypi.python.org/pypi: \"The Python Package Index\", (Le Répertoire " "des Paquets Python), ou auparavant surnommé \"The Cheese Shop\" (La " "Fromagerie), est un catalogue de modules Python disponibles au " "téléchargement, construit par les utilisateurs. Lorsque vous commencez à " "distribuer du code, vous pouvez l'inscrire ici afin que les autres puissent " "le trouver." #: ../Doc/tutorial/whatnow.rst:46 msgid "" "https://code.activestate.com/recipes/langs/python/: The Python Cookbook is a " "sizable collection of code examples, larger modules, and useful scripts. " "Particularly notable contributions are collected in a book also titled " "Python Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)" msgstr "" "https://code.activestate.com/recipes/langs/python/: \"The Python Cookbook\" " "est un recueil assez important d'exemples de code, de modules, et de " "scripts. Les contributions les plus remarquables y sont regroupées dans un " "livre appelé \"Python Cookbook\" (O'Reilly & Associates, ISBN 0-596-00797-3.)" #: ../Doc/tutorial/whatnow.rst:51 msgid "" "http://www.pyvideo.org collects links to Python-related videos from " "conferences and user-group meetings." msgstr "" "http://www.pyvideo.org regroupe des liens vers des vidéos relatives à " "Python, de conférences ou de réunions de groupes d'utilisateurs." #: ../Doc/tutorial/whatnow.rst:54 msgid "" "https://scipy.org: The Scientific Python project includes modules for fast " "array computations and manipulations plus a host of packages for such things " "as linear algebra, Fourier transforms, non-linear solvers, random number " "distributions, statistical analysis and the like." msgstr "" "https://scipy.org: Le projet \"The Scientific Python\" inclu des modules " "pour manipuler et effectuer des calculs efficients sur des listes. Le projet " "héberge aussi des paquets divers pour manipuler entre autre l'algèbre " "linéaire, les transformées de Fourier, des résolveurs non-linéaires, la " "distributions de nombres aléatoires, l'analyse statistique, etc." #: ../Doc/tutorial/whatnow.rst:59 msgid "" "For Python-related questions and problem reports, you can post to the " "newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at " "python-list@python.org. The newsgroup and mailing list are gatewayed, so " "messages posted to one will automatically be forwarded to the other. There " "are hundreds of postings a day, asking (and answering) questions, suggesting " "new features, and announcing new modules. Mailing list archives are " "available at https://mail.python.org/pipermail/." msgstr "" "Pour poser des questions ou rapporter des problèmes liés à Python, vous " "pouvez écrire sur le forum :newsgroup:`comp.lang.python`, ou les envoyer à " "la liste de diffusion à python-list@python.org. Le forum et la liste de " "diffusion sont liées, un message publié sur l'un sera automatiquement " "transféré sur l'autre. Il y sont publiés des centaines de messages par jour, " "demandant (ou répondant) à des questions, suggérant des nouvelles " "fonctionalités, et annoncant des nouveaux modules. Les archives sont " "disponibles à https://mail.python.org/pipermail/." #: ../Doc/tutorial/whatnow.rst:67 msgid "" "Before posting, be sure to check the list of :ref:`Frequently Asked " "Questions ` (also called the FAQ). The FAQ answers many of the " "questions that come up again and again, and may already contain the solution " "for your problem." msgstr "" "Avant de poster, assurez vous d'avoir lu la liste de la :ref:`Foire Aux " "Questions ` (aussi appelée FAQ). La FAQ répond à beaucoup de " "questions fréquentes, et contient probablement une solution à votre problème."