forked from AFPy/python-docs-fr
8745 lines
414 KiB
Plaintext
8745 lines
414 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 1990-2010, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: \n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2015-12-22 00:51+0100\n"
|
||
"PO-Revision-Date: 2015-12-22 12:17+0100\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 1.8.6\n"
|
||
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
||
"Language-Team: \n"
|
||
|
||
# 3056ef50444249728d9f473af9927a6b
|
||
#: tutorial/appendix.rst:5
|
||
msgid "Appendix"
|
||
msgstr "Annexe"
|
||
|
||
#: tutorial/appendix.rst:11 tutorial/interpreter.rst:89
|
||
msgid "Interactive Mode"
|
||
msgstr "Mode interactif"
|
||
|
||
#: tutorial/appendix.rst:16
|
||
msgid "Error Handling"
|
||
msgstr "Gestion des erreurs"
|
||
|
||
#: 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."
|
||
|
||
#: 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:`Control-C` ou :kbd:"
|
||
"`Delete`) au niveau de l'invite de commande primaire ou secondaire, 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`."
|
||
|
||
#: tutorial/appendix.rst:38
|
||
msgid "Executable Python Scripts"
|
||
msgstr "Scripts Python exécutables"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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."
|
||
|
||
#: 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 exécutable en utilisant la commande `chmod`."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/appendix.rst:69
|
||
msgid "The Interactive Startup File"
|
||
msgstr "La configuration du mode interactif"
|
||
|
||
#: 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."
|
||
|
||
#: 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``."
|
||
|
||
# 15ff626517a34a5aaf58d2f6f7b8b373
|
||
#: 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."
|
||
|
||
# d6945345e3fe4669981e2966a757ef2f
|
||
#: tutorial/appendix.rst:102
|
||
msgid "The Customization Modules"
|
||
msgstr "Les modules de Personnalisation"
|
||
|
||
# 5758a6756cb943b0aabe08600151d751
|
||
#: 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::"
|
||
|
||
# 07d2ef1091ac4086815e9ea6e57edd26
|
||
#: 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."
|
||
|
||
# 83a462362bb84a31bd2553bd13c41e2e
|
||
#: 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`."
|
||
|
||
#: tutorial/appendix.rst:123 tutorial/classes.rst:899
|
||
#: tutorial/controlflow.rst:674 tutorial/datastructures.rst:759
|
||
#: tutorial/interactive.rst:166 tutorial/introduction.rst:630
|
||
#: tutorial/modules.rst:554
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/appetite.rst:5
|
||
msgid "Whetting Your Appetite"
|
||
msgstr "Mise en bouche"
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/appetite.rst:20
|
||
msgid "Python is just the language for you."
|
||
msgstr "Python est le langage parfait pour vous."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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 :"
|
||
|
||
#: 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 ;"
|
||
|
||
#: 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 ;"
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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é !"
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/classes.rst:5
|
||
msgid "Classes"
|
||
msgstr "Classes"
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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.)"
|
||
|
||
#: tutorial/classes.rst:37
|
||
msgid "A Word About Names and Objects"
|
||
msgstr "Quelques mots au sujet des noms et objets"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/classes.rst:55
|
||
msgid "Python Scopes and Namespaces"
|
||
msgstr "Portées et espaces de noms en Python"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/classes.rst:63
|
||
msgid "Let's begin with some definitions."
|
||
msgstr "Tout d'abord, quelques définitions."
|
||
|
||
#: 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."
|
||
|
||
#: 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 ! [#]_"
|
||
|
||
#: 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``."
|
||
|
||
#: tutorial/classes.rst:90
|
||
msgid ""
|
||
"Namespaces are created at different moments and have different lifetimes. "
|
||
"The namespace containing the built-in names is created when the Python "
|
||
"interpreter starts up, and is never deleted. The global namespace for a "
|
||
"module is created when the module definition is read in; normally, module "
|
||
"namespaces also last until the interpreter quits. The statements executed "
|
||
"by the top-level invocation of the interpreter, either read from a script "
|
||
"file or interactively, are considered part of a module called :mod:"
|
||
"`__main__`, so they have their own global namespace. (The built-in names "
|
||
"actually also live in a module; this is called :mod:`__builtin__`.)"
|
||
msgstr ""
|
||
"Les espaces de noms sont créés à différents moments et ont différentes "
|
||
"durées de vie. L'espace de noms contenant les primitives est créé au "
|
||
"démarrage de l'interpréteur Python et n'est jamais effacé. L'espace de nom "
|
||
"global pour un module est créé lorsque la définition du module est lue. "
|
||
"Habituellement, les espaces de noms des modules durent aussi jusqu'à l'arrêt "
|
||
"de l'interpréteur. Les instructions exécutées par la première invocation de "
|
||
"l'interpréteur, qu'ils soient lus depuis un fichier de script ou de manière "
|
||
"interactive, sont considérés comme faisant partie d'un module appelé :mod:"
|
||
"`__main__`, de façon qu'elles possèdent leur propre espace de noms. (les "
|
||
"primitives vivent elles-mêmes dans un module, appelé :mod:`builtins`.)"
|
||
|
||
#: tutorial/classes.rst:100
|
||
msgid ""
|
||
"The local namespace for a function is created when the function is called, "
|
||
"and deleted when the function returns or raises an exception that is not "
|
||
"handled within the function. (Actually, forgetting would be a better way to "
|
||
"describe what actually happens.) Of course, recursive invocations each have "
|
||
"their own local namespace."
|
||
msgstr ""
|
||
"L'espace de noms local d'une fonction est créé lors de son appel, puis "
|
||
"effacé lorsqu'elle renvoie un résultat ou lève une exception non prise en "
|
||
"charge. (En fait, « oublier » serait une meilleure façon de décrire ce qui "
|
||
"se passe réellement). Bien sûr, des invocations récursives ont chacune leur "
|
||
"propre espace de noms."
|
||
|
||
#: 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."
|
||
|
||
#: 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 :"
|
||
|
||
#: 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"
|
||
|
||
#: 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"
|
||
|
||
#: 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"
|
||
|
||
#: 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"
|
||
|
||
#: tutorial/classes.rst:120
|
||
msgid ""
|
||
"If a name is declared global, then all references and assignments go "
|
||
"directly to the middle scope containing the module's global names. "
|
||
"Otherwise, all variables found outside of the innermost scope are read-only "
|
||
"(an attempt to write to such a variable will simply create a *new* local "
|
||
"variable in the innermost scope, leaving the identically named outer "
|
||
"variable unchanged)."
|
||
msgstr ""
|
||
"Si un nom est déclaré global, toutes les références et affectations vont "
|
||
"directement dans la portée intermédiaire contenant les noms globaux du "
|
||
"module. Pour réattacher des variables trouvées en dehors de la portée la "
|
||
"plus au centre, l'instruction :keyword:`nonlocal` peut être utilisée. Si "
|
||
"elles ne sont pas déclarées « nonlocal », ces variables sont en lecture "
|
||
"seule (toute tentative de modifier une telle variable créera simplement une "
|
||
"*nouvelle* variable locale dans la portée la plus au centre, en laissant "
|
||
"inchangée la variable du même nom dans la portée englobante)."
|
||
|
||
#: tutorial/classes.rst:126
|
||
msgid ""
|
||
"Usually, the local scope references the local names of the (textually) "
|
||
"current function. Outside functions, the local scope references the same "
|
||
"namespace as the global scope: the module's namespace. Class definitions "
|
||
"place yet another namespace in the local scope."
|
||
msgstr ""
|
||
"Habituellement, la portée locale référence les noms locaux de la fonction "
|
||
"courante. En dehors des fonctions, la portée locale référence le même espace "
|
||
"de noms que la portée globale : l'espace de noms du module. Les définitions "
|
||
"de classes créent un nouvel espace de noms dans la portée locale."
|
||
|
||
#: tutorial/classes.rst:131
|
||
msgid ""
|
||
"It is important to realize that scopes are determined textually: the global "
|
||
"scope of a function defined in a module is that module's namespace, no "
|
||
"matter from where or by what alias the function is called. On the other "
|
||
"hand, the actual search for names is done dynamically, at run time --- "
|
||
"however, the language definition is evolving towards static name resolution, "
|
||
"at \"compile\" time, so don't rely on dynamic name resolution! (In fact, "
|
||
"local variables are already determined statically.)"
|
||
msgstr ""
|
||
"Il est important de réaliser que les portées sont déterminées de manière "
|
||
"textuelle : la portée globale d'une fonction définie dans un module est "
|
||
"l'espace de nom de ce module, quel que soit la provenance de cet appel. Par "
|
||
"contre, la recherche réelle des noms est faite dynamiquement au moment de "
|
||
"l'exécution. Cependant la définition du langage est en train d'évoluer vers "
|
||
"une résolution statique des noms au moment de la « compilation », donc sans "
|
||
"se baser sur une résolution dynamique ! (En réalité, les variables locales "
|
||
"sont déjà déterminées de manière statique)."
|
||
|
||
#: tutorial/classes.rst:139
|
||
msgid ""
|
||
"A special quirk of Python is that -- if no :keyword:`global` statement is in "
|
||
"effect -- assignments to names always go into the innermost scope. "
|
||
"Assignments do not copy data --- they just bind names to objects. The same "
|
||
"is true for deletions: the statement ``del x`` removes the binding of ``x`` "
|
||
"from the namespace referenced by the local scope. In fact, all operations "
|
||
"that introduce new names use the local scope: in particular, :keyword:"
|
||
"`import` statements and function definitions bind the module or function "
|
||
"name in the local scope. (The :keyword:`global` statement can be used to "
|
||
"indicate that particular variables live in the global scope.)"
|
||
msgstr ""
|
||
"Une particularité de Python est que si aucune instruction :keyword:`global` "
|
||
"n'est active, les affectations de noms vont toujours dans la portée la plus "
|
||
"proche. Les affectations ne copient aucune donnée : elles se contentent de "
|
||
"lier des noms à des objets. Ceci est également vrai pour l'effacement : "
|
||
"l'instruction ``del x`` supprime la liaison de ``x`` dans l'espace de noms "
|
||
"référencé par la portée locale. En réalité, toutes les opérations qui "
|
||
"impliquent des nouveaux noms utilisent la portée locale : en particulier, "
|
||
"les instructions keyword:`import` et les définitions de fonctions effectuent "
|
||
"une liaison du module ou du nom de fonction dans la portée locale."
|
||
|
||
#: tutorial/classes.rst:153
|
||
msgid "A First Look at Classes"
|
||
msgstr "Une première approche des classes"
|
||
|
||
#: tutorial/classes.rst:155
|
||
msgid ""
|
||
"Classes introduce a little bit of new syntax, three new object types, and "
|
||
"some new semantics."
|
||
msgstr ""
|
||
"Le concept de classes introduit quelques nouveau éléments de syntaxe, trois "
|
||
"nouveaux types d'objets ainsi que de nouveaux éléments de sémantique"
|
||
|
||
#: tutorial/classes.rst:162
|
||
msgid "Class Definition Syntax"
|
||
msgstr "Syntaxe de définition des classes"
|
||
|
||
#: tutorial/classes.rst:164
|
||
msgid "The simplest form of class definition looks like this::"
|
||
msgstr "La forme la plus simple de définition de classe ressemble à ceci ::"
|
||
|
||
#: tutorial/classes.rst:173
|
||
msgid ""
|
||
"Class definitions, like function definitions (:keyword:`def` statements) "
|
||
"must be executed before they have any effect. (You could conceivably place "
|
||
"a class definition in a branch of an :keyword:`if` statement, or inside a "
|
||
"function.)"
|
||
msgstr ""
|
||
"Les définitions de classes, comme les définitions de fonctions (définitions :"
|
||
"keyword:`def`) doivent être exécutées avant d'avoir un effet. (Vous pouvez "
|
||
"tout à fait placer une définition de classe dans une branche d'une "
|
||
"instruction conditionnelle :keyword:`if` ou encore à l'intérieur d'une "
|
||
"fonction.)"
|
||
|
||
#: tutorial/classes.rst:177
|
||
msgid ""
|
||
"In practice, the statements inside a class definition will usually be "
|
||
"function definitions, but other statements are allowed, and sometimes useful "
|
||
"--- we'll come back to this later. The function definitions inside a class "
|
||
"normally have a peculiar form of argument list, dictated by the calling "
|
||
"conventions for methods --- again, this is explained later."
|
||
msgstr ""
|
||
"Dans la pratique, les déclarations dans une définition de classe seront "
|
||
"généralement des définitions de fonctions, mais d'autres déclarations sont "
|
||
"permises, et parfois utiles --- Nous reviendrons sur ce point plus tard. Les "
|
||
"définitions de fonction à l'intérieur d'une classe ont normalement une forme "
|
||
"particulière de liste d'arguments, dictée par les conventions d'appel aux "
|
||
"méthodes --- À nouveau, tout ceci sera expliqué plus tard."
|
||
|
||
#: tutorial/classes.rst:183
|
||
msgid ""
|
||
"When a class definition is entered, a new namespace is created, and used as "
|
||
"the local scope --- thus, all assignments to local variables go into this "
|
||
"new namespace. In particular, function definitions bind the name of the new "
|
||
"function here."
|
||
msgstr ""
|
||
"Quand une classe est définie, un nouvel espace de noms est créé et utilisé "
|
||
"comme portée locale --- Ainsi, toutes les affectations de variables locales "
|
||
"entrent dans ce nouvel espace de noms. En particulier, les définitions de "
|
||
"fonctions y lient le nom de la nouvelle fonction."
|
||
|
||
#: tutorial/classes.rst:188
|
||
msgid ""
|
||
"When a class definition is left normally (via the end), a *class object* is "
|
||
"created. This is basically a wrapper around the contents of the namespace "
|
||
"created by the class definition; we'll learn more about class objects in the "
|
||
"next section. The original local scope (the one in effect just before the "
|
||
"class definition was entered) is reinstated, and the class object is bound "
|
||
"here to the class name given in the class definition header (:class:"
|
||
"`ClassName` in the example)."
|
||
msgstr ""
|
||
"A la fin de la définition d'une classe, un *objet classe* est créé. C'est, "
|
||
"pour simplifier, une encapsulation du contenu de l'espace de noms créé par "
|
||
"la définition de classe. Nous reparlerons des objets classes dans la "
|
||
"prochaine section. La portée locale initiale (celle qui prévaut avant le "
|
||
"début de la définition de la classe) est réinstanciée, et l'objet de classe "
|
||
"est lié ici au nom de classe donné dans l'en-tête de définition de classe (:"
|
||
"class:`NomDeLaClasse` dans l'exemple)."
|
||
|
||
#: tutorial/classes.rst:200
|
||
msgid "Class Objects"
|
||
msgstr "Les objets classe"
|
||
|
||
#: tutorial/classes.rst:202
|
||
msgid ""
|
||
"Class objects support two kinds of operations: attribute references and "
|
||
"instantiation."
|
||
msgstr ""
|
||
"Les objets classes prennent en charge deux types d'opérations : des "
|
||
"références à des attributs et l'instanciation."
|
||
|
||
#: tutorial/classes.rst:205
|
||
msgid ""
|
||
"*Attribute references* use the standard syntax used for all attribute "
|
||
"references in Python: ``obj.name``. Valid attribute names are all the names "
|
||
"that were in the class's namespace when the class object was created. So, "
|
||
"if the class definition looked like this::"
|
||
msgstr ""
|
||
"Les *références d'attributs* utilisent la syntaxe standard utilisée pour "
|
||
"toutes les références d'attributs en Python : ``obj.nom``. Les noms "
|
||
"d'attribut valides sont tous les noms qui se trouvaient dans l'espace de "
|
||
"noms de la classe quand l'objet classe a été créé. Donc, si la définition de "
|
||
"classe ressemble à ceci ::"
|
||
|
||
# docstring doit il rester en anglais ou être traduit ?
|
||
#: tutorial/classes.rst:216
|
||
msgid ""
|
||
"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
|
||
"returning an integer and a function object, respectively. Class attributes "
|
||
"can also be assigned to, so you can change the value of ``MyClass.i`` by "
|
||
"assignment. :attr:`__doc__` is also a valid attribute, returning the "
|
||
"docstring belonging to the class: ``\"A simple example class\"``."
|
||
msgstr ""
|
||
"alors ``MaClasse.i`` et ``MaClasse.f`` sont des références valides à des "
|
||
"attributs, renvoyant respectivement un entier et un objet fonction. Les "
|
||
"attributs de classes peuvent également être affectés, de sorte que vous "
|
||
"pouvez modifier la valeur de ``MaClasse.i`` par affectation. :attr:`__doc__` "
|
||
"est aussi un attribut valide, renvoyant la docstring appartenant à la "
|
||
"classe : ``\"Une simple classe d'exemple\"``."
|
||
|
||
#: tutorial/classes.rst:222
|
||
msgid ""
|
||
"Class *instantiation* uses function notation. Just pretend that the class "
|
||
"object is a parameterless function that returns a new instance of the class. "
|
||
"For example (assuming the above class)::"
|
||
msgstr ""
|
||
"L'*instanciation* de classes utilise la notation des fonctions. Considérez "
|
||
"simplement que l'objet classe est une fonction sans paramètre qui renvoie "
|
||
"une nouvelle instance de la classe. Par exemple (en considérant la classe "
|
||
"définie ci-dessus) ::"
|
||
|
||
#: tutorial/classes.rst:228
|
||
msgid ""
|
||
"creates a new *instance* of the class and assigns this object to the local "
|
||
"variable ``x``."
|
||
msgstr ""
|
||
"crée une nouvelle *instance* de la classe et affecte cet objet à la variable "
|
||
"locale ``x``."
|
||
|
||
#: tutorial/classes.rst:231
|
||
msgid ""
|
||
"The instantiation operation (\"calling\" a class object) creates an empty "
|
||
"object. Many classes like to create objects with instances customized to a "
|
||
"specific initial state. Therefore a class may define a special method named :"
|
||
"meth:`__init__`, like this::"
|
||
msgstr ""
|
||
"L'opération d'instanciation (en \"appelant\" un objet classe) crée un objet "
|
||
"vide. De nombreuses classes aiment créer des objets personnalisés avec des "
|
||
"instances personnalisées en fonction d'un état initial spécifique. Ainsi une "
|
||
"classe peut définir une méthode spéciale nommée: meth:`__init__`, comme "
|
||
"ceci ::"
|
||
|
||
#: tutorial/classes.rst:239
|
||
msgid ""
|
||
"When a class defines an :meth:`__init__` method, class instantiation "
|
||
"automatically invokes :meth:`__init__` for the newly-created class "
|
||
"instance. So in this example, a new, initialized instance can be obtained "
|
||
"by::"
|
||
msgstr ""
|
||
"Quand une classe définit une méthode :meth:`__init__`, l'instanciation de la "
|
||
"classe appelle automatiquement :meth:`__init__` pour la nouvelle instance de "
|
||
"la classe. Donc, dans cet exemple, l'initialisation d'une nouvelle instance "
|
||
"peut être obtenue par ::"
|
||
|
||
#: tutorial/classes.rst:245
|
||
msgid ""
|
||
"Of course, the :meth:`__init__` method may have arguments for greater "
|
||
"flexibility. In that case, arguments given to the class instantiation "
|
||
"operator are passed on to :meth:`__init__`. For example, ::"
|
||
msgstr ""
|
||
"Bien sûr, la méthode meth::`__init__` peut avoir des arguments pour une plus "
|
||
"grande flexibilité. Dans ce cas, les arguments donnés à l'opérateur "
|
||
"d'instanciation de classe sont transmis à :meth:`__init__`. Par exemple, ::"
|
||
|
||
#: tutorial/classes.rst:262
|
||
msgid "Instance Objects"
|
||
msgstr "Objets instance"
|
||
|
||
#: tutorial/classes.rst:264
|
||
msgid ""
|
||
"Now what can we do with instance objects? The only operations understood by "
|
||
"instance objects are attribute references. There are two kinds of valid "
|
||
"attribute names, data attributes and methods."
|
||
msgstr ""
|
||
"Maintenant, que pouvons-nous faire avec des objets instance ? Les seules "
|
||
"opérations comprises par les objets instances sont des références "
|
||
"d'attributs. Il y a deux sortes de noms d'attributs valides, les attributs "
|
||
"données et les méthodes."
|
||
|
||
#: tutorial/classes.rst:268
|
||
msgid ""
|
||
"*data attributes* correspond to \"instance variables\" in Smalltalk, and to "
|
||
"\"data members\" in C++. Data attributes need not be declared; like local "
|
||
"variables, they spring into existence when they are first assigned to. For "
|
||
"example, if ``x`` is the instance of :class:`MyClass` created above, the "
|
||
"following piece of code will print the value ``16``, without leaving a "
|
||
"trace::"
|
||
msgstr ""
|
||
"Les *attributs données* correspondent à des \"variables d'instance\" en "
|
||
"Smalltalk, et aux \"membres de données\" en C++. Les attributs données n'ont "
|
||
"pas à être déclarés. Comme les variables locales, ils existent dès lors "
|
||
"qu'ils sont attribués une première fois. Par exemple, si ``x`` est "
|
||
"l'instance de :class:`MaClasse` créée ci-dessus, le code suivant affiche la "
|
||
"valeur ``16 ``, sans laisser de traces ::"
|
||
|
||
#: tutorial/classes.rst:280
|
||
msgid ""
|
||
"The other kind of instance attribute reference is a *method*. A method is a "
|
||
"function that \"belongs to\" an object. (In Python, the term method is not "
|
||
"unique to class instances: other object types can have methods as well. For "
|
||
"example, list objects have methods called append, insert, remove, sort, and "
|
||
"so on. However, in the following discussion, we'll use the term method "
|
||
"exclusively to mean methods of class instance objects, unless explicitly "
|
||
"stated otherwise.)"
|
||
msgstr ""
|
||
"L'autre type de référence à un attribut d'instance est une *méthode*. Une "
|
||
"méthode est une fonction qui \"appartient à\" un objet (en Python, le terme "
|
||
"de méthode n'est pas unique aux instances de classes : d'autres types "
|
||
"d'objets peuvent aussi avoir des méthodes. Par exemple, les objets listes "
|
||
"ont des méthodes appelées append, insert, remove, sort, et ainsi de suite. "
|
||
"Toutefois, dans la discussion qui suit, sauf indication contraire, nous "
|
||
"allons utiliser le terme de méthode exclusivement en référence à des "
|
||
"méthodes d'objets instances de classe)."
|
||
|
||
#: tutorial/classes.rst:289
|
||
msgid ""
|
||
"Valid method names of an instance object depend on its class. By "
|
||
"definition, all attributes of a class that are function objects define "
|
||
"corresponding methods of its instances. So in our example, ``x.f`` is a "
|
||
"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "
|
||
"not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as "
|
||
"``MyClass.f`` --- it is a *method object*, not a function object."
|
||
msgstr ""
|
||
"Les noms de méthodes valides d'un objet instance dépendent de sa classe. Par "
|
||
"définition, tous les attributs d'une classe qui sont des objets fonction "
|
||
"définissent les méthodes correspondantes de ses instances. Donc, dans notre "
|
||
"exemple, ``x.f`` est une méthode de référence valide, car ``MaClasse.f`` est "
|
||
"une fonction, mais pas ``x.i`` car ``MaClasse.i`` n'en est pas une. "
|
||
"Attention cependant, ``x.f`` n'est pas la même chose que ``MaClasse.f`` --- "
|
||
"Il s'agit d'un *objet méthode*, pas d'un objet fonction."
|
||
|
||
#: tutorial/classes.rst:300
|
||
msgid "Method Objects"
|
||
msgstr "Les objets méthode"
|
||
|
||
#: tutorial/classes.rst:302
|
||
msgid "Usually, a method is called right after it is bound::"
|
||
msgstr "Le plus souvent, une méthode est appelée juste après avoir été liée::"
|
||
|
||
#: tutorial/classes.rst:306
|
||
msgid ""
|
||
"In the :class:`MyClass` example, this will return the string ``'hello "
|
||
"world'``. However, it is not necessary to call a method right away: ``x.f`` "
|
||
"is a method object, and can be stored away and called at a later time. For "
|
||
"example::"
|
||
msgstr ""
|
||
"Dans l'exemple de la class :class! `MaClass`, cela va retourner la chaîne de "
|
||
"caractères ``hello world``. Toutefois, il n'est pas nécessaire d'appeler la "
|
||
"méthode directement: ``x.f`` est un objet méthode, il peut être gardé de "
|
||
"coté et être appelé plus tard. Par exemple::"
|
||
|
||
#: tutorial/classes.rst:314
|
||
msgid "will continue to print ``hello world`` until the end of time."
|
||
msgstr "va afficher ``hello world`` jusqu'à la fin des temps."
|
||
|
||
#: tutorial/classes.rst:316
|
||
msgid ""
|
||
"What exactly happens when a method is called? You may have noticed that ``x."
|
||
"f()`` was called without an argument above, even though the function "
|
||
"definition for :meth:`f` specified an argument. What happened to the "
|
||
"argument? Surely Python raises an exception when a function that requires an "
|
||
"argument is called without any --- even if the argument isn't actually "
|
||
"used..."
|
||
msgstr ""
|
||
"Que ce passe-t-il exactement quand une méthode est appelée ? Vous avez dû "
|
||
"remarquer que ``x.f()`` a été appelée dans le code ci-dessus sans argument, "
|
||
"alors que la définition de la méthode :meth: `f` spécifie bien qu'elle prend "
|
||
"un argument. Qu'est-il arrivé à l'argument ? Python doit sûrement lever une "
|
||
"exception lorsqu'une fonction qui requiert un argument est appelée sans -- "
|
||
"même si l'argument n'est pas utilisé..."
|
||
|
||
#: tutorial/classes.rst:322
|
||
msgid ""
|
||
"Actually, you may have guessed the answer: the special thing about methods "
|
||
"is that the object is passed as the first argument of the function. In our "
|
||
"example, the call ``x.f()`` is exactly equivalent to ``MyClass.f(x)``. In "
|
||
"general, calling a method with a list of *n* arguments is equivalent to "
|
||
"calling the corresponding function with an argument list that is created by "
|
||
"inserting the method's object before the first argument."
|
||
msgstr ""
|
||
"En fait, vous aurez peut-être deviné la réponse : la particularité des "
|
||
"méthodes est que l'objet est passé comme premier argument de la fonction. "
|
||
"Dans notre exemple, l'appel ``x.f ()`` est exactement équivalent à "
|
||
"``MaClasse.f(x)``. En général, appeler une méthode avec une liste "
|
||
"d'arguments *n* est équivalent à appeler la fonction correspondante avec "
|
||
"cette liste d'arguments modulo l'insertion de l'objet de la méthode avant le "
|
||
"premier argument."
|
||
|
||
#: tutorial/classes.rst:329
|
||
msgid ""
|
||
"If you still don't understand how methods work, a look at the implementation "
|
||
"can perhaps clarify matters. When an instance attribute is referenced that "
|
||
"isn't a data attribute, its class is searched. If the name denotes a valid "
|
||
"class attribute that is a function object, a method object is created by "
|
||
"packing (pointers to) the instance object and the function object just found "
|
||
"together in an abstract object: this is the method object. When the method "
|
||
"object is called with an argument list, a new argument list is constructed "
|
||
"from the instance object and the argument list, and the function object is "
|
||
"called with this new argument list."
|
||
msgstr ""
|
||
"Si vous ne comprenez toujours pas comment les méthodes fonctionnent, un coup "
|
||
"d'œil à l'implémentation vous aidera peut être. Lorsque l'instance d'un "
|
||
"attribut est référencé qui n'est pas un attribut donnée, sa classe est "
|
||
"recherchée. Si le nom correspond à un attribut valide qui est une fonction, "
|
||
"un objet méthode est créé en associant (via leurs pointeurs) l'objet "
|
||
"instance et l'objet fonction trouvé ensemble dans un nouvel objet abstrait : "
|
||
"c'est l'objet méthode. Lorsque l'objet méthode est appelé avec une liste "
|
||
"d'arguments, une nouvelle liste d'arguments est construite à partir de "
|
||
"l'objet méthode et de la liste des arguments. L'objet fonction est appelé "
|
||
"avec cette nouvelle liste d'arguments."
|
||
|
||
# ab1bfdd3fee34318aab4be64886cf45e
|
||
#: tutorial/classes.rst:343
|
||
msgid "Class and Instance Variables"
|
||
msgstr "Classes et variables d'instance"
|
||
|
||
# ecf91e018fbd48369aa4d90ce00dd2d0
|
||
#: tutorial/classes.rst:345
|
||
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::"
|
||
|
||
# 48f32152a9ce4d4fa5a1d6d5a99d8914
|
||
#: tutorial/classes.rst:367
|
||
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 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*::"
|
||
|
||
# 63436e0b027b42da8f8045c439d6cddb
|
||
#: tutorial/classes.rst:390
|
||
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 : :"
|
||
|
||
#: tutorial/classes.rst:414
|
||
msgid "Random Remarks"
|
||
msgstr "Remarques diverses"
|
||
|
||
#: tutorial/classes.rst:418
|
||
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."
|
||
|
||
#: tutorial/classes.rst:425
|
||
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)."
|
||
|
||
#: tutorial/classes.rst:433
|
||
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."
|
||
|
||
#: tutorial/classes.rst:439
|
||
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."
|
||
|
||
#: tutorial/classes.rst:444
|
||
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."
|
||
|
||
#: tutorial/classes.rst:450
|
||
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 ::"
|
||
|
||
#: tutorial/classes.rst:465
|
||
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."
|
||
|
||
#: tutorial/classes.rst:470
|
||
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`` ::"
|
||
|
||
#: tutorial/classes.rst:482
|
||
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."
|
||
|
||
#: tutorial/classes.rst:492
|
||
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__``."
|
||
|
||
#: tutorial/classes.rst:499
|
||
msgid "Inheritance"
|
||
msgstr "L'héritage"
|
||
|
||
#: tutorial/classes.rst:501
|
||
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 ::"
|
||
|
||
#: tutorial/classes.rst:512
|
||
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 ::"
|
||
|
||
#: tutorial/classes.rst:519
|
||
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."
|
||
|
||
#: tutorial/classes.rst:525
|
||
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."
|
||
|
||
#: tutorial/classes.rst:531
|
||
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``)."
|
||
|
||
#: tutorial/classes.rst:537
|
||
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)."
|
||
|
||
#: tutorial/classes.rst:544
|
||
msgid "Python has two built-in functions that work with inheritance:"
|
||
msgstr "Python a deux fonctions primitives qui gèrent l'héritage :"
|
||
|
||
#: tutorial/classes.rst:546
|
||
msgid ""
|
||
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
|
||
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
|
||
"derived from :class:`int`."
|
||
msgstr ""
|
||
"Utilisez :func:`isinstance` pour tester le type d'une instance : "
|
||
"``isinstance(obj, int)`` renverra ``True`` seulement si ``obj.__class__`` "
|
||
"est égal à :class:`int` ou à une autre classe dérivée de :class:`int`."
|
||
|
||
# 9eda01c71f1b43b2a9f80582775b12b2
|
||
#: tutorial/classes.rst:550
|
||
msgid ""
|
||
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
|
||
"is ``True`` since :class:`bool` is a subclass of :class:`int`. However, "
|
||
"``issubclass(unicode, str)`` is ``False`` since :class:`unicode` is not a "
|
||
"subclass of :class:`str` (they only share a common ancestor, :class:"
|
||
"`basestring`)."
|
||
msgstr ""
|
||
"Utilisez :func:`issubclass` pour tester l'héritage d'une class : "
|
||
"``issubclass(bool, int)`` renvoie ``True`` car la class :class:`bool` est "
|
||
"une sous-classe de :class:`int`. Par contre, ``issubclass(unicode, str)`` "
|
||
"renvoie ``False`` car :class:`unicode` n'est pas une sous-classe de :class:"
|
||
"`str` (ils partagent seulement un ancêtre commun, :class:`basestring`)."
|
||
|
||
#: tutorial/classes.rst:561
|
||
msgid "Multiple Inheritance"
|
||
msgstr "L'héritage multiple"
|
||
|
||
#: tutorial/classes.rst:563
|
||
msgid ""
|
||
"Python supports a limited form of multiple inheritance as well. A class "
|
||
"definition with multiple base classes looks like this::"
|
||
msgstr ""
|
||
"Python propose également une forme d'héritage multiple. Une définition de "
|
||
"classe ayant plusieurs classes de base ressemble à ::"
|
||
|
||
#: tutorial/classes.rst:573
|
||
msgid ""
|
||
"For old-style classes, the only rule is depth-first, left-to-right. Thus, "
|
||
"if an attribute is not found in :class:`DerivedClassName`, it is searched "
|
||
"in :class:`Base1`, then (recursively) in the base classes of :class:`Base1`, "
|
||
"and only if it is not found there, it is searched in :class:`Base2`, and so "
|
||
"on."
|
||
msgstr ""
|
||
"Pour les anciennes classes, la seule règle est : en profondeur, de gauche à "
|
||
"droite. Ainsi, si un attribut n'est pas trouvé dans :class:"
|
||
"`NomDeLaClasseDerivee`, il est recherché dans :class:`Base1`, puis "
|
||
"(récursivement) dans les classes de base de :class:`Base1` ; s'il n'y est "
|
||
"pas trouvé, il est recherché dans :class:`Base2` et ses classes de base, et "
|
||
"ainsi de suite."
|
||
|
||
# 0bd332ed666e47d1b82a9aa6ea6a3afe
|
||
#: tutorial/classes.rst:578
|
||
msgid ""
|
||
"(To some people breadth first --- searching :class:`Base2` and :class:"
|
||
"`Base3` before the base classes of :class:`Base1` --- looks more natural. "
|
||
"However, this would require you to know whether a particular attribute of :"
|
||
"class:`Base1` is actually defined in :class:`Base1` or in one of its base "
|
||
"classes before you can figure out the consequences of a name conflict with "
|
||
"an attribute of :class:`Base2`. The depth-first rule makes no differences "
|
||
"between direct and inherited attributes of :class:`Base1`.)"
|
||
msgstr ""
|
||
"(Pour certaines personnes, commencer la recherche \"en largeur\" --- "
|
||
"chercher dans :class:`Base2` et :class:`Base3` avant d'aller dans les "
|
||
"classes de base de :class:`Base1` --- peut sembler plus naturel. Toutefois, "
|
||
"ceci nécessiterait de savoir si un attribut particulier de :class:`Base1` "
|
||
"est actuellement défini dans :class:`Base1` ou dans l'une de ses classes de "
|
||
"base avant de pouvoir envisager les conséquences d'un conflit de nom avec un "
|
||
"attribut de :class:`Base2`. La règle qui consiste à rechercher d'abord en "
|
||
"profondeur ne fait aucune différence entre des attributs définis localement "
|
||
"et des attributs hérités de :class:`Base1`)."
|
||
|
||
# 065cbbda1701441f9d8f176d380ca4bf
|
||
#: tutorial/classes.rst:586
|
||
msgid ""
|
||
"For :term:`new-style class`\\es, the method resolution order changes "
|
||
"dynamically to support cooperative calls to :func:`super`. This approach is "
|
||
"known in some other multiple-inheritance languages as call-next-method and "
|
||
"is more powerful than the super call found in single-inheritance languages."
|
||
msgstr ""
|
||
"Pour les nouvelles classes, l'ordre de résolution des méthodes change "
|
||
"dynamiquement pour gérer les appels coopératifs de la fonction :func:"
|
||
"`super`. Cette approche est connue dans certains langages supportant "
|
||
"l'héritage multiple sous le nom de la \"méthode la plus proche\" (\"call-"
|
||
"next-method\"), et est plus puissante que le seul appel de la méthode \"super"
|
||
"\" que l'on trouve dans les langages ne gérant que l'héritage simple."
|
||
|
||
# d37280ea9d7743f686abf8f1e1859425
|
||
#: tutorial/classes.rst:591
|
||
msgid ""
|
||
"With new-style classes, dynamic ordering is necessary because all cases of "
|
||
"multiple inheritance exhibit one or more diamond relationships (where at "
|
||
"least one of the parent classes can be accessed through multiple paths from "
|
||
"the bottommost class). For example, all new-style classes inherit from :"
|
||
"class:`object`, so any case of multiple inheritance provides more than one "
|
||
"path to reach :class:`object`. To keep the base classes from being accessed "
|
||
"more than once, the dynamic algorithm linearizes the search order in a way "
|
||
"that preserves the left-to-right ordering specified in each class, that "
|
||
"calls each parent only once, and that is monotonic (meaning that a class can "
|
||
"be subclassed without affecting the precedence order of its parents). Taken "
|
||
"together, these properties make it possible to design reliable and "
|
||
"extensible classes with multiple inheritance. For more detail, see https://"
|
||
"www.python.org/download/releases/2.3/mro/."
|
||
msgstr ""
|
||
"Avec les nouvelles classes, l'ordre défini dynamiquement est nécessaire car "
|
||
"tous les cas d'héritage multiple comportent un arbre d'héritage en losange "
|
||
"(au moins l'une des classes parentes peut être accédée via plusieurs chemins "
|
||
"à partir d'une même sous-classe). Par exemple, toutes les nouvelles classes "
|
||
"héritent de :class:`object`, donc n'importe quel arbre d'héritage multiple "
|
||
"fournit plus d'un chemin pour atteindre :class:`object`. Pour qu'une classe "
|
||
"de base ne soit pas appelée plusieurs fois, l'algorithme dynamique linéarise "
|
||
"l'ordre de recherche d'une façon qui préserve l'ordre d'héritage, de la "
|
||
"gauche vers la droite, spécifié dans chaque classe, qui appelle chaque "
|
||
"classe parente une seule fois, qui est monotone (ce qui signifie qu'une "
|
||
"classe peut être sous-classée sans affecter l'ordre d'héritage de ses "
|
||
"parents). Prises ensemble, ces propriétés permettent de concevoir des "
|
||
"classes de façon fiable et extensible dans un contexte d'héritage multiple. "
|
||
"Pour plus de détail, consultez http://www.python.org/download/releases/2.3/"
|
||
"mro/."
|
||
|
||
# 0d63701d735e45d6b0ed3f46e2ff0bea
|
||
#: tutorial/classes.rst:609
|
||
msgid "Private Variables and Class-local References"
|
||
msgstr "Variables privées et références locales aux classes"
|
||
|
||
#: tutorial/classes.rst:611
|
||
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."
|
||
|
||
#: tutorial/classes.rst:618
|
||
msgid ""
|
||
"Since there is a valid use-case for class-private members (namely to avoid "
|
||
"name clashes of names with names defined by subclasses), there is limited "
|
||
"support for such a mechanism, called :dfn:`name mangling`. Any identifier "
|
||
"of the form ``__spam`` (at least two leading underscores, at most one "
|
||
"trailing underscore) is textually replaced with ``_classname__spam``, where "
|
||
"``classname`` is the current class name with leading underscore(s) "
|
||
"stripped. This mangling is done without regard to the syntactic position of "
|
||
"the identifier, as long as it occurs within the definition of a class."
|
||
msgstr ""
|
||
"Dès lors qu'il y a un cas d'utilisation valable pour avoir des membres "
|
||
"privés (notamment pour éviter des conflits avec des noms définis dans des "
|
||
"sous-classes), il existe un support (certes limité) pour un tel mécanisme, "
|
||
"appelé :dfn:`name mangling`. Tout identifiant sous la forme ``__spam`` (avec "
|
||
"au moins deux underscores en tête, et au plus un à la fin) est remplacé "
|
||
"textuellement par ``_classname__spam``, où ``classname`` est le nom de la "
|
||
"classe sans le(s) premier(s) underscore(s). Ce \"bricolage\" est effectué "
|
||
"sans tenir compte de la position syntaxique de l'identifiant, tant qu'il est "
|
||
"présent dans la définition d'une classe."
|
||
|
||
# 76822657f61145529176860bfd786541
|
||
# Une définition en français pour le "name mangling", littéralement
|
||
# "bricolage" ??
|
||
#: tutorial/classes.rst:627
|
||
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 ::"
|
||
|
||
#: tutorial/classes.rst:649
|
||
msgid ""
|
||
"Note that the mangling rules are designed mostly to avoid accidents; it "
|
||
"still is possible to access or modify a variable that is considered "
|
||
"private. This can even be useful in special circumstances, such as in the "
|
||
"debugger."
|
||
msgstr ""
|
||
"Notez que ces règles sont conçues avant tout pour éviter les accidents ; il "
|
||
"reste possible d'accéder ou de modifier une variable considérée comme "
|
||
"privée. Ceci peut même être utile dans certaines circonstances, comme au "
|
||
"sein du débogueur."
|
||
|
||
# 9412d7da01ba4f1c94661f38b627ccda
|
||
#: tutorial/classes.rst:653
|
||
msgid ""
|
||
"Notice that code passed to ``exec``, ``eval()`` or ``execfile()`` does not "
|
||
"consider the classname of the invoking class to be the current class; this "
|
||
"is similar to the effect of the ``global`` statement, the effect of which "
|
||
"is likewise restricted to code that is byte-compiled together. The same "
|
||
"restriction applies to ``getattr()``, ``setattr()`` and ``delattr()``, as "
|
||
"well as when referencing ``__dict__`` directly."
|
||
msgstr ""
|
||
"Notez que le code passé à ``exec()``, ``eval()`` ou ``execfile()`` ne "
|
||
"considère pas le nom de la classe appelante comme étant la classe courante ; "
|
||
"le même effet s'applique à la directive ``gloabl``, dont l'effet est de la "
|
||
"même façon restreint au code compilé dans le même ensemble de byte-code. Les "
|
||
"mêmes restrictions s'appliquent à ``getattr()``, ``setattr()`` et "
|
||
"``delattr()``, ainsi qu'aux références directes à ``__dict__``."
|
||
|
||
#: tutorial/classes.rst:664
|
||
msgid "Odds and Ends"
|
||
msgstr "Trucs et astuces"
|
||
|
||
#: tutorial/classes.rst:666
|
||
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 ::"
|
||
|
||
#: tutorial/classes.rst:680
|
||
msgid ""
|
||
"A piece of Python code that expects a particular abstract data type can "
|
||
"often be passed a class that emulates the methods of that data type "
|
||
"instead. For instance, if you have a function that formats some data from a "
|
||
"file object, you can define a class with methods :meth:`read` and :meth:`!"
|
||
"readline` that get the data from a string buffer instead, and pass it as an "
|
||
"argument."
|
||
msgstr ""
|
||
"On peut souvent fournir, à du code Python qui s'attend à recevoir un type de "
|
||
"donnée abstrait spécifique, une classe qui simule les méthodes de ce type. "
|
||
"Par exemple, si vous avez une fonction qui formate des données extraites "
|
||
"d'un objet fichier, vous pouvez définir une classe avec des méthodes :meth:"
|
||
"`read` et :meth:`readline` qui extrait ses données d'un tampon de chaînes de "
|
||
"caractères à la place, et lui passer une instance comme argument."
|
||
|
||
# 7ebc85600b7944a29e6e12ecc0f45219
|
||
#: tutorial/classes.rst:691
|
||
msgid ""
|
||
"Instance method objects have attributes, too: ``m.im_self`` is the instance "
|
||
"object with the method :meth:`m`, and ``m.im_func`` is the function object "
|
||
"corresponding to the method."
|
||
msgstr ""
|
||
"Les objets méthodes d'instances ont également des attributs : ``m.im_self`` "
|
||
"est l'instance d'objet avec la méthode :meth:`m`, et ``m.im_func`` est "
|
||
"l'objet fonction correspondant à la méthode."
|
||
|
||
#: tutorial/classes.rst:699
|
||
msgid "Exceptions Are Classes Too"
|
||
msgstr "Les exceptions sont aussi des classes"
|
||
|
||
#: tutorial/classes.rst:701
|
||
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."
|
||
|
||
#: tutorial/classes.rst:704
|
||
msgid ""
|
||
"There are two new valid (semantic) forms for the :keyword:`raise` statement::"
|
||
msgstr ""
|
||
"Il y a deux nouvelles formes (sémantiques) pour l'instruction :keyword:"
|
||
"`raise` ::"
|
||
|
||
# 8f5815c4d349473a91655b663f163fb7
|
||
#: tutorial/classes.rst:710
|
||
msgid ""
|
||
"In the first form, ``instance`` must be an instance of :class:`Class` or of "
|
||
"a class derived from it. The second form is a shorthand for::"
|
||
msgstr ""
|
||
"Dans la première forme, ``instance`` doit être une instance de :class:"
|
||
"`Class` ou d'une classe dérivée. La seconde forme est un raccourci pour ::"
|
||
|
||
#: tutorial/classes.rst:715
|
||
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 ::"
|
||
|
||
#: tutorial/classes.rst:737
|
||
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."
|
||
|
||
#: tutorial/classes.rst:740
|
||
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`."
|
||
|
||
#: tutorial/classes.rst:748
|
||
msgid "Iterators"
|
||
msgstr "Itérateurs"
|
||
|
||
#: tutorial/classes.rst:750
|
||
msgid ""
|
||
"By now you have probably noticed that most container objects can be looped "
|
||
"over using a :keyword:`for` statement::"
|
||
msgstr ""
|
||
"Vous avez maintenant certainement remarqué que l'on peut itérer sur la "
|
||
"plupart des objets conteneurs en utilisant une instruction :keyword:`for` ::"
|
||
|
||
# 6aba6be73fbf4173bdf405faaa3f4fbf
|
||
#: tutorial/classes.rst:764
|
||
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. 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ède aux é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. Cet exemple montre "
|
||
"comment tout cela fonctionne ::"
|
||
|
||
# 3b3fcc0b4bdf44b59d3a21fe85f65bae
|
||
#: tutorial/classes.rst:789
|
||
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:`~iterator.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`. Si la classe définit elle-même la méthode :meth:`~iterator.next`, "
|
||
"alors :meth:`__iter__` peut simplement renvoyer ``self`` ::"
|
||
|
||
#: tutorial/classes.rst:824
|
||
msgid "Generators"
|
||
msgstr "Générateurs"
|
||
|
||
# b93a03d2e68d4a60aa58eb2165d2ff9d
|
||
#: tutorial/classes.rst:826
|
||
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 ::"
|
||
|
||
# 3d70dcf3a7024e698039ee6bdaf21102
|
||
#: tutorial/classes.rst:847
|
||
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."
|
||
|
||
#: tutorial/classes.rst:852
|
||
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``."
|
||
|
||
#: tutorial/classes.rst:857
|
||
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."
|
||
|
||
#: tutorial/classes.rst:866
|
||
msgid "Generator Expressions"
|
||
msgstr "Expressions et générateurs"
|
||
|
||
#: tutorial/classes.rst:868
|
||
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."
|
||
|
||
#: tutorial/classes.rst:875
|
||
msgid "Examples::"
|
||
msgstr "Exemples ::"
|
||
|
||
#: tutorial/classes.rst:900
|
||
msgid ""
|
||
"Except for one thing. Module objects have a secret read-only attribute "
|
||
"called :attr:`__dict__` which returns the dictionary used to implement the "
|
||
"module's namespace; the name :attr:`__dict__` is an attribute but not a "
|
||
"global name. Obviously, using this violates the abstraction of namespace "
|
||
"implementation, and should be restricted to things like post-mortem "
|
||
"debuggers."
|
||
msgstr ""
|
||
"Sauf pour une chose. Les modules disposent d'un attribut secret en lecture "
|
||
"seule appelé :attr:`__dict__`, qui renvoie le dictionnaire utilisé pour "
|
||
"implémenter l'espace de noms du module ; le nom :attr:`__dict__` est un "
|
||
"attribut mais pas un nom global. Évidemment, son utilisation brise "
|
||
"l'abstraction de l'implémentation des espaces de noms, et ne doit être "
|
||
"restreinte qu'à des choses comme des debogueurs post-mortem."
|
||
|
||
#: tutorial/controlflow.rst:5
|
||
msgid "More Control Flow Tools"
|
||
msgstr "D'autres outils de contrôle de flux"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/controlflow.rst:14
|
||
msgid ":keyword:`if` Statements"
|
||
msgstr "L'instruction :keyword:`if`"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/controlflow.rst:43
|
||
msgid ":keyword:`for` Statements"
|
||
msgstr "L'instruction :keyword:`for`"
|
||
|
||
#: tutorial/controlflow.rst:49
|
||
msgid ""
|
||
"The :keyword:`for` statement in Python differs a bit from what you may be "
|
||
"used to in C or Pascal. Rather than always iterating over an arithmetic "
|
||
"progression of numbers (like in Pascal), or giving the user the ability to "
|
||
"define both the iteration step and halting condition (as C), Python's :"
|
||
"keyword:`for` statement iterates over the items of any sequence (a list or a "
|
||
"string), in the order that they appear in the sequence. For example (no pun "
|
||
"intended):"
|
||
msgstr ""
|
||
"L'instruction :keyword:`for` que propose Python est un peu différente de "
|
||
"celle que l'on peut trouver en C ou en Pascal. Au lieu de toujours itérer "
|
||
"sur une suite arithmétique de nombres (comme en Pascal), ou de donner à "
|
||
"l'utilisateur la possibilité de définir le pas d'itération et la condition "
|
||
"de fin (comme en C), l'instruction :keyword:`for` en Python itère sur les "
|
||
"éléments d'une séquence (qui peut être une liste, une chaîne de "
|
||
"caractères...), dans l'ordre dans lequel ils apparaissent dans la séquence. "
|
||
"Par exemple (sans jeu de mots) :"
|
||
|
||
# 8161ee2d167d4d359706f1ee40a4eee8
|
||
#: tutorial/controlflow.rst:70
|
||
msgid ""
|
||
"If you need to modify the sequence you are iterating over while inside the "
|
||
"loop (for example to duplicate selected items), it is recommended that you "
|
||
"first make a copy. Iterating over a sequence does not implicitly make a "
|
||
"copy. The slice notation makes this especially convenient::"
|
||
msgstr ""
|
||
"Si vous devez modifier la séquence sur laquelle s'effectue l'itération à "
|
||
"l'intérieur de la boucle (par exemple pour dupliquer ou supprimer un "
|
||
"élément), il est plus que recommandé de commencer par en faire une copie, "
|
||
"celle-ci n'étant pas implicite. La notation \"par tranches\" rend cette "
|
||
"opération particulièrement simple ::"
|
||
|
||
#: tutorial/controlflow.rst:86
|
||
msgid "The :func:`range` Function"
|
||
msgstr "La fonction :func:`range`"
|
||
|
||
# e970ab346e7c42babe10861bae0a2397
|
||
#: tutorial/controlflow.rst:88
|
||
msgid ""
|
||
"If you do need to iterate over a sequence of numbers, the built-in function :"
|
||
"func:`range` comes in handy. It generates lists containing arithmetic "
|
||
"progressions::"
|
||
msgstr ""
|
||
"Si vous devez itérer sur une suite de nombres, la fonction intégrée :func:"
|
||
"`range` est faite pour cela. Elle génère une liste contenant une simple "
|
||
"progression arithmétique ::"
|
||
|
||
# fe8625ff049a4316af3f2de7977238a9
|
||
#: tutorial/controlflow.rst:95
|
||
msgid ""
|
||
"The given end point is never part of the generated list; ``range(10)`` "
|
||
"generates a list of 10 values, the legal indices for items of a sequence of "
|
||
"length 10. It is possible to let the range start at another number, or to "
|
||
"specify a different increment (even negative; sometimes this is called the "
|
||
"'step')::"
|
||
msgstr ""
|
||
"Le dernier élément fourni en paramètre ne fait jamais partie de la liste "
|
||
"générée ; ``range(10)`` génère une liste de 10 valeurs, dont les valeurs "
|
||
"vont de 0 à 9. Il est possible de spécifier une valeur de début et/ou une "
|
||
"valeur d'incrément différente(s) (y compris négative pour cette dernière, "
|
||
"que l'on appelle également parfois le 'pas') ::"
|
||
|
||
#: tutorial/controlflow.rst:107
|
||
msgid ""
|
||
"To iterate over the indices of a sequence, you can combine :func:`range` "
|
||
"and :func:`len` as follows::"
|
||
msgstr ""
|
||
"Pour itérer sur les indices d'une séquence, on peut combiner les fonctions :"
|
||
"func:`range` et :func:`len` ::"
|
||
|
||
#: tutorial/controlflow.rst:120
|
||
msgid ""
|
||
"In most such cases, however, it is convenient to use the :func:`enumerate` "
|
||
"function, see :ref:`tut-loopidioms`."
|
||
msgstr ""
|
||
"Cependant, dans la plupart des cas, il est plus pratique d'utiliser la "
|
||
"fonction :func:`enumerate`. Voyez pour cela :ref:`tut-loopidioms`."
|
||
|
||
#: tutorial/controlflow.rst:127
|
||
msgid ""
|
||
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
|
||
"Clauses on Loops"
|
||
msgstr ""
|
||
"Les instructions :keyword:`break` et :keyword:`continue`, et les clauses :"
|
||
"keyword:`else` au sein des boucles"
|
||
|
||
#: tutorial/controlflow.rst:129
|
||
msgid ""
|
||
"The :keyword:`break` statement, like in C, breaks out of the smallest "
|
||
"enclosing :keyword:`for` or :keyword:`while` loop."
|
||
msgstr ""
|
||
"L'instruction :keyword:`break`, comme en C, interrompt la boucle :keyword:"
|
||
"`for` ou :keyword:`while` la plus imbriquée."
|
||
|
||
#: tutorial/controlflow.rst:132
|
||
msgid ""
|
||
"Loop statements may have an ``else`` clause; it is executed when the loop "
|
||
"terminates through exhaustion of the list (with :keyword:`for`) or when the "
|
||
"condition becomes false (with :keyword:`while`), but not when the loop is "
|
||
"terminated by a :keyword:`break` statement. This is exemplified by the "
|
||
"following loop, which searches for prime numbers::"
|
||
msgstr ""
|
||
"Les boucles peuvent également disposer d'une instruction ``else`` ; celle-ci "
|
||
"est exécutée lorsqu'une boucle se termine alors que tous ses éléments ont "
|
||
"été traités (dans le cas d'un :keyword:`for`) ou que la condition devient "
|
||
"fausse (dans le cas d'un :keyword:`while`), mais pas lorsque la boucle est "
|
||
"interrompue par une instruction :keyword:`break`. L'exemple suivant, qui "
|
||
"effectue une recherche de nombres premiers, en est une démonstration ::"
|
||
|
||
# c8cd94a1717f4d558d3e14aba3c8df90
|
||
#: tutorial/controlflow.rst:156
|
||
msgid ""
|
||
"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "
|
||
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
|
||
msgstr ""
|
||
"(Oui, ce code est correct. Regardez attentivement : l'instruction ``else`` "
|
||
"est rattachée à la boucle :keyword:`for`, et **non** à l'instruction :"
|
||
"keyword:`if`.)"
|
||
|
||
# 6d4b3d8e32a34b8a994523658f8824df
|
||
#: tutorial/controlflow.rst:159
|
||
msgid ""
|
||
"When used with a loop, the ``else`` clause has more in common with the "
|
||
"``else`` clause of a :keyword:`try` statement than it does that of :keyword:"
|
||
"`if` statements: a :keyword:`try` statement's ``else`` clause runs when no "
|
||
"exception occurs, and a loop's ``else`` clause runs when no ``break`` "
|
||
"occurs. For more on the :keyword:`try` statement and exceptions, see :ref:"
|
||
"`tut-handling`."
|
||
msgstr ""
|
||
"Lorsqu'elle utilisée dans une boucle, la clause ``else`` est donc plus "
|
||
"proche de celle associée à une instruction :keyword:`try` que de celle "
|
||
"associée à une instruction :keyword:`if` : la clause ``else`` d'une "
|
||
"instruction :keyword:`try` s'exécute lorsqu'aucune exception n'est "
|
||
"déclenchée, et celle d'une boucle lorsque aucun ``break`` n'intervient. Plus "
|
||
"plus d'informations sur l'instruction :keyword:`try` et le traitement des "
|
||
"exceptions, consultez :ref:`tut-handling`."
|
||
|
||
# 34627fe2528c4c689db6fab5cd77d971
|
||
#: tutorial/controlflow.rst:166
|
||
msgid ""
|
||
"The :keyword:`continue` statement, also borrowed from C, continues with the "
|
||
"next iteration of the loop::"
|
||
msgstr ""
|
||
"L'instruction :keyword:`continue`, également empruntée au C, fait passer la "
|
||
"boucle à son itération suivante ::"
|
||
|
||
#: tutorial/controlflow.rst:187
|
||
msgid ":keyword:`pass` Statements"
|
||
msgstr "L'instruction :keyword:`pass`"
|
||
|
||
#: tutorial/controlflow.rst:189
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:196
|
||
msgid "This is commonly used for creating minimal classes::"
|
||
msgstr ""
|
||
"On utilise couramment cette instruction pour créer des classes minimales ::"
|
||
|
||
#: tutorial/controlflow.rst:202
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:213
|
||
msgid "Defining Functions"
|
||
msgstr "Définir des fonctions"
|
||
|
||
#: tutorial/controlflow.rst:215
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:234
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:239
|
||
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 !"
|
||
|
||
#: tutorial/controlflow.rst:246
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:255
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:261
|
||
msgid ""
|
||
"A function definition introduces the function name in the current symbol "
|
||
"table. The value of the function name has a type that is recognized by the "
|
||
"interpreter as a user-defined function. This value can be assigned to "
|
||
"another name which can then also be used as a function. This serves as a "
|
||
"general renaming mechanism::"
|
||
msgstr ""
|
||
"Une définition de fonction introduit le nom de la fonction dans la table de "
|
||
"symboles courante. La valeur du nom de la fonction est un type qui est "
|
||
"reconnu par l'interpréteur comme une fonction utilisateur. Cette valeur peut "
|
||
"être affectée à un autre nom qui pourra alors être utilisé également comme "
|
||
"une fonction. Ceci fournit un mécanisme de renommage général ::"
|
||
|
||
# d0c90ca9530a40adbb720f8a235bd80d
|
||
#: tutorial/controlflow.rst:273
|
||
msgid ""
|
||
"Coming from other languages, you might object that ``fib`` is not a function "
|
||
"but a procedure since it doesn't return a value. In fact, even functions "
|
||
"without a :keyword:`return` statement do return a value, albeit a rather "
|
||
"boring one. This value is called ``None`` (it's a built-in name). Writing "
|
||
"the value ``None`` is normally suppressed by the interpreter if it would be "
|
||
"the only value written. You can see it if you really want to using :keyword:"
|
||
"`print`::"
|
||
msgstr ""
|
||
"Si vous venez d'autres langages, vous pouvez penser que ``fib`` n'est pas "
|
||
"une fonction mais une procédure, puisqu'elle ne renvoie pas de résultat. En "
|
||
"fait, même les fonctions sans instruction :keyword:`return` renvoient une "
|
||
"valeur, quoique ennuyeuse. Cette valeur est appelée ``None`` (c'est le nom "
|
||
"d'une primitive). Écrire la valeur ``None`` est normalement supprimé par "
|
||
"l'interpréteur lorsqu'il s'agit de la seule value écrite. Vous pouvez le "
|
||
"voir si vous y tenez vraiment en utilisant :keyword:`print` ::"
|
||
|
||
#: tutorial/controlflow.rst:284
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:300
|
||
msgid "This example, as usual, demonstrates some new Python features:"
|
||
msgstr ""
|
||
"Cet exemple, comme d'habitude, illustre de nouvelles fonctionnalités de "
|
||
"Python :"
|
||
|
||
#: tutorial/controlflow.rst:302
|
||
msgid ""
|
||
"The :keyword:`return` statement returns with a value from a function. :"
|
||
"keyword:`return` without an expression argument returns ``None``. Falling "
|
||
"off the end of a function also returns ``None``."
|
||
msgstr ""
|
||
"L'instruction :keyword:`return` provoque la sortie de la fonction en "
|
||
"renvoyant une valeur. :keyword:`return` sans expression en paramètre renvoie "
|
||
"``None``. Arriver à la fin d'une fonction sans instruction :keyword:`return` "
|
||
"renvoie également ``None``."
|
||
|
||
#: tutorial/controlflow.rst:306
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:321
|
||
msgid "More on Defining Functions"
|
||
msgstr "D'avantage sur la définition des fonctions"
|
||
|
||
#: tutorial/controlflow.rst:323
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:330
|
||
msgid "Default Argument Values"
|
||
msgstr "Valeur par défaut des arguments"
|
||
|
||
#: tutorial/controlflow.rst:332
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:348
|
||
msgid "This function can be called in several ways:"
|
||
msgstr "Cette fonction peut être appelée de plusieurs façons :"
|
||
|
||
#: tutorial/controlflow.rst:350
|
||
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 ?')``"
|
||
|
||
#: tutorial/controlflow.rst:352
|
||
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)``"
|
||
|
||
#: tutorial/controlflow.rst:354
|
||
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 !')``"
|
||
|
||
#: tutorial/controlflow.rst:357
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:360
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:371
|
||
msgid "will print ``5``."
|
||
msgstr "imprimera ``5``."
|
||
|
||
#: tutorial/controlflow.rst:373
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:386
|
||
msgid "This will print ::"
|
||
msgstr "Ceci imprimera ::"
|
||
|
||
#: tutorial/controlflow.rst:392
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:405
|
||
msgid "Keyword Arguments"
|
||
msgstr "Les arguments nommés"
|
||
|
||
# e2d74c8fda244844a959da21ed55e0ae
|
||
#: tutorial/controlflow.rst:407
|
||
msgid ""
|
||
"Functions can also be called using :term:`keyword arguments <keyword "
|
||
"argument>` of the form ``kwarg=value``. For instance, the following "
|
||
"function::"
|
||
msgstr ""
|
||
"Les fonctions peuvent également être appelées en utilisant des :term:"
|
||
"`arguments nommés <keyword argument>` sous la form ``kwarg=value``. Par "
|
||
"exemple, la fonction suivante ::"
|
||
|
||
# c811328e6e694919804103594d1803a0
|
||
#: tutorial/controlflow.rst:416
|
||
msgid ""
|
||
"accepts one required argument (``voltage``) and three optional arguments "
|
||
"(``state``, ``action``, and ``type``). This function can be called in any "
|
||
"of the following ways::"
|
||
msgstr ""
|
||
"accepte un argument obligatoire (``voltage``) et trois arguments facultatifs "
|
||
"(``state``, ``action`` et ``type``). Cette fonction peut être appelée de "
|
||
"n'importe laquelle des façons suivantes ::"
|
||
|
||
# 6437527f4e804c17878478bff4cab807
|
||
#: tutorial/controlflow.rst:427
|
||
msgid "but all the following calls would be invalid::"
|
||
msgstr "mais tous les appels qui suivent sont incorrects ::"
|
||
|
||
# 5665e42f479a44bcbf868c659ab8d3f0
|
||
#: tutorial/controlflow.rst:434
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:450
|
||
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 :"
|
||
|
||
#: tutorial/controlflow.rst:468
|
||
msgid "It could be called like this::"
|
||
msgstr "Elle pourrait être appelée comme ceci ::"
|
||
|
||
#: tutorial/controlflow.rst:476
|
||
msgid "and of course it would print::"
|
||
msgstr "et imprimera alors ::"
|
||
|
||
#: tutorial/controlflow.rst:487
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:494
|
||
msgid "Arbitrary Argument Lists"
|
||
msgstr "Listes d'arguments arbitraires"
|
||
|
||
#: tutorial/controlflow.rst:499
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:511
|
||
msgid "Unpacking Argument Lists"
|
||
msgstr "Séparation des listes d'arguments"
|
||
|
||
#: tutorial/controlflow.rst:513
|
||
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 ::"
|
||
|
||
#: tutorial/controlflow.rst:529
|
||
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 ``**`` ::"
|
||
|
||
#: tutorial/controlflow.rst:545
|
||
msgid "Lambda Expressions"
|
||
msgstr "Expressions lambda"
|
||
|
||
#: tutorial/controlflow.rst:547
|
||
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 ""
|
||
"Petites fonctions anonymes pouvant être construites via le mot clef :keyword:"
|
||
"`lambda`. 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 ::"
|
||
|
||
# 0a4906b6ec174baa951d833f5937c01b
|
||
#: tutorial/controlflow.rst:564
|
||
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::"
|
||
|
||
#: tutorial/controlflow.rst:576
|
||
msgid "Documentation Strings"
|
||
msgstr "Chaînes de documentation"
|
||
|
||
# 41dfd2967219444194cfcf734c8325c6
|
||
#: tutorial/controlflow.rst:583
|
||
msgid ""
|
||
"There are emerging conventions about the content and formatting of "
|
||
"documentation strings."
|
||
msgstr ""
|
||
"Il existe des conventions émergeantes concernant le contenu et le format des "
|
||
"chaînes de documentation."
|
||
|
||
#: tutorial/controlflow.rst:586
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:592
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:597
|
||
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)."
|
||
|
||
#: tutorial/controlflow.rst:609
|
||
msgid "Here is an example of a multi-line docstring::"
|
||
msgstr "Voici un exemple de chaîne de documentation multi-lignes ::"
|
||
|
||
#: tutorial/controlflow.rst:627
|
||
msgid "Intermezzo: Coding Style"
|
||
msgstr "Un style de codage : Intermezzo"
|
||
|
||
#: tutorial/controlflow.rst:632
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:638
|
||
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 :"
|
||
|
||
#: tutorial/controlflow.rst:643
|
||
msgid "Use 4-space indentation, and no tabs."
|
||
msgstr "Utilisez des indentations de 4 espaces, et pas de tabulation."
|
||
|
||
#: tutorial/controlflow.rst:645
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:649
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:651
|
||
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é."
|
||
|
||
#: tutorial/controlflow.rst:654
|
||
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."
|
||
|
||
#: tutorial/controlflow.rst:657
|
||
msgid "When possible, put comments on a line of their own."
|
||
msgstr ""
|
||
"Lorsque c'est possible, placez les commentaires sur leur propres lignes."
|
||
|
||
#: tutorial/controlflow.rst:659
|
||
msgid "Use docstrings."
|
||
msgstr "Utilisez les chaînes de documentation"
|
||
|
||
#: tutorial/controlflow.rst:661
|
||
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)``."
|
||
|
||
#: tutorial/controlflow.rst:664
|
||
msgid ""
|
||
"Name your classes and functions consistently; the convention is to use "
|
||
"``CamelCase`` for classes and ``lower_case_with_underscores`` for functions "
|
||
"and methods. Always use ``self`` as the name for the first method argument "
|
||
"(see :ref:`tut-firstclasses` for more on classes and methods)."
|
||
msgstr ""
|
||
"Nommez toujours vos classes et fonctions de la même manière ; la convention "
|
||
"est d'utiliser une notation ``CamelCase`` pour les classes, et "
|
||
"``minuscules_avec_trait_bas`` pour les fonctions et méthodes. Utilisez "
|
||
"toujours ``self`` comme nom du premier argument des méthodes (voyez :ref:"
|
||
"`tut-firstclasses` pour en savoir plus sur les classes et les méthodes)."
|
||
|
||
# 82cc90f14beb4e74801836b553a5595f
|
||
#: tutorial/controlflow.rst:669
|
||
msgid ""
|
||
"Don't use fancy encodings if your code is meant to be used in international "
|
||
"environments. Plain ASCII works best in any case."
|
||
msgstr ""
|
||
"N'utilisez pas d'encodages exotiques dès lors que votre code est sensé être "
|
||
"utilisé dans des environnements internationaux. L'ASCII est encore ce qui "
|
||
"marche le mieux dans la plupart des cas."
|
||
|
||
#: tutorial/controlflow.rst:675
|
||
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...)."
|
||
|
||
#: tutorial/datastructures.rst:5
|
||
msgid "Data Structures"
|
||
msgstr "Structures de données"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/datastructures.rst:14
|
||
msgid "More on Lists"
|
||
msgstr "Compléments sur les listes"
|
||
|
||
#: tutorial/datastructures.rst:16
|
||
msgid ""
|
||
"The list data type has some more methods. Here are all of the methods of "
|
||
"list objects:"
|
||
msgstr ""
|
||
"Le type liste dispose de méthodes supplémentaires. Voici la liste complète "
|
||
"des méthodes des objets de type liste :"
|
||
|
||
#: tutorial/datastructures.rst:23
|
||
msgid "Add an item to the end of the list; equivalent to ``a[len(a):] = [x]``."
|
||
msgstr ""
|
||
"Ajoute un élément à la fin de la liste ; équivalent à ``a[len(a):] = [x]``."
|
||
|
||
#: tutorial/datastructures.rst:29
|
||
msgid ""
|
||
"Extend the list by appending all the items in the given list; equivalent to "
|
||
"``a[len(a):] = L``."
|
||
msgstr ""
|
||
"Étend la liste en y ajoutant tous les éléments de la liste fournie ; "
|
||
"équivalent à ``a[len(a):] = L``."
|
||
|
||
#: tutorial/datastructures.rst:36
|
||
msgid ""
|
||
"Insert an item at a given position. The first argument is the index of the "
|
||
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
|
||
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
|
||
msgstr ""
|
||
"Insère un élément à la position indiquée. Le premier argument est la "
|
||
"position de l'élément courant avant lequel l'insertion doit s'effectuer, "
|
||
"donc ``a.insert(0, x)`` insère l'élément en tête de la liste, et ``a."
|
||
"insert(len(a), x)`` est équivalent à ``a.append(x)``."
|
||
|
||
#: tutorial/datastructures.rst:44
|
||
msgid ""
|
||
"Remove the first item from the list whose value is *x*. It is an error if "
|
||
"there is no such item."
|
||
msgstr ""
|
||
"Supprime de la liste le premier élément dont la valeur est *x*. Une "
|
||
"exception est levée s'il existe aucun élément avec cette valeur."
|
||
|
||
#: tutorial/datastructures.rst:51
|
||
msgid ""
|
||
"Remove the item at the given position in the list, and return it. If no "
|
||
"index is specified, ``a.pop()`` removes and returns the last item in the "
|
||
"list. (The square brackets around the *i* in the method signature denote "
|
||
"that the parameter is optional, not that you should type square brackets at "
|
||
"that position. You will see this notation frequently in the Python Library "
|
||
"Reference.)"
|
||
msgstr ""
|
||
"Enlève de la liste l'élément situé à la position indiquée, et le retourne. "
|
||
"Si aucune position n'est indiqué, ``a.pop()`` enlève et retourne le dernier "
|
||
"élément de la liste (les crochets autour du *i* dans la signature de la "
|
||
"méthode indiquent bien que ce paramètre est facultatif, et non que vous "
|
||
"devez placer des crochets dans votre code ! Vous retrouverez cette notation "
|
||
"fréquemment dans le Guide de Référence de la Bibliothèque Python)."
|
||
|
||
#: tutorial/datastructures.rst:61
|
||
msgid ""
|
||
"Return the index in the list of the first item whose value is *x*. It is an "
|
||
"error if there is no such item."
|
||
msgstr ""
|
||
"Retourne la position du premier élément de la liste ayant la valeur *x*. Une "
|
||
"exception est levée s'il n'existe aucun élément avec cette valeur."
|
||
|
||
#: tutorial/datastructures.rst:68
|
||
msgid "Return the number of times *x* appears in the list."
|
||
msgstr "Retourne le nombre d'éléments ayant la valeur *x* dans la liste."
|
||
|
||
# 6dc59ed94c2c47c3962f20b08b0eaf50
|
||
#: tutorial/datastructures.rst:74
|
||
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)."
|
||
|
||
#: tutorial/datastructures.rst:81
|
||
msgid "Reverse the elements of the list, in place."
|
||
msgstr "Inverse l'ordre des éléments de la liste, en place."
|
||
|
||
#: tutorial/datastructures.rst:83
|
||
msgid "An example that uses most of the list methods::"
|
||
msgstr "L'exemple suivant utilise la plupart des méthodes des listes ::"
|
||
|
||
# 9cff5f781f524707b2580a69eb21e165
|
||
#: tutorial/datastructures.rst:108
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:117
|
||
msgid "Using Lists as Stacks"
|
||
msgstr "Utiliser les listes comme des piles"
|
||
|
||
#: tutorial/datastructures.rst:122
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:147
|
||
msgid "Using Lists as Queues"
|
||
msgstr "Utiliser les listes comme des files"
|
||
|
||
#: tutorial/datastructures.rst:151
|
||
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)."
|
||
|
||
#: tutorial/datastructures.rst:157
|
||
msgid ""
|
||
"To implement a queue, use :class:`collections.deque` which was designed to "
|
||
"have fast appends and pops from both ends. For example::"
|
||
msgstr ""
|
||
"Pour implémenter une file, utilisez donc la classe :class:`collections."
|
||
"deque` qui a été conçue pour fournir des opérations d'ajouts et de retraits "
|
||
"rapides aux deux extrémités. Par exemple ::"
|
||
|
||
# f37a954339024319a4a38dcc87019274
|
||
#: tutorial/datastructures.rst:175
|
||
msgid "Functional Programming Tools"
|
||
msgstr "Outils de programmation fonctionnelle"
|
||
|
||
# 8ec920989c304fb3b1e7bc3ba16cc69d
|
||
#: tutorial/datastructures.rst:177
|
||
msgid ""
|
||
"There are three built-in functions that are very useful when used with "
|
||
"lists: :func:`filter`, :func:`map`, and :func:`reduce`."
|
||
msgstr ""
|
||
"Il existe trois fonctions primitives qui sont très utiles lorsqu'elles sont "
|
||
"utilisées avec des listes : :func:`filter`, :func:`map` et :func:`reduce`."
|
||
|
||
# bd57b7606e0443a0ab47c23c055f820e
|
||
#: tutorial/datastructures.rst:180
|
||
msgid ""
|
||
"``filter(function, sequence)`` returns a sequence consisting of those items "
|
||
"from the sequence for which ``function(item)`` is true. If *sequence* is a :"
|
||
"class:`str`, :class:`unicode` or :class:`tuple`, the result will be of the "
|
||
"same type; otherwise, it is always a :class:`list`. For example, to compute "
|
||
"a sequence of numbers divisible by 3 or 5::"
|
||
msgstr ""
|
||
"``filter(function, sequence)`` retourne une séquence composée des éléments "
|
||
"de la séquence initiale pour lesquels la fonction ``function(item)`` est "
|
||
"vraie. Si *sequence* est de type :class:`str`, :class:`unicode`, ou :class:"
|
||
"`tuple`, le résultat sera du même type ; sinon, il sera toujours de type :"
|
||
"class:`list`. Par exemple, pour construire une séquence de nombres "
|
||
"divisibles par 2 ou 5 ::"
|
||
|
||
# 5f5a7fc45a614c2891bf0573e3d5c5e9
|
||
#: tutorial/datastructures.rst:191
|
||
msgid ""
|
||
"``map(function, sequence)`` calls ``function(item)`` for each of the "
|
||
"sequence's items and returns a list of the return values. For example, to "
|
||
"compute some cubes::"
|
||
msgstr ""
|
||
"``map(function, sequence)`` appelle ``function(item)`` pour chaque élément "
|
||
"de la séquence et retourne une liste contenant l'ensemble des résultats. Par "
|
||
"exemple, pour calculer des cubes ::"
|
||
|
||
# c1de3d96a00b489784f899a7fc376b1f
|
||
#: tutorial/datastructures.rst:200
|
||
msgid ""
|
||
"More than one sequence may be passed; the function must then have as many "
|
||
"arguments as there are sequences and is called with the corresponding item "
|
||
"from each sequence (or ``None`` if some sequence is shorter than another). "
|
||
"For example::"
|
||
msgstr ""
|
||
"Plus d'une séquence peut être passée en paramètre ; dans ce cas, la fonction "
|
||
"doit avoir autant d'arguments qu'il y a de séquences, et elle sera appelée "
|
||
"avec l'élément correspondant de chaque séquence (ou ``None`` si certaines "
|
||
"séquences sont plus courtes que d'autres)."
|
||
|
||
# 8240028754784e7a84b5be66fa08f0ba
|
||
#: tutorial/datastructures.rst:211
|
||
msgid ""
|
||
"``reduce(function, sequence)`` returns a single value constructed by calling "
|
||
"the binary function *function* on the first two items of the sequence, then "
|
||
"on the result and the next item, and so on. For example, to compute the sum "
|
||
"of the numbers 1 through 10::"
|
||
msgstr ""
|
||
"``reduce(function, sequence)`` retourne une seule valeur construire en "
|
||
"appelant la fonction *function* avec comme paramètres les deux premiers "
|
||
"éléments de la séquence, puis le premier résultat et l'élément suivant, et "
|
||
"ainsi de suite. Par exemple, pour calculer la somme des nombres de 1 à 10 ::"
|
||
|
||
# cb31dca23a5d44aa970a94dab6c09da5
|
||
#: tutorial/datastructures.rst:221
|
||
msgid ""
|
||
"If there's only one item in the sequence, its value is returned; if the "
|
||
"sequence is empty, an exception is raised."
|
||
msgstr ""
|
||
"S'il n'y a qu'un seul élément dans la séquence, sa valeur est retournée ; si "
|
||
"la séquence est vide, une exception est levée."
|
||
|
||
# 67aeb633f3264986a2f5c0fad841946c
|
||
#: tutorial/datastructures.rst:224
|
||
msgid ""
|
||
"A third argument can be passed to indicate the starting value. In this case "
|
||
"the starting value is returned for an empty sequence, and the function is "
|
||
"first applied to the starting value and the first sequence item, then to the "
|
||
"result and the next item, and so on. For example, ::"
|
||
msgstr ""
|
||
"Un troisième paramètre peut être ajouté pour indiquer la valeur de départ. "
|
||
"Dans ce cas, cette valeur est retournée dans le cas d'une séquence vide ; "
|
||
"sinon, la fonction est d'abord appelée avec comme paramètres cette valeur de "
|
||
"départ et le premier élément de la séquence, puis ce premier résultat et "
|
||
"l'élément suivant, et ainsi de suite. Par exemple ::"
|
||
|
||
# 4c945638e9fd442d8f09748ac20cbc27
|
||
#: tutorial/datastructures.rst:238
|
||
msgid ""
|
||
"Don't use this example's definition of :func:`sum`: since summing numbers is "
|
||
"such a common need, a built-in function ``sum(sequence)`` is already "
|
||
"provided, and works exactly like this."
|
||
msgstr ""
|
||
"N'utilisez pas la fonction :func:`sum` fournie dans cet exemple. Effectuer "
|
||
"des sommes de nombres est un besoin tellement courant qu'il existe une "
|
||
"fonction native ``sum(sequence)`` qui fait exactement la même chose."
|
||
|
||
#: tutorial/datastructures.rst:245
|
||
msgid "List Comprehensions"
|
||
msgstr "Compréhensions de listes"
|
||
|
||
# bacb848669ad4fa9abb4a3d77791f4c2
|
||
#: tutorial/datastructures.rst:247
|
||
msgid ""
|
||
"List comprehensions provide a concise way to create lists. Common "
|
||
"applications are to make new lists where each element is the result of some "
|
||
"operations applied to each member of another sequence or iterable, or to "
|
||
"create a subsequence of those elements that satisfy a certain condition."
|
||
msgstr ""
|
||
"Les compréhensions de listes fournissent un moyen de construire des listes "
|
||
"de manière très concice. Une application classique est la construction de "
|
||
"nouvelles listes où chaque élément est le résultat d'une opération appliquée "
|
||
"à chaque élément d'une autre séquence, ou de créer une sous-séquence des "
|
||
"éléments satisfaisant une condition spécifique."
|
||
|
||
# 037f4e076d664f8389360ada349255eb
|
||
#: tutorial/datastructures.rst:252
|
||
msgid "For example, assume we want to create a list of squares, like::"
|
||
msgstr ""
|
||
"Par exemple, supposons que l'on veuille créer une liste de carrés, comme ::"
|
||
|
||
# f1ecaf420bcc491cb856a1f05ad37538
|
||
#: tutorial/datastructures.rst:261
|
||
msgid "We can obtain the same result with::"
|
||
msgstr "On peut obtenir le même résultat avec ::"
|
||
|
||
# d14333f8fdc241f09c158e509605a7f3
|
||
#: tutorial/datastructures.rst:265
|
||
msgid ""
|
||
"This is also equivalent to ``squares = map(lambda x: x**2, range(10))``, but "
|
||
"it's more concise and readable."
|
||
msgstr ""
|
||
"C'est également l'équivalent de ``squares = map(lambda x: x**2, "
|
||
"range(10))``, mais en plus concis et plus lisible."
|
||
|
||
# 3467ea01b37a4111a1dc155df11cf9f1
|
||
#: tutorial/datastructures.rst:268
|
||
msgid ""
|
||
"A list comprehension consists of brackets containing an expression followed "
|
||
"by a :keyword:`for` clause, then zero or more :keyword:`for` or :keyword:"
|
||
"`if` clauses. The result will be a new list resulting from evaluating the "
|
||
"expression in the context of the :keyword:`for` and :keyword:`if` clauses "
|
||
"which follow it. For example, this listcomp combines the elements of two "
|
||
"lists if they are not equal::"
|
||
msgstr ""
|
||
"Une compréhension de liste consiste en crochets contenant une expression "
|
||
"suivie par une clause :keyword:`for`, puis par zéro ou plus clauses :keyword:"
|
||
"`for` ou :keyword:`if`. Le résultat sera une nouvelle liste résultat de "
|
||
"l'évaluation de l'expression dans le contexte des clauses :keyword:`for` et :"
|
||
"keyword:`if` qui la suivent. Par exemple, cette compréhension de liste "
|
||
"combine les éléments de deux listes s'ils ne sont pas égaux ::"
|
||
|
||
# d67d99a05bc540d09311203640400abd
|
||
#: tutorial/datastructures.rst:278
|
||
msgid "and it's equivalent to:"
|
||
msgstr "et c'est équivaent à ::"
|
||
|
||
# c6f54fd8b04e497dbf2f03edaa0abc9e
|
||
#: tutorial/datastructures.rst:289
|
||
msgid ""
|
||
"Note how the order of the :keyword:`for` and :keyword:`if` statements is the "
|
||
"same in both these snippets."
|
||
msgstr ""
|
||
"Notez que l'ordre des instructions :keyword:`for` et :keyword:`if` est le "
|
||
"même dans ces différents extraits de code."
|
||
|
||
# d653b9fb2b45432d9e5e67ee70fbecd9
|
||
#: tutorial/datastructures.rst:292
|
||
msgid ""
|
||
"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "
|
||
"it must be parenthesized. ::"
|
||
msgstr ""
|
||
"Si l'expression est un tuple (c'est à dire ``(x, y)`` dans cet exemple), "
|
||
"elle doit être entourée par des parenthèses ::"
|
||
|
||
# 6519493b0333463c9e8d314fd4c1af4c
|
||
#: tutorial/datastructures.rst:323
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:331
|
||
msgid "Nested List Comprehensions"
|
||
msgstr "Compréhensions de listes imbriquées"
|
||
|
||
# 362a977414e741d3b6464df3bf5c11ce
|
||
#: tutorial/datastructures.rst:333
|
||
msgid ""
|
||
"The initial expression in a list comprehension can be any arbitrary "
|
||
"expression, including another list comprehension."
|
||
msgstr ""
|
||
"La première expression dans une compréhension de liste peut être n'importe "
|
||
"quelle expression, y compris une autre compréhension de liste."
|
||
|
||
# a88f2fa3f41144bfbd62a2693612ceb1
|
||
#: tutorial/datastructures.rst:336
|
||
msgid ""
|
||
"Consider the following example of a 3x4 matrix implemented as a list of 3 "
|
||
"lists of length 4::"
|
||
msgstr ""
|
||
"Voyez l'exemple suivant d'une matrice de 3x4, implémentée sous la forme de 3 "
|
||
"listes de 4 éléments ::"
|
||
|
||
# badd753c026841c9a79115aa2de84eab
|
||
#: tutorial/datastructures.rst:345
|
||
msgid "The following list comprehension will transpose rows and columns::"
|
||
msgstr ""
|
||
"Cette compréhension de liste va transposer les lignes et les colonnes ::"
|
||
|
||
# 5661198254ed47449d72c22038e9f2b9
|
||
#: tutorial/datastructures.rst:350
|
||
msgid ""
|
||
"As we saw in the previous section, the nested listcomp is evaluated in the "
|
||
"context of the :keyword:`for` that follows it, so this example is equivalent "
|
||
"to::"
|
||
msgstr ""
|
||
"Comme on l'a vu dans la section précédente, la compréhension de liste "
|
||
"imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui "
|
||
"la suit, donc cet exemple est équivalent à ::"
|
||
|
||
# 294e46c6a9bf43abbb25bdbab77ecfac
|
||
#: tutorial/datastructures.rst:361
|
||
msgid "which, in turn, is the same as::"
|
||
msgstr "lequel à son tour est équivalent à ::"
|
||
|
||
# 6eb39f5c7cee4c69bcdce5003c9dc1d9
|
||
#: tutorial/datastructures.rst:375
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:381
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:386
|
||
msgid "The :keyword:`del` statement"
|
||
msgstr "L'instruction :keyword:`del`"
|
||
|
||
#: tutorial/datastructures.rst:388
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:405
|
||
msgid ":keyword:`del` can also be used to delete entire variables::"
|
||
msgstr ""
|
||
":keyword:`del` peut aussi être utilisée pour supprimer des variables ::"
|
||
|
||
#: tutorial/datastructures.rst:409
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:416
|
||
msgid "Tuples and Sequences"
|
||
msgstr "Tuples et séquences"
|
||
|
||
#: tutorial/datastructures.rst:418
|
||
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*."
|
||
|
||
#: tutorial/datastructures.rst:424
|
||
msgid ""
|
||
"A tuple consists of a number of values separated by commas, for instance::"
|
||
msgstr ""
|
||
"Un tuple consiste en différentes valeurs séparées par des virgules, comme "
|
||
"par exemple ::"
|
||
|
||
# a5badcce7c75451982575cc784cb15da
|
||
#: tutorial/datastructures.rst:446
|
||
msgid ""
|
||
"As you see, on output tuples are always enclosed in parentheses, so that "
|
||
"nested tuples are interpreted correctly; they may be input with or without "
|
||
"surrounding parentheses, although often parentheses are necessary anyway (if "
|
||
"the tuple is part of a larger expression). It is not possible to assign to "
|
||
"the individual items of a tuple, however it is possible to create tuples "
|
||
"which contain mutable objects, such as lists."
|
||
msgstr ""
|
||
"Comme vous pouvez le voir, à l'affichage les tuples sont toujours encadrés "
|
||
"par des parenthèses, de façon à ce que des tuples imbriqués soient "
|
||
"interprétés correctement ; ils peuvent être entrés avec ou sans parenthèses, "
|
||
"même si celles-ci sont souvent nécessaires (notamment lorsqu'un tuple fait "
|
||
"partie d'une expression plus longue). Il n'est pas possible d'affecter de "
|
||
"valeur à un élément d'un tuple ; par contre, il est possible de créer des "
|
||
"tuples contenant des objets mutables, comme des listes."
|
||
|
||
# b6c3a9f8bf504d2383860d62b9823a5a
|
||
#: tutorial/datastructures.rst:453
|
||
msgid ""
|
||
"Though tuples may seem similar to lists, they are often used in different "
|
||
"situations and for different purposes. Tuples are :term:`immutable`, and "
|
||
"usually contain an heterogeneous sequence of elements that are accessed via "
|
||
"unpacking (see later in this section) or indexing (or even by attribute in "
|
||
"the case of :func:`namedtuples <collections.namedtuple>`). Lists are :term:"
|
||
"`mutable`, and their elements are usually homogeneous and are accessed by "
|
||
"iterating over the list."
|
||
msgstr ""
|
||
"Si les tuples peuvent sembler similaires aux listes, ils sont souvent "
|
||
"utilisés dans des cas différents et pour des raisons différentes. Les tuples "
|
||
"sont :term:`immuables <immuable>` et contiennent souvent des séquences "
|
||
"hétérogènes d'éléments qui sont accédés par \"déballage\" (voir plus loin) "
|
||
"ou indexation (ou même par attributs dans le cas des :func:`namedtuples "
|
||
"<collections.namedtuple>`). Les listes sont souvent :term:`mutables "
|
||
"<mutable>`, et contiennent des éléments homogènes qui sont accédés par "
|
||
"itération sur la liste."
|
||
|
||
#: tutorial/datastructures.rst:461
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:476
|
||
msgid ""
|
||
"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "
|
||
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
|
||
"together in a tuple. The reverse operation is also possible::"
|
||
msgstr ""
|
||
"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple d'un *emballage "
|
||
"de tuple* : les valeurs ``12345``, ``54321`` et ``hello !`` sont emballées "
|
||
"ensemble dans un tuple. L'opération inverse est aussi possible ::"
|
||
|
||
# bee7de83217d467eba7a079c65b7ad5d
|
||
#: tutorial/datastructures.rst:482
|
||
msgid ""
|
||
"This is called, appropriately enough, *sequence unpacking* and works for any "
|
||
"sequence on the right-hand side. Sequence unpacking requires the list of "
|
||
"variables on the left to have the same number of elements as the length of "
|
||
"the sequence. Note that multiple assignment is really just a combination of "
|
||
"tuple packing and sequence unpacking."
|
||
msgstr ""
|
||
"Ceci est appelé, de façon plus ou moins appropriée, un *déballage de "
|
||
"séquence* et fonctionne pour toute séquence placée à droite de l'expression. "
|
||
"Ce déballage requiert autant de variables dans la partie gauche qu'il y a "
|
||
"d'éléments dans la séquence. Notez également que cette affectation multiple "
|
||
"est juste une combinaison entre un emballage de tuple et un déballage de "
|
||
"séquence."
|
||
|
||
#: tutorial/datastructures.rst:492
|
||
msgid "Sets"
|
||
msgstr "Les ensembles"
|
||
|
||
#: tutorial/datastructures.rst:494
|
||
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."
|
||
|
||
# da01767b1479416bba017b6990483d52
|
||
#: tutorial/datastructures.rst:499
|
||
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()``."
|
||
|
||
#: tutorial/datastructures.rst:503
|
||
msgid "Here is a brief demonstration::"
|
||
msgstr "Voici une brève démonstration ::"
|
||
|
||
# a95edf151888454c84702a1853e2ab22
|
||
#: tutorial/datastructures.rst:529
|
||
msgid ""
|
||
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
|
||
"are also supported::"
|
||
msgstr ""
|
||
"Tout comme les :ref:`comprehensions de listes <tut-listcomps>`, il est "
|
||
"possibled'écrire des comprehensions d'ensembles ::"
|
||
|
||
#: tutorial/datastructures.rst:540
|
||
msgid "Dictionaries"
|
||
msgstr "Dictionnaires"
|
||
|
||
#: tutorial/datastructures.rst:542
|
||
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`."
|
||
|
||
#: tutorial/datastructures.rst:553
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:559
|
||
msgid ""
|
||
"The main operations on a dictionary are storing a value with some key and "
|
||
"extracting the value given the key. It is also possible to delete a key:"
|
||
"value pair with ``del``. If you store using a key that is already in use, "
|
||
"the old value associated with that key is forgotten. It is an error to "
|
||
"extract a value using a non-existent key."
|
||
msgstr ""
|
||
"Les principales opérations effectuées sur un dictionnaire consistent à "
|
||
"stocker une valeur pour une clé et à extraire la valeur correspondant à une "
|
||
"clé. Il est également possible de supprimer une paire clé:valeur avec "
|
||
"``del``. Si vous stockez une valeur pour une clé qui est déjà utilisée, "
|
||
"l'ancienne valeur associée à cette clé est perdue. Si vous tentez d'extraire "
|
||
"une valeur associée à une clé qui n'existe pas, une exception est levée."
|
||
|
||
# a554aa7680394a23a6e1b29ad07b5253
|
||
#: tutorial/datastructures.rst:565
|
||
msgid ""
|
||
"The :meth:`keys` method of a dictionary object returns a list of all the "
|
||
"keys used in the dictionary, in arbitrary order (if you want it sorted, just "
|
||
"apply the :func:`sorted` function to it). To check whether a single key is "
|
||
"in the dictionary, use the :keyword:`in` keyword."
|
||
msgstr ""
|
||
"La méthode :meth:`keys` d'un dictionnaire retourne une liste de toutes les "
|
||
"clés utilisées dans le dictionnaire, dans un ordre arbitraire (si vous "
|
||
"voulez qu'elle soit triée, appliquez-lui la fonction :func:`sorted`). Pour "
|
||
"tester si une clé est dans le dictionnaire, utilisez le mot-clé :keyword:"
|
||
"`in`."
|
||
|
||
#: tutorial/datastructures.rst:570
|
||
msgid "Here is a small example using a dictionary::"
|
||
msgstr "Voici un petit exemple utilisant un dictionnaire ::"
|
||
|
||
# da517bdab6f24e778cac08736d919390
|
||
#: tutorial/datastructures.rst:587
|
||
#, fuzzy
|
||
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. Lorsque "
|
||
"les paires forment un motif, des compréhensions de listes permettent de "
|
||
"fournir la liste des clés-valeurs sous une forme compacte ::"
|
||
|
||
# 098a1063baa44926bfd63f941681c98f
|
||
#: tutorial/datastructures.rst:593
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:599
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:609
|
||
msgid "Looping Techniques"
|
||
msgstr "Techniques de boucles"
|
||
|
||
#: tutorial/datastructures.rst:611
|
||
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`."
|
||
|
||
#: tutorial/datastructures.rst:621
|
||
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` ::"
|
||
|
||
#: tutorial/datastructures.rst:633
|
||
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` ::"
|
||
|
||
#: tutorial/datastructures.rst:645
|
||
msgid ""
|
||
"To loop over a sequence in sorted order, use the :func:`sorted` function "
|
||
"which returns a new sorted list while leaving the source unaltered. ::"
|
||
msgstr ""
|
||
"Pour faire une boucle sur une séquence triée, utilisez la fonction :func:"
|
||
"`sorted`, qui renvoie une nouvelle liste triée sans altérer la source ::"
|
||
|
||
# a1e578bf4b954f29a28fc5bb96bfe66a
|
||
#: tutorial/datastructures.rst:657
|
||
msgid ""
|
||
"When looping through dictionaries, the key and corresponding value can be "
|
||
"retrieved at the same time using the :meth:`iteritems` method. ::"
|
||
msgstr ""
|
||
"Lorsque vous faites une boucle sur un dictionnaire, les clés et leurs "
|
||
"valeurs peuvent être récupérées en même temps en utilisant la méthode :meth:"
|
||
"`iteritems` ::"
|
||
|
||
#: tutorial/datastructures.rst:667
|
||
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. ::"
|
||
|
||
#: tutorial/datastructures.rst:684
|
||
msgid "More on Conditions"
|
||
msgstr "Plus d'informations sur les conditions"
|
||
|
||
#: tutorial/datastructures.rst:686
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:689
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:695
|
||
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``."
|
||
|
||
#: tutorial/datastructures.rst:698
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:705
|
||
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é."
|
||
|
||
#: tutorial/datastructures.rst:712
|
||
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 ::"
|
||
|
||
#: tutorial/datastructures.rst:720
|
||
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."
|
||
|
||
#: tutorial/datastructures.rst:729
|
||
msgid "Comparing Sequences and Other Types"
|
||
msgstr "Comparer des séquences avec d'autres types"
|
||
|
||
# 41977cc17fef443ea5ee4eb2acbc42b4
|
||
#: tutorial/datastructures.rst:731
|
||
msgid ""
|
||
"Sequence objects may be compared to other objects with the same sequence "
|
||
"type. The comparison uses *lexicographical* ordering: first the first two "
|
||
"items are compared, and if they differ this determines the outcome of the "
|
||
"comparison; if they are equal, the next two items are compared, and so on, "
|
||
"until either sequence is exhausted. If two items to be compared are "
|
||
"themselves sequences of the same type, the lexicographical comparison is "
|
||
"carried out recursively. If all items of two sequences compare equal, the "
|
||
"sequences are considered equal. If one sequence is an initial sub-sequence "
|
||
"of the other, the shorter sequence is the smaller (lesser) one. "
|
||
"Lexicographical ordering for strings uses the ASCII ordering for individual "
|
||
"characters. Some examples of comparisons between sequences of the same "
|
||
"type::"
|
||
msgstr ""
|
||
"Des séquences peuvent être comparées avec d'autres séquences du même type. "
|
||
"La comparaison utilise un ordre *lexicographique* : les deux premiers "
|
||
"éléments de chaque séquence sont comparés, et s'ils diffèrent cela détermine "
|
||
"le résultat de la comparaison ; s'ils sont égaux, les deux éléments suivants "
|
||
"sont comparés à leur tour, et ainsi de suite jusqu'à ce que l'une des "
|
||
"séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des "
|
||
"séquences du même type, alors la comparaison lexicographique est effectuée "
|
||
"récursivement. Si tous les éléments des deux séquences sont égaux, les deux "
|
||
"séquences sont alors considérées comme égales. Si une séquence est une sous-"
|
||
"séquence de l'autre, la séquence la plus courte est celle dont la valeur est "
|
||
"inférieure. La comparaison lexicographique des chaînes de caractères utilise "
|
||
"l'ordre ASCII des caractères. Voici quelques exemples de comparaisons entre "
|
||
"séquences de même type ::"
|
||
|
||
# f6a8739089604c31b9a69729e466dbd3
|
||
#: tutorial/datastructures.rst:751
|
||
msgid ""
|
||
"Note that comparing objects of different types is legal. The outcome is "
|
||
"deterministic but arbitrary: the types are ordered by their name. Thus, a "
|
||
"list is always smaller than a string, a string is always smaller than a "
|
||
"tuple, etc. [#]_ Mixed numeric types are compared according to their numeric "
|
||
"value, so 0 equals 0.0, etc."
|
||
msgstr ""
|
||
"La comparaison d'objets de types différents est autorisée. Le résultat est "
|
||
"déterminé mais arbitraire : les types sont ordonnés par leur nom. Ainsi, une "
|
||
"liste (type ``list``) est toujours inférieure à une chaîne de caractères "
|
||
"(type ``str``), une chaîne de caractères toujours inférieure à un tuple... "
|
||
"[#]_ Des types numériques mélangés sont comparés en fonction de leur valeur "
|
||
"numérique, donc 0 est égal à 0.0, etc."
|
||
|
||
# 9443e810e7df404caf028d0caea7657d
|
||
#: tutorial/datastructures.rst:760
|
||
msgid ""
|
||
"The rules for comparing objects of different types should not be relied "
|
||
"upon; they may change in a future version of the language."
|
||
msgstr ""
|
||
"Les règles de comparaison d'objets de types différents ne doivent pas être "
|
||
"considérées comme fiables ; elles peuvent être amenées à changer dans une "
|
||
"future version du langage."
|
||
|
||
#: tutorial/errors.rst:5
|
||
msgid "Errors and Exceptions"
|
||
msgstr "Erreurs et exceptions"
|
||
|
||
#: 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*."
|
||
|
||
#: tutorial/errors.rst:15
|
||
msgid "Syntax Errors"
|
||
msgstr "Les erreurs de syntaxe"
|
||
|
||
#: tutorial/errors.rst:17
|
||
msgid ""
|
||
"Syntax errors, also known as parsing errors, are perhaps the most common "
|
||
"kind of complaint you get while you are still learning Python::"
|
||
msgstr ""
|
||
"Les erreurs de syntaxe, qui sont des erreurs d'analyse du code, sont peut-"
|
||
"être celles que vous rencontrez le plus souvent lorsque vous êtes encore en "
|
||
"phase d'apprentissage de Python ::"
|
||
|
||
# 137385ef98c047a296ca35d560a94016
|
||
#: tutorial/errors.rst:26
|
||
msgid ""
|
||
"The parser repeats the offending line and displays a little 'arrow' pointing "
|
||
"at the earliest point in the line where the error was detected. The error "
|
||
"is caused by (or at least detected at) the token *preceding* the arrow: in "
|
||
"the example, the error is detected at the keyword :keyword:`print`, since a "
|
||
"colon (``':'``) is missing before it. File name and line number are printed "
|
||
"so you know where to look in case the input came from a script."
|
||
msgstr ""
|
||
"L'analyseur répère la ligne incriminée et affiche une petite 'flèche' "
|
||
"pointant vers le premier endroit de la ligne où l'erreur a été détectée. "
|
||
"L'erreur est causée (ou, au moins, a été détectée comme telle) par le "
|
||
"symbole placé *avant* la flèche, ici car il manque deux points (``':'``) "
|
||
"avant lui. Le nom de fichier et le numéro de ligne sont affichés pour vous "
|
||
"permettre de localiser facilement l'erreur lorsque le code provient d'un "
|
||
"script."
|
||
|
||
#: tutorial/errors.rst:37
|
||
msgid "Exceptions"
|
||
msgstr "Les exceptions"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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)."
|
||
|
||
#: 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é."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/errors.rst:80
|
||
msgid "Handling Exceptions"
|
||
msgstr "Gestion des exceptions"
|
||
|
||
#: 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`."
|
||
|
||
#: tutorial/errors.rst:96
|
||
msgid "The :keyword:`try` statement works as follows."
|
||
msgstr "L'instruction :keyword:`try` fonctionne comme ceci."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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`."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/errors.rst:114
|
||
msgid ""
|
||
"A :keyword:`try` statement may have more than one except clause, to specify "
|
||
"handlers for different exceptions. At most one handler will be executed. "
|
||
"Handlers only handle exceptions that occur in the corresponding try clause, "
|
||
"not in other handlers of the same :keyword:`try` statement. An except "
|
||
"clause may name multiple exceptions as a parenthesized tuple, for example::"
|
||
msgstr ""
|
||
"Une instruction :keyword:`try` peut comporter plusieurs clauses except, pour "
|
||
"permettre la prise en charge de différentes exceptions. Mais un seul "
|
||
"gestionnaire, au plus, sera exécuté. Les gestionnaires ne prennent en charge "
|
||
"que les exceptions qui interviennent dans la clause try correspondante, pas "
|
||
"dans d'autres gestionnaires de la même instruction :keyword:`try`. Mais une "
|
||
"même clause except peut citer plusieurs exceptions sous la forme d'un tuple "
|
||
"entre parenthèses, comme dans cet exemple ::"
|
||
|
||
# 27502966a9b0494b8e62e5b731c29743
|
||
#: tutorial/errors.rst:123
|
||
msgid ""
|
||
"Note that the parentheses around this tuple are required, because ``except "
|
||
"ValueError, e:`` was the syntax used for what is normally written as "
|
||
"``except ValueError as e:`` in modern Python (described below). The old "
|
||
"syntax is still supported for backwards compatibility. This means ``except "
|
||
"RuntimeError, TypeError`` is not equivalent to ``except (RuntimeError, "
|
||
"TypeError):`` but to ``except RuntimeError as TypeError:`` which is not what "
|
||
"you want."
|
||
msgstr ""
|
||
"Notez que les parenthèses autour de ce tuple sont nécessaires, car ``except "
|
||
"ValueError, e:`` est la syntaxe utilisée pour ce qui s'écrit désormais "
|
||
"``except ValueError as e:`` dans les dernières versions de Python (comme "
|
||
"décrit ci-dessous). L'ancienne syntaxe est toujours supportée pour la "
|
||
"compatibilité ascendante. Ce qui signifie que ``except RuntimeError, "
|
||
"TypeError:`` n'est pas l'équivalent de ``except (RuntimeError, TypeError):`` "
|
||
"mais de ``except RuntimeError as TypeError:``, ce qui n'est pas ce que l'on "
|
||
"souhaite."
|
||
|
||
#: tutorial/errors.rst:131
|
||
msgid ""
|
||
"The last except clause may omit the exception name(s), to serve as a "
|
||
"wildcard. Use this with extreme caution, since it is easy to mask a real "
|
||
"programming error in this way! It can also be used to print an error "
|
||
"message and then re-raise the exception (allowing a caller to handle the "
|
||
"exception as well)::"
|
||
msgstr ""
|
||
"La dernière clause except peut omettre le(s) nom(s) d'exception(s), pour "
|
||
"servir de joker. C'est toutefois à utiliser avec beaucoup de précautions, "
|
||
"car il est très facile de masquer une vraie erreur de programmation par ce "
|
||
"biais. Elle peut aussi être utilisée pour afficher un message d'erreur avant "
|
||
"de re-lever l'exception (en permettant à un appelant de prendre également en "
|
||
"charge l'exception) ::"
|
||
|
||
#: tutorial/errors.rst:150
|
||
msgid ""
|
||
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
|
||
"clause*, which, when present, must follow all except clauses. It is useful "
|
||
"for code that must be executed if the try clause does not raise an "
|
||
"exception. For example::"
|
||
msgstr ""
|
||
"L'instruction :keyword:`try` ... :keyword:`except` a également une *clause "
|
||
"else* optionnelle qui, lorsqu'elle est présente, doit suivre toutes les "
|
||
"clauses except. Elle est utile pour du code qui doit être exécuté "
|
||
"lorsqu'aucune exception n'a été levée par la clause try. Par exemple ::"
|
||
|
||
#: tutorial/errors.rst:164
|
||
msgid ""
|
||
"The use of the :keyword:`else` clause is better than adding additional code "
|
||
"to the :keyword:`try` clause because it avoids accidentally catching an "
|
||
"exception that wasn't raised by the code being protected by the :keyword:"
|
||
"`try` ... :keyword:`except` statement."
|
||
msgstr ""
|
||
"Il vaut mieux utiliser la clause :keyword:`else`, plutôt que d'ajouter du "
|
||
"code à la clause :keyword:`try`, car cela évite de capturer accidentellement "
|
||
"une exception qui n'a pas été levée par le code initialement protégé par "
|
||
"l'instruction :keyword:`try` ... :keyword:`except`."
|
||
|
||
#: tutorial/errors.rst:169
|
||
msgid ""
|
||
"When an exception occurs, it may have an associated value, also known as the "
|
||
"exception's *argument*. The presence and type of the argument depend on the "
|
||
"exception type."
|
||
msgstr ""
|
||
"Quand une exception intervient, une valeur peut lui être associée, que l'on "
|
||
"appelle également *l'argument* de l'exception. La présence de cet argument "
|
||
"et son type dépendent du type de l'exception."
|
||
|
||
# 3855bca41cb3406db419bd42ce816d50
|
||
#: tutorial/errors.rst:173
|
||
msgid ""
|
||
"The except clause may specify a variable after the exception name (or "
|
||
"tuple). The variable is bound to an exception instance with the arguments "
|
||
"stored in ``instance.args``. For convenience, the exception instance "
|
||
"defines :meth:`__str__` so the arguments can be printed directly without "
|
||
"having to reference ``.args``."
|
||
msgstr ""
|
||
"La clause except peut spécifier un nom de variable après le nom de "
|
||
"l'exception (ou le tuple). Cette variable est liée à une instance "
|
||
"d'exception avec les arguments stockés dans ``instance.args``. Pour plus de "
|
||
"commodité, l'instance de l'exception définit la méthode :meth:`__str__` afin "
|
||
"que les arguments puissent être imprimés directement sans avoir à référencer "
|
||
"``.args``."
|
||
|
||
# 9bff2f04b9604cb88961036a1dd56433
|
||
#: tutorial/errors.rst:179
|
||
msgid ""
|
||
"One may also instantiate an exception first before raising it and add any "
|
||
"attributes to it as desired. ::"
|
||
msgstr ""
|
||
"On peut aussi instancier une exception et lui ajouter autant d'attributs que "
|
||
"nécessaire avant de la déclencher ::"
|
||
|
||
# 1f3feaf7ef4c4dc59fef2b8afae9b8a2
|
||
#: tutorial/errors.rst:198
|
||
msgid ""
|
||
"If an exception has an argument, it is printed as the last part ('detail') "
|
||
"of the message for unhandled exceptions."
|
||
msgstr ""
|
||
"Si une exception a un argument, il est imprimé dans la dernière partie "
|
||
"('detail') du message des exceptions non gérées."
|
||
|
||
#: tutorial/errors.rst:201
|
||
msgid ""
|
||
"Exception handlers don't just handle exceptions if they occur immediately in "
|
||
"the try clause, but also if they occur inside functions that are called "
|
||
"(even indirectly) in the try clause. For example::"
|
||
msgstr ""
|
||
"Les gestionnaires d'exceptions n'interceptent pas que les exceptions qui "
|
||
"sont levées immédiatement dans leur clause try, mais aussi celles qui sont "
|
||
"levées au sein de fonctions appelées (parfois indirectement) dans la clause "
|
||
"try. Par exemple ::"
|
||
|
||
#: tutorial/errors.rst:219
|
||
msgid "Raising Exceptions"
|
||
msgstr "Déclencher des exceptions"
|
||
|
||
#: tutorial/errors.rst:221
|
||
msgid ""
|
||
"The :keyword:`raise` statement allows the programmer to force a specified "
|
||
"exception to occur. For example::"
|
||
msgstr ""
|
||
"L'instruction :keyword:`raise` permet au programmeur de déclencher une "
|
||
"exception spécifique. Par exemple ::"
|
||
|
||
#: tutorial/errors.rst:229
|
||
msgid ""
|
||
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
|
||
"This must be either an exception instance or an exception class (a class "
|
||
"that derives from :class:`Exception`)."
|
||
msgstr ""
|
||
"Le seul argument à :keyword:`raise` indique l'exception à déclencher. Cela "
|
||
"peut être soit une instance d'exception, soit une classe d'exception (une "
|
||
"classe dérivée de :class:`Exception`)."
|
||
|
||
#: tutorial/errors.rst:233
|
||
msgid ""
|
||
"If you need to determine whether an exception was raised but don't intend to "
|
||
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
|
||
"raise the exception::"
|
||
msgstr ""
|
||
"Si vous devez savoir qu'une exception a été levée mais sans intention de la "
|
||
"prendre en charge, une forme plus simple de l'instruction :keyword:`raise` "
|
||
"permet de re-déclencher l'exception ::"
|
||
|
||
#: tutorial/errors.rst:252
|
||
msgid "User-defined Exceptions"
|
||
msgstr "Exceptions définies par l'utilisateur"
|
||
|
||
#: tutorial/errors.rst:254
|
||
msgid ""
|
||
"Programs may name their own exceptions by creating a new exception class "
|
||
"(see :ref:`tut-classes` for more about Python classes). Exceptions should "
|
||
"typically be derived from the :exc:`Exception` class, either directly or "
|
||
"indirectly. For example::"
|
||
msgstr ""
|
||
"Les programmes peuvent nommer leur propres exceptions en créant de nouvelles "
|
||
"classes (voir :ref:`tut-classes` à propos des classes Python). Ces "
|
||
"exceptions doivent typiquement être dérivées de la classe :exc:`Exception`, "
|
||
"directement ou indirectement. Par exemple ::"
|
||
|
||
#: tutorial/errors.rst:276
|
||
msgid ""
|
||
"In this example, the default :meth:`__init__` of :class:`Exception` has been "
|
||
"overridden. The new behavior simply creates the *value* attribute. This "
|
||
"replaces the default behavior of creating the *args* attribute."
|
||
msgstr ""
|
||
"Dans cet exemple, la méthode :meth:`__init__` de la classe :class:"
|
||
"`Exception` a été surchargée. Le nouveau comportement crée simplement "
|
||
"l'attribut *value*. Ceci remplace le comportement par défaut qui crée "
|
||
"l'attribut *args*."
|
||
|
||
#: tutorial/errors.rst:280
|
||
msgid ""
|
||
"Exception classes can be defined which do anything any other class can do, "
|
||
"but are usually kept simple, often only offering a number of attributes that "
|
||
"allow information about the error to be extracted by handlers for the "
|
||
"exception. When creating a module that can raise several distinct errors, a "
|
||
"common practice is to create a base class for exceptions defined by that "
|
||
"module, and subclass that to create specific exception classes for different "
|
||
"error conditions::"
|
||
msgstr ""
|
||
"Les classes d'exceptions peuvent être définies pour faire tout ce qu'une "
|
||
"autre classe peut faire. Mais elles sont le plus souvent assez simples, "
|
||
"n'offrant que les attributs permettant aux gestionnaires de ces exceptions "
|
||
"d'extraire les informations relatives à l'erreur qui s'est produite. Lorsque "
|
||
"l'on crée un module qui peut déclencher plusieurs types d'erreurs distincts, "
|
||
"une pratique courante est de créer une classe de base pour l'ensemble des "
|
||
"exceptions définies dans ce module, et de créer des sous-classes spécifiques "
|
||
"d'exceptions pour les différentes conditions d'erreurs ::"
|
||
|
||
#: tutorial/errors.rst:318
|
||
msgid ""
|
||
"Most exceptions are defined with names that end in \"Error,\" similar to the "
|
||
"naming of the standard exceptions."
|
||
msgstr ""
|
||
"La plupart des exceptions sont définies avec des noms qui se terminent par "
|
||
"\"Error\", comme pour les exceptions standards."
|
||
|
||
#: tutorial/errors.rst:321
|
||
msgid ""
|
||
"Many standard modules define their own exceptions to report errors that may "
|
||
"occur in functions they define. More information on classes is presented in "
|
||
"chapter :ref:`tut-classes`."
|
||
msgstr ""
|
||
"La plupart des modules standards définissent leurs propres exceptions pour "
|
||
"décrire les erreurs que l'on peut rencontrer dans les fonctions qu'ils "
|
||
"définissent. Plus d'informations sur les classes sont présentées dans le "
|
||
"chapitre :ref:`tut-classes`."
|
||
|
||
#: tutorial/errors.rst:329
|
||
msgid "Defining Clean-up Actions"
|
||
msgstr "Définition d'actions de nettoyage"
|
||
|
||
#: tutorial/errors.rst:331
|
||
msgid ""
|
||
"The :keyword:`try` statement has another optional clause which is intended "
|
||
"to define clean-up actions that must be executed under all circumstances. "
|
||
"For example::"
|
||
msgstr ""
|
||
"L'instruction :keyword:`try` a une autre clause optionnelle qui est destinée "
|
||
"à définir des actions de nettoyage devant être exécutées dans certaines "
|
||
"circonstances. Par exemple ::"
|
||
|
||
# c7f7bd06fdcb44f6af089f25280ca0e6
|
||
#: tutorial/errors.rst:345
|
||
msgid ""
|
||
"A *finally clause* is always executed before leaving the :keyword:`try` "
|
||
"statement, whether an exception has occurred or not. When an exception has "
|
||
"occurred in the :keyword:`try` clause and has not been handled by an :"
|
||
"keyword:`except` clause (or it has occurred in a :keyword:`except` or :"
|
||
"keyword:`else` clause), it is re-raised after the :keyword:`finally` clause "
|
||
"has been executed. The :keyword:`finally` clause is also executed \"on the "
|
||
"way out\" when any other clause of the :keyword:`try` statement is left via "
|
||
"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement. A "
|
||
"more complicated example (having :keyword:`except` and :keyword:`finally` "
|
||
"clauses in the same :keyword:`try` statement works as of Python 2.5)::"
|
||
msgstr ""
|
||
"Une *clause finally* est toujours exécutée avant de quitter l'instruction :"
|
||
"keyword:`try`, qu'une exception ait été déclenchée ou non. Quand une "
|
||
"exception a été déclenchée dans la clause :keyword:`try` et n'a pas été "
|
||
"prise en charge par une clause :keyword:`except` (ou si elle a été "
|
||
"déclenchée dans une clause :keyword:`except` ou :keyword:`else`), elle est "
|
||
"re-déclenchée après l'exécution de la clause :keyword:`finally`. La clause :"
|
||
"keyword:`finally` est également exécutée \"à la sortie\" quand n'importe "
|
||
"quelle autre clause de l'instruction :keyword:`try` est abandonnée par une "
|
||
"instruction :keyword:`break`, :keyword:`continue` ou :keyword:`return`. "
|
||
"Voici un exemple plus compliqué (l'utilisation de clauses :keyword:`except` "
|
||
"et :keyword:`finally` dans la même instruction :keyword:`try` nécessite au "
|
||
"moins Python 2.5) ::"
|
||
|
||
#: tutorial/errors.rst:379
|
||
msgid ""
|
||
"As you can see, the :keyword:`finally` clause is executed in any event. "
|
||
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
|
||
"keyword:`except` clause and therefore re-raised after the :keyword:`finally` "
|
||
"clause has been executed."
|
||
msgstr ""
|
||
"Comme vous pouvez le voir, la clause :keyword:`finally` est exécutée dans "
|
||
"tous les cas. L'exception de type :exc:`TypeError` déclenchée en divisant "
|
||
"deux chaînes de caractères n'est pas prise en charge par la clause :keyword:"
|
||
"`except` et est donc re-déclenchée après que la clause :keyword:`finally` "
|
||
"ait été exécutée."
|
||
|
||
#: tutorial/errors.rst:384
|
||
msgid ""
|
||
"In real world applications, the :keyword:`finally` clause is useful for "
|
||
"releasing external resources (such as files or network connections), "
|
||
"regardless of whether the use of the resource was successful."
|
||
msgstr ""
|
||
"Dans les vraies applicatons, la clause :keyword:`finally` est notamment "
|
||
"utile pour libérer des ressources externes (telles que des fichiers ou des "
|
||
"connections réseau), que l'utilisation de ces ressources ait réussi ou non."
|
||
|
||
#: tutorial/errors.rst:392
|
||
msgid "Predefined Clean-up Actions"
|
||
msgstr "Actions de nettoyage prédéfinies"
|
||
|
||
#: tutorial/errors.rst:394
|
||
msgid ""
|
||
"Some objects define standard clean-up actions to be undertaken when the "
|
||
"object is no longer needed, regardless of whether or not the operation using "
|
||
"the object succeeded or failed. Look at the following example, which tries "
|
||
"to open a file and print its contents to the screen. ::"
|
||
msgstr ""
|
||
"Certains objets définissent des actions de nettoyage standards qui doivent "
|
||
"être exécutées lorsque l'objet n'est plus nécessaire, indépendamment du fait "
|
||
"que l'opération ayant utilisé l'objet ait réussi ou non. Regardez l'exemple "
|
||
"suivant, qui tente d'ouvrir un fichier et d'afficher son contenu à l'écran ::"
|
||
|
||
# 3e128929b44e4ce8a471c6bfe6295a5d
|
||
#: tutorial/errors.rst:402
|
||
msgid ""
|
||
"The problem with this code is that it leaves the file open for an "
|
||
"indeterminate amount of time after the code has finished executing. This is "
|
||
"not an issue in simple scripts, but can be a problem for larger "
|
||
"applications. The :keyword:`with` statement allows objects like files to be "
|
||
"used in a way that ensures they are always cleaned up promptly and "
|
||
"correctly. ::"
|
||
msgstr ""
|
||
"Le problème avec ce code est qu'il laisse le fichier ouvert pendant une "
|
||
"durée indéterminée après que le code ait fini de s'exécuter. Ce n'est pas un "
|
||
"problème avec des scripts simples, mais peut l'être au sein d'applications "
|
||
"plus conséquentes. L'instruction :keyword:`with` permet d'utiliser certains "
|
||
"objets comme des fichiers d'une façon qui assure qu'ils seront toujours "
|
||
"nettoyés rapidement et correctement ::"
|
||
|
||
# fa61bd22ee7f41deb8a86ef987c0432e
|
||
#: tutorial/errors.rst:412
|
||
msgid ""
|
||
"After the statement is executed, the file *f* is always closed, even if a "
|
||
"problem was encountered while processing the lines. Other objects which "
|
||
"provide predefined clean-up actions will indicate this in their "
|
||
"documentation."
|
||
msgstr ""
|
||
"Dès que l'instruction est exécutée, le fichier *f* est toujours fermé, même "
|
||
"si un problème est intervenu pendant l'exécution de ces lignes. D'autres "
|
||
"objets qui fournissent des actions de nettoyage prédéfinies l'indiquent dans "
|
||
"leur documentation."
|
||
|
||
#: tutorial/floatingpoint.rst:5
|
||
msgid "Floating Point Arithmetic: Issues and Limitations"
|
||
msgstr "Arithmétique en Nombre à Virgule Flottante : Problèmes et Limites"
|
||
|
||
#: tutorial/floatingpoint.rst:10
|
||
msgid ""
|
||
"Floating-point numbers are represented in computer hardware as base 2 "
|
||
"(binary) fractions. For example, the decimal fraction ::"
|
||
msgstr ""
|
||
"Les nombres à virgule flottante sont représentés, au niveau matériel, en "
|
||
"fractions de nombres binaires (base 2). Par exemple, la fraction décimale ::"
|
||
|
||
#: tutorial/floatingpoint.rst:15
|
||
msgid ""
|
||
"has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
|
||
msgstr ""
|
||
"a la valeur 1/10 + 2/100 + 5/1000, et de la même manière, la fraction "
|
||
"binaire ::"
|
||
|
||
#: tutorial/floatingpoint.rst:19
|
||
msgid ""
|
||
"has value 0/2 + 0/4 + 1/8. These two fractions have identical values, the "
|
||
"only real difference being that the first is written in base 10 fractional "
|
||
"notation, and the second in base 2."
|
||
msgstr ""
|
||
"a la valeur 0/2 + 0/4 + 1/8. Ces deux fractions ont une valeur identique, la "
|
||
"seule différence est que la première est une fraction décimale, la seconde "
|
||
"binaire."
|
||
|
||
#: tutorial/floatingpoint.rst:23
|
||
msgid ""
|
||
"Unfortunately, most decimal fractions cannot be represented exactly as "
|
||
"binary fractions. A consequence is that, in general, the decimal floating-"
|
||
"point numbers you enter are only approximated by the binary floating-point "
|
||
"numbers actually stored in the machine."
|
||
msgstr ""
|
||
"Malheureusement, la plupart des fractions décimales n'ont pas de "
|
||
"représentation exacte en fractions binaires. Par conséquent, en général, les "
|
||
"nombres à virgule flottante que vous donnez sont seulement approximés en "
|
||
"fraction binaire pour être stocké dans la machine."
|
||
|
||
#: tutorial/floatingpoint.rst:28
|
||
msgid ""
|
||
"The problem is easier to understand at first in base 10. Consider the "
|
||
"fraction 1/3. You can approximate that as a base 10 fraction::"
|
||
msgstr ""
|
||
"Le problème est plus simple à aborder en base 10. Prenons par exemple, la "
|
||
"fraction 1/3. Vous pouvez l'approximer en une fraction décimale::"
|
||
|
||
#: tutorial/floatingpoint.rst:33 tutorial/floatingpoint.rst:37
|
||
msgid "or, better, ::"
|
||
msgstr "ou, mieux, ::"
|
||
|
||
#: tutorial/floatingpoint.rst:41
|
||
msgid ""
|
||
"and so on. No matter how many digits you're willing to write down, the "
|
||
"result will never be exactly 1/3, but will be an increasingly better "
|
||
"approximation of 1/3."
|
||
msgstr ""
|
||
"etc... Peu importe le nombre de décimales que vous écrirez, le résultat ne "
|
||
"sera jamais exactement 1/3, mais une estimation s'en approchant toujours "
|
||
"mieux."
|
||
|
||
#: tutorial/floatingpoint.rst:45
|
||
msgid ""
|
||
"In the same way, no matter how many base 2 digits you're willing to use, the "
|
||
"decimal value 0.1 cannot be represented exactly as a base 2 fraction. In "
|
||
"base 2, 1/10 is the infinitely repeating fraction ::"
|
||
msgstr ""
|
||
"De la même manière, peu importe combien de décimales en base 2 vous "
|
||
"utiliserez, la valeur décimale 0.1 ne peut être représentée exactement en "
|
||
"fraction binaire. En base 2, 1/10 est le nombre périodique suivant ::"
|
||
|
||
# 585f9afa498948edb520ddba73906b61
|
||
#: tutorial/floatingpoint.rst:51
|
||
msgid "Stop at any finite number of bits, and you get an approximation."
|
||
msgstr ""
|
||
"Arrêtez à n'importe quelle quantité finie de bits, et vous obtiendez une "
|
||
"approximation."
|
||
|
||
# a3e931a40eb6454aaf8258fe6dcc2c2a
|
||
#: tutorial/floatingpoint.rst:53
|
||
msgid ""
|
||
"On a typical machine running Python, there are 53 bits of precision "
|
||
"available for a Python float, so the value stored internally when you enter "
|
||
"the decimal number ``0.1`` is the binary fraction ::"
|
||
msgstr ""
|
||
"Pour Python, sur une machine typique, 53 bits sont utilisés pour la "
|
||
"précision d'un flottant, donc la valeur stockée lorsque vous entrez le "
|
||
"nombre décimal ``0.1`` est la fraction binaire ::"
|
||
|
||
# b19de5faee084120b720b24ac015d415
|
||
#: tutorial/floatingpoint.rst:59
|
||
msgid "which is close to, but not exactly equal to, 1/10."
|
||
msgstr "qui est proche, mais pas exactement égale, à 1/10."
|
||
|
||
# 8933cbcb05124de785ee6c7fe3365adb
|
||
#: tutorial/floatingpoint.rst:61
|
||
msgid ""
|
||
"It's easy to forget that the stored value is an approximation to the "
|
||
"original decimal fraction, because of the way that floats are displayed at "
|
||
"the interpreter prompt. Python only prints a decimal approximation to the "
|
||
"true decimal value of the binary approximation stored by the machine. If "
|
||
"Python were to print the true decimal value of the binary approximation "
|
||
"stored for 0.1, it would have to display ::"
|
||
msgstr ""
|
||
"Il est facile d'oublier que la valeur stockée est une approximation de la "
|
||
"fraction décimale d'origine, du fait de la manière dont les flottants sont "
|
||
"affichés dans l'interpréteur. Python n'affiche qu'une approximation décimale "
|
||
"de la valeur stockée en binaire. Si Python devait afficher la vraie valeur "
|
||
"décimale de l'approximation binaire stockée pour 0.1, il afficherait ::"
|
||
|
||
#: tutorial/floatingpoint.rst:71
|
||
msgid ""
|
||
"That is more digits than most people find useful, so Python keeps the number "
|
||
"of digits manageable by displaying a rounded value instead ::"
|
||
msgstr ""
|
||
"C'est bien plus de décimales que nécessaire, donc Python affiche une valeur "
|
||
"arrondie afin d'améliorer la lisibilité ::"
|
||
|
||
# 5e4f51ce66ca42769953b535fc42cc18
|
||
#: tutorial/floatingpoint.rst:77
|
||
msgid ""
|
||
"It's important to realize that this is, in a real sense, an illusion: the "
|
||
"value in the machine is not exactly 1/10, you're simply rounding the "
|
||
"*display* of the true machine value. This fact becomes apparent as soon as "
|
||
"you try to do arithmetic with these values ::"
|
||
msgstr ""
|
||
"Il est important de comprendre qu'en réalité, c'est une illusion : la valeur "
|
||
"stockée n'est pas exactement 1/10, c'est simplement à *l'affichage* que la "
|
||
"valeur stockée est arrondie. Ceci devient évident dès que vous effectuez des "
|
||
"opérations arithmétiques avec ces valeurs ::"
|
||
|
||
#: tutorial/floatingpoint.rst:85
|
||
msgid ""
|
||
"Note that this is in the very nature of binary floating-point: this is not a "
|
||
"bug in Python, and it is not a bug in your code either. You'll see the same "
|
||
"kind of thing in all languages that support your hardware's floating-point "
|
||
"arithmetic (although some languages may not *display* the difference by "
|
||
"default, or in all output modes)."
|
||
msgstr ""
|
||
"Ce comportement est inhérent au comportement des nombres à virgule "
|
||
"flottante : ce n'est pas un bug dans Python, et ce n'est pas non plus un bug "
|
||
"dans votre code. Vous verrez le même type de comportement dans tous les "
|
||
"autres langages utilisant le support matériel pour le calcul des nombres à "
|
||
"virgules flottante (bien que certains langages ne rendent pas visible la "
|
||
"différence par défaut, ou pas dans tous les modes d'affichage)."
|
||
|
||
# e5c2f7d498224bb3b5219ca6b49574e9
|
||
#: tutorial/floatingpoint.rst:91
|
||
msgid ""
|
||
"Other surprises follow from this one. For example, if you try to round the "
|
||
"value 2.675 to two decimal places, you get this ::"
|
||
msgstr ""
|
||
"Une autre surprise est inhérente à celle-ci. Par exemple, si vous tentez "
|
||
"d'arrondir la valeur 2.675 à deux décimales, vous obtiendrez ::"
|
||
|
||
# b6492664b1a14c72aa3e3152d4802419
|
||
#: tutorial/floatingpoint.rst:97
|
||
msgid ""
|
||
"The documentation for the built-in :func:`round` function says that it "
|
||
"rounds to the nearest value, rounding ties away from zero. Since the "
|
||
"decimal fraction 2.675 is exactly halfway between 2.67 and 2.68, you might "
|
||
"expect the result here to be (a binary approximation to) 2.68. It's not, "
|
||
"because when the decimal string ``2.675`` is converted to a binary floating-"
|
||
"point number, it's again replaced with a binary approximation, whose exact "
|
||
"value is ::"
|
||
msgstr ""
|
||
"La documentation de la primitive :func:`round` indique qu'elle arrondit à la "
|
||
"valeur la plus proche en s'éloignant de zéro. Puisque la fraction décimale "
|
||
"est exactement à mi-chemin entre 2.67 et 2.68, vous devriez vous attendre à "
|
||
"obtenir (une approximation binaire de) 2.68. Ce n'est pourtant pas le cas, "
|
||
"car lorsque la fraction décimale ``2.675`` est convertie en flottant, elle "
|
||
"est stockée par une approximation dont la valeur exacte est ::"
|
||
|
||
# b6ad3e1f39374a2492515e10f77134d6
|
||
#: tutorial/floatingpoint.rst:106
|
||
msgid ""
|
||
"Since this approximation is slightly closer to 2.67 than to 2.68, it's "
|
||
"rounded down."
|
||
msgstr ""
|
||
"Puisque l'approximation est légèrement plus proche de 2.67 que 2.68, "
|
||
"l'arrondi se fait vers le bas."
|
||
|
||
# 3683a07c343348568f95d1964fd2a7b7
|
||
#: tutorial/floatingpoint.rst:109
|
||
msgid ""
|
||
"If you're in a situation where you care which way your decimal halfway-cases "
|
||
"are rounded, you should consider using the :mod:`decimal` module. "
|
||
"Incidentally, the :mod:`decimal` module also provides a nice way to \"see\" "
|
||
"the exact value that's stored in any particular Python float ::"
|
||
msgstr ""
|
||
"Si vous êtes dans une situation où les arrondis de nombres décimaux à mi-"
|
||
"chemin ont de l'importance, vous devriez utiliser le module :mod:`decimal`. "
|
||
"Soit dit en passant, le module :mod:`decimal` propose aussi un moyen "
|
||
"pratique de \"voir\" la valeur exacte stockée pour n'importe quel flottant."
|
||
|
||
# 41ea13ad53d44bb28b904415c1ea2417
|
||
#: tutorial/floatingpoint.rst:118
|
||
msgid ""
|
||
"Another consequence is that since 0.1 is not exactly 1/10, summing ten "
|
||
"values of 0.1 may not yield exactly 1.0, either::"
|
||
msgstr ""
|
||
"Une autre conséquence du fait que 0.1 n'est pas exactement stocké 1/10 est "
|
||
"que la somme de dix valeurs de 0.1 ne donne pas 1.0 non plus ::"
|
||
|
||
#: tutorial/floatingpoint.rst:128
|
||
msgid ""
|
||
"Binary floating-point arithmetic holds many surprises like this. The "
|
||
"problem with \"0.1\" is explained in precise detail below, in the "
|
||
"\"Representation Error\" section. See `The Perils of Floating Point <http://"
|
||
"www.lahey.com/float.htm>`_ for a more complete account of other common "
|
||
"surprises."
|
||
msgstr ""
|
||
"L'arithmétique des nombres binaires à virgule flottante réserve beaucoup de "
|
||
"surprises de ce genre. Le problème avec \"0.1\" est expliqué en détails ci-"
|
||
"desous, dans la section \"Représentation d'Erreur\". Voir `The Perils of "
|
||
"Floating Point <http://www.lahey.com/float.htm>`_ pour une liste plus "
|
||
"complète de ce genre de surprises."
|
||
|
||
# 87e3aaf0e7e2477fb17072c49a0e5058
|
||
#: tutorial/floatingpoint.rst:133
|
||
msgid ""
|
||
"As that says near the end, \"there are no easy answers.\" Still, don't be "
|
||
"unduly wary of floating-point! The errors in Python float operations are "
|
||
"inherited from the floating-point hardware, and on most machines are on the "
|
||
"order of no more than 1 part in 2\\*\\*53 per operation. That's more than "
|
||
"adequate for most tasks, but you do need to keep in mind that it's not "
|
||
"decimal arithmetic, and that every float operation can suffer a new rounding "
|
||
"error."
|
||
msgstr ""
|
||
"Il est vrai qu'il n'existe pas de réponse simple, cependant ne vous méfiez "
|
||
"pas trop des nombres à virtule flottante ! Les erreurs, en Python, dans les "
|
||
"opérations de nombres à virgule flottante sont dues au matériel sous-jacent, "
|
||
"et sur la plupart des machines ne sont pas plus importantes que 1 sur 2\\*"
|
||
"\\*53 par opération. C'est plus que nécessaire pour la plupart des tâches, "
|
||
"mais vous devez garder à l'esprit que ce ne sont pas des opérations "
|
||
"décimales, et que chaque opération sur des nombres à virgule flottante peut "
|
||
"souffrir d'une nouvelle erreur."
|
||
|
||
# 0d5b6ba08bee41ae81e33306aca23343
|
||
#: tutorial/floatingpoint.rst:140
|
||
msgid ""
|
||
"While pathological cases do exist, for most casual use of floating-point "
|
||
"arithmetic you'll see the result you expect in the end if you simply round "
|
||
"the display of your final results to the number of decimal digits you "
|
||
"expect. For fine control over how a float is displayed see the :meth:`str."
|
||
"format` method's format specifiers in :ref:`formatstrings`."
|
||
msgstr ""
|
||
"Bien que des cas pathologiques existent, pour la plupart des cas "
|
||
"d'utilisations courants vous obtiendrez le résultat attendu à la fin en "
|
||
"arrondissant simplement au nombre de décimales désirées à l'affichage. Pour "
|
||
"un contrôle fin sur la manière dont les flottants sont affichés, consultez "
|
||
"dans :ref:`formatstrings` les spécifications de formattage de la méthode :"
|
||
"meth:`str.format`"
|
||
|
||
#: tutorial/floatingpoint.rst:150
|
||
msgid "Representation Error"
|
||
msgstr "Erreurs de représentation"
|
||
|
||
#: tutorial/floatingpoint.rst:152
|
||
msgid ""
|
||
"This section explains the \"0.1\" example in detail, and shows how you can "
|
||
"perform an exact analysis of cases like this yourself. Basic familiarity "
|
||
"with binary floating-point representation is assumed."
|
||
msgstr ""
|
||
"Cette section explique en détail l'exemple du \"0.1\", et montre comment "
|
||
"vous pouvez effectuer une analyse exacte de ce type de cas par vous-même. Il "
|
||
"est supposé que vous êtes déjà familier de la représentation binaire des "
|
||
"nombres flottants."
|
||
|
||
# e9ea0a68b7bf4ca098eb417f0ed61ccb
|
||
#: tutorial/floatingpoint.rst:156
|
||
msgid ""
|
||
":dfn:`Representation error` refers to the fact that some (most, actually) "
|
||
"decimal fractions cannot be represented exactly as binary (base 2) "
|
||
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
|
||
"Fortran, and many others) often won't display the exact decimal number you "
|
||
"expect::"
|
||
msgstr ""
|
||
"Le terme :dfn:`Representation error` signifie que la plupart des fractions "
|
||
"décimales ne peuvent être représentées exactement en binaire. C'est la "
|
||
"principale raison pour laquelle Python (ou Perl, C, C++, Java, Fortran, et "
|
||
"beuacoup d'autres) n'affiche habituellement pas le résultat exact en "
|
||
"décimal::"
|
||
|
||
# be0b2bc761654882a6612a05f3ceb463
|
||
#: tutorial/floatingpoint.rst:164
|
||
msgid ""
|
||
"Why is that? 1/10 and 2/10 are not exactly representable as a binary "
|
||
"fraction. Almost all machines today (July 2010) use IEEE-754 floating point "
|
||
"arithmetic, and almost all platforms map Python floats to IEEE-754 \"double "
|
||
"precision\". 754 doubles contain 53 bits of precision, so on input the "
|
||
"computer strives to convert 0.1 to the closest fraction it can of the form "
|
||
"*J*/2**\\ *N* where *J* is an integer containing exactly 53 bits. "
|
||
"Rewriting ::"
|
||
msgstr ""
|
||
"Pourquoi ? 1/10 et 2/10 ne sont pas représentable de manière exacte en "
|
||
"fractions binaires. Cependant, toutes les machines d'aujourd'hui (Juillet "
|
||
"2010) suivent la norme IEEE-754 en ce qui concerne l'arithmétique des "
|
||
"nombres à virgule flottante. et la plupart des plateformes utilisent un "
|
||
"\"IEEE-754 double precision\" pour représenter les floats de Python. Les "
|
||
"\"IEEE-754 double precision\" utilisent 53 bits de précision, donc a la "
|
||
"lecture l'ordinateur essaie de convertir 0.1 dans la fraction la plus proche "
|
||
"possible de la forme *J*/2**\\ *N* avec *J* un nombre entier d'exactement 53 "
|
||
"bits. Réecrire ::"
|
||
|
||
#: tutorial/floatingpoint.rst:173
|
||
msgid "as ::"
|
||
msgstr "en ::"
|
||
|
||
#: tutorial/floatingpoint.rst:177
|
||
msgid ""
|
||
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
|
||
"2**53``), the best value for *N* is 56::"
|
||
msgstr ""
|
||
"en se rappelant que *J* fait exactement 53 bits (donc ``>= 2**52`` mais ``< "
|
||
"2**53``), la meilleur valeur possible pour *N* est 56::"
|
||
|
||
# 2e98f1c2739a481cbe0243853a3217af
|
||
#: tutorial/floatingpoint.rst:187
|
||
msgid ""
|
||
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits. "
|
||
"The best possible value for *J* is then that quotient rounded::"
|
||
msgstr ""
|
||
"Donc 56 est la seule valeur possible pour *N* qui laisse exactement 53 bits "
|
||
"pour *J*. La meilleure valeur possible pour *J* est donc ce quotient, "
|
||
"arrondi::"
|
||
|
||
#: tutorial/floatingpoint.rst:194
|
||
msgid ""
|
||
"Since the remainder is more than half of 10, the best approximation is "
|
||
"obtained by rounding up::"
|
||
msgstr ""
|
||
"Puisque la retenue est plus grande que la moitié de 10, la meilleure "
|
||
"approximation est obtenue en arrondissant par le haut:"
|
||
|
||
# 2e0305eb55864b539f378f91726a0131
|
||
#: tutorial/floatingpoint.rst:200
|
||
msgid ""
|
||
"Therefore the best possible approximation to 1/10 in 754 double precision is "
|
||
"that over 2\\*\\*56, or ::"
|
||
msgstr ""
|
||
"Par conséquent la meilleure approximation possible pour 1/10 en \"IEEE-754 "
|
||
"double precision\" est cette au desus de 2\\*\\*56, soit ::"
|
||
|
||
#: tutorial/floatingpoint.rst:205
|
||
msgid ""
|
||
"Note that since we rounded up, this is actually a little bit larger than "
|
||
"1/10; if we had not rounded up, the quotient would have been a little bit "
|
||
"smaller than 1/10. But in no case can it be *exactly* 1/10!"
|
||
msgstr ""
|
||
"Notez que puisque l'arrondi a été fait vers le haut, le résultat est en "
|
||
"réalité légèrement plus grand que 1/10; si nous n'avions pas arrondi par le "
|
||
"haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun "
|
||
"cas il ne vaut *exactement* 1/10 !"
|
||
|
||
#: tutorial/floatingpoint.rst:209
|
||
msgid ""
|
||
"So the computer never \"sees\" 1/10: what it sees is the exact fraction "
|
||
"given above, the best 754 double approximation it can get::"
|
||
msgstr ""
|
||
"Donc l'ordinateur ne \"voit\" jamais 1/10: ce qu'il voit est la fraction "
|
||
"exacte donnée ci-dessus, la meilleure approximation utilisant les nombres à "
|
||
"virgule flottante double précision de l'\"IEEE-754\""
|
||
|
||
# 387b544ab4cc483783898ef3a17eb2ff
|
||
#: tutorial/floatingpoint.rst:215
|
||
msgid ""
|
||
"If we multiply that fraction by 10\\*\\*30, we can see the (truncated) value "
|
||
"of its 30 most significant decimal digits::"
|
||
msgstr ""
|
||
"Si on multiplie cette fraction par 10\\*\\*30, on peut observer les valeurs "
|
||
"de ses 30 décimales de poid fort."
|
||
|
||
# 956b2754e34c462ab54d636a54cbbda9
|
||
#: tutorial/floatingpoint.rst:221
|
||
msgid ""
|
||
"meaning that the exact number stored in the computer is approximately equal "
|
||
"to the decimal value 0.100000000000000005551115123125. In versions prior to "
|
||
"Python 2.7 and Python 3.1, Python rounded this value to 17 significant "
|
||
"digits, giving '0.10000000000000001'. In current versions, Python displays "
|
||
"a value based on the shortest decimal fraction that rounds correctly back to "
|
||
"the true binary value, resulting simply in '0.1'."
|
||
msgstr ""
|
||
"signifiant que la valeur exacte stockée dans l'ordinateur est "
|
||
"approximativement évale à la valeur décimale "
|
||
"0.100000000000000005551115123125. Dans les versions antérieurs à Python 2.7 "
|
||
"et Python 3.1, Python arrondissait ces valeurs à 17 décimales "
|
||
"significatives, affichant '0.10000000000000001'. Dans les versions actuelles "
|
||
"de Python, la valeur affichée est la valeur dont la fraction est la plus "
|
||
"courte possible tout en redonnant exactement la même représentation une fois "
|
||
"reconverti en binaire, affichant simplement '0.1'."
|
||
|
||
#: tutorial/index.rst:5
|
||
msgid "The Python Tutorial"
|
||
msgstr "Le tutoriel python"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/index.rst:13
|
||
#, fuzzy
|
||
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."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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."
|
||
|
||
#: 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`."
|
||
|
||
#: tutorial/index.rst:40
|
||
msgid "The :ref:`glossary` is also worth going through."
|
||
msgstr "Pensez aussi à consulter le :ref:`glossary`."
|
||
|
||
#: tutorial/inputoutput.rst:5
|
||
msgid "Input and Output"
|
||
msgstr "Les entrées/sorties"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/inputoutput.rst:15
|
||
msgid "Fancier Output Formatting"
|
||
msgstr "Formatage de données"
|
||
|
||
# 3028974fd106477a98b3edd53c6e934c
|
||
#: tutorial/inputoutput.rst:17
|
||
msgid ""
|
||
"So far we've encountered two ways of writing values: *expression statements* "
|
||
"and the :keyword:`print` statement. (A third way is using the :meth:`write` "
|
||
"method of file objects; the standard output file can be referenced as ``sys."
|
||
"stdout``. See the Library Reference for more information on this.)"
|
||
msgstr ""
|
||
"Jusque là, nous avons rencontré deux moyens d'écrire des données : les "
|
||
"*déclarations d'expressions* et l'instruction :keyword:`print`. (Une "
|
||
"troisième méthode consiste à utiliser la méthode :meth:`write` des "
|
||
"fichiers ; le fichier de sortie standard peut être référence en tant que "
|
||
"``sys.stdout``. Voyez le Guide de Référence de la Bibliothèque Standard pour "
|
||
"en savoir plus.)"
|
||
|
||
# 4f0a1c8e63414433ad1247d6a3397a54
|
||
#: tutorial/inputoutput.rst:22
|
||
msgid ""
|
||
"Often you'll want more control over the formatting of your output than "
|
||
"simply printing space-separated values. There are two ways to format your "
|
||
"output; the first way is to do all the string handling yourself; using "
|
||
"string slicing and concatenation operations you can create any layout you "
|
||
"can imagine. The string types have some methods that perform useful "
|
||
"operations for padding strings to a given column width; these will be "
|
||
"discussed shortly. The second way is to use the :meth:`str.format` method."
|
||
msgstr ""
|
||
"Mais vous voudrez souvent avoir plus de contrôle sur le formatage de vos "
|
||
"sorties que de simplement imprimer des valeurs séparées par des espaces. Il "
|
||
"y a deux méthodes pour formater ces sorties ; la première est de gérer les "
|
||
"chaînes de caractères par vous même ; en utilisant des tranches sur vos "
|
||
"chaînes et des opérations de concaténation, vous pouvez créer n'importe "
|
||
"quelle présentation imaginable. Mais les chaînes de caractères disposent "
|
||
"également de méthodes qui facilitent, par exemple, les alignements de "
|
||
"chaînes de caractères selon une certaines largeur de colonne, et qui seront "
|
||
"présentées rapidement. La seconde méthode consiste à utiliser la méthode :"
|
||
"meth:`format`."
|
||
|
||
# ca5251e779794352a357fb6d45e792c4
|
||
#: tutorial/inputoutput.rst:30
|
||
msgid ""
|
||
"The :mod:`string` module contains a :class:`~string.Template` class which "
|
||
"offers yet another way to substitute values into strings."
|
||
msgstr ""
|
||
"Le module :mod:`string` contient une classe :class:`~string.Template` qui "
|
||
"offre encore une autre façon de remplacer des valeurs au sein de chaînes de "
|
||
"caractères."
|
||
|
||
#: tutorial/inputoutput.rst:33
|
||
msgid ""
|
||
"One question remains, of course: how do you convert values to strings? "
|
||
"Luckily, Python has ways to convert any value to a string: pass it to the :"
|
||
"func:`repr` or :func:`str` functions."
|
||
msgstr ""
|
||
"Mais une question demeure, bien sûr : comment convertir des valeurs en "
|
||
"chaînes de caractères ? Heureusement, Python fournit plusieurs moyens de "
|
||
"convertir n'importe quelle valeur en chaîne : les fonctions :func:`repr` et :"
|
||
"func:`str`."
|
||
|
||
# 588f2644f358422b905e034d7e0ef059
|
||
#: tutorial/inputoutput.rst:37
|
||
msgid ""
|
||
"The :func:`str` function is meant to return representations of values which "
|
||
"are fairly human-readable, while :func:`repr` is meant to generate "
|
||
"representations which can be read by the interpreter (or will force a :exc:"
|
||
"`SyntaxError` if there is no equivalent syntax). For objects which don't "
|
||
"have a particular representation for human consumption, :func:`str` will "
|
||
"return the same value as :func:`repr`. Many values, such as numbers or "
|
||
"structures like lists and dictionaries, have the same representation using "
|
||
"either function. Strings and floating point numbers, in particular, have "
|
||
"two distinct representations."
|
||
msgstr ""
|
||
"La fonction :func:`str` est destinée à renvoyer des représentations de "
|
||
"valeurs qui soient lisibles par un être humain, alors que la fonction :func:"
|
||
"`repr` est destinée à générer des représentations qui puissent être lues par "
|
||
"l'interpréteur (ou forceront une :exc:`SyntaxError` s'il n'existe aucune "
|
||
"syntaxe équivalente). Pour les objets qui n'ont pas de représentation "
|
||
"humaine spécifique, :func:`str` renverra la même valeur que :func:`repr`. "
|
||
"Beaucoup de valeurs, comme les nombres ou les structures telles que les "
|
||
"listes ou les dictionnaires, ont la même représentation en utilisant les "
|
||
"deux fonctions. Les chaînes de caractères et les nombres à virgule "
|
||
"flottante, en revanche, ont deux représentations distinctes."
|
||
|
||
#: tutorial/inputoutput.rst:46 tutorial/introduction.rst:22
|
||
msgid "Some examples::"
|
||
msgstr "Quelques exemples ::"
|
||
|
||
#: tutorial/inputoutput.rst:71
|
||
msgid "Here are two ways to write a table of squares and cubes::"
|
||
msgstr "Voici deux façons d'écrire une table de carrés et de cubes ::"
|
||
|
||
# 0c685c72e1ab4135b590a4b3a75395dc
|
||
#: tutorial/inputoutput.rst:103
|
||
msgid ""
|
||
"(Note that in the first example, one space between each column was added by "
|
||
"the way :keyword:`print` works: it always adds spaces between its arguments.)"
|
||
msgstr ""
|
||
"(Notez que dans ce premier exemple, un espace entre chaque colonne a été "
|
||
"ajouté par la façon dont fonctionne :keyword:`print`, qui ajoute toujours "
|
||
"des espaces entre ses arguments.)"
|
||
|
||
# e9c272eb28c244f19113ee5315437b51
|
||
#: tutorial/inputoutput.rst:106
|
||
msgid ""
|
||
"This example demonstrates the :meth:`str.rjust` method of string objects, "
|
||
"which right-justifies a string in a field of a given width by padding it "
|
||
"with spaces on the left. There are similar methods :meth:`str.ljust` and :"
|
||
"meth:`str.center`. These methods do not write anything, they just return a "
|
||
"new string. If the input string is too long, they don't truncate it, but "
|
||
"return it unchanged; this will mess up your column lay-out but that's "
|
||
"usually better than the alternative, which would be lying about a value. "
|
||
"(If you really want truncation you can always add a slice operation, as in "
|
||
"``x.ljust(n)[:n]``.)"
|
||
msgstr ""
|
||
"Cet exemple démontre l'utilisation de la méthode :meth:`str.rjust` des "
|
||
"chaînes de caractères, qui fait une justification à droite d'une chaîne dans "
|
||
"un champ d'une largeur donnée en ajoutant des espaces sur la gauche. Il "
|
||
"existe des méthodes similaires :meth:`str.ljust` et :meth:`str.center`. Ces "
|
||
"méthodes n'écrivent rien, elles retournent simplement une nouvelle chaîne. "
|
||
"Si la chaîne passée en paramètre est trop longue, elle n'est pas tronquée "
|
||
"mais renvoyée sans modification ; ce qui peut déranger votre mise en page "
|
||
"mais est souvent préférable à l'alternative, qui pourrait mentir sur une "
|
||
"valeur (et si vous voulez vraiment tronquer vos valeurs, vous pouvez "
|
||
"toujours utiliser une tranche, comme dans ``x.ljust(n)[:n]``)."
|
||
|
||
# 89a84b85112846d4b95a173d0f535c99
|
||
#: tutorial/inputoutput.rst:116
|
||
msgid ""
|
||
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
|
||
"the left with zeros. It understands about plus and minus signs::"
|
||
msgstr ""
|
||
"Il existe une autre méthode, :meth:`str.zfill`, qui comble une chaîne "
|
||
"numérique à gauche avec des zéros. Elle comprend les signes plus et moins ::"
|
||
|
||
#: tutorial/inputoutput.rst:126
|
||
msgid "Basic usage of the :meth:`str.format` method looks like this::"
|
||
msgstr ""
|
||
"L'utilisation de base de la méthode :meth:`str.format` ressemble à cela ::"
|
||
|
||
# 1e61c1b7493e41ea8ba7032cf978617c
|
||
#: tutorial/inputoutput.rst:131
|
||
msgid ""
|
||
"The brackets and characters within them (called format fields) are replaced "
|
||
"with the objects passed into the :meth:`str.format` method. A number in the "
|
||
"brackets refers to the position of the object passed into the :meth:`str."
|
||
"format` method. ::"
|
||
msgstr ""
|
||
"Les crochets et les caractères qu'ils contiennent (appelés les champs de "
|
||
"formatage) sont remplacés par les objets passés en paramètres à la méthode :"
|
||
"meth:`str.format`. Un nombre entre crochets se réfère à la position de "
|
||
"l'objet passé à la méthode :meth:`str.format` ::"
|
||
|
||
# 8aeeda4a340947aa83e9ec64db9a40f2
|
||
#: tutorial/inputoutput.rst:141
|
||
msgid ""
|
||
"If keyword arguments are used in the :meth:`str.format` method, their values "
|
||
"are referred to by using the name of the argument. ::"
|
||
msgstr ""
|
||
"Si des arguments nommés sont utilisés dans la méthode :meth:`str.format`, "
|
||
"leurs valeurs sont utilisées en se basant sur le nom des arguments ::"
|
||
|
||
#: tutorial/inputoutput.rst:148
|
||
msgid "Positional and keyword arguments can be arbitrarily combined::"
|
||
msgstr ""
|
||
"Les arguments positionnés et nommés peuvent être combinés arbitrairement ::"
|
||
|
||
# d68785b3547d4ceea462a3cf386fdf0b
|
||
#: tutorial/inputoutput.rst:154
|
||
msgid ""
|
||
"``'!s'`` (apply :func:`str`) and ``'!r'`` (apply :func:`repr`) can be used "
|
||
"to convert the value before it is formatted. ::"
|
||
msgstr ""
|
||
"``'!s'`` (appliquer :func:`str`) et ``'!r'`` (appliquer :func:`repr`) "
|
||
"peuvent être utilisées pour convertir les valeurs avant leur formatage ::"
|
||
|
||
# 5aaef826c29848228e82d92b68e3ed8c
|
||
#: tutorial/inputoutput.rst:163
|
||
msgid ""
|
||
"An optional ``':'`` and format specifier can follow the field name. This "
|
||
"allows greater control over how the value is formatted. The following "
|
||
"example rounds Pi to three places after the decimal."
|
||
msgstr ""
|
||
"Des caractères ``':'`` suivis d'une spécification de formatage peuvent "
|
||
"suivre le nom du champ. Ceci offre un niveau de contrôle plus fin sur la "
|
||
"façon dont les valeurs sont formatées. L'exemple suivant arrondit Pi à trois "
|
||
"décimales ::"
|
||
|
||
#: tutorial/inputoutput.rst:171
|
||
msgid ""
|
||
"Passing an integer after the ``':'`` will cause that field to be a minimum "
|
||
"number of characters wide. This is useful for making tables pretty. ::"
|
||
msgstr ""
|
||
"Indiquer un entier après le ``':'`` indique la largeur minimale de ce champ "
|
||
"en nombre de caractères. C'est utile pour faire de jolis tableaux ::"
|
||
|
||
#: tutorial/inputoutput.rst:182
|
||
msgid ""
|
||
"If you have a really long format string that you don't want to split up, it "
|
||
"would be nice if you could reference the variables to be formatted by name "
|
||
"instead of by position. This can be done by simply passing the dict and "
|
||
"using square brackets ``'[]'`` to access the keys ::"
|
||
msgstr ""
|
||
"Si vous avez vraiment une longue chaîne de formatage que vous ne voulez pas "
|
||
"découper, ce serait bien de pouvoir référencer les variables à formater par "
|
||
"leur nom plutôt que par leur position. Cela peut être fait simplement en "
|
||
"passant un dictionnaire et en utilisant des crochets ``'[]'`` pour accéder "
|
||
"aux clés ::"
|
||
|
||
#: tutorial/inputoutput.rst:192
|
||
msgid ""
|
||
"This could also be done by passing the table as keyword arguments with the "
|
||
"'**' notation. ::"
|
||
msgstr ""
|
||
"On pourrait également faire ça en passant le tableau comme des arguments "
|
||
"nommés en utilisant la notation '**' ::"
|
||
|
||
# c99b63c3b0fd4e268a3c7987e17a775c
|
||
#: tutorial/inputoutput.rst:199
|
||
msgid ""
|
||
"This is particularly useful in combination with the built-in function :func:"
|
||
"`vars`, which returns a dictionary containing all local variables."
|
||
msgstr ""
|
||
"C'est particulièrement utile en combinaison avec la fonction native :func:"
|
||
"`vars`, qui retourne un dictionnaire contenant toutes les variables locales."
|
||
|
||
#: tutorial/inputoutput.rst:202
|
||
msgid ""
|
||
"For a complete overview of string formatting with :meth:`str.format`, see :"
|
||
"ref:`formatstrings`."
|
||
msgstr ""
|
||
"Pour avoir une vue complète du formatage des chaînes de caractères avec la "
|
||
"méthode :meth:`str.format`, voyez : :ref:`formatstrings`."
|
||
|
||
#: tutorial/inputoutput.rst:207
|
||
msgid "Old string formatting"
|
||
msgstr "Anciennes méthodes de formatage de chaînes"
|
||
|
||
# 5f6042e30fbb4813bd0d41dcf6ef2022
|
||
#: tutorial/inputoutput.rst:209
|
||
msgid ""
|
||
"The ``%`` operator can also be used for string formatting. It interprets the "
|
||
"left argument much like a :c:func:`sprintf`\\ -style format string to be "
|
||
"applied to the right argument, and returns the string resulting from this "
|
||
"formatting operation. For example::"
|
||
msgstr ""
|
||
"L'opérateur ``%`` peut aussi être utilisé pour formater des chaînes. Il "
|
||
"interprète l'argument de gauche un peu comme une chaîne de formatage d'une "
|
||
"fonction :c:func:`sprintf` à appliquer à l'argument de droite, et retourne "
|
||
"la chaîne résultant de cette opération de formatage. Par exemple ::"
|
||
|
||
# a470a92caf504e9e9abdf08789ab9890
|
||
#: tutorial/inputoutput.rst:218
|
||
msgid "More information can be found in the :ref:`string-formatting` section."
|
||
msgstr ""
|
||
"Vous trouverez plus d'informations dans la section :ref:`string-formatting`."
|
||
|
||
#: tutorial/inputoutput.rst:224
|
||
msgid "Reading and Writing Files"
|
||
msgstr "Lecture et écriture de fichiers"
|
||
|
||
#: tutorial/inputoutput.rst:230
|
||
msgid ""
|
||
":func:`open` returns a file object, and is most commonly used with two "
|
||
"arguments: ``open(filename, mode)``."
|
||
msgstr ""
|
||
":func:`open` retourne un objet fichier, et est le plus souvent utilisé avec "
|
||
"deux arguments : ``open(filename, mode)``."
|
||
|
||
#: tutorial/inputoutput.rst:239
|
||
msgid ""
|
||
"The first argument is a string containing the filename. The second argument "
|
||
"is another string containing a few characters describing the way in which "
|
||
"the file will be used. *mode* can be ``'r'`` when the file will only be "
|
||
"read, ``'w'`` for only writing (an existing file with the same name will be "
|
||
"erased), and ``'a'`` opens the file for appending; any data written to the "
|
||
"file is automatically added to the end. ``'r+'`` opens the file for both "
|
||
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
|
||
"assumed if it's omitted."
|
||
msgstr ""
|
||
"Le premier argument est une chaîne contenant le nom du fichier. Le second "
|
||
"argument est une autre chaîne contenant quelques caractères décrivant la "
|
||
"façon dont le fichier sera utilisé. *mode* peut être ``'r'`` quand le "
|
||
"fichier ne sera accédé qu'en lecture, ``'w'`` en écriture seulement (un "
|
||
"fichier existant portant le même nom sera alors écrasé), et ``'a'`` ouvre le "
|
||
"fichier en mode ajout (toute donnée écrite dans le fichier est "
|
||
"automatiquement ajoutée à la fin). ``'r+'`` ouvre le fichier en mode lecture/"
|
||
"écriture. L'argument *mode* est optionnel ; sa valeur par défaut est ``'r'``."
|
||
|
||
# 9ff01378e50d4134a460523dad57e264
|
||
#: tutorial/inputoutput.rst:248
|
||
msgid ""
|
||
"On Windows, ``'b'`` appended to the mode opens the file in binary mode, so "
|
||
"there are also modes like ``'rb'``, ``'wb'``, and ``'r+b'``. Python on "
|
||
"Windows makes a distinction between text and binary files; the end-of-line "
|
||
"characters in text files are automatically altered slightly when data is "
|
||
"read or written. This behind-the-scenes modification to file data is fine "
|
||
"for ASCII text files, but it'll corrupt binary data like that in :file:"
|
||
"`JPEG` or :file:`EXE` files. Be very careful to use binary mode when "
|
||
"reading and writing such files. On Unix, it doesn't hurt to append a "
|
||
"``'b'`` to the mode, so you can use it platform-independently for all binary "
|
||
"files."
|
||
msgstr ""
|
||
"Sous Windows, ``'b'`` ajouté au mode ouvre le fichier en mode binaire, et il "
|
||
"existe donc des modes comme ``'rb'``, ``'wb'`` et ``'r+b'``. Python sous "
|
||
"Windows fait effectivement une distinction entre fichiers texte et "
|
||
"binaires ; le caractère de fin de ligne des fichiers texte est "
|
||
"automatiquement modifié lorsqu'une donnée est lue ou écrite. Cette "
|
||
"modification sous le manteau des données du fichier n'est pas un problème "
|
||
"pour les fichiers textes en ASCII, mais elle peut corrompre les données "
|
||
"binaires comme celles des fichiers :file:`JPEG` ou :file:`EXE`. Soyez donc "
|
||
"attentifs à toujours bien utiliser le mode binaire lorsque vous travaillez "
|
||
"avec de tels fichiers. Sous Unix, le mode binaire n'a aucun effet mais vous "
|
||
"pouvez l'utiliser pour tous les fichiers binaires pour que votre code soit "
|
||
"indépendant de la plate-forme."
|
||
|
||
#: tutorial/inputoutput.rst:262
|
||
msgid "Methods of File Objects"
|
||
msgstr "Méthodes des objets fichiers"
|
||
|
||
#: tutorial/inputoutput.rst:264
|
||
msgid ""
|
||
"The rest of the examples in this section will assume that a file object "
|
||
"called ``f`` has already been created."
|
||
msgstr ""
|
||
"Les derniers exemples de cette section supposeront qu'un objet fichier "
|
||
"appelé ``f`` a déjà été créé."
|
||
|
||
# 2a8f9b43ebde48819bcb8e6362c55669
|
||
#: tutorial/inputoutput.rst:267
|
||
msgid ""
|
||
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
|
||
"of data and returns it as a string. *size* is an optional numeric "
|
||
"argument. When *size* is omitted or negative, the entire contents of the "
|
||
"file will be read and returned; it's your problem if the file is twice as "
|
||
"large as your machine's memory. Otherwise, at most *size* bytes are read and "
|
||
"returned. If the end of the file has been reached, ``f.read()`` will return "
|
||
"an empty string (``\"\"``). ::"
|
||
msgstr ""
|
||
"Pour lire le contenu d'un fichier, appelez ``f.read(size)``, qui lit une "
|
||
"certaine quantité de données et les retourne sous la forme d'une chaîne de "
|
||
"caractères. *size* est un argument numérique optionnel. Quand *size* est "
|
||
"omis ou négatif, le contenu entier du fichier est lu et retourné ; c'est "
|
||
"votre problème si le fichier est deux fois plus gros que la mémoire de votre "
|
||
"machine. Sinon, au plus *size* octets sont lus et retournés. Lorsque la fin "
|
||
"du fichier est atteinte, ``f.read()`` renvoie une chaîne vide (``\"\"``) ::"
|
||
|
||
# 1e6e90d979e44728babc12e0982b6fc4
|
||
#: tutorial/inputoutput.rst:280
|
||
msgid ""
|
||
"``f.readline()`` reads a single line from the file; a newline character (``"
|
||
"\\n``) is left at the end of the string, and is only omitted on the last "
|
||
"line of the file if the file doesn't end in a newline. This makes the "
|
||
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
|
||
"end of the file has been reached, while a blank line is represented by "
|
||
"``'\\n'``, a string containing only a single newline. ::"
|
||
msgstr ""
|
||
"``f.readline()`` lit une seule ligne du fichier ; un caractère de fin de "
|
||
"ligne (``\\n``) est laissé à la fin de la chaîne, et n'est omis que sur la "
|
||
"dernière ligne du fichier si celui-ci ne se termine pas un caractère de fin "
|
||
"de ligne. Ceci permet de rendre la valeur de retour non ambigüe : si ``f."
|
||
"readline()`` retourne une chaîne vide, c'est que la fin du fichier a été "
|
||
"atteinte, alors qu'une ligne vide est représentée par ``'\\n'``, une chaîne "
|
||
"de caractères ne contenant qu'une fin de ligne ::"
|
||
|
||
#: tutorial/inputoutput.rst:294
|
||
#, fuzzy
|
||
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 ::"
|
||
|
||
# c9d2cb570f624080832cb1c22091174a
|
||
#: tutorial/inputoutput.rst:303
|
||
msgid ""
|
||
"If you want to read all the lines of a file in a list you can also use "
|
||
"``list(f)`` or ``f.readlines()``."
|
||
msgstr ""
|
||
"Pour lire toutes les lignes d'un fichier, il est aussi possible d'utiliser "
|
||
"``list(f)`` ou ``f.readlines()``."
|
||
|
||
# 0ead0c7ac8ca40f7bb963339561c47e9
|
||
#: tutorial/inputoutput.rst:306
|
||
msgid ""
|
||
"``f.write(string)`` writes the contents of *string* to the file, returning "
|
||
"``None``. ::"
|
||
msgstr ""
|
||
"``f.write(string)`` écrit le contenu de *string* dans le fichier, et renvoie "
|
||
"``None`` ::"
|
||
|
||
#: tutorial/inputoutput.rst:311
|
||
msgid ""
|
||
"To write something other than a string, it needs to be converted to a string "
|
||
"first::"
|
||
msgstr ""
|
||
"Pour écrire autre chose qu'une chaîne, il faut commencer par la convertir en "
|
||
"chaîne ::"
|
||
|
||
#: tutorial/inputoutput.rst:318
|
||
msgid ""
|
||
"``f.tell()`` returns an integer giving the file object's current position in "
|
||
"the file, measured in bytes from the beginning of the file. To change the "
|
||
"file object's position, use ``f.seek(offset, from_what)``. The position is "
|
||
"computed from adding *offset* to a reference point; the reference point is "
|
||
"selected by the *from_what* argument. A *from_what* value of 0 measures "
|
||
"from the beginning of the file, 1 uses the current file position, and 2 uses "
|
||
"the end of the file as the reference point. *from_what* can be omitted and "
|
||
"defaults to 0, using the beginning of the file as the reference point. ::"
|
||
msgstr ""
|
||
"``f.tell()`` retourne un entier indiquant la position actuelle dans le "
|
||
"fichier, mesurée en octets à partir du début du fichier. Pour modifier la "
|
||
"position dans le fichier, utilisez ``f.seek(offset, from_what)``. La "
|
||
"position est calculée en ajoutant *offset* à un point de référence ; ce "
|
||
"point de référence est sélectionné par l'argument *from_what* : 0 pour le "
|
||
"début du fichier, 1 pour la position actuelle, et 2 pour la fin du fichier. "
|
||
"*from_what* peut être omis et sa valeur par défaut est 0, utilisant le début "
|
||
"du fichier comme point de référence ::"
|
||
|
||
#: tutorial/inputoutput.rst:336
|
||
msgid ""
|
||
"When you're done with a file, call ``f.close()`` to close it and free up any "
|
||
"system resources taken up by the open file. After calling ``f.close()``, "
|
||
"attempts to use the file object will automatically fail. ::"
|
||
msgstr ""
|
||
"Quand vous avez terminé d'utiliser un fichier, appeler ``f.close()`` pour le "
|
||
"fermer et libérer toutes les ressources système qu'il a pu utiliser. Après "
|
||
"l'appel de ``f.close()``, toute tentative d'utilisation de l'objet fichier "
|
||
"échouera systématiquement ::"
|
||
|
||
#: tutorial/inputoutput.rst:346
|
||
msgid ""
|
||
"It is good practice to use the :keyword:`with` keyword when dealing with "
|
||
"file objects. This has the advantage that the file is properly closed after "
|
||
"its suite finishes, even if an exception is raised on the way. It is also "
|
||
"much shorter than writing equivalent :keyword:`try`\\ -\\ :keyword:`finally` "
|
||
"blocks::"
|
||
msgstr ""
|
||
"C'est une bonne pratique d'utiliser le mot-clé :keyword:`with` lorsque vous "
|
||
"traitez des fichiers. Ceci procure l'avantage de toujours fermer "
|
||
"correctement le fichier, même si une exception a été déclenchée. C'est aussi "
|
||
"beaucoup plus court que d'utiliser l'équivalent avec des blocs :keyword:`try`"
|
||
"\\ - \\ :keyword:`finally` ::"
|
||
|
||
#: tutorial/inputoutput.rst:356
|
||
msgid ""
|
||
"File objects have some additional methods, such as :meth:`~file.isatty` and :"
|
||
"meth:`~file.truncate` which are less frequently used; consult the Library "
|
||
"Reference for a complete guide to file objects."
|
||
msgstr ""
|
||
"Les fichiers disposent de méthodes supplémentaires, telles que :meth:`~file."
|
||
"isatty` et :meth:`~file.truncate` qui sont moins souvent utilisées ; "
|
||
"consultez la Référence de la Bibliothèque Standard pour avoir un guide "
|
||
"complet des objets fichiers."
|
||
|
||
# c0fc908435b34686b8e3d1c331dca304
|
||
#: tutorial/inputoutput.rst:364
|
||
msgid "Saving structured data with :mod:`json`"
|
||
msgstr "Sauvegarder des données structurées avec le module :mod:`json`"
|
||
|
||
#: tutorial/inputoutput.rst:368
|
||
#, fuzzy
|
||
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."
|
||
|
||
#: tutorial/inputoutput.rst:375
|
||
#, fuzzy
|
||
msgid ""
|
||
"Rather than having users constantly writing and debugging code to save "
|
||
"complicated data types to files, Python allows you to use the popular data "
|
||
"interchange format called `JSON (JavaScript Object Notation) <http://json."
|
||
"org>`_. The standard module called :mod:`json` can take Python data "
|
||
"hierarchies, and convert them to string representations; this process is "
|
||
"called :dfn:`serializing`. Reconstructing the data from the string "
|
||
"representation is called :dfn:`deserializing`. Between serializing and "
|
||
"deserializing, the string representing the object may have been stored in a "
|
||
"file or data, or sent over a network connection to some distant machine."
|
||
msgstr ""
|
||
"Plutôt que de passer son temps à écrire et déboguer du code permettant de "
|
||
"sauvegarder des types de données compliquées, Python fournit un module "
|
||
"standard appelé :mod:`pickle`. C'est un module extraordinaire qui peut "
|
||
"prendre à peu près n'importe quel objet Python (y compris certaines formes "
|
||
"de code Python), et les représenter sous la forme de chaînes de caractères ; "
|
||
"ce processus est appelé :dfn:`pickling`. La reconstruction des objets à "
|
||
"partir de leur représentation sous forme de chaîne est appelée :dfn:"
|
||
"`unpickling`. Entre ces deux phases, la chaîne représentant l'objet peut "
|
||
"avoir été stockée dans un fichier ou envoyée via une connexion réseau vers "
|
||
"une machine distante."
|
||
|
||
# e1b89b3bc75f412c8dd35d6ef0fa5bc0
|
||
#: tutorial/inputoutput.rst:386
|
||
msgid ""
|
||
"The JSON format is commonly used by modern applications to allow for data "
|
||
"exchange. Many programmers are already familiar with it, which makes it a "
|
||
"good choice for interoperability."
|
||
msgstr ""
|
||
"Le format JSON 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é."
|
||
|
||
#: tutorial/inputoutput.rst:390
|
||
#, fuzzy
|
||
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``, et un objet fichier ``f`` qui a été ouvert en "
|
||
"écriture, la méthode la plus simple d'écrire cet objet ne prend qu'une ligne "
|
||
"de code ::"
|
||
|
||
# 1f4e44bb05df474ba9c35c7674143147
|
||
#: tutorial/inputoutput.rst:396
|
||
#, fuzzy
|
||
msgid ""
|
||
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
|
||
"dump`, simply serializes the object to a file. So if ``f`` is a :term:`file "
|
||
"object` opened for writing, we can do this::"
|
||
msgstr ""
|
||
"Une variation de la fonction :func:`~jspn.dumps`, nommée :func:`~json.dump`, "
|
||
"sérialise simplement l'objet donné vers un fichier. Donc si ``f`` est un :"
|
||
"term:`fichier texte` ouvert en écriture, il devient possible de faire ::"
|
||
|
||
#: tutorial/inputoutput.rst:402
|
||
#, fuzzy
|
||
msgid ""
|
||
"To decode the object again, if ``f`` is a :term:`file object` which has been "
|
||
"opened for reading::"
|
||
msgstr ""
|
||
"Pour reconstruire l'objet, si ``f`` est cette fois un objet fichier ouvert "
|
||
"en lecture ::"
|
||
|
||
# 334875c8946c46c6b368aa91dfaab56a
|
||
#: tutorial/inputoutput.rst:407
|
||
msgid ""
|
||
"This simple serialization technique can handle lists and dictionaries, but "
|
||
"serializing arbitrary class instances in JSON requires a bit of extra "
|
||
"effort. The reference for the :mod:`json` module contains an explanation of "
|
||
"this."
|
||
msgstr ""
|
||
"Cette méthode de 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."
|
||
|
||
#: tutorial/inputoutput.rst:413
|
||
#, fuzzy
|
||
msgid ":mod:`pickle` - the pickle module"
|
||
msgstr "Le module :mod:`pickle`"
|
||
|
||
# cb6f98c360cb46e4af9277ca15e4db4b
|
||
#: tutorial/inputoutput.rst:415
|
||
msgid ""
|
||
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
|
||
"serialization of arbitrarily complex Python objects. As such, it is "
|
||
"specific to Python and cannot be used to communicate with applications "
|
||
"written in other languages. It is also insecure by default: deserializing "
|
||
"pickle data coming from an untrusted source can execute arbitrary code, if "
|
||
"the data was crafted by a skilled attacker."
|
||
msgstr ""
|
||
"À l'inverse de :ref:`JSON <tut-json>`, *pickle* est un protocole permettant "
|
||
"la serialisation d'objets Python arbitrairement complexes. Il est donc "
|
||
"spécifique à Python et ne peut être utilisé pour communiquer avec d'autres "
|
||
"langages. Il n'est aussi pas sans failles : desérialiser des données au "
|
||
"format pickle provenant d'une source malveillante et particulièrement habile "
|
||
"pourrait mener exécuter du code arbitraire."
|
||
|
||
#: tutorial/interactive.rst:5
|
||
msgid "Interactive Input Editing and History Substitution"
|
||
msgstr "Édition interactive des entrées et substitution d'historique"
|
||
|
||
#: tutorial/interactive.rst:7
|
||
msgid ""
|
||
"Some versions of the Python interpreter support editing of the current input "
|
||
"line and history substitution, similar to facilities found in the Korn shell "
|
||
"and the GNU Bash shell. This is implemented using the `GNU Readline`_ "
|
||
"library, which supports Emacs-style and vi-style editing. This library has "
|
||
"its own documentation which I won't duplicate here; however, the basics are "
|
||
"easily explained. The interactive editing and history described here are "
|
||
"optionally available in the Unix and Cygwin versions of the interpreter."
|
||
msgstr ""
|
||
"Certaines versions de l'interpréteur Python prennent en charge l'édition de "
|
||
"la ligne d'entrée courante et la substitution d'historique, similaires aux "
|
||
"facilités que l'on trouve dans le shell Korn et dans le shell GNU Bash. "
|
||
"C'est implémenté en utilisant la bibliothèque `GNU Readline`_, qui supporte "
|
||
"l'édition en style Emacs et en style Vi. La bibliothèque a sa propre "
|
||
"documentation qui ne va pas être dupliquée ici ; toutefois, les bases seront "
|
||
"expliquées rapidement. L'éditeur interactif et la gestion d'historique "
|
||
"décrits ici sont disponibles en option sous les versions Unix et Cygwin de "
|
||
"l'interpréteur."
|
||
|
||
#: tutorial/interactive.rst:15
|
||
msgid ""
|
||
"This chapter does *not* document the editing facilities of Mark Hammond's "
|
||
"PythonWin package or the Tk-based environment, IDLE, distributed with "
|
||
"Python. The command line history recall which operates within DOS boxes on "
|
||
"NT and some other DOS and Windows flavors is yet another beast."
|
||
msgstr ""
|
||
"Ce chapitre *ne décrit pas* les possibilités d'édition du paquet PythonWin "
|
||
"de Mark Hammond ou de l'environnement basé sur Tk, IDLE, distribué avec "
|
||
"Python. Le rappel d'historique des lignes de commandes qui fonctionne dans "
|
||
"des fenêtres DOS sous NT ou d'autres variétés de Windows est encore une "
|
||
"autre histoire."
|
||
|
||
#: tutorial/interactive.rst:24
|
||
msgid "Line Editing"
|
||
msgstr "Édition de ligne"
|
||
|
||
#: tutorial/interactive.rst:26
|
||
msgid ""
|
||
"If supported, input line editing is active whenever the interpreter prints a "
|
||
"primary or secondary prompt. The current line can be edited using the "
|
||
"conventional Emacs control characters. The most important of these are: :"
|
||
"kbd:`C-A` (Control-A) moves the cursor to the beginning of the line, :kbd:`C-"
|
||
"E` to the end, :kbd:`C-B` moves it one position to the left, :kbd:`C-F` to "
|
||
"the right. Backspace erases the character to the left of the cursor, :kbd:"
|
||
"`C-D` the character to its right. :kbd:`C-K` kills (erases) the rest of the "
|
||
"line to the right of the cursor, :kbd:`C-Y` yanks back the last killed "
|
||
"string. :kbd:`C-underscore` undoes the last change you made; it can be "
|
||
"repeated for cumulative effect."
|
||
msgstr ""
|
||
"Si elle est supportée, l'édition de la ligne d'entrée est active lorsque "
|
||
"l'interpréteur affiche une invite primaire ou secondaire. La ligne courante "
|
||
"peut être éditée en utilisant les caractères de contrôles traditionnels "
|
||
"d'Emacs. Les plus importants d'entre eux sont : :kbd:`C-A` (Contrôle-A) "
|
||
"déplace le curseur au début de la ligne, :kbd:`C-E` à la fin, :kbd:`C-B` "
|
||
"d'un caractère vers la gauche, :kbd:`C-F` d'un caractère vers la droite. La "
|
||
"touche retour arrière efface le caractère à la gauche du curseur, :kbd:`C-D` "
|
||
"le caractère à sa droite. :kbd:`C-K` supprime le reste de la ligne à la "
|
||
"droite du curseur, :kbd:`C-Y` rappelle la dernière chaîne supprimée. :kbd:`C-"
|
||
"tiret bas` annule la dernière modification ; cette commande peut être "
|
||
"répétée pour cumuler ses effets."
|
||
|
||
#: tutorial/interactive.rst:41
|
||
msgid "History Substitution"
|
||
msgstr "Substitution d'historique"
|
||
|
||
#: tutorial/interactive.rst:43
|
||
msgid ""
|
||
"History substitution works as follows. All non-empty input lines issued are "
|
||
"saved in a history buffer, and when a new prompt is given you are positioned "
|
||
"on a new line at the bottom of this buffer. :kbd:`C-P` moves one line up "
|
||
"(back) in the history buffer, :kbd:`C-N` moves one down. Any line in the "
|
||
"history buffer can be edited; an asterisk appears in front of the prompt to "
|
||
"mark a line as modified. Pressing the :kbd:`Return` key passes the current "
|
||
"line to the interpreter. :kbd:`C-R` starts an incremental reverse search; :"
|
||
"kbd:`C-S` starts a forward search."
|
||
msgstr ""
|
||
"La substitution d'historique fonctionne comme ceci. Toutes les lignes non "
|
||
"vides reçues sont enregistrées dans un tampon d'historique et, à chaque fois "
|
||
"qu'une invite est affichée, vous êtes positionné sur une nouvelle ligne à la "
|
||
"fin de ce tampon. :kbd:`C-P` remonte d'une ligne (en arrière) dans ce "
|
||
"tampon, :kbd:`C-N` descend d'une ligne. Chaque ligne présente dans le tampon "
|
||
"d'historique peut être éditée ; un astérisque apparaît en face de l'invite "
|
||
"pour indiquer qu'une ligne a été modifiée. Presser la touche :kbd:`Entrée` "
|
||
"envoie la ligne en cours à l'interpréteur. :kbd:`C-R` démarre une recherche "
|
||
"incrémentale en arrière ; :kbd:`C-S` démarre une recherche en avant."
|
||
|
||
#: tutorial/interactive.rst:56
|
||
msgid "Key Bindings"
|
||
msgstr "Raccourcis clavier"
|
||
|
||
#: tutorial/interactive.rst:58
|
||
msgid ""
|
||
"The key bindings and some other parameters of the Readline library can be "
|
||
"customized by placing commands in an initialization file called :file:`~/."
|
||
"inputrc`. Key bindings have the form ::"
|
||
msgstr ""
|
||
"Les raccourcis clavier ainsi que d'autres paramètres de la bibliothèque "
|
||
"Readline peuvent être personnalisés en inscrivant des commandes dans un "
|
||
"fichier d'initialisation appelé :file:`~/.inputrc`. Les raccourcis sont de "
|
||
"la forme ::"
|
||
|
||
#: tutorial/interactive.rst:64
|
||
msgid "or ::"
|
||
msgstr "ou ::"
|
||
|
||
#: tutorial/interactive.rst:68
|
||
msgid "and options can be set with ::"
|
||
msgstr "et les options peuvent être définies avec ::"
|
||
|
||
#: tutorial/interactive.rst:72
|
||
msgid "For example::"
|
||
msgstr "Par exemple ::"
|
||
|
||
#: tutorial/interactive.rst:85
|
||
msgid ""
|
||
"Note that the default binding for :kbd:`Tab` in Python is to insert a :kbd:"
|
||
"`Tab` character instead of Readline's default filename completion function. "
|
||
"If you insist, you can override this by putting ::"
|
||
msgstr ""
|
||
"Notez que le raccourci par défaut pour la touche :kbd:`Tab` en Python est "
|
||
"d'insérer un caractère de tabulation au lieu de la fonction par défaut de "
|
||
"complétion des noms de fichiers de la bibliothèque Readline. Si vous y "
|
||
"tenez, vous pouvez surcharger ce comportement en indiquant ::"
|
||
|
||
#: tutorial/interactive.rst:91
|
||
msgid ""
|
||
"in your :file:`~/.inputrc`. (Of course, this makes it harder to type "
|
||
"indented continuation lines if you're accustomed to using :kbd:`Tab` for "
|
||
"that purpose.)"
|
||
msgstr ""
|
||
"dans votre fichier :file:`~/.inputrc` (bien sûr, avec cela il devient plus "
|
||
"difficile d'entrer des lignes de continuation indentées si vous êtes habitué "
|
||
"à utiliser :kbd:`Tab` dans ce but)."
|
||
|
||
#: tutorial/interactive.rst:98
|
||
msgid ""
|
||
"Automatic completion of variable and module names is optionally available. "
|
||
"To enable it in the interpreter's interactive mode, add the following to "
|
||
"your startup file: [#]_ ::"
|
||
msgstr ""
|
||
"La complétude automatique des noms de variables et de modules est disponible "
|
||
"de manière optionnelle. Pour l'activer dans le mode interactif de "
|
||
"l'interpréteur, ajoutez les lignes suivantes à votre fichier de démarrage : "
|
||
"[#]_ ::"
|
||
|
||
#: tutorial/interactive.rst:105
|
||
msgid ""
|
||
"This binds the :kbd:`Tab` key to the completion function, so hitting the :"
|
||
"kbd:`Tab` key twice suggests completions; it looks at Python statement "
|
||
"names, the current local variables, and the available module names. For "
|
||
"dotted expressions such as ``string.a``, it will evaluate the expression up "
|
||
"to the final ``'.'`` and then suggest completions from the attributes of the "
|
||
"resulting object. Note that this may execute application-defined code if an "
|
||
"object with a :meth:`__getattr__` method is part of the expression."
|
||
msgstr ""
|
||
"Ceci lie la touche :kbd:`Tab` à la fonction de complétude, donc taper la "
|
||
"touche :kbd:`Tab` deux fois de suite suggère les options disponibles ; la "
|
||
"recherche s'effectue dans les noms d'instructions Python, les noms des "
|
||
"variables locales et les noms de modules disponibles. Pour les expressions "
|
||
"pointées telles que ``string.a``, l'expression est évaluée jusqu'au dernier "
|
||
"``'.'`` avant de suggérer les options disponibles à partir des attributs de "
|
||
"l'objet résultant de cette évaluation. Notez bien que ceci peut exécuter une "
|
||
"partie du code de l'application si un objet disposant d'une méthode :meth:"
|
||
"`__getattr__` fait partie de l'expression."
|
||
|
||
#: tutorial/interactive.rst:113
|
||
msgid ""
|
||
"A more capable startup file might look like this example. Note that this "
|
||
"deletes the names it creates once they are no longer needed; this is done "
|
||
"since the startup file is executed in the same namespace as the interactive "
|
||
"commands, and removing the names avoids creating side effects in the "
|
||
"interactive environment. You may find it convenient to keep some of the "
|
||
"imported modules, such as :mod:`os`, which turn out to be needed in most "
|
||
"sessions with the interpreter. ::"
|
||
msgstr ""
|
||
"Un fichier de démarrage plus complet peut ressembler à cet exemple. Notez "
|
||
"que celui-ci supprime les noms qu'il crée dès qu'ils ne sont plus "
|
||
"nécessaires ; ceci est possible car le fichier de démarrage est exécuté dans "
|
||
"le même espace de noms que les commandes interactives, et supprimer les noms "
|
||
"évite de générer des effets de bord dans l'environnement interactif. Vous "
|
||
"pouvez trouver pratique de conserver certains des modules importés, tels "
|
||
"que :mod:`os`, qui s'avère nécessaire dans la plupart des sessions avec "
|
||
"l'interpréteur."
|
||
|
||
#: tutorial/interactive.rst:149
|
||
msgid "Alternatives to the Interactive Interpreter"
|
||
msgstr "Alternatives à l'interpréteur interactif"
|
||
|
||
#: tutorial/interactive.rst:151
|
||
msgid ""
|
||
"This facility is an enormous step forward compared to earlier versions of "
|
||
"the interpreter; however, some wishes are left: It would be nice if the "
|
||
"proper indentation were suggested on continuation lines (the parser knows if "
|
||
"an indent token is required next). The completion mechanism might use the "
|
||
"interpreter's symbol table. A command to check (or even suggest) matching "
|
||
"parentheses, quotes, etc., would also be useful."
|
||
msgstr ""
|
||
"Cette facilité constitue un énorme pas en avant comparé aux versions "
|
||
"précédentes de l'interpréteur ; toutefois, certains souhaits sont laissés de "
|
||
"côté : ce serait bien si une indentation correcte était proposée sur les "
|
||
"lignes de continuation (l'analyseur sait si une indentation doit suivre). Le "
|
||
"mécanisme de complétion devrait utiliser la table de symboles de "
|
||
"l'interpréteur. Une commande pour vérifier (ou même suggérer) les "
|
||
"correspondances de parenthèses, de guillemets..., serait également utile."
|
||
|
||
# fe2adb8ab2894fa58e38a0a9e9e22c21
|
||
#: tutorial/interactive.rst:158
|
||
msgid ""
|
||
"One alternative enhanced interactive interpreter that has been around for "
|
||
"quite some time is IPython_, which features tab completion, object "
|
||
"exploration and advanced history management. It can also be thoroughly "
|
||
"customized and embedded into other applications. Another similar enhanced "
|
||
"interactive environment is bpython_."
|
||
msgstr ""
|
||
"Une alternative améliorée de l'interpréteur interactif qui a été développée "
|
||
"depuis maintenant quelques temps est IPython_, qui fournit la complétude, "
|
||
"l'exploration d'objets et une gestion avancée de l'historique. Il peut "
|
||
"également être personnalisé en profondeur et embarqué dans d'autres "
|
||
"applications. Un autre environnement interactif amélioré similaire est "
|
||
"bpython_."
|
||
|
||
# 4e8a30bcc9b34e4e8be51474820e2db6
|
||
#: tutorial/interactive.rst:167
|
||
msgid ""
|
||
"Python will execute the contents of a file identified by the :envvar:"
|
||
"`PYTHONSTARTUP` environment variable when you start an interactive "
|
||
"interpreter. To customize Python even for non-interactive mode, see :ref:"
|
||
"`tut-customize`."
|
||
msgstr ""
|
||
"Python exécute le contenu d'un fichier identifié par la variable "
|
||
"d'environnement :envvar:`PYTHONSTARTUP` lorsque vous démarrez un "
|
||
"interpréteur interactif. Pour personnaliser Python y compris en mode non "
|
||
"interactif, consultez :ref:`tut-customize`."
|
||
|
||
#: tutorial/interpreter.rst:5
|
||
msgid "Using the Python Interpreter"
|
||
msgstr "Utiliser l'interpréteur Python"
|
||
|
||
#: tutorial/interpreter.rst:11
|
||
msgid "Invoking the Interpreter"
|
||
msgstr "Invoquer l'interpréteur"
|
||
|
||
# 1fe8d6c4d9b34bf591bf05002c64109c
|
||
#: tutorial/interpreter.rst:13
|
||
msgid ""
|
||
"The Python interpreter is usually installed as :file:`/usr/local/bin/python` "
|
||
"on those machines where it is available; putting :file:`/usr/local/bin` in "
|
||
"your Unix shell's search path makes it possible to start it by typing the "
|
||
"command ::"
|
||
msgstr ""
|
||
"L'interpréteur python est habituellement installé :file:`/usr/local/bin/"
|
||
"python` sur les machines où il est disponible. En mettant :file:`/usr/local/"
|
||
"bin` dans les chemins de recherche de votre shell Unix, vous permettez de "
|
||
"lancer l'interpréteur Python en tapant la commande ::"
|
||
|
||
# e074012e6a55498fad926d939d5ce0f7
|
||
#: tutorial/interpreter.rst:19
|
||
msgid ""
|
||
"to the shell. Since the choice of the directory where the interpreter lives "
|
||
"is an installation option, other places are possible; check with your local "
|
||
"Python guru or system administrator. (E.g., :file:`/usr/local/python` is a "
|
||
"popular alternative location.)"
|
||
msgstr ""
|
||
"dans le shell. Le choix du répertoire où se trouve l'interpréteur étant une "
|
||
"option d'installation, d'autres chemins sont possibles; voyez avec votre "
|
||
"guru Python local ou votre administrateur système. (Par exemple, :file:`/usr/"
|
||
"local/python` est une localisation courante.)"
|
||
|
||
# 9d462e2928f341308d62bcd4963089f4
|
||
#: tutorial/interpreter.rst:24
|
||
msgid ""
|
||
"On Windows machines, the Python installation is usually placed in :file:`C:\\"
|
||
"\\Python27`, though you can change this when you're running the installer. "
|
||
"To add this directory to your path, you can type the following command into "
|
||
"the command prompt in a DOS box::"
|
||
msgstr ""
|
||
"Sur les machines Windows, l'installation de Python se situe généralement "
|
||
"dans :file:`C:\\\\Python27`, bien que vous puissiez changer cela lorsque "
|
||
"vous lancer l'installateur. Pour ajouter ce chemin dans vos chemins de "
|
||
"recherche, vous pouvez taper la commande suivante dans votre émulateur de "
|
||
"terminal DOS ::"
|
||
|
||
#: tutorial/interpreter.rst:31
|
||
msgid ""
|
||
"Typing an end-of-file character (:kbd:`Control-D` on Unix, :kbd:`Control-Z` "
|
||
"on Windows) at the primary prompt causes the interpreter to exit with a zero "
|
||
"exit status. If that doesn't work, you can exit the interpreter by typing "
|
||
"the following command: ``quit()``."
|
||
msgstr ""
|
||
"Taper un caractère de fin de fichier (:kbd:`Ctrl-D` sous Unix, :kbd:`Ctrl-Z` "
|
||
"sous Windows) suive à une invite de commande primaire provoque la fermeture "
|
||
"de l'interpréteur avec un statut d'erreur nul. Si cela ne fonctionne pas, "
|
||
"vous pouvez fermer l'interpréteur en tapant la commande ``quit()``."
|
||
|
||
#: tutorial/interpreter.rst:36
|
||
#, fuzzy
|
||
msgid ""
|
||
"The interpreter's line-editing features usually aren't very sophisticated. "
|
||
"On Unix, whoever installed the interpreter may have enabled support for the "
|
||
"GNU readline library, which adds more elaborate interactive editing and "
|
||
"history features. Perhaps the quickest check to see whether command line "
|
||
"editing is supported is typing :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 possibilités d'édition de l'interpréteur ne sont généralement pas très "
|
||
"sophistiquées. Sous Unix, quiconque a installé l'interpréteur est "
|
||
"susceptible d'avoir la gestion de la bibliothèque GNU readline d'activé, ce "
|
||
"qui ajoute une édition interactive plus élaborée et une fonctionnalité "
|
||
"d'historique. Le moyen le plus rapide de tester si l'édition de la ligne de "
|
||
"commande est gérée est peut-être de taper :kbd:`Ctrl-P` suite au premier "
|
||
"invite de commande que vous rencontrez. Si cela bip, vous disposez de "
|
||
"l'édition de la ligne de commande; voyez l'appendice :ref:`tut-interacting` "
|
||
"pour une introduction aux touches. Si rien ne semble se produire ou si "
|
||
"``^P`` s'affiche, l'édition de la ligne de commande n'est pas disponible; "
|
||
"vous serez seulement en mesure d'utiliser la touche retour arrière pour "
|
||
"supprimer des caractères de la ligne courante."
|
||
|
||
#: tutorial/interpreter.rst:46
|
||
msgid ""
|
||
"The interpreter operates somewhat like the Unix shell: when called with "
|
||
"standard input connected to a tty device, it reads and executes commands "
|
||
"interactively; when called with a file name argument or with a file as "
|
||
"standard input, it reads and executes a *script* from that file."
|
||
msgstr ""
|
||
"L'interpréteur opère de façon similaire au shell Unix : lorsqu'il est appelé "
|
||
"avec l'entrée standard connectée à un périphérique tty, il lit et exécute "
|
||
"les commandes de façon interactive; lorsqu'il est appelé avec un nom de "
|
||
"fichier en argument ou avec un fichier comme entrée standard, il lit et "
|
||
"exécute un *script* depuis ce fichier."
|
||
|
||
#: tutorial/interpreter.rst:51
|
||
msgid ""
|
||
"A second way of starting the interpreter is ``python -c command [arg] ...``, "
|
||
"which executes the statement(s) in *command*, analogous to the shell's :"
|
||
"option:`-c` option. Since Python statements often contain spaces or other "
|
||
"characters that are special to the shell, it is usually advised to quote "
|
||
"*command* in its entirety with single quotes."
|
||
msgstr ""
|
||
"Une autre façon de lancer l'interpréteur est ``python -c commande [arg] ..."
|
||
"``. Cela exécute les instructions de *commande* de façon analogue à "
|
||
"l'option :option:`-c` du shell. Parce que les instructions Python "
|
||
"contiennent souvent des espaces et d'autres caractères spéciaux pour le "
|
||
"shell, il est généralement conseillé de mettre *commande* entre guillemets "
|
||
"simples."
|
||
|
||
#: tutorial/interpreter.rst:57
|
||
msgid ""
|
||
"Some Python modules are also useful as scripts. These can be invoked using "
|
||
"``python -m module [arg] ...``, which executes the source file for *module* "
|
||
"as if you had spelled out its full name on the command line."
|
||
msgstr ""
|
||
"Certains modules Python sont aussi utiles en tant que scripts. Ils peuvent "
|
||
"être appelé avec ``python -m module [arg] ...`` qui exécute le fichier "
|
||
"source de *module* comme si vous aviez tapé son nom complet dans la ligne de "
|
||
"commande."
|
||
|
||
# 3cbdf83437db4943ba9c24f111feb698
|
||
#: tutorial/interpreter.rst:61
|
||
msgid ""
|
||
"When a script file is used, it is sometimes useful to be able to run the "
|
||
"script and enter interactive mode afterwards. This can be done by passing :"
|
||
"option:`-i` before the script."
|
||
msgstr ""
|
||
"Quand un fichier de script est utilisé, il est parfois utile de pouvoir "
|
||
"lancer le script puis d'entrer dans le mode interactif après coup. Cela est "
|
||
"possible en passant :option:`-i` avant le script."
|
||
|
||
#: tutorial/interpreter.rst:65
|
||
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`."
|
||
|
||
#: tutorial/interpreter.rst:71
|
||
msgid "Argument Passing"
|
||
msgstr "Passage d'arguments"
|
||
|
||
# cf63c591cb9a4616a61a495bd06cf8af
|
||
#: tutorial/interpreter.rst:73
|
||
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."
|
||
|
||
#: tutorial/interpreter.rst:91
|
||
msgid ""
|
||
"When commands are read from a tty, the interpreter is said to be in "
|
||
"*interactive mode*. In this mode it prompts for the next command with the "
|
||
"*primary prompt*, usually three greater-than signs (``>>>``); for "
|
||
"continuation lines it prompts with the *secondary prompt*, by default three "
|
||
"dots (``...``). The interpreter prints a welcome message stating its version "
|
||
"number and a copyright notice before printing the first prompt::"
|
||
msgstr ""
|
||
"Lorsque les commandes sont lues depuis un tty, l'interpréteur est dit *en "
|
||
"mode interactif*. Dans ce mode, il attend la prochaine commande en affichant "
|
||
"*l'invite de commande primaire*, généralement trois \"signes supérieur à"
|
||
"\" (``>>>``); pour demander une ligne de continuation, l'interpréteur "
|
||
"affiche *l'invite de commande secondaire*, par défaut trois points (``..."
|
||
"``). L'interpréteur affiche un message de bienvenue indiquant son numéro de "
|
||
"version et une mention de *copyright* avant d'afficher le premier invite de "
|
||
"commande ::"
|
||
|
||
#: tutorial/interpreter.rst:103
|
||
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` ::"
|
||
|
||
# 1d814a4f499e49cd906e688ac4990345
|
||
#: tutorial/interpreter.rst:113
|
||
msgid "For more on interactive mode, see :ref:`tut-interac`."
|
||
msgstr ""
|
||
"Pour plus d'informations sur le mode interactif, voir :ref:`tut-interac`."
|
||
|
||
#: tutorial/interpreter.rst:119
|
||
msgid "The Interpreter and Its Environment"
|
||
msgstr "L'interpréteur et son environnement"
|
||
|
||
#: tutorial/interpreter.rst:125
|
||
msgid "Source Code Encoding"
|
||
msgstr "Encodage du code source"
|
||
|
||
# 5b068a5d06ac42b8bf82ceb101a1e483
|
||
#: tutorial/interpreter.rst:127
|
||
msgid ""
|
||
"It is possible to use encodings different than ASCII in Python source files. "
|
||
"The best way to do it is to put one more special comment line right after "
|
||
"the ``#!`` line to define the source file encoding::"
|
||
msgstr ""
|
||
"Il est possible d'utiliser un autre encodage que l'ASCII dans un fichier "
|
||
"source Python. La meilleure façon de faire est de placer un commentaire "
|
||
"spécial supplémentaire juste après le ``#!`` pour définir l'encodage du "
|
||
"fichier source::"
|
||
|
||
# 168d80cdf66a411d9af2e4d90f8b5fdf
|
||
#: tutorial/interpreter.rst:134
|
||
msgid ""
|
||
"With that declaration, all characters in the source file will be treated as "
|
||
"having the encoding *encoding*, and it will be possible to directly write "
|
||
"Unicode string literals in the selected encoding. The list of possible "
|
||
"encodings can be found in the Python Library Reference, in the section on :"
|
||
"mod:`codecs`."
|
||
msgstr ""
|
||
"Avec cette déclaration, tous les caractères du fichier source sont traités "
|
||
"comme étant dans l'encodage *encoding* et il est possible de d'écrire "
|
||
"directement des littéraux de chaîne Unicode dans l'encodage choisi. La liste "
|
||
"des encodages disponibles peut être trouvée dans la référence de la "
|
||
"bibliothèque Python dans la partie à propos de :mod:`codecs`."
|
||
|
||
# 136855779690415a8c5aac7ceb545218
|
||
#: tutorial/interpreter.rst:140
|
||
#, fuzzy
|
||
msgid ""
|
||
"For example, to write Unicode literals including the Euro currency symbol, "
|
||
"the ISO-8859-15 encoding can be used, with the Euro symbol having the "
|
||
"ordinal value 164. This script, when saved in the ISO-8859-15 encoding, "
|
||
"will print the value 8364 (the Unicode code point corresponding to the Euro "
|
||
"symbol) and then exit::"
|
||
msgstr ""
|
||
"Par exemple, l'encodage ISO-8859-15 peut être utilisé pour écrire le "
|
||
"littéral Unicode décrivant le symbole Euro, ce dernier portant la valeur "
|
||
"ordinal 164 dans cet encodage. Ce script affiche la valeur 8364 (le point de "
|
||
"code Unicode correspondant au symbole Euro) et se termine ::"
|
||
|
||
# f6dd13cd8acb47b1b663b044df22ddf5
|
||
#: tutorial/interpreter.rst:150
|
||
msgid ""
|
||
"If your editor supports saving files as ``UTF-8`` with a UTF-8 *byte order "
|
||
"mark* (aka BOM), you can use that instead of an encoding declaration. IDLE "
|
||
"supports this capability if ``Options/General/Default Source Encoding/"
|
||
"UTF-8`` is set. Notice that this signature is not understood in older Python "
|
||
"releases (2.2 and earlier), and also not understood by the operating system "
|
||
"for script files with ``#!`` lines (only used on Unix systems)."
|
||
msgstr ""
|
||
"Si votre éditeur peut enregistrer les fichiers en ``UTF-8`` avec un "
|
||
"indicateur d'ordre des octets (*BOM*), vous pouvez l'utiliser à la place de "
|
||
"la déclaration d'encodage. IDLE peut le faire si l'option ``Options/General/"
|
||
"Default Source Encoding/UTF-8`` est configurée. Notez que cet indicateur "
|
||
"n'est pas géré par les versions plus anciennes de Python (plus vieilles que "
|
||
"2.2 inclue), et aussi n'est pas compris par le shebang unix ``#!``."
|
||
|
||
# 54d62eeac9bc4555818501cd2d0d843d
|
||
#: tutorial/interpreter.rst:157
|
||
msgid ""
|
||
"By using UTF-8 (either through the signature or an encoding declaration), "
|
||
"characters of most languages in the world can be used simultaneously in "
|
||
"string literals and comments. Using non-ASCII characters in identifiers is "
|
||
"not supported. To display all these characters properly, your editor must "
|
||
"recognize that the file is UTF-8, and it must use a font that supports all "
|
||
"the characters in the file."
|
||
msgstr ""
|
||
"En utilisant UTF-8 (soit via un indicateur soit via une déclaration), les "
|
||
"caractères de la pluspart les langages du monde peuvent être utilisés dans "
|
||
"les mêmes chaînes de caractères litérales, et dans les commentaires. "
|
||
"Utiliser des caractères autres que les caractères ASCII dans les "
|
||
"identifiants n'est pas supporté. Pour afficher tous ces caractères "
|
||
"correctement, votre éditeur doit reconnaître que le fichier est encodé en "
|
||
"UTF-8, et il doit utiliser une fonte de caractères comprenant tous les "
|
||
"caractères utilisés dans le fichier."
|
||
|
||
#: tutorial/introduction.rst:5
|
||
msgid "An Informal Introduction to Python"
|
||
msgstr "Introduction informelle à Python"
|
||
|
||
#: tutorial/introduction.rst:7
|
||
#, fuzzy
|
||
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 (``>>>`` et ``...``) : pour reproduire les "
|
||
"exemples, vous devez taper tout ce qui est après l'invite, au moment où "
|
||
"celle-ci apparaît ; les lignes qui n'affichent pas d'invite sont les sorties "
|
||
"de l'interpréteur. Notez qu'une invite secondaire affichée seule sur une "
|
||
"ligne dans un exemple indique que vous devez entrer une ligne vide ; ceci "
|
||
"est utilisé pour terminer une commande multi-lignes."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/introduction.rst:33
|
||
msgid "Using Python as a Calculator"
|
||
msgstr "Utiliser Python comme une calculatrice"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/introduction.rst:42
|
||
msgid "Numbers"
|
||
msgstr "Les nombres"
|
||
|
||
#: tutorial/introduction.rst:44
|
||
#, fuzzy
|
||
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 ::"
|
||
|
||
# 7b9b56f9e273421eb20e67d6bde63dbd
|
||
#: 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."
|
||
|
||
# 659e965541a646aab63e6d711725f32d
|
||
#: tutorial/introduction.rst:63
|
||
msgid ""
|
||
"The return type of a division (``/``) operation depends on its operands. If "
|
||
"both operands are of type :class:`int`, :term:`floor division` is performed "
|
||
"and an :class:`int` is returned. If either operand is a :class:`float`, "
|
||
"classic division is performed and a :class:`float` is returned. The ``//`` "
|
||
"operator is also provided for doing floor division no matter what the "
|
||
"operands are. The remainder can be calculated with the ``%`` operator::"
|
||
msgstr ""
|
||
"Le type donné en résultat d'une division (``/``) dépend de ses opérandes. Si "
|
||
"les deux opérandes sont de type :class:`int`, c'est une :term:`division "
|
||
"entière` qui est effectuée, et un :class:`int` et donné. Si l'une des "
|
||
"opérandes est un :class:`float`, une division classique est effectuée et un :"
|
||
"class:`float` est renvoyé. L'opérateur ``//`` permet quand à lui d'effectuer "
|
||
"des division entières peu importe ses opérandes. Le reste de la division est "
|
||
"calculé grâce à l'opérateur ``%`` ::"
|
||
|
||
# 488914a0ef4a4523ad455e804719d93c
|
||
#: tutorial/introduction.rst:81
|
||
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 "
|
||
"``**`` [#]_ ::"
|
||
|
||
#: tutorial/introduction.rst:88
|
||
#, fuzzy
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:96
|
||
#, fuzzy
|
||
msgid ""
|
||
"If a variable is not \"defined\" (assigned a value), trying to use it will "
|
||
"give you an error::"
|
||
msgstr ""
|
||
"Les variables doivent être \"définies\" (une valeur doit leur être affectée) "
|
||
"pour qu'elles puissent être utilisées, sans quoi une erreur interviendra ::"
|
||
|
||
#: tutorial/introduction.rst:104
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:112
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:125
|
||
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."
|
||
|
||
# 19a0a69a362f45c19ef8d6d6a29e0465
|
||
#: tutorial/introduction.rst:129
|
||
msgid ""
|
||
"In addition to :class:`int` and :class:`float`, Python supports other types "
|
||
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
|
||
"Fraction`. Python also has built-in support for :ref:`complex numbers "
|
||
"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "
|
||
"imaginary part (e.g. ``3+5j``)."
|
||
msgstr ""
|
||
"En plus des :class:`int` et des :class:`float`, il existe les :class:"
|
||
"`~decimal.Decimal` et les :class:`~fractions.Fraction`. Python gère aussi "
|
||
"les :ref:`nombre complexes <typesnumeric>`, en utilisant le suffixe ``j`` ou "
|
||
"``J`` pour indiquer la partie imaginaire (tel que: ``3+5j``)."
|
||
|
||
#: tutorial/introduction.rst:139
|
||
msgid "Strings"
|
||
msgstr "Les chaînes de caractères"
|
||
|
||
#: tutorial/introduction.rst:141
|
||
#, fuzzy
|
||
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 apostrophes ou entre guillemets."
|
||
|
||
# 9c733fd1348b4d048794c552b36f40fe
|
||
#: tutorial/introduction.rst:159
|
||
#, fuzzy
|
||
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 :keyword:`print` statement produces a more "
|
||
"readable output, by omitting the enclosing quotes and by printing escaped "
|
||
"and special characters::"
|
||
msgstr ""
|
||
"L'interpréteur affiche les chaînes de caractères de la même manière qu'elles "
|
||
"s'écrivent : entre guillemets et en protégant les guillemets et autres "
|
||
"caractères spéciaux avec des antislash, afin d'afficher une représentation "
|
||
"précise. La chaîne est affichée entre guillemets si elle contient un "
|
||
"guillemet simple mais aucun guillemet, sinon elle est affichée entre "
|
||
"guillemets simples."
|
||
|
||
# 19c1122b24cf49138e4523f22314bff9
|
||
#: tutorial/introduction.rst:179
|
||
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`` ::"
|
||
|
||
# c62f03c744a64be280c22a78c455a790
|
||
#: tutorial/introduction.rst:189
|
||
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 ::"
|
||
|
||
# 11daeac1da4f4f93ae387aad6a042560
|
||
#: tutorial/introduction.rst:200
|
||
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) :"
|
||
|
||
#: tutorial/introduction.rst:208
|
||
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 ``*``::"
|
||
|
||
# 15608e4291844e01803013d0842e63bf
|
||
#: tutorial/introduction.rst:215
|
||
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. ::"
|
||
|
||
# 19c4cdfc11354a0ba24e43dc7e257efb
|
||
#: tutorial/introduction.rst:221
|
||
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 ::"
|
||
|
||
# b4fabb6326ca4278b57d37982f33c928
|
||
#: tutorial/introduction.rst:231
|
||
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 ``+``::"
|
||
|
||
# 4da7e6d1dc5940b69c55b49bd22ca20e
|
||
#: tutorial/introduction.rst:236
|
||
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 ::"
|
||
|
||
# 81b99e3ed45148568543d7906b031fef
|
||
#: tutorial/introduction.rst:243
|
||
#, fuzzy
|
||
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 ; comme en C, le premier "
|
||
"caractère d'une chaîne est à la position 0. Il n'existe pas de type distinct "
|
||
"pour les caractères ; un caractère est simplement une chaîne de longueur 1. "
|
||
"Comme dans Icon, des sous-chaînes peuvent être spécifiées via une *notation "
|
||
"par tranches* : deux indices séparés par deux points ::"
|
||
|
||
#: tutorial/introduction.rst:253
|
||
#, fuzzy
|
||
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 ::"
|
||
|
||
# 2396721f786f406abc44eac947210655
|
||
#: tutorial/introduction.rst:262
|
||
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."
|
||
|
||
# 9a6822d665b84ab3a5d38055c73bb077
|
||
#: tutorial/introduction.rst:264
|
||
#, fuzzy
|
||
msgid ""
|
||
"In addition to indexing, *slicing* is also supported. While indexing is "
|
||
"used to obtain individual characters, *slicing* allows you to obtain a "
|
||
"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 ::"
|
||
|
||
# b7c539be3f7b473d81fc2321525dd5e7
|
||
#: tutorial/introduction.rst:272
|
||
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`` ::"
|
||
|
||
#: tutorial/introduction.rst:280
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:290
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:301
|
||
#, fuzzy
|
||
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...5 dans la "
|
||
"chaîne ; la deuxième ligne donne l'indice négatif correspondant. La tranche "
|
||
"de *i* à *j* est constituée de tous les caractères situés entre les bords "
|
||
"libellés *i* et *j*, respectivement."
|
||
|
||
#: tutorial/introduction.rst:306
|
||
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."
|
||
|
||
# f740872fc6ac484ca5465bdb0819ee73
|
||
#: tutorial/introduction.rst:310
|
||
#, fuzzy
|
||
msgid "Attempting to use a index that is too large will result in an error::"
|
||
msgstr "Utiliser un indice trop grand générera une erreur ::"
|
||
|
||
# b8602220b26e4c1a9f6ffb179188e2f0
|
||
#: tutorial/introduction.rst:317
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:325
|
||
#, fuzzy
|
||
msgid ""
|
||
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
|
||
"assigning to an indexed position in the string results in an error::"
|
||
msgstr ""
|
||
"À la différence des chaînes de caractères en C, les chaînes Python ne "
|
||
"peuvent pas être modifiées. Affecter une nouvelle valeur à un indice d'une "
|
||
"chaîne produit une erreur ::"
|
||
|
||
# e6f19742421b4743a89d8785cf57573e
|
||
#: tutorial/introduction.rst:335
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:342
|
||
msgid "The built-in function :func:`len` returns the length of a string::"
|
||
msgstr "La fonction native :func:`len` renvoie la longue d'une chaîne ::"
|
||
|
||
#: tutorial/introduction.rst:354
|
||
msgid "typesseq"
|
||
msgstr "typesseq"
|
||
|
||
# dc94a4264e3a4a0fa21b4f0848b59ea8
|
||
#: tutorial/introduction.rst:352
|
||
msgid ""
|
||
"Strings, and the Unicode strings described in the next section, are examples "
|
||
"of *sequence types*, and support the common operations supported by such "
|
||
"types."
|
||
msgstr ""
|
||
"Les chaînes de caractères, et les chaînes Unicode décrites dans la prochaine "
|
||
"section, sont des exemples de *types de séquences*, et supportent donc les "
|
||
"opérations classiques prises en charge par ces types."
|
||
|
||
#: tutorial/introduction.rst:358
|
||
msgid "string-methods"
|
||
msgstr "string-methods"
|
||
|
||
# 0e3c9c88390d40f8b435ceca2e3e5fa2
|
||
#: tutorial/introduction.rst:357
|
||
msgid ""
|
||
"Both strings and Unicode strings support a large number of methods for basic "
|
||
"transformations and searching."
|
||
msgstr ""
|
||
"Aussi bien les chaînes de caractères que les chaînes Unicode supportent un "
|
||
"large éventail de méthodes de transformations basiques et de recherche."
|
||
|
||
#: tutorial/introduction.rst:362
|
||
#, fuzzy
|
||
msgid "new-string-formatting"
|
||
msgstr "Anciennes méthodes de formatage de chaînes"
|
||
|
||
#: tutorial/introduction.rst:361
|
||
msgid ""
|
||
"Information about string formatting with :meth:`str.format` is described "
|
||
"here."
|
||
msgstr ""
|
||
"Le formatage des chaînes avec la méthode :meth:`str.format` est décrit ici."
|
||
|
||
#: tutorial/introduction.rst:365
|
||
#, fuzzy
|
||
msgid "string-formatting"
|
||
msgstr "Anciennes méthodes de formatage de chaînes"
|
||
|
||
#: tutorial/introduction.rst:365
|
||
msgid ""
|
||
"The old formatting operations invoked when strings and Unicode strings are "
|
||
"the left operand of the ``%`` operator are described in more detail here."
|
||
msgstr ""
|
||
"Les anciennes opérations de formatage appelées lorsque les chaînes de "
|
||
"caractères et les chaînes Unicode sont les opérandes placés à gauche de "
|
||
"l'opérateur ``%`` sont décrites plus en détail ici."
|
||
|
||
# e9f5c7de8cd043048a81c59a606bda57
|
||
#: tutorial/introduction.rst:372
|
||
msgid "Unicode Strings"
|
||
msgstr "Chaînes Unicode"
|
||
|
||
# ff4a88fc4dbf4203a1963c8e8042a016
|
||
#: tutorial/introduction.rst:377
|
||
msgid ""
|
||
"Starting with Python 2.0 a new data type for storing text data is available "
|
||
"to the programmer: the Unicode object. It can be used to store and "
|
||
"manipulate Unicode data (see http://www.unicode.org/) and integrates well "
|
||
"with the existing string objects, providing auto-conversions where necessary."
|
||
msgstr ""
|
||
"À partir de Python 2.0, un nouveau type permettant de stocker du texte est "
|
||
"mis à la disposition du programmeur : le type Unicode. Il peut être utilisé "
|
||
"pour stocker et manipuler des données Unicode (voir http://www.unicode.org/) "
|
||
"et s'intègre très bien avec les types de chaînes de caractères existant, en "
|
||
"fournissant une conversion automatique lorsque c'est nécessaire."
|
||
|
||
#: tutorial/introduction.rst:382
|
||
msgid ""
|
||
"Unicode has the advantage of providing one ordinal for every character in "
|
||
"every script used in modern and ancient texts. Previously, there were only "
|
||
"256 possible ordinals for script characters. Texts were typically bound to a "
|
||
"code page which mapped the ordinals to script characters. This lead to very "
|
||
"much confusion especially with respect to internationalization (usually "
|
||
"written as ``i18n`` --- ``'i'`` + 18 characters + ``'n'``) of software. "
|
||
"Unicode solves these problems by defining one code page for all scripts."
|
||
msgstr ""
|
||
"Unicode a l'avantage de fournir une valeur ordinale pour chaque caractère "
|
||
"d'un script utilisé aussi bien dans d'anciens textes que dans des textes "
|
||
"modernes. Auparavant, il n'y avait que 256 valeurs ordinales possibles pour "
|
||
"chaque caractère. Chaque texte était typiquement associé à une page de codes "
|
||
"qui associait une valeur ordinale à chaque caractère. Ceci conduisait à une "
|
||
"grande confusion, notamment pour tout ce qui touchait à "
|
||
"l'internationalisation (souvent écrite ``i18n`` --- ``'i'`` + 18 caractères "
|
||
"+ ``'n'``) des logiciels. Unicode résout ces problèmes en définissant une "
|
||
"page de code unique pour tous les scripts."
|
||
|
||
# 9c768ff79bed4b06873ef02799f68dee
|
||
#: tutorial/introduction.rst:390
|
||
msgid ""
|
||
"Creating Unicode strings in Python is just as simple as creating normal "
|
||
"strings::"
|
||
msgstr ""
|
||
"Créer des chaînes Unicode en Python est aussi simple que de créer des "
|
||
"chaînes de caractères normales ::"
|
||
|
||
# 49929afe29c94cd38e866dcbb014004e
|
||
#: tutorial/introduction.rst:396
|
||
msgid ""
|
||
"The small ``'u'`` in front of the quote indicates that a Unicode string is "
|
||
"supposed to be created. If you want to include special characters in the "
|
||
"string, you can do so by using the Python *Unicode-Escape* encoding. The "
|
||
"following example shows how::"
|
||
msgstr ""
|
||
"Le petit ``'u'`` qui précède l'apostrophe indique que l'on veut créer une "
|
||
"chaîne Unicode. Si vous voulez intégrer des caractères spéciaux dans la "
|
||
"chaîne, vous pouvez le faire en utilisant l'encodage Python d'échappement "
|
||
"des caractères Unicode. Comme dans cet exemple ::"
|
||
|
||
#: tutorial/introduction.rst:404
|
||
msgid ""
|
||
"The escape sequence ``\\u0020`` indicates to insert the Unicode character "
|
||
"with the ordinal value 0x0020 (the space character) at the given position."
|
||
msgstr ""
|
||
"La séquence d'échappement ``\\u0020`` indique d'insérer le caractère Unicode "
|
||
"de valeur ordinale 0x0020 (un espace) à la position indiquée."
|
||
|
||
#: tutorial/introduction.rst:407
|
||
msgid ""
|
||
"Other characters are interpreted by using their respective ordinal values "
|
||
"directly as Unicode ordinals. If you have literal strings in the standard "
|
||
"Latin-1 encoding that is used in many Western countries, you will find it "
|
||
"convenient that the lower 256 characters of Unicode are the same as the 256 "
|
||
"characters of Latin-1."
|
||
msgstr ""
|
||
"Les autres caractères sont interprétés en utilisant leurs valeurs ordinales "
|
||
"respectives directement comme des ordinaux Unicode. Si vous avez des chaînes "
|
||
"littérales dans l'encodage standard Latin-1 utilisé dans de nombreux pays "
|
||
"occidentaux, vous trouverez pratique que les 256 premiers caractères Unicode "
|
||
"soient les mêmes que ceux de l'encodage Latin-1."
|
||
|
||
# e704dbdcc7b84d5fa5187b18e3df045b
|
||
#: tutorial/introduction.rst:413
|
||
msgid ""
|
||
"For experts, there is also a raw mode just like the one for normal strings. "
|
||
"You have to prefix the opening quote with 'ur' to have Python use the *Raw-"
|
||
"Unicode-Escape* encoding. It will only apply the above ``\\uXXXX`` "
|
||
"conversion if there is an uneven number of backslashes in front of the small "
|
||
"'u'. ::"
|
||
msgstr ""
|
||
"Pour les experts, il existe également un mode \"brut\" identique à celui "
|
||
"disponible pour les chaînes de caractères. Vous devez préfixer la première "
|
||
"apostrophe avec 'ur' pour que Python utilise l'encodage *Unicode-Brut*. Il "
|
||
"n'appliquera la conversion ``\\uXXXX`` de l'exemple ci-dessous que s'il y a "
|
||
"un nombre impair d'antislashs devant le petit 'u' ::"
|
||
|
||
# f7d8ba88d48343f1bc5e81982b1faf00
|
||
#: tutorial/introduction.rst:424
|
||
msgid ""
|
||
"The raw mode is most useful when you have to enter lots of backslashes, as "
|
||
"can be necessary in regular expressions."
|
||
msgstr ""
|
||
"Le mode brut est le plus utile lorsque vous devez saisir de nombreux "
|
||
"antislashs, comme il peut être nécessaire de le faire dans des expressions "
|
||
"rationnelles."
|
||
|
||
#: tutorial/introduction.rst:427
|
||
msgid ""
|
||
"Apart from these standard encodings, Python provides a whole set of other "
|
||
"ways of creating Unicode strings on the basis of a known encoding."
|
||
msgstr ""
|
||
"En dehors de ces encodages standards, Python fournit d'autres méthodes pour "
|
||
"créer des chaînes Unicode sur la base d'un encodage connu."
|
||
|
||
# 6b911ea5f8a24a2a8531621f77f2b074
|
||
#: tutorial/introduction.rst:432
|
||
msgid ""
|
||
"The built-in function :func:`unicode` provides access to all registered "
|
||
"Unicode codecs (COders and DECoders). Some of the more well known encodings "
|
||
"which these codecs can convert are *Latin-1*, *ASCII*, *UTF-8*, and "
|
||
"*UTF-16*. The latter two are variable-length encodings that store each "
|
||
"Unicode character in one or more bytes. The default encoding is normally set "
|
||
"to ASCII, which passes through characters in the range 0 to 127 and rejects "
|
||
"any other characters with an error. When a Unicode string is printed, "
|
||
"written to a file, or converted with :func:`str`, conversion takes place "
|
||
"using this default encoding. ::"
|
||
msgstr ""
|
||
"La primitive :func:`unicode` donne accès à tous les codecs (COdeurs et "
|
||
"DECodeurs) enregistrés. Certains des encodages les plus connus pris en "
|
||
"charge par ces codecs sont *Latin-1*, *ASCII*, *UTF-8* et *UTF-16*. Les deux "
|
||
"derniers sont des encodages à longueur variable qui stockent chaque "
|
||
"caractère Unicode dans un ou plusieurs octets. L'encodage par défaut est "
|
||
"normalement défini en ASCII, qui gère les caractères de valeur ordinale 0 à "
|
||
"127 et rejette tous les autres caractères avec une erreur. Quand une chaîne "
|
||
"Unicode est imprimée, écrite dans un fichier ou convertie avec la fonction :"
|
||
"func:`str`, une conversion s'effectue en utilisant cet encodage par défaut ::"
|
||
|
||
# 8b0b7540567140749bbd4a088d41db0b
|
||
#: tutorial/introduction.rst:452
|
||
msgid ""
|
||
"To convert a Unicode string into an 8-bit string using a specific encoding, "
|
||
"Unicode objects provide an :func:`encode` method that takes one argument, "
|
||
"the name of the encoding. Lowercase names for encodings are preferred. ::"
|
||
msgstr ""
|
||
"Pour convertir une chaîne Unicode en une chaîne encodée sur 8 bits en "
|
||
"utilisant un encodage spécifique, les objets Unicode fournissent une "
|
||
"méthode :func:`encode` qui prend pour argument le nom de l'encodage. Les "
|
||
"noms d'encodages en minuscules sont préférés ::"
|
||
|
||
# 88ffe7f4fb0340b290b1ce47aced804e
|
||
#: tutorial/introduction.rst:459
|
||
msgid ""
|
||
"If you have data in a specific encoding and want to produce a corresponding "
|
||
"Unicode string from it, you can use the :func:`unicode` function with the "
|
||
"encoding name as the second argument. ::"
|
||
msgstr ""
|
||
"Si vous avez une donnée dans un encodage spécifique et voulez générer la "
|
||
"chaîne Unicode correspondante, vous pouvez utiliser la fonction :func:"
|
||
"`unicode` en fournissant le nom de l'encodage comme second argument ::"
|
||
|
||
#: tutorial/introduction.rst:470
|
||
msgid "Lists"
|
||
msgstr "Les listes"
|
||
|
||
#: tutorial/introduction.rst:472
|
||
#, fuzzy
|
||
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 espaces placée "
|
||
"entre crochets. Les éléments d'une liste ne doivent pas obligatoirement être "
|
||
"tous du même type ::"
|
||
|
||
# 81098069b1194a0187318b856300bed8
|
||
#: tutorial/introduction.rst:481
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:491
|
||
#, fuzzy
|
||
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 *a* ::"
|
||
|
||
# f7fe9f98c794433782fc91cb7e94bf90
|
||
#: tutorial/introduction.rst:497
|
||
#, fuzzy
|
||
msgid "Lists also supports operations like concatenation::"
|
||
msgstr "Les listes gèrent aussi les opérations comme les concaténations ::"
|
||
|
||
#: tutorial/introduction.rst:502
|
||
#, fuzzy
|
||
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 *immuables*, il est possible de "
|
||
"modifier un élément d'une liste ::"
|
||
|
||
# 48a20ff5d1ce4fbf8027ba7b65a64c9b
|
||
#: tutorial/introduction.rst:512
|
||
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) ::"
|
||
|
||
#: tutorial/introduction.rst:520
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:539
|
||
msgid "The built-in function :func:`len` also applies to lists::"
|
||
msgstr "La primitive :func:`len` s'applique aussi aux listes ::"
|
||
|
||
#: tutorial/introduction.rst:545
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:561
|
||
msgid "First Steps Towards Programming"
|
||
msgstr "Premiers pas vers la programmation"
|
||
|
||
#: tutorial/introduction.rst:563
|
||
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 ::"
|
||
|
||
#: tutorial/introduction.rst:581
|
||
msgid "This example introduces several new features."
|
||
msgstr "Cet exemple introduit plusieurs nouvelles fonctionnalités."
|
||
|
||
#: tutorial/introduction.rst:583
|
||
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."
|
||
|
||
#: tutorial/introduction.rst:589
|
||
msgid ""
|
||
"The :keyword:`while` loop executes as long as the condition (here: ``b < "
|
||
"10``) remains true. In Python, like in C, any non-zero integer value is "
|
||
"true; zero is false. The condition may also be a string or list value, in "
|
||
"fact any sequence; anything with a non-zero length is true, empty sequences "
|
||
"are false. The test used in the example is a simple comparison. The "
|
||
"standard comparison operators are written the same as in C: ``<`` (less "
|
||
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
|
||
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
|
||
msgstr ""
|
||
"La boucle :keyword:`while` s'exécute tant que la condition (ici : ``b < "
|
||
"10``) reste vraie. En Python, comme en C, tout entier différent de zéro est "
|
||
"vrai et zéro est faux. La condition peut aussi être une chaîne de "
|
||
"caractères, une liste, ou en fait toute séquence ; une séquence avec une "
|
||
"valeur non nulle est vraie, une séquence vide est fausse. Le test utilisé "
|
||
"dans l'exemple est une simple comparaison. Les opérateurs de comparaison "
|
||
"standards sont écrits comme en C : ``<`` (inférieur), ``>`` (supérieur), "
|
||
"``==`` (égal), ``<=`` (inférieur ou égal), ``>=`` (supérieur ou égal) et ``!"
|
||
"=`` (non égal)."
|
||
|
||
# c3ffd8600fb6465eb41e1b71ee58a106
|
||
#: tutorial/introduction.rst:598
|
||
msgid ""
|
||
"The *body* of the loop is *indented*: indentation is Python's way of "
|
||
"grouping statements. At the interactive prompt, you have to type a tab or "
|
||
"space(s) for each indented line. In practice you will prepare more "
|
||
"complicated input for Python with a text editor; all decent text editors "
|
||
"have an auto-indent facility. When a compound statement is entered "
|
||
"interactively, it must be followed by a blank line to indicate completion "
|
||
"(since the parser cannot guess when you have typed the last line). Note "
|
||
"that each line within a basic block must be indented by the same amount."
|
||
msgstr ""
|
||
"Le *corps* de la boucle est *indenté* : l'indentation est la méthode "
|
||
"utilisée par Python pour regrouper des instructions. En mode interactif, "
|
||
"vous devez saisir une tabulation ou des espaces pour chaque ligne indentée. "
|
||
"En pratique, vous aurez intérêt à utiliser un éditeur de texte pour les "
|
||
"saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom "
|
||
"disposent d'une fonction d'auto-indentation. Lorsqu'une expression composée "
|
||
"est saisie en mode interactif, elle doit être suivie d'une ligne vide pour "
|
||
"indiquer qu'elle est terminée (car l'analyseur ne peut pas deviner que vous "
|
||
"venez de saisir la dernière ligne). Notez bien que toutes les lignes à "
|
||
"l'intérieur d'un bloc doivent être indentées au même niveau."
|
||
|
||
# 77dfda61249149ebbff3415dc7f626c0
|
||
#: tutorial/introduction.rst:607
|
||
msgid ""
|
||
"The :keyword:`print` statement writes the value of the expression(s) it is "
|
||
"given. It differs from just writing the expression you want to write (as we "
|
||
"did earlier in the calculator examples) in the way it handles multiple "
|
||
"expressions and strings. Strings are printed without quotes, and a space is "
|
||
"inserted between items, so you can format things nicely, like this::"
|
||
msgstr ""
|
||
"L'instruction :keyword:`print` écrit la valeur de l'expression qui lui est "
|
||
"fournie. Ce n'est pas la même chose que d'écrire l'expression que vous "
|
||
"voulez écrire (comme nous l'avons fait dans l'exemple de la calculatrice), "
|
||
"et diffère dans la façon dont elle gère les expressions et chaînes de "
|
||
"caractères multiples. Les chaînes sont imprimées sans apostrophes et un "
|
||
"espace est inséré entre les éléments de telle sorte que vous pouvez "
|
||
"facilement formater les choses, comme ceci ::"
|
||
|
||
# f1fa0b0caa934963ad37b6df950d1d60
|
||
#: tutorial/introduction.rst:617
|
||
msgid "A trailing comma avoids the newline after the output::"
|
||
msgstr "Une virgule à la fin de l'instruction supprime le saut de ligne ::"
|
||
|
||
# 9af5f173627d4c51a46b129d40db499d
|
||
#: tutorial/introduction.rst:626
|
||
msgid ""
|
||
"Note that the interpreter inserts a newline before it prints the next prompt "
|
||
"if the last line was not completed."
|
||
msgstr ""
|
||
"Notez que l'interpréteur insère un saut de ligne avant d'afficher l'invite "
|
||
"suivante si la dernière ligne n'était pas complète."
|
||
|
||
# 18b4eeae89f74e5986a556177ba9f3a6
|
||
#: tutorial/introduction.rst:631
|
||
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``."
|
||
|
||
# 986c20e64eda48919db6dac30f3acab2
|
||
#: tutorial/introduction.rst:635
|
||
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."
|
||
|
||
#: tutorial/modules.rst:5
|
||
msgid "Modules"
|
||
msgstr "Modules"
|
||
|
||
#: 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."
|
||
|
||
#: 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)."
|
||
|
||
#: 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 ::"
|
||
|
||
#: tutorial/modules.rst:44
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:49
|
||
msgid ""
|
||
"This does not enter the names of the functions defined in ``fibo`` directly "
|
||
"in the current symbol table; it only enters the module name ``fibo`` there. "
|
||
"Using the module name you can access the functions::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/modules.rst:60
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:70
|
||
msgid "More on Modules"
|
||
msgstr "Les modules en détails"
|
||
|
||
# 68120fe1cf1e43d2b26b0e1e3af197bb
|
||
#: tutorial/modules.rst:72
|
||
msgid ""
|
||
"A module can contain executable statements as well as function definitions. "
|
||
"These statements are intended to initialize the module. They are executed "
|
||
"only the *first* time the module 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.)"
|
||
|
||
#: tutorial/modules.rst:77
|
||
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``."
|
||
|
||
#: tutorial/modules.rst:84
|
||
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."
|
||
|
||
#: tutorial/modules.rst:89
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:96
|
||
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)."
|
||
|
||
#: tutorial/modules.rst:99
|
||
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 ::"
|
||
|
||
# a576f929fa4b4f03a5ecc568fbc39da4
|
||
#: tutorial/modules.rst:105
|
||
msgid ""
|
||
"This imports all names except those beginning with an underscore (``_``)."
|
||
msgstr "Importe tous les noms sauf ceux commençant par un tiret bas (``_``)."
|
||
|
||
#: tutorial/modules.rst:107
|
||
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."
|
||
|
||
# 43ceb255506f40879d48e04284318f2b
|
||
#: tutorial/modules.rst:113
|
||
#, fuzzy
|
||
msgid ""
|
||
"For efficiency reasons, each module is only imported once per interpreter "
|
||
"session. Therefore, if you change your modules, you must restart the "
|
||
"interpreter -- or, if it's just one module you want to test interactively, "
|
||
"use :func:`reload`, e.g. ``reload(modulename)``."
|
||
msgstr ""
|
||
"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:`imp.reload`, par exemple : ``import imp; imp."
|
||
"reload(modulename)``."
|
||
|
||
#: tutorial/modules.rst:122
|
||
msgid "Executing modules as scripts"
|
||
msgstr "Exécuter des modules comme des scripts"
|
||
|
||
#: tutorial/modules.rst:124
|
||
msgid "When you run a Python module with ::"
|
||
msgstr "Lorsque vous exécutez un module Python avec ::"
|
||
|
||
#: tutorial/modules.rst:128
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:136
|
||
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 ""
|
||
"vous pouvez rendre le fichier utilisable comme un script ou importable en "
|
||
"temps que module, puisque le code qui lis les paramètres de la ligne de "
|
||
"commande n'est exécuté que si le module est le fichier principal ::"
|
||
|
||
#: tutorial/modules.rst:143
|
||
msgid "If the module is imported, the code is not run::"
|
||
msgstr "Si le fichier est importé, le code n'est pas exécuté ::"
|
||
|
||
#: tutorial/modules.rst:148
|
||
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)."
|
||
|
||
#: tutorial/modules.rst:155
|
||
msgid "The Module Search Path"
|
||
msgstr "Les dossiers de recherche de modules"
|
||
|
||
# 7eb1de98727b457bb47241fe0f9a3c7a
|
||
#: tutorial/modules.rst:159
|
||
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` initialisée par défaut "
|
||
"à ::"
|
||
|
||
# 2cfb18e596454d35aba4942f36ffb217
|
||
#: tutorial/modules.rst:164
|
||
msgid "the directory containing the input script (or the current directory)."
|
||
msgstr "le dossier contenant le script d'entrée (ou le dossier courant)."
|
||
|
||
# 92b653933f904f2ba5db5eeb5106e97d
|
||
#: tutorial/modules.rst:165
|
||
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`)."
|
||
|
||
# 5f64433feec849c99a5c0234fbe44b86
|
||
#: tutorial/modules.rst:167
|
||
msgid "the installation-dependent default."
|
||
msgstr "les valeurs par défaut dépendantes de l'installation."
|
||
|
||
# 06804f6bce114936a931a03ac145ec9a
|
||
#: tutorial/modules.rst:169
|
||
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."
|
||
|
||
#: tutorial/modules.rst:178
|
||
msgid "\"Compiled\" Python files"
|
||
msgstr "Fichiers Python \"compilés\""
|
||
|
||
#: tutorial/modules.rst:180
|
||
msgid ""
|
||
"As an important speed-up of the start-up time for short programs that use a "
|
||
"lot of standard modules, if a file called :file:`spam.pyc` exists in the "
|
||
"directory where :file:`spam.py` is found, this is assumed to contain an "
|
||
"already-\"byte-compiled\" version of the module :mod:`spam`. The "
|
||
"modification time of the version of :file:`spam.py` used to create :file:"
|
||
"`spam.pyc` is recorded in :file:`spam.pyc`, and the :file:`.pyc` file is "
|
||
"ignored if these don't match."
|
||
msgstr ""
|
||
"Un gain de temps important au démarrage pour les courts programmes utilisant "
|
||
"beaucoup de modules standards, si un fichier :file:`spam.pyc` existe dans le "
|
||
"dossier où :file:`spam.py`est trouvé, il est supposé contenir une version "
|
||
"compilée du module :mod:`spam`. La date de modification du fichier :file:"
|
||
"`spam.py` est utilisée pour créer le fichier :file:`spam.pyc`, ainsi le "
|
||
"fichier :file:`.pyc` est ignoré si ces deux dates ne coïncident pas."
|
||
|
||
#: tutorial/modules.rst:187
|
||
msgid ""
|
||
"Normally, you don't need to do anything to create the :file:`spam.pyc` file. "
|
||
"Whenever :file:`spam.py` is successfully compiled, an attempt is made to "
|
||
"write the compiled version to :file:`spam.pyc`. It is not an error if this "
|
||
"attempt fails; if for any reason the file is not written completely, the "
|
||
"resulting :file:`spam.pyc` file will be recognized as invalid and thus "
|
||
"ignored later. The contents of the :file:`spam.pyc` file are platform "
|
||
"independent, so a Python module directory can be shared by machines of "
|
||
"different architectures."
|
||
msgstr ""
|
||
"Normalement, vous n'avez rien à faire pour créer un fichier :file:`spam."
|
||
"pyc`. Lorsque le fichier :file:`spam.py` est compilé, Python essaye d'écrire "
|
||
"la version compilée dans :file:`spam.pyc`. Ce n'est pas une erreur si cette "
|
||
"tentative échoue, et si pour n'importe quelle raison, le fichier :file:`."
|
||
"pyc` viendrait à ne pas être écrit entièrement, il serait reconnu comme "
|
||
"invalide et ignoré. Le contenu du fichier :file:`spam.pyc` est indépendant "
|
||
"de la plateforme, donc un dossier contenant des modules Python peut être "
|
||
"partagé entre différentes machines de différentes architectures."
|
||
|
||
#: tutorial/modules.rst:195
|
||
msgid "Some tips for experts:"
|
||
msgstr "Astuces pour les experts :"
|
||
|
||
#: tutorial/modules.rst:197
|
||
msgid ""
|
||
"When the Python interpreter is invoked with the :option:`-O` flag, optimized "
|
||
"code is generated and stored in :file:`.pyo` files. The optimizer currently "
|
||
"doesn't help much; it only removes :keyword:`assert` statements. When :"
|
||
"option:`-O` is used, *all* :term:`bytecode` is optimized; ``.pyc`` files are "
|
||
"ignored and ``.py`` files are compiled to optimized bytecode."
|
||
msgstr ""
|
||
"Lorsque l'interpréteur Python est invoqué avec l'option :option:`-O`, un "
|
||
"code optimisé est généré et stocké dans des fichiers en :file:`.pyo`. "
|
||
"L'optimiseur, aujourd'hui, n'aide pas beaucoup, il ne fait que supprimer les "
|
||
"instructions :keyword:`assert`. Lorsque l'option :option:`-O` est utilisée, "
|
||
"*tous* les bytecodes sont optimisés, les fichiers ``.pyc`` sont ignorés, et "
|
||
"les fichier ``.py`` compilés en un bytecode optimisé."
|
||
|
||
#: tutorial/modules.rst:203
|
||
msgid ""
|
||
"Passing two :option:`-O` flags to the Python interpreter (:option:`-OO`) "
|
||
"will cause the bytecode compiler to perform optimizations that could in some "
|
||
"rare cases result in malfunctioning programs. Currently only ``__doc__`` "
|
||
"strings are removed from the bytecode, resulting in more compact :file:`."
|
||
"pyo` files. Since some programs may rely on having these available, you "
|
||
"should only use this option if you know what you're doing."
|
||
msgstr ""
|
||
"Donner deux :option:`-O` à l'interpréteur (:option:`-OO`) engendrera un "
|
||
"bytecode qui pourrait dans de rare cas provoquer un dysfonctionnement du "
|
||
"programme. Actuellement seulement les chaînes ``__doc__`` sont retirés du "
|
||
"bytecode, rendant les :file:`.pyo` plus petits. Puisque certains programmes "
|
||
"peuvent en avoir besoin, vous ne devriez utiliser cette option que si vous "
|
||
"savez ce que vous faites."
|
||
|
||
#: tutorial/modules.rst:210
|
||
msgid ""
|
||
"A program doesn't run any faster when it is read from a :file:`.pyc` or :"
|
||
"file:`.pyo` file than when it is read from a :file:`.py` file; the only "
|
||
"thing that's faster about :file:`.pyc` or :file:`.pyo` files is the speed "
|
||
"with which they are loaded."
|
||
msgstr ""
|
||
"Un programme ne s'exécute pas plus vite lorsqu'il est lu depuis un :file:`."
|
||
"pyc` ou :file:`.pyo`, la seule chose qui est plus rapide est la vitesse à "
|
||
"laquelle ils sont chargés."
|
||
|
||
#: tutorial/modules.rst:215
|
||
msgid ""
|
||
"When a script is run by giving its name on the command line, the bytecode "
|
||
"for the script is never written to a :file:`.pyc` or :file:`.pyo` file. "
|
||
"Thus, the startup time of a script may be reduced by moving most of its code "
|
||
"to a module and having a small bootstrap script that imports that module. "
|
||
"It is also possible to name a :file:`.pyc` or :file:`.pyo` file directly on "
|
||
"the command line."
|
||
msgstr ""
|
||
"Lorsqu'un programme est lancé en donnant son nom à une invite de commande, "
|
||
"le bytecode du script n'est jamais écrit dans un :file:`.pyc` ni :file:`."
|
||
"pyo`. Cependant son temps de chargement peut être réduit en déplaçant la "
|
||
"plupart de son code vers un module, et n'utiliser qu'un script léger pour "
|
||
"importer ce module. Il est aussi possible d'exécuter un fichier :file:`.pyc` "
|
||
"ou :file:`.pyo` directement depuis l'invite de commande."
|
||
|
||
#: tutorial/modules.rst:222
|
||
msgid ""
|
||
"It is possible to have a file called :file:`spam.pyc` (or :file:`spam.pyo` "
|
||
"when :option:`-O` is used) without a file :file:`spam.py` for the same "
|
||
"module. This can be used to distribute a library of Python code in a form "
|
||
"that is moderately hard to reverse engineer."
|
||
msgstr ""
|
||
"Il est possible d'avoir un fichier :file:`spam.pyc` (ou :file:`spam.pyo` "
|
||
"lorsque :option:`-O` a été utilisée) sans :file:`spam.py` pour un même "
|
||
"module. Cela permet de distribuer une bibliothèque Python dans un format qui "
|
||
"est modérément compliqué à rétro-ingénierer."
|
||
|
||
#: tutorial/modules.rst:229
|
||
#, fuzzy
|
||
msgid ""
|
||
"The module :mod:`compileall` can create :file:`.pyc` files (or :file:`.pyo` "
|
||
"files when :option:`-O` is used) for all modules in a directory."
|
||
msgstr ""
|
||
"Le module :mod:`compileall` permet de compiler tous les modules d'un dossier "
|
||
"(et accepte aussi le paramètre :option:`-O`)."
|
||
|
||
#: tutorial/modules.rst:236
|
||
msgid "Standard Modules"
|
||
msgstr "Modules standards"
|
||
|
||
# 0572f328979e445b8f24801a89a1e2b0
|
||
#: tutorial/modules.rst:240
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:263
|
||
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."
|
||
|
||
#: tutorial/modules.rst:265
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:278
|
||
msgid "The :func:`dir` Function"
|
||
msgstr "La fonction :func:`dir`"
|
||
|
||
#: tutorial/modules.rst:280
|
||
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 :;"
|
||
|
||
#: tutorial/modules.rst:303
|
||
msgid ""
|
||
"Without arguments, :func:`dir` lists the names you have defined currently::"
|
||
msgstr "Sans paramètres, :func:`dir` listes les noms actuellement définis ::"
|
||
|
||
#: tutorial/modules.rst:311
|
||
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."
|
||
|
||
# 38ddad117ec74e9885481c252bed3daf
|
||
#: tutorial/modules.rst:315
|
||
#, fuzzy
|
||
msgid ""
|
||
":func:`dir` does not list the names of built-in functions and variables. If "
|
||
"you want a list of those, they are defined in the standard module :mod:"
|
||
"`__builtin__`::"
|
||
msgstr ""
|
||
":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` ::"
|
||
|
||
#: tutorial/modules.rst:352
|
||
msgid "Packages"
|
||
msgstr "Les paquets"
|
||
|
||
#: tutorial/modules.rst:354
|
||
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."
|
||
|
||
# 0c3e2b19ba7c46b3a367e0649f5bcace
|
||
#: tutorial/modules.rst:362
|
||
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) :"
|
||
|
||
#: tutorial/modules.rst:399
|
||
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."
|
||
|
||
#: tutorial/modules.rst:402
|
||
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)."
|
||
|
||
#: tutorial/modules.rst:409
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:414
|
||
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. ::"
|
||
|
||
#: tutorial/modules.rst:419
|
||
msgid "An alternative way of importing the submodule is::"
|
||
msgstr "Une autre manière d'importer des sous-modules est ::"
|
||
|
||
#: tutorial/modules.rst:423
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:428
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:432
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:437
|
||
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 `ImportError` est levée."
|
||
|
||
#: tutorial/modules.rst:444
|
||
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."
|
||
|
||
#: tutorial/modules.rst:453
|
||
msgid "Importing \\* From a Package"
|
||
msgstr "Importer \\* depuis un paquet"
|
||
|
||
#: tutorial/modules.rst:457
|
||
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."
|
||
|
||
# 8f1258abef7b47319a5ab764ae9e7512
|
||
#: tutorial/modules.rst:463
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:475
|
||
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`."
|
||
|
||
#: tutorial/modules.rst:478
|
||
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 ::"
|
||
|
||
#: tutorial/modules.rst:491
|
||
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.)"
|
||
|
||
#: tutorial/modules.rst:496
|
||
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."
|
||
|
||
#: tutorial/modules.rst:500
|
||
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."
|
||
|
||
#: tutorial/modules.rst:507
|
||
msgid "Intra-package References"
|
||
msgstr "Références internes dans un paquet"
|
||
|
||
# 20ba5d3273454eefa50529336214baa5
|
||
#: tutorial/modules.rst:509
|
||
msgid ""
|
||
"The submodules often need to refer to each other. For example, the :mod:"
|
||
"`surround` module might use the :mod:`echo` module. In fact, such "
|
||
"references are so common that the :keyword:`import` statement first looks in "
|
||
"the containing package before looking in the standard module search path. "
|
||
"Thus, the :mod:`surround` module can simply use ``import echo`` or ``from "
|
||
"echo import echofilter``. If the imported module is not found in the "
|
||
"current package (the package of which the current module is a submodule), "
|
||
"the :keyword:`import` statement looks for a top-level module with the given "
|
||
"name."
|
||
msgstr ""
|
||
"Les sous modules ont souvent besoin de s'utiliser entre eux. Par exemple le "
|
||
"module :mod:`surround` pourrait utiliser le module :mod:`echo`. Dans les "
|
||
"faits ces références sont si communes que l'instruction clef :keyword:"
|
||
"`import` regarde d'abord dans le paquet avant de chercher dans les modules "
|
||
"standard. Donc le module :mod:`surround` peut simplement utiliser ``import "
|
||
"echo`` ou ``from echo import echofilter``. Si le module n'est pas trouvé "
|
||
"dans le paquet courrant (le paquet pour lequel le module actuel est un sous "
|
||
"module), l'instruction :keyword:`import` cherchera le nom donné en dehors du "
|
||
"paquet."
|
||
|
||
#: tutorial/modules.rst:518
|
||
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``."
|
||
|
||
# 82c84536e5f94eb8ad4f365cde80af40
|
||
#: tutorial/modules.rst:524
|
||
msgid ""
|
||
"Starting with Python 2.5, in addition to the implicit relative imports "
|
||
"described above, you can write explicit relative imports with the ``from "
|
||
"module import name`` form of import statement. These explicit relative "
|
||
"imports use leading dots to indicate the current and parent packages "
|
||
"involved in the relative import. From the :mod:`surround` module for "
|
||
"example, you might use::"
|
||
msgstr ""
|
||
"Depuis Python 2.5, en plus des imports relatifs décris plus haut, vous "
|
||
"pouvez écrire des imports relatifs explicites via la syntaxe ``form module "
|
||
"import name``. Ces imports relatifs explicits utilisent le préfixe point (``."
|
||
"``) pour indiquer le paquet courant ou le paquet parent. Pour le module :mod:"
|
||
"`surround` par exemple vous pourriez utiliser ::"
|
||
|
||
# 0a545e217ccb4074a3817733279c812b
|
||
#: tutorial/modules.rst:534
|
||
#, fuzzy
|
||
msgid ""
|
||
"Note that both explicit and implicit relative imports are based on the name "
|
||
"of the current module. Since the name of the main module is always ``"
|
||
"\"__main__\"``, modules intended for use as the main module of a Python "
|
||
"application should always use absolute imports."
|
||
msgstr ""
|
||
"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."
|
||
|
||
#: tutorial/modules.rst:541
|
||
msgid "Packages in Multiple Directories"
|
||
msgstr "Paquets dans plusieurs dossiers"
|
||
|
||
#: tutorial/modules.rst:543
|
||
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."
|
||
|
||
#: tutorial/modules.rst:549
|
||
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."
|
||
|
||
# 718bdfb2db00454588feb7477e850abf
|
||
#: tutorial/modules.rst:555
|
||
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."
|
||
|
||
#: tutorial/stdlib.rst:5
|
||
msgid "Brief Tour of the Standard Library"
|
||
msgstr "Survol de la Bibliothèque Standard"
|
||
|
||
#: tutorial/stdlib.rst:11
|
||
msgid "Operating System Interface"
|
||
msgstr "Interface avec le Système d'Exploitation"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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."
|
||
|
||
#: 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` ::"
|
||
|
||
#: 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 ::"
|
||
|
||
#: tutorial/stdlib.rst:49
|
||
msgid "File Wildcards"
|
||
msgstr "Jokers sur les noms de Fichiers"
|
||
|
||
#: tutorial/stdlib.rst:51
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib.rst:62
|
||
msgid "Command Line Arguments"
|
||
msgstr "Paramètres en ligne de Commande"
|
||
|
||
#: tutorial/stdlib.rst:64
|
||
msgid ""
|
||
"Common utility scripts often need to process command line arguments. These "
|
||
"arguments are stored in the :mod:`sys` module's *argv* attribute as a list. "
|
||
"For instance the following output results from running ``python demo.py one "
|
||
"two three`` at the command line::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/stdlib.rst:73
|
||
msgid ""
|
||
"The :mod:`getopt` module processes *sys.argv* using the conventions of the "
|
||
"Unix :func:`getopt` function. More powerful and flexible command line "
|
||
"processing is provided by the :mod:`argparse` module."
|
||
msgstr ""
|
||
"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`."
|
||
|
||
#: tutorial/stdlib.rst:81
|
||
msgid "Error Output Redirection and Program Termination"
|
||
msgstr "Redirection de la sortie d'erreur et fin d'exécution"
|
||
|
||
#: tutorial/stdlib.rst:83
|
||
msgid ""
|
||
"The :mod:`sys` module also has attributes for *stdin*, *stdout*, and "
|
||
"*stderr*. The latter is useful for emitting warnings and error messages to "
|
||
"make them visible even when *stdout* has been redirected::"
|
||
msgstr ""
|
||
"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é ::"
|
||
|
||
#: tutorial/stdlib.rst:90
|
||
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()``."
|
||
|
||
#: tutorial/stdlib.rst:96
|
||
msgid "String Pattern Matching"
|
||
msgstr "Recherche de motifs dans les Chaînes"
|
||
|
||
#: tutorial/stdlib.rst:98
|
||
msgid ""
|
||
"The :mod:`re` module provides regular expression tools for advanced string "
|
||
"processing. For complex matching and manipulation, regular expressions offer "
|
||
"succinct, optimized solutions::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/stdlib.rst:108
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib.rst:118
|
||
msgid "Mathematics"
|
||
msgstr "Mathématiques"
|
||
|
||
#: tutorial/stdlib.rst:120
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib.rst:129
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib.rst:145
|
||
msgid "Internet Access"
|
||
msgstr "Accès à internet"
|
||
|
||
# 621033cc072a4a8da88740058de8f289
|
||
#: tutorial/stdlib.rst:147
|
||
#, fuzzy
|
||
msgid ""
|
||
"There are a number of modules for accessing the internet and processing "
|
||
"internet protocols. Two of the simplest are :mod:`urllib2` for retrieving "
|
||
"data from URLs and :mod:`smtplib` for sending mail::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/stdlib.rst:168
|
||
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.)"
|
||
|
||
#: tutorial/stdlib.rst:174
|
||
msgid "Dates and Times"
|
||
msgstr "Dates et heures"
|
||
|
||
#: tutorial/stdlib.rst:176
|
||
msgid ""
|
||
"The :mod:`datetime` module supplies classes for manipulating dates and times "
|
||
"in both simple and complex ways. While date and time arithmetic is "
|
||
"supported, the focus of the implementation is on efficient member extraction "
|
||
"for output formatting and manipulation. The module also supports objects "
|
||
"that are timezone aware. ::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/stdlib.rst:200
|
||
msgid "Data Compression"
|
||
msgstr "Compression de donnée"
|
||
|
||
#: tutorial/stdlib.rst:202
|
||
#, fuzzy
|
||
msgid ""
|
||
"Common data archiving and compression formats are directly supported by "
|
||
"modules including: :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`zipfile` and :"
|
||
"mod:`tarfile`. ::"
|
||
msgstr ""
|
||
"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` ::"
|
||
|
||
#: tutorial/stdlib.rst:222
|
||
msgid "Performance Measurement"
|
||
msgstr "Mesure des Performances"
|
||
|
||
#: tutorial/stdlib.rst:224
|
||
msgid ""
|
||
"Some Python users develop a deep interest in knowing the relative "
|
||
"performance of different approaches to the same problem. Python provides a "
|
||
"measurement tool that answers those questions immediately."
|
||
msgstr ""
|
||
"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."
|
||
|
||
#: tutorial/stdlib.rst:228
|
||
msgid ""
|
||
"For example, it may be tempting to use the tuple packing and unpacking "
|
||
"feature instead of the traditional approach to swapping arguments. The :mod:"
|
||
"`timeit` module quickly demonstrates a modest performance advantage::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/stdlib.rst:238
|
||
msgid ""
|
||
"In contrast to :mod:`timeit`'s fine level of granularity, the :mod:`profile` "
|
||
"and :mod:`pstats` modules provide tools for identifying time critical "
|
||
"sections in larger blocks of code."
|
||
msgstr ""
|
||
"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."
|
||
|
||
#: tutorial/stdlib.rst:246
|
||
msgid "Quality Control"
|
||
msgstr "Contrôle Qualité"
|
||
|
||
#: tutorial/stdlib.rst:248
|
||
msgid ""
|
||
"One approach for developing high quality software is to write tests for each "
|
||
"function as it is developed and to run those tests frequently during the "
|
||
"development process."
|
||
msgstr ""
|
||
"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."
|
||
|
||
#: tutorial/stdlib.rst:252
|
||
msgid ""
|
||
"The :mod:`doctest` module provides a tool for scanning a module and "
|
||
"validating tests embedded in a program's docstrings. Test construction is "
|
||
"as simple as cutting-and-pasting a typical call along with its results into "
|
||
"the docstring. This improves the documentation by providing the user with an "
|
||
"example and it allows the doctest module to make sure the code remains true "
|
||
"to the documentation::"
|
||
msgstr ""
|
||
"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 ::"
|
||
|
||
#: tutorial/stdlib.rst:270
|
||
msgid ""
|
||
"The :mod:`unittest` module is not as effortless as the :mod:`doctest` "
|
||
"module, but it allows a more comprehensive set of tests to be maintained in "
|
||
"a separate file::"
|
||
msgstr ""
|
||
"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é ::"
|
||
|
||
#: tutorial/stdlib.rst:292
|
||
msgid "Batteries Included"
|
||
msgstr "Piles Fournies"
|
||
|
||
#: tutorial/stdlib.rst:294
|
||
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:"
|
||
|
||
# 1f0e345bae7b4a83861dd3cfabcc8448
|
||
#: tutorial/stdlib.rst:297
|
||
msgid ""
|
||
"The :mod:`xmlrpclib` and :mod:`SimpleXMLRPCServer` modules make implementing "
|
||
"remote procedure calls into an almost trivial task. Despite the modules "
|
||
"names, no direct knowledge or handling of XML is needed."
|
||
msgstr ""
|
||
"Les modules :mod:`xmlrpclib` et :mod:`SimpleXMLRPCServer` permettent "
|
||
"d'appeler des fonctions à distance quasiment sans effort. En dépit du nom "
|
||
"des modules, aucune connaissance du XML n'est nécessaire."
|
||
|
||
#: tutorial/stdlib.rst:301
|
||
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."
|
||
|
||
#: tutorial/stdlib.rst:308
|
||
msgid ""
|
||
"The :mod:`xml.dom` and :mod:`xml.sax` packages provide robust support for "
|
||
"parsing this popular data interchange format. Likewise, the :mod:`csv` "
|
||
"module supports direct reads and writes in a common database format. "
|
||
"Together, these modules and packages greatly simplify data interchange "
|
||
"between Python applications and other tools."
|
||
msgstr ""
|
||
"Les paquets :mod:`xml.dom` et :mod:`xml.sax` fournissent un moyen solide de "
|
||
"parser ce format populaire. Aussi, le module :mod:`csv` peut lire et écrire "
|
||
"dans un format de base de donnée commun. Ensemble, ces modules et paquets "
|
||
"simplifient grandement l'échange de donnée entre les applications Python et "
|
||
"les autres outils."
|
||
|
||
#: tutorial/stdlib.rst:314
|
||
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`."
|
||
|
||
#: tutorial/stdlib2.rst:5
|
||
msgid "Brief Tour of the Standard Library -- Part II"
|
||
msgstr "Rapide tour de la Bibliothèque Standard -- Deuxième partie"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/stdlib2.rst:14
|
||
msgid "Output Formatting"
|
||
msgstr "Formatage"
|
||
|
||
# 20922d986c434cb78ddac80e1a60633b
|
||
#: tutorial/stdlib2.rst:16
|
||
#, fuzzy
|
||
msgid ""
|
||
"The :mod:`repr` 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 ::"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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 ::"
|
||
|
||
#: tutorial/stdlib2.rst:72
|
||
msgid "Templating"
|
||
msgstr "Gabarits (Templates)"
|
||
|
||
# dc541a6f18e54caaa2101a76a6b5d13e
|
||
#: 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."
|
||
|
||
#: 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 ``"
|
||
"$``."
|
||
|
||
# 0f345ca7b4ad4fcfbe5c7bc89e145880
|
||
#: 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 ::"
|
||
|
||
#: 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 ::"
|
||
|
||
#: 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, ..."
|
||
|
||
#: tutorial/stdlib2.rst:133
|
||
msgid "Working with Binary Data Record Layouts"
|
||
msgstr "Travailler avec des données binaires"
|
||
|
||
# ecdb9e781e96479390eae1e533a9729e
|
||
#: 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."
|
||
|
||
#: tutorial/stdlib2.rst:164
|
||
msgid "Multi-threading"
|
||
msgstr "Threads"
|
||
|
||
#: tutorial/stdlib2.rst:166
|
||
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."
|
||
|
||
#: tutorial/stdlib2.rst:171
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib2.rst:194
|
||
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, lemodule :mod:`threading` expose quelques outils dédiés à la "
|
||
"synchronisation comme les verrous (locks), événement (events), variables "
|
||
"conditionnelles (condition variables), et les sémaphores."
|
||
|
||
# 5b0b88c3eb2844fa903eb3e3ff72d79b
|
||
#: tutorial/stdlib2.rst:199
|
||
#, fuzzy
|
||
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."
|
||
|
||
#: tutorial/stdlib2.rst:210
|
||
msgid "Logging"
|
||
msgstr "Journalisation"
|
||
|
||
#: tutorial/stdlib2.rst:212
|
||
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`` ::"
|
||
|
||
# 5d44183c6fb0489091fbd795f42c8dab
|
||
#: tutorial/stdlib2.rst:222
|
||
msgid "This produces the following output:"
|
||
msgstr "Produisant l'affichage suivant :"
|
||
|
||
# 4451a96b39044ca9a34bfc37d5e15a2d
|
||
#: tutorial/stdlib2.rst:230
|
||
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`."
|
||
|
||
#: tutorial/stdlib2.rst:237
|
||
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."
|
||
|
||
#: tutorial/stdlib2.rst:245
|
||
msgid "Weak References"
|
||
msgstr "Références faibles"
|
||
|
||
#: tutorial/stdlib2.rst:247
|
||
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-miette`\\s (garbage collector) "
|
||
"pour éliminer les cycles). La mémoire est libérée rapidement lorsque sa "
|
||
"dernière référence est perdue."
|
||
|
||
#: tutorial/stdlib2.rst:251
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib2.rst:286
|
||
msgid "Tools for Working with Lists"
|
||
msgstr "Outils pour travailler avec des listes"
|
||
|
||
#: tutorial/stdlib2.rst:288
|
||
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."
|
||
|
||
# 8151b144d69d4e5b923a9b04e58f445a
|
||
#: tutorial/stdlib2.rst:292
|
||
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 ::"
|
||
|
||
# 88ac3346818c4236a3a4fcd5b0a7f3b0
|
||
#: tutorial/stdlib2.rst:305
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib2.rst:326
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib2.rst:336
|
||
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 ::"
|
||
|
||
#: tutorial/stdlib2.rst:352
|
||
msgid "Decimal Floating Point Arithmetic"
|
||
msgstr "Arithmétique décimale à Virgule Flottante"
|
||
|
||
# 1310d96aa0b3487a80a410ced6503e4e
|
||
#: tutorial/stdlib2.rst:354
|
||
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"
|
||
|
||
#: tutorial/stdlib2.rst:358
|
||
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,"
|
||
|
||
#: tutorial/stdlib2.rst:360
|
||
msgid "control over precision,"
|
||
msgstr "contrôle sur la précision, "
|
||
|
||
#: tutorial/stdlib2.rst:361
|
||
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,"
|
||
|
||
#: tutorial/stdlib2.rst:362
|
||
msgid "tracking of significant decimal places, or"
|
||
msgstr "suivre les décimales significatives, ou"
|
||
|
||
#: tutorial/stdlib2.rst:363
|
||
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."
|
||
|
||
#: tutorial/stdlib2.rst:366
|
||
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 ::"
|
||
|
||
# ef886201e784491dbacb38684b1c056d
|
||
#: 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."
|
||
|
||
# c19c2c8bbcf94f47b5e5b98d181ffbcf
|
||
#: 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 ::"
|
||
|
||
#: 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 ::"
|
||
|
||
#: tutorial/whatnow.rst:5
|
||
msgid "What Now?"
|
||
msgstr "Et Maintenant ?"
|
||
|
||
#: 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 ?"
|
||
|
||
#: 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 ::"
|
||
|
||
#: tutorial/whatnow.rst:14
|
||
msgid ":ref:`library-index`:"
|
||
msgstr ":ref:`library-index`:"
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/whatnow.rst:24
|
||
#, fuzzy
|
||
msgid ""
|
||
":ref:`install-index` explains how to install external modules written by "
|
||
"other Python users."
|
||
msgstr ""
|
||
":ref:`installing-index` explique comment installer des paquets écrits par "
|
||
"d'autres utilisateurs de Python."
|
||
|
||
#: 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."
|
||
|
||
#: tutorial/whatnow.rst:31
|
||
msgid "More Python resources:"
|
||
msgstr "D'autres ressources:"
|
||
|
||
# d10cebd2bc97492488f5f335751d7f9f
|
||
#: 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."
|
||
|
||
# ef4dce91b88f4be895ce894dae4c3ac1
|
||
#: 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)"
|
||
|
||
# 1bc5b0b2722b4b73a301218b55c823a9
|
||
#: 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."
|
||
|
||
# c5c8fa10010b4c049a4cc8e3ef708395
|
||
#: tutorial/whatnow.rst:46
|
||
msgid ""
|
||
"http://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 ""
|
||
"http://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.)"
|
||
|
||
# fba35de8bfaa4de4990c57775317239c
|
||
#: tutorial/whatnow.rst:51
|
||
msgid ""
|
||
"For Python-related questions and problem reports, you can post to the "
|
||
"newsgroup :newsgroup:`comp.lang.python`, or send them to the mailing list at "
|
||
"python-list@python.org. The newsgroup and mailing list are gatewayed, so "
|
||
"messages posted to one will automatically be forwarded to the other. There "
|
||
"are around 120 postings a day (with peaks up to several hundred), asking "
|
||
"(and answering) questions, suggesting new features, and announcing new "
|
||
"modules. Before posting, be sure to check the list of :ref:`Frequently Asked "
|
||
"Questions <faq-index>` (also called the FAQ). Mailing list archives are "
|
||
"available at https://mail.python.org/pipermail/. The FAQ answers many of the "
|
||
"questions that come up again and again, and may already contain the solution "
|
||
"for your problem."
|
||
msgstr ""
|
||
"Pour les questions et problèmes liés à Python, vous pouvez écrire sur le "
|
||
"newsgroup :newsgroup:`comp.lang.python`, ou les envoyer à la mailing-list "
|
||
"python-list@python.org. Le newsgroup et la mailing list sont liés, les "
|
||
"messages écris d'un côté sont automatiquement transférés de l'autre. Il y a "
|
||
"environ 120 messages par jour, (avec des pics autour de plusieurs centaines) "
|
||
"demandant (et répondant) à des questions, suggérant de nouvelles "
|
||
"fonctionnalités, et annonçant de nouveaux modules. Avant d'y écrire, assurez-"
|
||
"vous d'avoir lu la :ref:`Foire Aux Questions <faq-index>` (autrement nommée "
|
||
"FAQ). Les archives de la mailing list sont disponnibles à https://mail."
|
||
"python.org/pipermail/. La FAQ répond à la pluspart des questions qui "
|
||
"reviennent fréquemment, et peut contenir la solution à votre problème."
|
||
|
||
# ce8381976b434e66b7c5471cd5d43209
|
||
#~ msgid ""
|
||
#~ "To change a sequence you are iterating over while inside the loop (for "
|
||
#~ "example to duplicate certain items), it is recommended that you first "
|
||
#~ "make a copy. Looping over a sequence does not implicitly make a copy. "
|
||
#~ "The slice notation makes this especially convenient::"
|
||
#~ msgstr ""
|
||
#~ "Si vous devez modifier une séquence sur laquelle vous êtes en train de "
|
||
#~ "faire une boucle (par exemple pour dupliquer ou supprimer certains "
|
||
#~ "éléments), il est recommandé de commencer par en faire une copie. Celle-"
|
||
#~ "ci n'est pas implicite lorsque vous faites une boucle sur une séquence. "
|
||
#~ "La notation par tranches rend cette opération particulièrement pratique ::"
|
||
|
||
#, fuzzy
|
||
#~ msgid ":ref:`string-formatting`"
|
||
#~ msgstr "Anciennes méthodes de formatage de chaînes"
|
||
|
||
#~ msgid "A value can be assigned to several variables simultaneously::"
|
||
#~ msgstr ""
|
||
#~ "Une valeur peut être affectée à plusieurs variables simultanément ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Complex numbers are also supported; imaginary numbers are written with a "
|
||
#~ "suffix of ``j`` or ``J``. Complex numbers with a nonzero real component "
|
||
#~ "are written as ``(real+imagj)``, or can be created with the "
|
||
#~ "``complex(real, imag)`` function. ::"
|
||
#~ msgstr ""
|
||
#~ "Les nombres complexes sont aussi supportés ; les nombres imaginaires sont "
|
||
#~ "écrits avec un suffixe ``j`` ou ``J``. Les nombres complexes avec une "
|
||
#~ "composante réelle différente de zéro sont écrits sous la forme ``(réel"
|
||
#~ "+imagj)``, ou peuvent être créés avec la fonction ``complex(real, imag)``."
|
||
|
||
#~ msgid ""
|
||
#~ "Complex numbers are always represented as two floating point numbers, the "
|
||
#~ "real and imaginary part. To extract these parts from a complex number "
|
||
#~ "*z*, use ``z.real`` and ``z.imag``. ::"
|
||
#~ msgstr ""
|
||
#~ "Les nombres complexes sont toujours représentés comme deux nombres à "
|
||
#~ "virgule flottante, la partie réelle et la partie imaginaire. Pour "
|
||
#~ "extraire ces deux parties d'un nombre complexe *z*, utilisez ``z.real`` "
|
||
#~ "et ``z.imag`` ::"
|
||
|
||
# 7e26ce7f84464f10b0c9c677e62c4fd3
|
||
#~ msgid ""
|
||
#~ "The conversion functions to floating point and integer (:func:`float`, :"
|
||
#~ "func:`int` and :func:`long`) don't work for complex numbers --- there is "
|
||
#~ "no one correct way to convert a complex number to a real number. Use "
|
||
#~ "``abs(z)`` to get its magnitude (as a float) or ``z.real`` to get its "
|
||
#~ "real part. ::"
|
||
#~ msgstr ""
|
||
#~ "Les fonctions de conversion en nombres à virgule flottante et en entiers :"
|
||
#~ "func:`float`, :func:`int` et :func:`long`) ne fonctionnent pas pour les "
|
||
#~ "nombres complexes --- il n'y a pas de manière correcte de convertir un "
|
||
#~ "nombre complexe en nombre réel. Utilisez ``abs(z)`` pour obtenir sa "
|
||
#~ "magnitude (de type flottant) ou ``z.real`` pour obtenir sa partie "
|
||
#~ "réelle ::"
|
||
|
||
#~ msgid ""
|
||
#~ "String literals can span multiple lines in several ways. Continuation "
|
||
#~ "lines can be used, with a backslash as the last character on the line "
|
||
#~ "indicating that the next line is a logical continuation of the line::"
|
||
#~ msgstr ""
|
||
#~ "Les chaînes littérales peuvent être réparties sur plusieurs lignes de "
|
||
#~ "plusieurs façons. On peut utiliser des lignes de continuation, un "
|
||
#~ "antislash en dernière position d'une ligne indiquant que celle-ci se "
|
||
#~ "continue sur la ligne suivante ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Note that newlines still need to be embedded in the string using ``\\n`` "
|
||
#~ "-- the newline following the trailing backslash is discarded. This "
|
||
#~ "example would print the following:"
|
||
#~ msgstr ""
|
||
#~ "Notez que les caractères de retour à la ligne sont toujours à écrire en "
|
||
#~ "utilisant ``\\n`` -- la fin de ligne précédée d'un antislash est ignorée. "
|
||
#~ "Cet exemple affichera :"
|
||
|
||
#~ msgid ""
|
||
#~ "Or, strings can be surrounded in a pair of matching triple-quotes: ``"
|
||
#~ "\"\"\"`` or ``'''``. End of lines do not need to be escaped when using "
|
||
#~ "triple-quotes, but they will be included in the string. ::"
|
||
#~ msgstr ""
|
||
#~ "Aussi, les chaînes de caractères peuvent être entourées de trois "
|
||
#~ "guillemets ``\"\"\"`` ou ``'''``. Il n'est pas nécessaire de protéger "
|
||
#~ "avec un antislash les fins de lignes en utilisant les triple guillemets, "
|
||
#~ "mais il seront inclus dans la chaîne."
|
||
|
||
#~ msgid "produces the following output:"
|
||
#~ msgstr "produit l'affichage suivant :"
|
||
|
||
#~ msgid ""
|
||
#~ "If we make the string literal a \"raw\" string, ``\\n`` sequences are not "
|
||
#~ "converted to newlines, but the backslash at the end of the line, and the "
|
||
#~ "newline character in the source, are both included in the string as "
|
||
#~ "data. Thus, the example::"
|
||
#~ msgstr ""
|
||
#~ "En utilisant une chaîne de caractère brute, (\"raw\" string), les "
|
||
#~ "séquence d'échappement``\\n`` ne sont pas convertis en retour à la ligne, "
|
||
#~ "mais l'antislash en fin de ligne et le retour à la ligne présent dans le "
|
||
#~ "code source sont tous les deux inclus dans la chaîne de caractère. Par "
|
||
#~ "exemple::"
|
||
|
||
#~ msgid "would print:"
|
||
#~ msgstr "imprimerait :"
|
||
|
||
#~ msgid ""
|
||
#~ "Two string literals next to each other are automatically concatenated; "
|
||
#~ "the first line above could also have been written ``word = 'Help' 'A'``; "
|
||
#~ "this only works with two literals, not with arbitrary string expressions::"
|
||
#~ msgstr ""
|
||
#~ "Deux chaînes de caractères l'une à côté de l'autre sont automatiquement "
|
||
#~ "concaténées ; la première ligne ci-dessous aurait également pu être "
|
||
#~ "écrite ``word = 'Help' 'A'`` ; ceci ne fonctionne qu'avec deux chaînes "
|
||
#~ "littérales, pas avec des expressions arbitraires ::"
|
||
|
||
#~ msgid ""
|
||
#~ "However, creating a new string with the combined content is easy and "
|
||
#~ "efficient::"
|
||
#~ msgstr ""
|
||
#~ "Par contre, créer une nouvelle chaîne avec le contenu combiné est simple "
|
||
#~ "et efficace ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Here's a useful invariant of slice operations: ``s[:i] + s[i:]`` equals "
|
||
#~ "``s``. ::"
|
||
#~ msgstr ""
|
||
#~ "Voici un invariant utile des opérations par tranches : ``s[:i] + s[i:]`` "
|
||
#~ "est égal à ``s`` ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Degenerate slice indices are handled gracefully: an index that is too "
|
||
#~ "large is replaced by the string size, an upper bound smaller than the "
|
||
#~ "lower bound returns an empty string. ::"
|
||
#~ msgstr ""
|
||
#~ "Des indices de tranches erronés sont également gérés gracieusement : un "
|
||
#~ "indice trop élevé est remplacé par la taille de la chaîne, un indice de "
|
||
#~ "fin plus petit que l'indice de début retourne une chaîne vide ::"
|
||
|
||
#~ msgid ""
|
||
#~ "But note that -0 is really the same as 0, so it does not count from the "
|
||
#~ "right! ::"
|
||
#~ msgstr ""
|
||
#~ "Mais notez bien que -0 est vraiment la même chose que 0, et n'effectue "
|
||
#~ "donc pas son décompte à partir de la droite !"
|
||
|
||
#~ msgid ""
|
||
#~ "Out-of-range negative slice indices are truncated, but don't try this for "
|
||
#~ "single-element (non-slice) indices::"
|
||
#~ msgstr ""
|
||
#~ "Des tranches avec des indices négatifs en dehors des valeurs autorisées "
|
||
#~ "sont tronquées, mais n'essayez pas de les utiliser avec des indices pour "
|
||
#~ "des valeurs isolées (hors tranches) ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Like string indices, list indices start at 0, and lists can be sliced, "
|
||
#~ "concatenated and so on::"
|
||
#~ msgstr ""
|
||
#~ "Comme les indices d'une chaîne de caractères, les indices des éléments "
|
||
#~ "d'une liste commencent à 0, les listes peuvent être extraites par "
|
||
#~ "tranches, concaténées et ainsi de suite ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Note that in the last example, ``p[1]`` and ``q`` really refer to the "
|
||
#~ "same object! We'll come back to *object semantics* later."
|
||
#~ msgstr ""
|
||
#~ "Notez que dans le dernier exemple, ``p[1]`` et ``q`` se réfèrent "
|
||
#~ "réellement au même objet ! Nous reviendrons plus tard sur la *sémantique "
|
||
#~ "des objets*."
|
||
|
||
#~ msgid "Sort the items of the list, in place."
|
||
#~ msgstr "Trie les éléments de la liste, en place."
|
||
|
||
#~ msgid ""
|
||
#~ "(There are other variants of this, used when pickling many objects or "
|
||
#~ "when you don't want to write the pickled data to a file; consult the "
|
||
#~ "complete documentation for :mod:`pickle` in the Python Library Reference.)"
|
||
#~ msgstr ""
|
||
#~ "(Il existe d'autres variantes, utilisées lorsque vous voulez enregistrer "
|
||
#~ "beaucoup d'objets ou lorsque vous ne voulez pas écrire les données dans "
|
||
#~ "un fichier ; consultez la documentation complète du module :mod:`pickle` "
|
||
#~ "dans le Guide de Référence de la Bibliothèque Standard.)"
|
||
|
||
#~ msgid ""
|
||
#~ ":mod:`pickle` is the standard way to make Python objects which can be "
|
||
#~ "stored and reused by other programs or by a future invocation of the same "
|
||
#~ "program; the technical term for this is a :dfn:`persistent` object. "
|
||
#~ "Because :mod:`pickle` is so widely used, many authors who write Python "
|
||
#~ "extensions take care to ensure that new data types such as matrices can "
|
||
#~ "be properly pickled and unpickled."
|
||
#~ msgstr ""
|
||
#~ ":mod:`pickle` est la façon standard pour enregistrer des objets Python "
|
||
#~ "pour les réutiliser dans d'autres programmes ou lors d'une autre "
|
||
#~ "invocation du même programme ; le terme technique pour cela est de rendre "
|
||
#~ "les objets :dfn:`persistants`. Comme le module :mod:`pickle` est si "
|
||
#~ "largement utilisé, beaucoup d'auteurs qui écrivent des extensions Python "
|
||
#~ "prennent soin de s'assurer que les nouveaux types de données tels que les "
|
||
#~ "matrices peuvent être correctement sauvegardées et reconstruits au "
|
||
#~ "travers de ce module."
|
||
|
||
#~ msgid "Lambda Forms"
|
||
#~ msgstr "Les fonctions lambda"
|
||
|
||
#~ msgid ""
|
||
#~ "Since :meth:`str.format` is quite new, a lot of Python code still uses "
|
||
#~ "the ``%`` operator. However, because this old style of formatting will "
|
||
#~ "eventually be removed from the language, :meth:`str.format` should "
|
||
#~ "generally be used."
|
||
#~ msgstr ""
|
||
#~ "Comme :meth:`str.format` est relativement récente, beaucoup de code "
|
||
#~ "Python utilise encore l'opérateur ``%``. Toutefois, dans la mesure où cet "
|
||
#~ "ancien style de formatage sera peut-être à terme supprimé du langage, il "
|
||
#~ "vaut mieux utiliser :meth:`str.format`."
|
||
|
||
#~ msgid ""
|
||
#~ "``f.readlines()`` returns a list containing all the lines of data in the "
|
||
#~ "file. If given an optional parameter *sizehint*, it reads that many bytes "
|
||
#~ "from the file and enough more to complete a line, and returns the lines "
|
||
#~ "from that. This is often used to allow efficient reading of a large file "
|
||
#~ "by lines, but without having to load the entire file in memory. Only "
|
||
#~ "complete lines will be returned. ::"
|
||
#~ msgstr ""
|
||
#~ "``f.readlines()`` retourne une liste contenant toutes les lignes du "
|
||
#~ "fichier. Si l'argument optionnel *sizehint* est fourni, la méthode lit "
|
||
#~ "autant d'octets que le nombre indiqué, plus la quantité juste nécessaire "
|
||
#~ "pour compléter une ligne, et retourne toutes les lignes lues. Ceci est "
|
||
#~ "souvent utilisé pour permettre une lecture efficace d'un gros fichier par "
|
||
#~ "lignes, mais sans avoir à charger tout le fichier en mémoire. Seules des "
|
||
#~ "lignes entières sont retournées. ::"
|
||
|
||
#~ msgid ""
|
||
#~ "The alternative approach is simpler but does not provide as fine-grained "
|
||
#~ "control. Since the two approaches manage line buffering differently, "
|
||
#~ "they should not be mixed."
|
||
#~ msgstr ""
|
||
#~ "Cette autre méthode est plus simple mais ne permet pas d'avoir un "
|
||
#~ "contrôle très fin sur la lecture. Comme les deux approches gèrent la mise "
|
||
#~ "en mémoire tampon des lignes différemment, elle ne doivent pas être "
|
||
#~ "mélangées."
|
||
|
||
# c6ce45f20f7743deb76e188301a62651
|
||
#~ msgid ""
|
||
#~ "Later in the tutorial, we will learn about Generator Expressions which "
|
||
#~ "are even better suited for the task of supplying key-values pairs to the :"
|
||
#~ "func:`dict` constructor."
|
||
#~ msgstr ""
|
||
#~ "Plus loin dans ce tutoriel, vous en apprendez plus sur les générateurs "
|
||
#~ "qui sont encore plus adaptés à cette tâche consistant à fournir des "
|
||
#~ "paires de clés-valeurs au constructeur :func:`dict`."
|
||
|
||
#~ msgid "|version|"
|
||
#~ msgstr "|version|"
|
||
|
||
#~ msgid "|today|"
|
||
#~ msgstr "|today|"
|
||
|
||
#~ msgid ""
|
||
#~ "The :keyword:`global` statement can be used to indicate that particular "
|
||
#~ "variables live in the global scope and should be rebound there; the :"
|
||
#~ "keyword:`nonlocal` statement indicates that particular variables live in "
|
||
#~ "an enclosing scope and should be rebound there."
|
||
#~ msgstr ""
|
||
#~ "L'instruction :keyword:`global` peut être utilisée pour indiquer que "
|
||
#~ "certaines variables existent dans la portée globale et doivent être "
|
||
#~ "reliées en local ; l'instruction :keyword:`nonlocal` indique que "
|
||
#~ "certaines variables existent dans une portée supérieure et doivent être "
|
||
#~ "reliées en local."
|
||
|
||
#~ msgid "Scopes and Namespaces Example"
|
||
#~ msgstr "Exemple de portées et d'espaces de noms"
|
||
|
||
#~ msgid ""
|
||
#~ "This is an example demonstrating how to reference the different scopes "
|
||
#~ "and namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "
|
||
#~ "variable binding::"
|
||
#~ msgstr ""
|
||
#~ "Ceci est un exemple montrant comment utiliser les différentes portées et "
|
||
#~ "espaces de noms, et comment :keyword:`global` et :keyword:`nonlocal` "
|
||
#~ "modifient l'affectation de variable ::"
|
||
|
||
#~ msgid ""
|
||
#~ "def scope_test(): def do_local(): spam = \"local spam\" "
|
||
#~ "def do_nonlocal(): nonlocal spam spam = \"nonlocal spam"
|
||
#~ "\" def do_global(): global spam spam = \"global spam"
|
||
#~ "\" spam = \"test spam\" do_local() print(\"After local "
|
||
#~ "assignment:\", spam) do_nonlocal() print(\"After nonlocal "
|
||
#~ "assignment:\", spam) do_global() print(\"After global assignment:"
|
||
#~ "\", spam) scope_test() print(\"In global scope:\", spam)"
|
||
#~ msgstr ""
|
||
#~ "def scope_test(): def do_local(): spam = \"local spam\" "
|
||
#~ "def do_nonlocal(): nonlocal spam spam = \"nonlocal spam"
|
||
#~ "\" def do_global(): global spam spam = \"global spam"
|
||
#~ "\" spam = \"test spam\" do_local() print(\"After local "
|
||
#~ "assignment:\", spam) do_nonlocal() print(\"After nonlocal "
|
||
#~ "assignment:\", spam) do_global() print(\"After global assignment:"
|
||
#~ "\", spam) scope_test() print(\"In global scope:\", spam)"
|
||
|
||
#~ msgid "The output of the example code is::"
|
||
#~ msgstr "Ce code donne le résultat suivant ::"
|
||
|
||
#~ msgid ""
|
||
#~ "After local assignment: test spam After nonlocal assignment: nonlocal "
|
||
#~ "spam After global assignment: nonlocal spam In global scope: global spam"
|
||
#~ msgstr ""
|
||
#~ "After local assignment: test spam After nonlocal assignment: nonlocal "
|
||
#~ "spam After global assignment: nonlocal spam In global scope: global spam"
|
||
|
||
#~ msgid ""
|
||
#~ "Note how the *local* assignment (which is default) didn't change "
|
||
#~ "*scope_test*\\'s binding of *spam*. The :keyword:`nonlocal` assignment "
|
||
#~ "changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "
|
||
#~ "assignment changed the module-level binding."
|
||
#~ msgstr ""
|
||
#~ "Vous pouvez constater que l'affectation *locale* (qui est effectuée par "
|
||
#~ "défaut) n'a pas modifié la liaison de *spam* dans *scope_test*. "
|
||
#~ "L'affectation :keyword:`nonlocal` a changé la liaison de *spam* dans "
|
||
#~ "*scope_test* et l'affectation :keyword:`global` a changé la liaison au "
|
||
#~ "niveau du module."
|
||
|
||
#~ msgid ""
|
||
#~ "You can also see that there was no previous binding for *spam* before "
|
||
#~ "the :keyword:`global` assignment."
|
||
#~ msgstr ""
|
||
#~ "Vous pouvez également voir qu'aucune liaison pour *spam* n'a été faite "
|
||
#~ "avant l'affectation :keyword:`global`."
|
||
|
||
#~ msgid ""
|
||
#~ "class ClassName: <statement-1> . . . <statement-N>"
|
||
#~ msgstr "class NomDeLaClasse: <déclaration-1>. . . <déclaration-N>"
|
||
|
||
#~ msgid ""
|
||
#~ "class MyClass: \"\"\"A simple example class\"\"\" i = 12345 "
|
||
#~ "def f(self): return 'hello world'"
|
||
#~ msgstr ""
|
||
#~ "class MaClasse: \"\"\"Une simple classe d'exemple\"\"\" i = 12345 def "
|
||
#~ "f(self): return 'hello world'"
|
||
|
||
#~ msgid "x = MyClass()"
|
||
#~ msgstr "x = MaClasse()"
|
||
|
||
#~ msgid "def __init__(self): self.data = []"
|
||
#~ msgstr "def __init__(self): self.data = []"
|
||
|
||
#~ msgid ""
|
||
#~ ">>> class Complex: ... def __init__(self, realpart, "
|
||
#~ "imagpart): ... self.r = realpart ... self.i = "
|
||
#~ "imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)"
|
||
#~ msgstr ""
|
||
#~ ">>> class Complexe: ... def __init__(self, partie_reelle, "
|
||
#~ "partie_imaginaire): ... self.r = partie_reelle ... self.i "
|
||
#~ "= partie_imaginaire ... >>> x = Complexe(3.0, -4.5) >>> x.r, x.i (3.0, "
|
||
#~ "-4.5)"
|
||
|
||
#~ msgid ""
|
||
#~ "x.counter = 1 while x.counter < 10: x.counter = x.counter * 2 print(x."
|
||
#~ "counter) del x.counter"
|
||
#~ msgstr ""
|
||
#~ "x.compteur = 1 while x.compteur < 10: x.compteur = x.compteur * 2 "
|
||
#~ "print(x.compteur) del x.compteur"
|
||
|
||
#, fuzzy
|
||
#~ msgid "xf = x.f while True: print(xf())"
|
||
#~ msgstr "xf = x.f while True: print(xf())"
|
||
|
||
#~ msgid ""
|
||
#~ "# Function defined outside the class def f1(self, x, y): return "
|
||
#~ "min(x, x+y) class C: f = f1 def g(self): return 'hello "
|
||
#~ "world' h = g"
|
||
#~ msgstr ""
|
||
#~ "# Function définie à l'extérieur d'une classe def f1(self, x, y): return "
|
||
#~ "min(x, x+y) class C: f = f1 def g(self): return 'bonjour tout le monde' h "
|
||
#~ "= g"
|
||
|
||
#~ msgid ""
|
||
#~ "class DerivedClassName(BaseClassName): "
|
||
#~ "<statement-1> . . . <statement-N>"
|
||
#~ msgstr ""
|
||
#~ "class ClasseDerivee(ClasseDeBase): <déclaration-1> . . . <déclaration-N>"
|
||
|
||
#~ msgid "class DerivedClassName(modname.BaseClassName):"
|
||
#~ msgstr "class ClasseDerivee(nommodule.ClasseDeBase):"
|
||
|
||
#, fuzzy
|
||
#~ msgid ""
|
||
#~ "class DerivedClassName(Base1, Base2, Base3): "
|
||
#~ "<statement-1> . . . <statement-N>"
|
||
#~ msgstr ""
|
||
#~ "class NomDeLaClasseDerivee(Base1, Base2, Base3): <instruction-1> . . . "
|
||
#~ "<instruction-N>"
|