From a6eaac9f7d7ea4de4c17d90ae38ffb8bf61fa52b Mon Sep 17 00:00:00 2001 From: awecx Date: Wed, 12 Jun 2019 14:29:00 +0200 Subject: [PATCH] Working on howto/programming (#733) --- dict | 17 +- faq/programming.po | 1163 ++++++++++++++++++++++++++++++++------------ 2 files changed, 863 insertions(+), 317 deletions(-) diff --git a/dict b/dict index cc50cd73..aed8d45e 100644 --- a/dict +++ b/dict @@ -1,5 +1,4 @@ 017F -12h 212A allocateur allocateurs @@ -14,6 +13,7 @@ concourance coroutine coroutine coroutines +Cython d'allocateurs déduplication désenregistre @@ -27,8 +27,9 @@ désérialiser déserialisés déserialiseur déserialiseurs -émoji +docstrings d'itérateurs +émoji réusiné réusinage réusinages @@ -36,11 +37,13 @@ encodable Farrugia finaliseur Fredrik +freeze Guido hachabilité hachable hachables Hettinger +html ı -ième indiçage @@ -60,6 +63,7 @@ lorsqu'aucune mar. mémoïsant Marc-André +mémoïsation Mersenne métacaractère métacaractères @@ -71,10 +75,18 @@ muables multiensemble multiensembles namespace +pdb pip pourcent +précompilé préemptif proleptique +Pydb +PyChecker +Pylint +PythonWin +py2exe +pyc recompilation réentrants réessayable @@ -103,6 +115,7 @@ tokenisé tokenisés tty W3C +wxWidgets Zope délimitants contribués diff --git a/faq/programming.po b/faq/programming.po index 3e1bc078..07194dd2 100644 --- a/faq/programming.po +++ b/faq/programming.po @@ -5,19 +5,19 @@ msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2019-05-23 16:48+0200\n" -"PO-Revision-Date: 2019-04-24 11:30+0200\n" -"Last-Translator: Jules Lasne \n" +"POT-Creation-Date: 2018-12-21 09:48+0100\n" +"PO-Revision-Date: 2019-05-23 19:19+0200\n" +"Last-Translator: Antoine Wecxsteen\n" "Language-Team: FRENCH \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 2.2.1\n" +"X-Generator: Poedit 2.0.6\n" #: ../Doc/faq/programming.rst:5 msgid "Programming FAQ" -msgstr "" +msgstr "FAQ de programmation" #: ../Doc/faq/programming.rst:8 msgid "Contents" @@ -25,13 +25,15 @@ msgstr "Sommaire" #: ../Doc/faq/programming.rst:12 msgid "General Questions" -msgstr "" +msgstr "Questions générales" #: ../Doc/faq/programming.rst:15 msgid "" "Is there a source code level debugger with breakpoints, single-stepping, " "etc.?" msgstr "" +"Existe-t'il un débogueur de code source avec points d'arrêts, exécution pas-" +"à-pas, etc. ?" #: ../Doc/faq/programming.rst:17 ../Doc/faq/programming.rst:63 msgid "Yes." @@ -50,6 +52,10 @@ msgid "" "Library Reference Manual `. You can also write your own debugger by " "using the code for pdb as an example." msgstr "" +"Le module pdb est un débogueur console simple, mais parfaitement adapté à " +"Python. Il fait partie de la bibliothèque standard de Python, sa " +"documentation se trouve dans le :mod:`manuel de référence `. Vous " +"pouvez vous inspirer du code de pdb pour écrire votre propre débogueur." #: ../Doc/faq/programming.rst:27 msgid "" @@ -57,6 +63,9 @@ msgid "" "Python distribution (normally available as Tools/scripts/idle), includes a " "graphical debugger." msgstr "" +"L'environnement de développement interactif IDLE, qui est fourni avec la " +"distribution standard de Python (normalement disponible dans Tools/scripts/" +"idle) contient un débogueur graphique." #: ../Doc/faq/programming.rst:31 msgid "" @@ -67,6 +76,13 @@ msgid "" ">`__ project and as a part of the ActivePython distribution (see https://www." "activestate.com/activepython\\ )." msgstr "" +"PythonWin est un environnement de développement intégré (EDI) Python qui " +"embarque un débogueur graphique basé sur pdb. Le débogueur PythonWin colore " +"les points d'arrêts et possède quelques fonctionnalités sympathiques, comme " +"la possibilité de déboguer des programmes développés sans PythonWin. " +"Pythonwin est disponible dans le projet `Extensions Python pour Windows " +"`__ et fait partie de la " +"distribution ActivePython (voir https://www.activestate.com/activepython\\ )." #: ../Doc/faq/programming.rst:38 msgid "" @@ -76,12 +92,21 @@ msgid "" "browsers, inheritance hierarchies, doc string generated html documentation, " "an advanced debugger, integrated help, and Zope support." msgstr "" +"`Boa Constructor `_ est un EDI et " +"un constructeur d'interface homme-machine basé sur wxWidgets. Il propose la " +"création et la manipulation de fenêtres, un inspecteur d'objets, de " +"nombreuses façons de visualiser des sources comme un navigateur d'objets, " +"les hiérarchies d'héritage, la documentation html générée par les " +"docstrings, un débogueur avancé, une aide intégrée et la prise en charge de " +"Zope." #: ../Doc/faq/programming.rst:44 msgid "" "`Eric `_ is an IDE built on PyQt and " "the Scintilla editing component." msgstr "" +"`Eric `_ est un EDI basé sur PyQt et " +"l'outil d'édition Scintilla." #: ../Doc/faq/programming.rst:47 msgid "" @@ -90,28 +115,36 @@ msgid "" "can be found at http://bashdb.sourceforge.net/pydb/ and DDD can be found at " "https://www.gnu.org/software/ddd." msgstr "" +"Pydb est une version du débogueur standard Python pdb, modifié pour être " +"utilisé avec DDD (Data Display Debugger), un célèbre débogueur graphique. " +"Pydb est disponible sur http://bashdb.sourceforge.net/pydb/ et DDD est " +"disponible sur https://www.gnu.org/software/ddd." #: ../Doc/faq/programming.rst:52 msgid "" "There are a number of commercial Python IDEs that include graphical " "debuggers. They include:" msgstr "" +"Il existe de nombreux EDI Python propriétaires qui embarquent un débogueur " +"graphique. Notamment :" #: ../Doc/faq/programming.rst:55 msgid "Wing IDE (https://wingware.com/)" -msgstr "" +msgstr "Wing IDE (https://wingware.com/)" #: ../Doc/faq/programming.rst:56 msgid "Komodo IDE (https://komodoide.com/)" -msgstr "" +msgstr "Komodo IDE (https://komodoide.com/)" #: ../Doc/faq/programming.rst:57 msgid "PyCharm (https://www.jetbrains.com/pycharm/)" -msgstr "" +msgstr "PyCharm (https://www.jetbrains.com/pycharm/)" #: ../Doc/faq/programming.rst:61 msgid "Is there a tool to help find bugs or perform static analysis?" msgstr "" +"Existe-t'il des outils pour aider à trouver des bogues ou faire de l'analyse " +"statique de code ?" #: ../Doc/faq/programming.rst:65 msgid "" @@ -119,6 +152,10 @@ msgid "" "and warns about code complexity and style. You can get PyChecker from " "http://pychecker.sourceforge.net/." msgstr "" +"PyChecker est un outil d'analyse statique qui trouve les bogues dans le code " +"source Python et émet des avertissements relatifs à la complexité et au " +"style du code. PyChecker est disponible sur http://pychecker.sourceforge." +"net/." #: ../Doc/faq/programming.rst:69 msgid "" @@ -130,6 +167,14 @@ msgid "" "standard, whether declared interfaces are fully implemented, and more. " "https://docs.pylint.org/ provides a full list of Pylint's features." msgstr "" +"Pylint `_ est un autre outil qui vérifie si un " +"module satisfait aux normes de développement, et qui permet en plus d'écrire " +"des greffons pour ajouter des fonctionnalités personnalisées. En plus de la " +"vérification des bogues effectuée par PyChecker, Pylint effectue quelques " +"vérifications supplémentaires comme la longueur des lignes, les conventions " +"de nommage des variables, que les interfaces déclarées sont implémentées en " +"totalité, et plus encore. https://docs.pylint.org/ fournit la liste complète " +"des fonctionnalités de Pylint." #: ../Doc/faq/programming.rst:77 msgid "" @@ -137,10 +182,14 @@ msgid "" "pyre-check.org/>`_, and `Pytype `_ can " "check type hints in Python source code." msgstr "" +"Les vérificateurs statiques de typage comme `Mypy `_, " +"`Pyre `_, et `Pytype `_ peuvent vérifier les indications de type dans du code source " +"Python." #: ../Doc/faq/programming.rst:84 msgid "How can I create a stand-alone binary from a Python script?" -msgstr "" +msgstr "Comment créer un binaire autonome à partir d'un script Python ?" #: ../Doc/faq/programming.rst:86 msgid "" @@ -150,6 +199,12 @@ msgid "" "determine the set of modules required by a program and bind these modules " "together with a Python binary to produce a single executable." msgstr "" +"Pour créer un programme autonome, c'est-à-dire un programme que n'importe " +"qui peut télécharger et exécuter sans avoir à installer une distribution " +"Python au préalable, il n'est pas nécessaire de compiler du code Python en " +"code C. Il existe en effet plusieurs outils qui déterminent les modules " +"requis par un programme et lient ces modules avec un binaire Python pour " +"produire un seul exécutable." #: ../Doc/faq/programming.rst:92 msgid "" @@ -158,6 +213,11 @@ msgid "" "you can embed all your modules into a new program, which is then linked with " "the standard Python modules." msgstr "" +"Un de ces outils est freeze, qui se trouve dans ``Tools/freeze`` de " +"l'arborescence des sources de Python. Il convertit le code intermédiaire " +"(*bytecode*) Python en tableaux C ; un compilateur C permet d'intégrer tous " +"vos modules dans un nouveau programme, qui est ensuite lié aux modules " +"standards Python." #: ../Doc/faq/programming.rst:97 msgid "" @@ -171,40 +231,60 @@ msgid "" "rest of the Python interpreter to form a self-contained binary which acts " "exactly like your script." msgstr "" +"Il fonctionne en cherchant de manière récursive les instructions d'import " +"(sous les deux formes) dans le code source et en recherchant ces modules " +"dans le chemin Python standard ainsi que dans le répertoire source (pour les " +"modules natifs). Il transforme ensuite le code intermédiaire des modules " +"écrits en Python en code C (des tableaux pré-remplis qui peuvent être " +"transformés en objets code à l'aide du module *marshal*) et crée un fichier " +"de configuration personnalisé qui contient uniquement les modules natifs qui " +"sont réellement utilisés dans le programme. Il compile ensuite le code C " +"généré et le lie au reste de l'interpréteur Python pour former un binaire " +"autonome qui fait exactement la même chose que le script." #: ../Doc/faq/programming.rst:106 msgid "" "Obviously, freeze requires a C compiler. There are several other utilities " "which don't. One is Thomas Heller's py2exe (Windows only) at" msgstr "" +"Bien évidemment, freeze nécessite un compilateur C. Il existe d'autres " +"outils qui peuvent s'en passer. Un de ceux-ci est py2exe de Thomas Heller " +"(pour Windows uniquement) disponible sur" #: ../Doc/faq/programming.rst:109 msgid "http://www.py2exe.org/" -msgstr "" +msgstr "http://www.py2exe.org/" #: ../Doc/faq/programming.rst:111 msgid "" "Another tool is Anthony Tuininga's `cx_Freeze `_." msgstr "" +"Un autre de ces outils est `cx_Freeze `_ d'Anthony Tuininga." #: ../Doc/faq/programming.rst:115 msgid "Are there coding standards or a style guide for Python programs?" msgstr "" +"Existe-t'il des normes de développement ou un guide de style pour écrire des " +"programmes Python ?" #: ../Doc/faq/programming.rst:117 msgid "" "Yes. The coding style required for standard library modules is documented " "as :pep:`8`." msgstr "" +"Oui. Le style de développement que les modules de la bibliothèque standard " +"doivent obligatoirement respecter est documenté dans la :pep:`8`." #: ../Doc/faq/programming.rst:122 msgid "Core Language" -msgstr "" +msgstr "Fondamentaux" #: ../Doc/faq/programming.rst:125 msgid "Why am I getting an UnboundLocalError when the variable has a value?" msgstr "" +"Pourquoi une UnboundLocalError est levée alors qu'une variable a une valeur ?" #: ../Doc/faq/programming.rst:127 msgid "" @@ -212,18 +292,21 @@ msgid "" "when it is modified by adding an assignment statement somewhere in the body " "of a function." msgstr "" +"Il est parfois surprenant d'obtenir une UnboundLocalError dans du code " +"jusqu'à présent correct, quand celui-ci est modifié en ajoutant une " +"instruction d'affectation quelque part dans le corps d'une fonction." #: ../Doc/faq/programming.rst:131 msgid "This code:" -msgstr "" +msgstr "Le code suivant :" #: ../Doc/faq/programming.rst:139 msgid "works, but this code:" -msgstr "" +msgstr "fonctionne, mais le suivant :" #: ../Doc/faq/programming.rst:146 msgid "results in an UnboundLocalError:" -msgstr "" +msgstr "lève une UnboundLocalError :" #: ../Doc/faq/programming.rst:153 msgid "" @@ -234,12 +317,20 @@ msgid "" "Consequently when the earlier ``print(x)`` attempts to print the " "uninitialized local variable and an error results." msgstr "" +"Cela est dû au fait que, quand une variable est affectée dans un contexte, " +"cette variable devient locale à ce contexte et remplace toute variable du " +"même nom du contexte appelant. Vu que la dernière instruction dans *foo* " +"affecte une nouvelle valeur à ``x``, le compilateur la traite comme une " +"nouvelle variable. Par conséquent, quand le ``print(x)`` essaye d'afficher " +"la variable non initialisée, une erreur se produit." #: ../Doc/faq/programming.rst:160 msgid "" "In the example above you can access the outer scope variable by declaring it " "global:" msgstr "" +"Dans l'exemple ci-dessus, la variable du contexte appelant reste accessible " +"en la déclarant globale :" #: ../Doc/faq/programming.rst:171 msgid "" @@ -247,16 +338,23 @@ msgid "" "the superficially analogous situation with class and instance variables) you " "are actually modifying the value of the variable in the outer scope:" msgstr "" +"Cette déclaration explicite est obligatoire pour se rappeler que " +"(contrairement au cas à peu près similaire avec des variables de classe et " +"d'instance), c'est la valeur de la variable du contexte appelant qui est " +"modifiée :" #: ../Doc/faq/programming.rst:178 msgid "" "You can do a similar thing in a nested scope using the :keyword:`nonlocal` " "keyword:" msgstr "" +"Une alternative dans un contexte imbriqué consiste à utiliser le mot-clé :" +"keyword:`nonlocal` :" #: ../Doc/faq/programming.rst:195 msgid "What are the rules for local and global variables in Python?" msgstr "" +"Quelles sont les règles pour les variables locales et globales en Python ?" #: ../Doc/faq/programming.rst:197 msgid "" @@ -265,6 +363,10 @@ msgid "" "function's body, it's assumed to be a local unless explicitly declared as " "global." msgstr "" +"En Python, si une variable n'est pas modifiée dans une fonction mais " +"seulement lue, elle est implicitement considérée comme globale. Si une " +"valeur lui est affectée, elle est considérée locale (sauf si elle est " +"explicitement déclarée globale)." #: ../Doc/faq/programming.rst:201 msgid "" @@ -276,18 +378,30 @@ msgid "" "a component of an imported module. This clutter would defeat the usefulness " "of the ``global`` declaration for identifying side-effects." msgstr "" +"Bien que surprenant au premier abord, ce choix s'explique facilement. D'une " +"part, exiger :keyword:`global` pour des variables affectées est une " +"protection contre des effets de bord inattendus. D'autre part, si ``global`` " +"était obligatoire pour toutes les références à des objets globaux, il " +"faudrait mettre ``global`` partout, car il faudrait dans ce cas déclarer " +"globale chaque référence à une fonction native ou à un composant d'un module " +"importé. Le codé serait alors truffé de déclarations ``global``, ce qui " +"nuirait à leur raison d'être : identifier les effets de bords." #: ../Doc/faq/programming.rst:211 msgid "" "Why do lambdas defined in a loop with different values all return the same " "result?" msgstr "" +"Pourquoi des expressions lambda définies dans une boucle avec des valeurs " +"différentes retournent-elles le même résultat ?" #: ../Doc/faq/programming.rst:213 msgid "" "Assume you use a for loop to define a few different lambdas (or even plain " "functions), e.g.::" msgstr "" +"Supposons que l'on utilise une boucle itérative pour définir des expressions " +"lambda (voire même des fonctions) différentes, par exemple ::" #: ../Doc/faq/programming.rst:220 msgid "" @@ -296,6 +410,9 @@ msgid "" "``1``, ``4``, ``9``, and ``16``. However, when you actually try you will " "see that they all return ``16``::" msgstr "" +"Le code précédent crée une liste de 5 expressions lambda qui calculent " +"chacune ``x**2``. En les exécutant, on pourrait s'attendre à obtenir ``0``, " +"``1``, ``4``, ``9`` et ``16``. Elles renvoient en réalité toutes ``16`` :" #: ../Doc/faq/programming.rst:230 msgid "" @@ -305,12 +422,21 @@ msgid "" "the functions now return ``4**2``, i.e. ``16``. You can also verify this by " "changing the value of ``x`` and see how the results of the lambdas change::" msgstr "" +"Ceci s'explique par le fait que ``x`` n'est pas une variable locale aux " +"expressions, mais est définie dans le contexte appelant. Elle est lue à " +"l'appel de l'expression lambda – et non au moment où cette expression est " +"définie. À la fin de la boucle, ``x`` vaut ``4``, donc toutes les fonctions " +"renvoient ``4*2``, i.e. ``16``. Ceci se vérifie également en changeant la " +"valeur de ``x`` et en constatant que les résultats sont modifiés :" #: ../Doc/faq/programming.rst:240 msgid "" "In order to avoid this, you need to save the values in variables local to " "the lambdas, so that they don't rely on the value of the global ``x``::" msgstr "" +"Pour éviter ce phénomène, les valeurs doivent être stockées dans des " +"variables locales aux expressions lambda pour que celles-ci ne se basent " +"plus sur la variable globale ``x`` :" #: ../Doc/faq/programming.rst:247 msgid "" @@ -320,16 +446,24 @@ msgid "" "the first lambda, ``1`` in the second, ``2`` in the third, and so on. " "Therefore each lambda will now return the correct result::" msgstr "" +"Dans ce code, ``n=x`` crée une nouvelle variable ``n``, locale à " +"l'expression. Cette variable est évaluée quand l'expression est définie donc " +"``n`` a la même valeur que ``x`` à ce moment. La valeur de ``n`` est donc " +"``0`` dans la première lambda, ``1`` dans la deuxième, ``2`` dans la " +"troisième et ainsi de suite. Chaque expression lambda renvoie donc le " +"résultat correct :" #: ../Doc/faq/programming.rst:258 msgid "" "Note that this behaviour is not peculiar to lambdas, but applies to regular " "functions too." msgstr "" +"Ce comportement n'est pas propre aux expressions lambda, mais s'applique " +"aussi aux fonctions normales." #: ../Doc/faq/programming.rst:263 msgid "How do I share global variables across modules?" -msgstr "" +msgstr "Comment partager des variables globales entre modules ?" #: ../Doc/faq/programming.rst:265 msgid "" @@ -340,28 +474,37 @@ msgid "" "each module, any changes made to the module object get reflected " "everywhere. For example:" msgstr "" +"La manière standard de partager des informations entre modules d'un même " +"programme est de créer un module spécial (souvent appelé *config* ou *cfg*) " +"et de l'importer dans tous les modules de l'application ; le module devient " +"accessible depuis l'espace de nommage global. Vu qu'il n'y a qu'une instance " +"de chaque module, tout changement dans l'instance est propagé partout. Par " +"exemple :" #: ../Doc/faq/programming.rst:271 msgid "config.py::" -msgstr "" +msgstr "*config.py* ::" #: ../Doc/faq/programming.rst:275 msgid "mod.py::" -msgstr "" +msgstr "*mod.py* ::" #: ../Doc/faq/programming.rst:280 msgid "main.py::" -msgstr "" +msgstr "*main.py* ::" #: ../Doc/faq/programming.rst:286 msgid "" "Note that using a module is also the basis for implementing the Singleton " "design pattern, for the same reason." msgstr "" +"Pour les mêmes raisons, l'utilisation d'un module est aussi à la base de " +"l'implémentation du patron de conception singleton." #: ../Doc/faq/programming.rst:291 msgid "What are the \"best practices\" for using import in a module?" msgstr "" +"Quelles sont les « bonnes pratiques » pour utiliser import dans un module ?" #: ../Doc/faq/programming.rst:293 msgid "" @@ -369,6 +512,9 @@ msgid "" "importer's namespace, and makes it much harder for linters to detect " "undefined names." msgstr "" +"De manière générale, il ne faut pas faire ``from modulename import *``. Ceci " +"encombre l'espace de nommage de l'importateur et rend la détection de noms " +"non-définis beaucoup plus ardue pour les analyseurs de code." #: ../Doc/faq/programming.rst:297 msgid "" @@ -377,30 +523,42 @@ msgid "" "is in scope. Using one import per line makes it easy to add and delete " "module imports, but using multiple imports per line uses less screen space." msgstr "" +"Les modules doivent être importés au début d'un fichier. Ceci permet " +"d'afficher clairement de quels modules le code à besoin et évite de se " +"demander si le module est dans le contexte. Faire un seul `import` par ligne " +"rend l'ajout et la suppression d'une importation de module plus aisé, mais " +"importer plusieurs modules sur une même ligne prend moins d'espace." #: ../Doc/faq/programming.rst:302 msgid "It's good practice if you import modules in the following order:" -msgstr "" +msgstr "Il est recommandé d'importer les modules dans l'ordre suivant :" #: ../Doc/faq/programming.rst:304 msgid "standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``" msgstr "" +"les modules de la bibliothèque standard — e.g. ``sys``, ``os``, ``getopt``, " +"``re``" #: ../Doc/faq/programming.rst:305 msgid "" "third-party library modules (anything installed in Python's site-packages " "directory) -- e.g. mx.DateTime, ZODB, PIL.Image, etc." msgstr "" +"les modules externes (tout ce qui est installé dans le dossier *site-" +"packages* de Python) — e.g. *mx.DateTime, ZODB, PIL.Image*, etc." #: ../Doc/faq/programming.rst:307 msgid "locally-developed modules" -msgstr "" +msgstr "les modules développés en local" #: ../Doc/faq/programming.rst:309 msgid "" "It is sometimes necessary to move imports to a function or class to avoid " "problems with circular imports. Gordon McMillan says:" msgstr "" +"Il est parfois nécessaire de déplacer des importations dans une fonction ou " +"une classe pour éviter les problèmes d'importations circulaires. Comme le " +"souligne Gordon McMillan :" #: ../Doc/faq/programming.rst:312 msgid "" @@ -410,6 +568,12 @@ msgid "" "That's because names in the 1st are not yet available, because the first " "module is busy importing the 2nd." msgstr "" +"Il n'y a aucun souci à faire des importations circulaires tant que les deux " +"modules utilisent la forme \"import \" . Ça ne pose problème que si " +"le second module cherche à récupérer un nom du premier module (*\"from " +"module import name\"*) et que l'importation est dans l'espace de nommage du " +"fichier. Les noms du premier module ne sont en effet pas encore disponibles " +"car le premier module est occupé à importer le second." #: ../Doc/faq/programming.rst:318 msgid "" @@ -418,6 +582,10 @@ msgid "" "called, the first module will have finished initializing, and the second " "module can do its import." msgstr "" +"Dans ce cas, si le second module n'est utilisé que dans une fonction, " +"l'importation peut facilement être déplacée dans cette fonction. Au moment " +"où l'importation sera appelée, le premier module aura fini de s'initialiser " +"et le second pourra faire son importation." #: ../Doc/faq/programming.rst:323 msgid "" @@ -427,6 +595,12 @@ msgid "" "importing the correct modules in the corresponding platform-specific code is " "a good option." msgstr "" +"Il peut parfois être nécessaire de déplacer des importations de modules hors " +"de l'espace de plus haut niveau du code si certains de ces modules dépendent " +"de la machine utilisée. Dans ce cas de figure, il est parfois impossible " +"d'importer tous les modules au début du fichier. Dans ce cas, il est " +"recommandé d'importer les modules adéquats dans le code spécifique à la " +"machine." #: ../Doc/faq/programming.rst:328 msgid "" @@ -441,16 +615,30 @@ msgid "" "only a couple of dictionary lookups. Even if the module name has gone out " "of scope, the module is probably available in :data:`sys.modules`." msgstr "" +"Les imports ne devraient être déplacés dans un espace local, comme dans la " +"définition d'une fonction, que si cela est nécessaire pour résoudre un " +"problème comme éviter des dépendances circulaires ou réduire le temps " +"d'initialisation d'un module. Cette technique est particulièrement utile si " +"la majorité des imports est superflue selon le flux d'exécution du " +"programme. Il est également pertinent de déplacer des importations dans une " +"fonction si le module n'est utilisé qu'au sein de cette fonction. Le premier " +"chargement d'un module peut être coûteux à cause du coût fixe " +"d'initialisation d'un module, mais charger un module plusieurs fois est " +"quasiment gratuit, cela ne coûte que quelques indirections dans un " +"dictionnaire. Même si le nom du module est sorti du contexte courant, le " +"module est probablement disponible dans :data:`sys.modules`." #: ../Doc/faq/programming.rst:341 msgid "Why are default values shared between objects?" -msgstr "" +msgstr "Pourquoi les arguments par défaut sont-ils partagés entre les objets ?" #: ../Doc/faq/programming.rst:343 msgid "" "This type of bug commonly bites neophyte programmers. Consider this " "function::" msgstr "" +"C'est un problème que rencontrent souvent les programmeurs débutants. " +"Examinons la fonction suivante ::" #: ../Doc/faq/programming.rst:350 msgid "" @@ -458,6 +646,9 @@ msgid "" "The second time, ``mydict`` contains two items because when ``foo()`` begins " "executing, ``mydict`` starts out with an item already in it." msgstr "" +"Au premier appel de cette fonction, ``mydict`` ne contient qu'un seul " +"élément. Au second appel, ``mydict`` contient deux éléments car quand " +"``foo()`` commence son exécution, ``mydict`` contient déjà un élément." #: ../Doc/faq/programming.rst:354 msgid "" @@ -467,6 +658,11 @@ msgid "" "dictionary in this example, subsequent calls to the function will refer to " "this changed object." msgstr "" +"On est souvent amené à croire qu'un appel de fonction créé des nouveau " +"objets pour les valeurs par défaut. Ce n'est pas le cas. Les valeurs par " +"défaut ne sont créées qu'une et une seule fois, au moment où la fonction est " +"définie. Si l'objet est modifié, comme le dictionnaire dans cet exemple, les " +"appels suivants à cette fonction font référence à l'objet ainsi modifié." #: ../Doc/faq/programming.rst:359 msgid "" @@ -474,6 +670,10 @@ msgid "" "``None``, are safe from change. Changes to mutable objects such as " "dictionaries, lists, and class instances can lead to confusion." msgstr "" +"Par définition, les objets immuables comme les nombres, les chaînes de " +"caractères, les n-uplets et ``None`` ne sont pas modifiés. Les changements " +"sur des objets muables comme les dictionnaires, les listes et les instances " +"de classe peuvent porter à confusion." #: ../Doc/faq/programming.rst:363 msgid "" @@ -482,10 +682,15 @@ msgid "" "inside the function, check if the parameter is ``None`` and create a new " "list/dictionary/whatever if it is. For example, don't write::" msgstr "" +"En raison de cette fonctionnalité, il vaut mieux ne pas utiliser d'objets " +"muables comme valeurs par défaut. Il vaut mieux utiliser ``None`` comme " +"valeur par défaut et, à l'intérieur de la fonction, vérifier si le paramètre " +"est à ``None`` et créer une nouvelle liste, dictionnaire ou autre, le cas " +"échéant. Par exemple, il ne faut pas écrire ::" #: ../Doc/faq/programming.rst:371 msgid "but::" -msgstr "" +msgstr "mais plutôt ::" #: ../Doc/faq/programming.rst:377 msgid "" @@ -495,17 +700,25 @@ msgid "" "value is requested again. This is called \"memoizing\", and can be " "implemented like this::" msgstr "" +"Cette fonctionnalité a une utilité. Il est courant de mettre en cache les " +"paramètres et la valeur de retour de chacun des appels d'une fonction " +"coûteuse à exécuter, et de renvoyer la valeur stockée en cache si le même " +"appel est ré-effectué. C'est la technique dite de « mémoïsation », qui " +"s'implémente de la manière suivante ::" #: ../Doc/faq/programming.rst:392 msgid "" "You could use a global variable containing a dictionary instead of the " "default value; it's a matter of taste." msgstr "" +"Il est possible d'utiliser une variable globale contenant un dictionnaire à " +"la place de la valeur par défaut ; ce n'est qu'une question de goût." #: ../Doc/faq/programming.rst:397 msgid "" "How can I pass optional or keyword parameters from one function to another?" msgstr "" +"Comment passer des paramètres optionnels ou nommés d'une fonction à l'autre ?" #: ../Doc/faq/programming.rst:399 msgid "" @@ -514,10 +727,15 @@ msgid "" "tuple and the keyword arguments as a dictionary. You can then pass these " "arguments when calling another function by using ``*`` and ``**``::" msgstr "" +"Il faut récupérer les arguments en utilisant les sélecteurs ``*`` et ``**`` " +"dans la liste des paramètres de la fonction ; ceci donne les arguments " +"positionnels sous la forme d'un n-uplet et les arguments nommés sous forme " +"de dictionnaire. Ces arguments peuvent être passés à une autre fonction en " +"utilisant ``*`` et ``**`` ::" #: ../Doc/faq/programming.rst:418 msgid "What is the difference between arguments and parameters?" -msgstr "" +msgstr "Quelle est la différence entre les arguments et les paramètres ?" #: ../Doc/faq/programming.rst:420 msgid "" @@ -527,20 +745,27 @@ msgid "" "of arguments a function can accept. For example, given the function " "definition::" msgstr "" +"Les :term:`paramètres ` sont les noms qui apparaissent dans une " +"définition de fonction, alors que les :term:`arguments ` sont les " +"valeurs qui sont réellement passées à une fonction lors de l'appel de celle-" +"ci. Les paramètres définissent les types des arguments qu'une fonction " +"accepte. Ainsi, avec la définition de fonction suivante ::" #: ../Doc/faq/programming.rst:428 msgid "" "*foo*, *bar* and *kwargs* are parameters of ``func``. However, when calling " "``func``, for example::" msgstr "" +"*foo*, *bar* et *kwargs* sont des paramètres de ``func``. Mais à l'appel de " +"``func`` avec, par exemple ::" #: ../Doc/faq/programming.rst:433 msgid "the values ``42``, ``314``, and ``somevar`` are arguments." -msgstr "" +msgstr "les valeurs ``42``, ``314``, et ``somevar`` sont des arguments." #: ../Doc/faq/programming.rst:437 msgid "Why did changing list 'y' also change list 'x'?" -msgstr "" +msgstr "Pourquoi modifier la liste 'y' modifie aussi la liste 'x' ?" #: ../Doc/faq/programming.rst:439 msgid "If you wrote code like::" @@ -550,10 +775,12 @@ msgstr "Si vous avez écrit du code comme ::" msgid "" "you might be wondering why appending an element to ``y`` changed ``x`` too." msgstr "" +"vous vous demandez peut-être pourquoi l'ajout d'un élément à ``y`` a aussi " +"changé ``x``." #: ../Doc/faq/programming.rst:451 msgid "There are two factors that produce this result:" -msgstr "" +msgstr "Il y a deux raisons qui conduisent à ce comportement :" #: ../Doc/faq/programming.rst:453 msgid "" @@ -562,11 +789,17 @@ msgid "" "the same object ``x`` refers to. This means that there is only one object " "(the list), and both ``x`` and ``y`` refer to it." msgstr "" +"Les variables ne sont que des noms qui font référence à des objets. La ligne " +"``y = x`` ne crée pas une copie de la liste — elle crée une nouvelle " +"variable ``y`` qui pointe sur le même objet que ``x``. Ceci signifie qu'il " +"n'existe qu'un seul objet (la liste) auquel ``x`` et ``y`` font référence." #: ../Doc/faq/programming.rst:457 msgid "" "Lists are :term:`mutable`, which means that you can change their content." msgstr "" +"Les listes sont des :term:`muable`, ce qui signifie que leur contenu peut " +"être modifié." #: ../Doc/faq/programming.rst:459 msgid "" @@ -574,10 +807,14 @@ msgid "" "has changed from ``[]`` to ``[10]``. Since both the variables refer to the " "same object, using either name accesses the modified value ``[10]``." msgstr "" +"Après l'appel de :meth:`~list.append`, le contenu de l'objet muable est " +"passé de ``[]`` à ``[10]``. Vu que les deux variables font référence au même " +"objet, il est possible d'accéder à la valeur modifiée ``[10]`` avec chacun " +"des noms." #: ../Doc/faq/programming.rst:463 msgid "If we instead assign an immutable object to ``x``::" -msgstr "" +msgstr "Si au contraire, on affecte un objet immuable à ``x`` ::" #: ../Doc/faq/programming.rst:473 msgid "" @@ -589,6 +826,14 @@ msgid "" "objects (the ints ``6`` and ``5``) and two variables that refer to them " "(``x`` now refers to ``6`` but ``y`` still refers to ``5``)." msgstr "" +"on observe que ``x`` et ``y`` ne sont ici plus égales. Les entiers sont des " +"immuables (:term:`immutable`), et ``x = x + 1`` ne change pas l'entier ``5`` " +"en incrémentant sa valeur. Au contraire, un nouvel objet est créé (l'entier " +"``6``) et affecté à ``x`` (c'est à dire qu'on change l'objet auquel fait " +"référence ``x``). Après cette affectation on a deux objets (les entiers " +"``6`` et ``5``) et deux variables qui font référence à ces deux objets " +"(``x`` fait désormais référence à ``6`` mais ``y`` fait toujours référence à " +"``5``)." #: ../Doc/faq/programming.rst:481 msgid "" @@ -601,6 +846,14 @@ msgid "" "copy of ``y``, you'll instead end up with ``None``, which will likely cause " "your program to generate an easily diagnosed error." msgstr "" +"Certaines opérations (par exemple, ``y.append(10)`` et ``y.sort()``) " +"modifient l'objet, alors que des opérations identiques en apparence (par " +"exemple ``y = y + [10]`` et ``sorted(y)``) créent un nouvel objet. En " +"général, en Python, une méthode qui modifie un objet renvoie ``None`` (c'est " +"même systématique dans la bibliothèque standard) pour éviter la confusion " +"entre les deux opérations. Donc écrire par erreur ``y.sort()`` en pensant " +"obtenir une copie triée de ``y`` donne ``None``, ce qui conduit très souvent " +"le programme à générer une erreur facile à diagnostiquer." #: ../Doc/faq/programming.rst:490 msgid "" @@ -611,10 +864,16 @@ msgid "" "mutates ``a_list``, whereas ``some_tuple += (1, 2, 3)`` and ``some_int += " "1`` create new objects)." msgstr "" +"Il existe cependant une classe d'opérations qui se comporte différemment " +"selon le type : les opérateurs d'affectation incrémentaux. Par exemple, ``" +"+=`` modifie les listes mais pas les n-uplets ni les entiers (``a_list += " +"[1, 2, 3]`` équivaut à ``a_list.extend([1, 2, 3])`` et modifie ``a_list``, " +"alors que ``some_tuple += (1, 2, 3)`` et ``some_int += 1`` créent de " +"nouveaux objets)." #: ../Doc/faq/programming.rst:497 msgid "In other words:" -msgstr "" +msgstr "En d'autres termes :" #: ../Doc/faq/programming.rst:499 msgid "" @@ -622,6 +881,9 @@ msgid "" "etc.), we can use some specific operations to mutate it and all the " "variables that refer to it will see the change." msgstr "" +"Il est possible d'appliquer des opérations qui modifient un objet muable (:" +"class:`list`, :class:`dict`, :class:`set`, etc.) et toutes les variables qui " +"y font référence verront le changement." #: ../Doc/faq/programming.rst:502 msgid "" @@ -630,16 +892,24 @@ msgid "" "but operations that transform that value into a new value always return a " "new object." msgstr "" +"Toutes les variables qui font référence à un objet immuable (:class:`str`, :" +"class:`int`, :class:`tuple`, etc.) renvoient la même valeur, mais les " +"opérations qui transforment cette valeur en une nouvelle valeur renvoient " +"toujours un nouvel objet." #: ../Doc/faq/programming.rst:507 msgid "" "If you want to know if two variables refer to the same object or not, you " "can use the :keyword:`is` operator, or the built-in function :func:`id`." msgstr "" +"L'opérateur :keyword:`is` ou la fonction native :func:`id` permettent de " +"savoir si deux variables font référence au même objet." #: ../Doc/faq/programming.rst:512 msgid "How do I write a function with output parameters (call by reference)?" msgstr "" +"Comment écrire une fonction qui modifie ses paramètres ? (passage par " +"référence)" #: ../Doc/faq/programming.rst:514 msgid "" @@ -648,21 +918,27 @@ msgid "" "argument name in the caller and callee, and so no call-by-reference per se. " "You can achieve the desired effect in a number of ways." msgstr "" +"En Python, les arguments sont passés comme des affectations de variables. Vu " +"qu'une affectation crée des références à des objets, il n'y pas de lien " +"entre un argument dans l'appel de la fonction et sa définition, et donc pas " +"de passage par référence en soi. Il y a cependant plusieurs façon d'en " +"émuler un." #: ../Doc/faq/programming.rst:519 msgid "By returning a tuple of the results::" -msgstr "" +msgstr "En renvoyant un n-uplet de résultats ::" #: ../Doc/faq/programming.rst:530 msgid "This is almost always the clearest solution." -msgstr "" +msgstr "C'est presque toujours la meilleure solution." #: ../Doc/faq/programming.rst:532 msgid "" "By using global variables. This isn't thread-safe, and is not recommended." msgstr "" -"En utilisant des variables globales. Ce qui n'est pas *thread-safe*, et " -"n'est donc pas recommandé." +"En utilisant des variables globales. Cette approche ne fonctionne pas dans " +"des contextes à plusieurs fils d'exécution (elle n'est pas *thread-safe*), " +"et n'est donc pas recommandée." #: ../Doc/faq/programming.rst:534 msgid "By passing a mutable (changeable in-place) object::" @@ -678,14 +954,12 @@ msgstr "Ou regrouper les valeurs dans une instance de classe ::" #: ../Doc/faq/programming.rst:570 msgid "There's almost never a good reason to get this complicated." -msgstr "" -"Il n'y a pratiquement jamais de bonne raison de faire quelque chose d'aussi " -"compliqué." +msgstr "Faire quelque chose d'aussi compliqué est rarement une bonne idée." #: ../Doc/faq/programming.rst:572 msgid "Your best choice is to return a tuple containing the multiple results." msgstr "" -"Votre meilleure option est de renvoyer un *tuple* contenant les multiples " +"La meilleure option reste de renvoyer un n-uplet contenant les différents " "résultats." #: ../Doc/faq/programming.rst:576 @@ -699,10 +973,10 @@ msgid "" "returns a function ``f(x)`` that computes the value ``a*x+b``. Using nested " "scopes::" msgstr "" -"Vous avez deux choix : vous pouvez utiliser les portées imbriquées ou vous " -"pouvez utiliser des objets appelables. Par exemple, supposons que vous " -"vouliez définir ``linear(a, b)`` qui renvoie une fonction ``f(x)`` qui " -"calcule la valeur ``a*x+b``. En utilisant les portées imbriquées ::" +"Deux possibilités : on peut utiliser des portées imbriquées ou bien des " +"objets appelables. Par exemple, supposons que l'on souhaite définir " +"``linear(a, b)`` qui renvoie une fonction ``f(x)`` qui calcule la valeur " +"``a*x+b``. En utilisant les portées imbriquées ::" #: ../Doc/faq/programming.rst:587 msgid "Or using a callable object::" @@ -710,7 +984,7 @@ msgstr "Ou en utilisant un objet appelable ::" #: ../Doc/faq/programming.rst:597 msgid "In both cases, ::" -msgstr "dans les deux cas, ::" +msgstr "Dans les deux cas, ::" #: ../Doc/faq/programming.rst:601 msgid "gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``." @@ -724,7 +998,7 @@ msgid "" msgstr "" "L'approche par objet appelable a le désavantage d'être légèrement plus lente " "et de produire un code légèrement plus long. Cependant, il faut noter qu'une " -"collection d'objet appelables peuvent partager leur signatures par " +"collection d'objet appelables peuvent partager leurs signatures par " "héritage ::" #: ../Doc/faq/programming.rst:612 @@ -748,17 +1022,16 @@ msgid "" "In general, try :func:`copy.copy` or :func:`copy.deepcopy` for the general " "case. Not all objects can be copied, but most can." msgstr "" -"En général, essayez :func:`copy.copy` ou :func:`copy.deepcopy` pour le cas " -"général. Tout les objets ne peuvent pas être copiés, mais la plupart le " -"peuvent." +"En général, essayez :func:`copy.copy` ou :func:`copy.deepcopy`. Tous les " +"objets ne peuvent pas être copiés, mais la plupart le peuvent." #: ../Doc/faq/programming.rst:640 msgid "" "Some objects can be copied more easily. Dictionaries have a :meth:`~dict." "copy` method::" msgstr "" -"Certains objets peuvent être copiés plus facilement. Les Dictionnaires ont " -"une méthode :meth:`~dict.copy` ::" +"Certains objets peuvent être copiés plus facilement que d'autres. Les " +"dictionnaires ont une méthode :meth:`~dict.copy` ::" #: ../Doc/faq/programming.rst:645 msgid "Sequences can be copied by slicing::" @@ -766,7 +1039,7 @@ msgstr "Les séquences peuvent être copiées via la syntaxe des tranches ::" #: ../Doc/faq/programming.rst:651 msgid "How can I find the methods or attributes of an object?" -msgstr "Comment puis-je trouver les méthodes ou les attribues d'un objet?" +msgstr "Comment récupérer les méthodes ou les attributs d'un objet ?" #: ../Doc/faq/programming.rst:653 msgid "" @@ -780,7 +1053,7 @@ msgstr "" #: ../Doc/faq/programming.rst:659 msgid "How can my code discover the name of an object?" -msgstr "Comment mon code peut il découvrir le nom d'un objet?" +msgstr "Comment un code peut-il obtenir le nom d'un objet ?" #: ../Doc/faq/programming.rst:661 msgid "" @@ -789,11 +1062,11 @@ msgid "" "``def`` and ``class`` statements, but in that case the value is a callable. " "Consider the following code::" msgstr "" -"De façon générale, il ne peut pas, par ce que les objets n'ont pas " -"réellement de noms. Essentiellement, l'assignation attache un nom à une " -"valeur; C'est vrai aussi pour les instructions ``def`` et ``class``, à la " -"différence que dans ce cas la valeur est appelable. Par exemple, dans le " -"code suivant ::" +"C'est impossible en général, parce qu'un objet n'a pas de nom à proprement " +"parler. Schématiquement, l'affectation fait correspondre un nom à une " +"valeur ; c'est vrai aussi pour les instructions ``def`` et ``class``, à la " +"différence près que, dans ce cas, la valeur est un appelable. Par exemple, " +"dans le code suivant ::" #: ../Doc/faq/programming.rst:677 msgid "" @@ -802,10 +1075,10 @@ msgid "" "instance of class A. However, it is impossible to say whether the " "instance's name is a or b, since both names are bound to the same value." msgstr "" -"Le fait que la classe ait un nom est discutable, bien qu'elles soit liée à " -"deux noms, et qu'elle soit appelée via le nom B, l'instance crée déclare " -"tout de même être une instance de la classe A. De même Il est impossible de " -"dire si le nom de l'instance est a ou b, les deux noms sont attachés à la " +"Affirmer que la classe a un nom est discutable. Bien qu'elle soit liée à " +"deux noms, et qu'elle soit appelée via le nom B, l'instance créée déclare " +"tout de même être une instance de la classe A. De même, il est impossible de " +"dire si le nom de l'instance est a ou b, les deux noms étant attachés à la " "même valeur." #: ../Doc/faq/programming.rst:682 @@ -815,10 +1088,10 @@ msgid "" "introspective programs, this is usually an indication that a change of " "approach might be beneficial." msgstr "" -"De façon général, il ne devrait pas être nécessaire pour votre application " -"de \"connaître le nom\" d'une valeur particulière. À moins que vous soyez " -"délibérément en train d'écrire un programme introspectif, c'est souvent une " -"indication qu'un changement d'approche pourrait être bénéfique." +"De façon générale, une application ne devrait pas avoir besoin de « " +"connaître le nom » d'une valeur particulière. À moins d'être délibérément en " +"train d'écrire un programme introspectif, c'est souvent l'indication qu'un " +"changement d'approche serait bénéfique." #: ../Doc/faq/programming.rst:687 msgid "" @@ -826,7 +1099,7 @@ msgid "" "to this question:" msgstr "" "Sur *comp.lang.python*, Fredrik Lundh a donné un jour une excellente " -"analogie pour répondre à cette question:" +"analogie pour répondre à cette question :" #: ../Doc/faq/programming.rst:690 msgid "" @@ -835,9 +1108,9 @@ msgid "" "so the only way to find out what it's called is to ask all your neighbours " "(namespaces) if it's their cat (object)..." msgstr "" -"C'est pareil que trouver le nom du chat qui traîne devant votre porte : Le " -"chat (objet) ne peux pas vous dire lui même son nom, et il s'en moque un peu " -"-- alors le meilleur moyen de savoir comment il s'appelle est de demander à " +"C'est pareil que trouver le nom du chat qui traîne devant votre porte : le " +"chat (objet) ne peut pas vous dire lui-même son nom, et il s'en moque un peu " +"­– alors le meilleur moyen de savoir comment il s'appelle est de demander à " "tous vos voisins (espaces de nommage) si c'est leur chat (objet)…." #: ../Doc/faq/programming.rst:695 @@ -845,8 +1118,8 @@ msgid "" "....and don't be surprised if you'll find that it's known by many names, or " "no name at all!" msgstr "" -"…et ne soyez pas surpris si vous découvrez qu'il est connus sous plusieurs " -"noms différents, ou pas de nom du tout!" +"…et ne soyez pas surpris si vous découvrez qu'il est connu sous plusieurs " +"noms, ou s'il n'a pas de nom du tout !" #: ../Doc/faq/programming.rst:700 msgid "What's up with the comma operator's precedence?" @@ -855,7 +1128,7 @@ msgstr "Qu'en est-il de la précédence de l'opérateur virgule ?" #: ../Doc/faq/programming.rst:702 msgid "Comma is not an operator in Python. Consider this session::" msgstr "" -"La virgule n'est pas un opérateur en Python. Observez la session suivante ::" +"La virgule n'est pas un opérateur en Python. Observez le code suivant ::" #: ../Doc/faq/programming.rst:707 msgid "" @@ -863,7 +1136,7 @@ msgid "" "above is evaluated as if you had entered::" msgstr "" "Comme la virgule n'est pas un opérateur, mais un séparateur entre deux " -"expression, l'expression ci dessus, est évaluée de la même façon que si vous " +"expressions, l'expression ci-dessus est évaluée de la même façon que si vous " "aviez écrit ::" #: ../Doc/faq/programming.rst:712 @@ -876,9 +1149,9 @@ msgid "" "They are not truly operators but syntactic delimiters in assignment " "statements." msgstr "" -"Ceci est vrai pour tous les opérateurs d'assignations (``=``, ``+=`` etc). " -"Ce ne sont pas vraiment des opérateurs mais des délimiteurs syntaxiques dans " -"les instructions d'assignation." +"Ceci est vrai pour tous les opérateurs d'affectation (``=``, ``+=`` etc). Ce " +"ne sont pas vraiment des opérateurs mais plutôt des délimiteurs syntaxiques " +"dans les instructions d'affectation." #: ../Doc/faq/programming.rst:721 msgid "Is there an equivalent of C's \"?:\" ternary operator?" @@ -886,13 +1159,15 @@ msgstr "Existe-t-il un équivalent à l'opérateur ternaire \"?:\" du C ?" #: ../Doc/faq/programming.rst:723 msgid "Yes, there is. The syntax is as follows::" -msgstr "Oui, il y en a un. Sa syntaxe est la suivante ::" +msgstr "Oui. Sa syntaxe est la suivante ::" #: ../Doc/faq/programming.rst:730 msgid "" "Before this syntax was introduced in Python 2.5, a common idiom was to use " "logical operators::" msgstr "" +"Avant l'introduction de cette syntaxe dans Python 2.5, il était courant " +"d'utiliser les opérateurs de logique ::" #: ../Doc/faq/programming.rst:735 msgid "" @@ -900,6 +1175,9 @@ msgid "" "has a false boolean value. Therefore, it is always better to use the ``... " "if ... else ...`` form." msgstr "" +"Cet idiome est dangereux, car il donne un résultat erroné quand *on_true* a " +"la valeur booléenne fausse. Il faut donc toujours utiliser la forme ``... " +"if ... else ...``." #: ../Doc/faq/programming.rst:741 msgid "Is it possible to write obfuscated one-liners in Python?" @@ -908,21 +1186,23 @@ msgstr "" "en Python ?" #: ../Doc/faq/programming.rst:743 -#, fuzzy msgid "" "Yes. Usually this is done by nesting :keyword:`lambda` within :keyword:`!" "lambda`. See the following three examples, due to Ulf Bartelt::" msgstr "" -"Oui. Cela est généralement réalisé en imbriquant les :keyword:`lambda` dans " -"des :keyword:`lambda`. Observez les trois exemples suivants de Ulf Bartelt ::" +"Oui. C'est souvent le cas en imbriquant des :keyword:`lambda` dans des :" +"keyword:`!lambda`. Par exemple les trois morceaux de code suivants, créés " +"par Ulf Bartelt ::" #: ../Doc/faq/programming.rst:770 msgid "Don't try this at home, kids!" -msgstr "Les enfants, ne faîtes pas ça chez vous !" +msgstr "Les enfants, ne faites pas ça chez vous !" #: ../Doc/faq/programming.rst:776 msgid "What does the slash(/) in the parameter list of a function mean?" msgstr "" +"Que signifie la barre oblique (/) dans la liste des paramètres d'une " +"fonction ?" #: ../Doc/faq/programming.rst:778 msgid "" @@ -933,6 +1213,14 @@ msgid "" "position. For example, :func:`pow` is a function that accepts positional-" "only parameters. Its documentation looks like this::" msgstr "" +"Une barre oblique dans la liste des arguments d'une fonction indique que les " +"paramètres la précédant sont uniquement positionnels. Les paramètres " +"uniquement positionnels ne peuvent pas être référencés par leur nom depuis " +"l'extérieur. Lors de l'appel d'une fonction qui accepte des paramètres " +"uniquement positionnels, les arguments sont affectés aux paramètres en " +"fonction de leur position. Par exemple, la fonction :func:`pow` n'accepte " +"que des paramètres uniquement positionnels. Sa documentation est la " +"suivante ::" #: ../Doc/faq/programming.rst:794 msgid "" @@ -940,6 +1228,9 @@ msgid "" "are positional-only. Thus, calling :func:`pow` with keyword aguments would " "lead to an error::" msgstr "" +"La barre oblique à la fin de la liste des paramètres signifie que les trois " +"paramètres sont uniquement positionnels. Et donc, appeler :func:`pow` avec " +"des arguments nommés provoque une erreur ::" #: ../Doc/faq/programming.rst:803 msgid "" @@ -947,6 +1238,9 @@ msgid "" "syntax in Python, although there is :pep:`570`, which proposes a syntax for " "position-only parameters in Python." msgstr "" +"Notez que cet exemple n'est fourni qu'à titre informatif et n'est pas une " +"syntaxe Python valide, bien que la :pep:`570` propose une syntaxe pour les " +"paramètres uniquement positionnels en Python." #: ../Doc/faq/programming.rst:809 msgid "Numbers and strings" @@ -954,7 +1248,7 @@ msgstr "Nombres et chaînes de caractères" #: ../Doc/faq/programming.rst:812 msgid "How do I specify hexadecimal and octal integers?" -msgstr "Comment puis-je écrire des entiers hexadécimaux ou octaux ?" +msgstr "Comment écrire des entiers hexadécimaux ou octaux ?" #: ../Doc/faq/programming.rst:814 msgid "" @@ -963,8 +1257,8 @@ msgid "" "octal value \"10\" (8 in decimal), type::" msgstr "" "Pour écrire un entier octal, faites précéder la valeur octale par un zéro, " -"puis un \"o\" majuscule ou minuscule. Par exemple assigner la valeur octale " -"\"10\" (8 en décimal) à la variable \"a\", tapez ::" +"puis un \"o\" majuscule ou minuscule. Par exemple pour affecter la valeur " +"octale \"10\" (8 en décimal) à la variable \"a\", tapez ::" #: ../Doc/faq/programming.rst:822 msgid "" @@ -972,7 +1266,7 @@ msgid "" "zero, and then a lower or uppercase \"x\". Hexadecimal digits can be " "specified in lower or uppercase. For example, in the Python interpreter::" msgstr "" -"L'hexadécimal est tout aussi simple, faîtes précéder le nombre hexadécimal " +"L'hexadécimal est tout aussi simple, faites précéder le nombre hexadécimal " "par un zéro, puis un \"x\" majuscule ou minuscule. Les nombres hexadécimaux " "peuvent être écrit en majuscules ou en minuscules. Par exemple, dans " "l'interpréteur Python ::" @@ -986,8 +1280,8 @@ msgid "" "It's primarily driven by the desire that ``i % j`` have the same sign as " "``j``. If you want that, and also want::" msgstr "" -"Cela est principalement due à la volonté que ``i % j`` ait le même signe que " -"j. Si vous voulez cela, vous voulez aussi ::" +"Cela est principalement dû à la volonté que ``i % j`` ait le même signe que " +"j. Si vous voulez en plus que ::" #: ../Doc/faq/programming.rst:842 msgid "" @@ -995,8 +1289,8 @@ msgid "" "identity to hold, and then compilers that truncate ``i // j`` need to make " "``i % j`` have the same sign as ``i``." msgstr "" -"Alors la division entière doit renvoyer l'entier inférieur. Le C demande " -"aussi à ce que cette égalité soit vérifiée, et donc les compilateur qui " +"alors la division entière doit renvoyer l'entier inférieur. Le C impose " +"également que cette égalité soit vérifiée, et donc les compilateurs qui " "tronquent ``i // j`` ont besoin que ``i % j`` ait le même signe que ``i``." #: ../Doc/faq/programming.rst:846 @@ -1007,15 +1301,15 @@ msgid "" "say 200 hours ago? ``-190 % 12 == 2`` is useful; ``-190 % 12 == -10`` is a " "bug waiting to bite." msgstr "" -"Il y a peu de cas d'utilisation réels pour ``i%j`` quand ``j`` est négatif. " -"Quand ``j`` est positif, il y en a beaucoup, et dans pratiquement tous, il " -"est plus utile que ``i % j`` soit ``>=0``. Si l'horloge dit *10h* " -"maintenant, que disait-elle il y a 200 heures? ``-190%12 == 2`` est utile; " -"``-192 % 12 == -10`` est un bug qui attends pour mordre." +"Il y a peu de cas d'utilisation réels pour ``i % j`` quand ``j`` est " +"négatif. Quand ``j`` est positif, il y en a beaucoup, et dans pratiquement " +"tous, il est plus utile que ``i % j`` soit ``>=0``. Si l'horloge affiche " +"10h maintenant, qu'affichait-elle il y a 200 heures ? ``-190 % 12 == 2`` est " +"utile ; ``-190 % 12 == -10`` est un bogue en puissance." #: ../Doc/faq/programming.rst:854 msgid "How do I convert a string to a number?" -msgstr "Comment puis-je convertir une chaine de caractère en nombre?" +msgstr "Comment convertir une chaîne de caractères en nombre ?" #: ../Doc/faq/programming.rst:856 msgid "" @@ -1023,9 +1317,9 @@ msgid "" "``int('144') == 144``. Similarly, :func:`float` converts to floating-point, " "e.g. ``float('144') == 144.0``." msgstr "" -"Pour les entiers, utilisez la fonction native :func:`int` de type " -"constructeur, par exemple ``int('144') == 144``. De façon similaire, :func:" -"`float` convertit en valeur flottante, par exemple ``float('144') == 144.0``." +"Pour les entiers, utilisez le constructeur natif de :func:`int`, par exemple " +"``int('144') == 144``. De façon similaire, :func:`float` donne la valeur " +"flottante, par exemple ``float('144') == 144.0``." #: ../Doc/faq/programming.rst:860 msgid "" @@ -1036,13 +1330,12 @@ msgid "" "interpreted using Python's rules: a leading '0o' indicates octal, and '0x' " "indicates a hex number." msgstr "" -"Par défaut, ces fonctions interprètent les nombre en tant que décimaux, de " -"telles façons que ``int('0144') == 144`` et ``int('0x144')`` lève une :exc:" -"`ValueError`. ``int(string, base)`` prends la base depuis laquelle il faut " -"convertir dans le second argument, optionnel, donc ``int('0x144', 16) == " -"324``. Si la base donnée est 0, le nombre est interprété selon les règles " -"Python: un préfixe ``0o`` indique de l'octal, et ``0x`` indique de " -"l'hexadécimal." +"Par défaut, ces fonctions interprètent les nombres comme des décimaux, de " +"telle façon que ``int('0144') == 144`` et ``int('0x144')`` lève une :exc:" +"`ValueError`. Le second argument (optionnel) de ``int(string, base)`` est la " +"base dans laquelle convertir, donc ``int('0x144', 16) == 324``. Si la base " +"donnée est 0, le nombre est interprété selon les règles Python : un préfixe " +"``0o`` indique de l'octal et ``0x`` indique de l'hexadécimal." #: ../Doc/faq/programming.rst:866 msgid "" @@ -1053,13 +1346,12 @@ msgid "" "``__import__('os').system(\"rm -rf $HOME\")`` which would erase your home " "directory." msgstr "" -"N'utilisez pas la fonction native :func:`eval` si tout ce que vous avez " -"besoin est de convertir des chaines en nombres. :func:`eval` sera " -"significativement plus lent et implique des risque de sécurité: quelqu'un " -"pourrait vous envoyez une expression Python pouvant avoir des effets de bord " -"indésirables. Par exemple, quelqu'un pourrait passer ``__import__('os')." -"system(\"rm -rf $HOME\")`` ce qui aurait pour effet d'effacer votre " -"répertoire d’accueil." +"N'utilisez pas la fonction native :func:`eval` pour convertir des chaînes de " +"caractères en nombres. :func:`eval` est beaucoup plus lente et pose des " +"problèmes de sécurité : quelqu'un pourrait vous envoyer une expression " +"Python pouvant avoir des effets de bord indésirables. Par exemple, quelqu'un " +"pourrait passer ``__import__('os').system(\"rm -rf $HOME\")`` ce qui " +"effacerait votre répertoire personnel." #: ../Doc/faq/programming.rst:873 msgid "" @@ -1068,13 +1360,13 @@ msgid "" "does not allow leading '0' in a decimal number (except '0')." msgstr "" ":func:`eval` a aussi pour effet d'interpréter les nombres comme comme des " -"expression Python, ainsi ``eval('09')`` produit une erreur de syntaxe par ce " -"que Python ne permet pas les '0' en tête d'un nombre décimal (à l'exception " -"du nombre '0')." +"expressions Python. Ainsi ``eval('09')`` produit une erreur de syntaxe, " +"parce que Python ne permet pas les '0' en tête d'un nombre décimal (à " +"l'exception du nombre '0')." #: ../Doc/faq/programming.rst:879 msgid "How do I convert a number to a string?" -msgstr "Comment convertir un nombre en chaine de caractère?" +msgstr "Comment convertir un nombre en chaîne de caractères ?" #: ../Doc/faq/programming.rst:881 msgid "" @@ -1085,10 +1377,17 @@ msgid "" "``\"{:04d}\".format(144)`` yields ``'0144'`` and ``\"{:.3f}\"." "format(1.0/3.0)`` yields ``'0.333'``." msgstr "" +"Pour transformer, par exemple, le nombre 144 en la chaîne de caractères " +"'144', il faut utiliser la fonction native :func:`str`. Pour obtenir la " +"représentation hexadécimale ou octale, il faut utiliser les fonctions " +"natives :func:`hex` ou :func:`oct`. Pour des représentations non-" +"conventionnelles, se référer aux sections :ref:`f-strings` et :ref:" +"`formatstrings`, e.g. ``\"{:04d}\".format(144)`` produit ``'0144'`` et ``" +"\"{:.3f}\".format(1.0/3.0)`` produit ``'0.333'``." #: ../Doc/faq/programming.rst:890 msgid "How do I modify a string in place?" -msgstr "Comment modifier une chaine de caractère \"en place\"?" +msgstr "Comment modifier une chaîne de caractères « sur place » ?" #: ../Doc/faq/programming.rst:892 msgid "" @@ -1098,16 +1397,21 @@ msgid "" "unicode data, try using an :class:`io.StringIO` object or the :mod:`array` " "module::" msgstr "" +"C'est impossible car les chaînes de caractères sont immuables. Dans la " +"plupart des cas, il faut tout simplement construire une nouvelle chaîne à " +"partir des morceaux de l'ancienne. Si toutefois vous avez besoin d'un objet " +"capable de modifier de la donnée Unicode « sur place », essayez d'utiliser " +"un objet :class:`io.StringIO` ou le module :mod:`array` ::" #: ../Doc/faq/programming.rst:922 msgid "How do I use strings to call functions/methods?" msgstr "" -"Comment utiliser des chaines de caractères pour appeler des fonctions/" +"Comment utiliser des chaînes de caractères pour appeler des fonctions/" "méthodes?" #: ../Doc/faq/programming.rst:924 msgid "There are various techniques." -msgstr "Il y a différentes techniques." +msgstr "Il y a plusieurs façons de faire." #: ../Doc/faq/programming.rst:926 msgid "" @@ -1117,9 +1421,9 @@ msgid "" "a case construct::" msgstr "" "La meilleure est d'utiliser un dictionnaire qui fait correspondre les " -"chaines de caractères à des fonctions. Le principal avantage de cette " -"technique est que les chaines n'ont pas besoin d'être égales aux noms de " -"fonctions. C'est aussi la principale façon d'imiter la construction \"case" +"chaînes de caractères à des fonctions. Le principal avantage de cette " +"technique est que les chaînes n'ont pas besoin d'être égales aux noms de " +"fonctions. C'est aussi la façon principale d'imiter la construction \"case" "\" ::" #: ../Doc/faq/programming.rst:941 @@ -1137,13 +1441,14 @@ msgstr "" #: ../Doc/faq/programming.rst:949 msgid "This is used in several places in the standard library, like this::" msgstr "" -"Ceci est utilisé dans plusieurs endroit de la bibliothèque standard, de " +"Ceci est utilisé à plusieurs reprises dans la bibliothèque standard, de " "cette façon ::" #: ../Doc/faq/programming.rst:962 msgid "Use :func:`locals` or :func:`eval` to resolve the function name::" msgstr "" -"Utilisez :func:`locals` ou :func:`eval` pour résoudre le nom de fonction ::" +"Utilisez :func:`locals` ou :func:`eval` pour résoudre le nom de la " +"fonction ::" #: ../Doc/faq/programming.rst:975 msgid "" @@ -1151,10 +1456,10 @@ msgid "" "control over the contents of the string, someone could pass a string that " "resulted in an arbitrary function being executed." msgstr "" -"Note: En utilisant :func:`eval` est lent est dangereux. Si vous n'avez pas " -"un contrôle absolu sur le contenu de la chaine de caractère, quelqu'un peut " -"passer une chaine de caractère pouvant résulter en l'exécution de code " -"arbitraire." +"Note : utiliser :func:`eval` est lent est dangereux. Si vous n'avez pas un " +"contrôle absolu sur le contenu de la chaîne de caractères, quelqu'un " +"pourrait passer une chaîne de caractères pouvant appeler n'importe quelle " +"fonction." #: ../Doc/faq/programming.rst:980 msgid "" @@ -1162,7 +1467,7 @@ msgid "" "strings?" msgstr "" "Existe-t-il un équivalent à la fonction ``chomp()`` de Perl, pour retirer " -"les caractères de fin de ligne d'une chaine de caractère ?" +"les caractères de fin de ligne d'une chaîne de caractères ?" #: ../Doc/faq/programming.rst:982 msgid "" @@ -1172,19 +1477,19 @@ msgid "" "empty lines at the end, the line terminators for all the blank lines will be " "removed::" msgstr "" -"Vous pouvez utiliser ``S.rstrip(\"\\r\\n\")`` pour retirer toute occurrence " -"de tout marqueur de fin de ligne, à la fin d'une chaîne de caractère ``S``, " -"sans en retirer aucun espace. Si la chaîne ``S`` représente plus d'une " -"ligne, avec plusieurs lignes vides, les marqueurs de fin de de lignes de " -"chaque lignes vides seront retirés ::" +"Vous pouvez utiliser ``S.rstrip(\"\\r\\n\")`` pour retirer toutes les " +"occurrences de tout marqueur de fin de ligne à la fin d'une chaîne de " +"caractère ``S``, sans en enlever aucune espace. Si la chaîne ``S`` " +"représente plus d'une ligne, avec plusieurs lignes vides, les marqueurs de " +"fin de de ligne de chaque ligne vide seront retirés ::" #: ../Doc/faq/programming.rst:994 msgid "" "Since this is typically only desired when reading text one line at a time, " "using ``S.rstrip()`` this way works well." msgstr "" -"Du fait que ce soit principalement utile en lisant un texte ligne à ligne, " -"utiliser ``S.rstrip()`` devrait marcher correctement." +"Vu que cela ne sert presque qu'à lire un texte ligne à ligne, utiliser ``S." +"rstrip()`` de cette manière fonctionne correctement." #: ../Doc/faq/programming.rst:999 msgid "Is there a scanf() or sscanf() equivalent?" @@ -1203,20 +1508,20 @@ msgid "" "parameter which is useful if the line uses something other than whitespace " "as a separator." msgstr "" -"Pour une simple analyse de chaine, l'approche la plus simple est " +"Pour une simple analyse de chaîne, l'approche la plus simple est " "généralement de découper la ligne en mots délimités par des espaces, en " -"utilisant la méthode :meth:`~str.split` des objets chaine de caractères, et " -"ensuite de convertir les chaines de décimales en valeurs numériques en " -"utilisant la fonction :func:`int` ou :func:`float`, ``split()`` supporte un " +"utilisant la méthode :meth:`~str.split` des objets chaîne de caractères, et " +"ensuite de convertir les chaînes de décimaux en valeurs numériques en " +"utilisant la fonction :func:`int` ou :func:`float`. ``split()`` possède un " "paramètre optionnel \"sep\" qui est utile si la ligne utilise autre chose " -"que des espaces comme séparateur." +"que des espaces comme séparateurs." #: ../Doc/faq/programming.rst:1009 msgid "" "For more complicated input parsing, regular expressions are more powerful " "than C's :c:func:`sscanf` and better suited for the task." msgstr "" -"Pour les analyses plus compliquées, les expressions rationnelles sont plus " +"Pour des analyses plus compliquées, les expressions rationnelles sont plus " "puissantes que la fonction :c:func:`sscanf` de C et mieux adaptées à la " "tâche." @@ -1227,45 +1532,57 @@ msgstr "" #: ../Doc/faq/programming.rst:1016 msgid "See the :ref:`unicode-howto`." -msgstr "Regardez :ref:`unicode-howto`." +msgstr "Voir :ref:`unicode-howto`." #: ../Doc/faq/programming.rst:1020 msgid "Performance" -msgstr "" +msgstr "Performances" #: ../Doc/faq/programming.rst:1023 msgid "My program is too slow. How do I speed it up?" -msgstr "" +msgstr "Mon programme est trop lent. Comment l'accélérer ?" #: ../Doc/faq/programming.rst:1025 msgid "" "That's a tough one, in general. First, here are a list of things to " "remember before diving further:" msgstr "" +"Question difficile en général. Il faut garder en tête les points suivants " +"avant d'aller plus loin :" #: ../Doc/faq/programming.rst:1028 msgid "" "Performance characteristics vary across Python implementations. This FAQ " "focusses on :term:`CPython`." msgstr "" +"Les performances varient en fonction des implémentations de Python. Cette " +"FAQ ne traite que de :term:`CPython`." #: ../Doc/faq/programming.rst:1030 msgid "" "Behaviour can vary across operating systems, especially when talking about I/" "O or multi-threading." msgstr "" +"Les comportements peuvent différer d'un système d'exploitation à l'autre, " +"tout particulièrement quand il s'agit d'entrée/sortie ou de fils d'exécution " +"multiples." #: ../Doc/faq/programming.rst:1032 msgid "" "You should always find the hot spots in your program *before* attempting to " "optimize any code (see the :mod:`profile` module)." msgstr "" +"Il faut toujours essayer de trouver où sont les points de contention d'un " +"programme *avant* d'essayer d'optimiser du code (voir le module :mod:" +"`profile`)." #: ../Doc/faq/programming.rst:1034 msgid "" "Writing benchmark scripts will allow you to iterate quickly when searching " "for improvements (see the :mod:`timeit` module)." msgstr "" +"Écrire des scripts d'évaluation de performances permet de progresser " +"rapidement dans la recherche d'améliorations (voir le module :mod:`timeit`)." #: ../Doc/faq/programming.rst:1036 msgid "" @@ -1273,6 +1590,9 @@ msgid "" "any other technique) before potentially introducing regressions hidden in " "sophisticated optimizations." msgstr "" +"Il est très fortement recommandé d'avoir une bonne couverture de code (avec " +"des tests unitaires ou autre) avant d'ajouter des erreurs dans des " +"optimisations sophistiquées." #: ../Doc/faq/programming.rst:1040 msgid "" @@ -1280,6 +1600,9 @@ msgid "" "some general principles which go a long way towards reaching acceptable " "performance levels:" msgstr "" +"Ceci étant dit, il y a beaucoup d'astuces pour accélérer du code Python. " +"Voici quelques principes généraux qui peuvent aider à atteindre des niveaux " +"de performance satisfaisants :" #: ../Doc/faq/programming.rst:1044 msgid "" @@ -1287,12 +1610,17 @@ msgid "" "larger benefits than trying to sprinkle micro-optimization tricks all over " "your code." msgstr "" +"Améliorer les algorithmes (ou en changer pour des plus performants) peut " +"produire de bien meilleurs résultats que d'optimiser ça et là de petites " +"portions du code." #: ../Doc/faq/programming.rst:1048 msgid "" "Use the right data structures. Study documentation for the :ref:`bltin-" "types` and the :mod:`collections` module." msgstr "" +"Utiliser les structures de données adaptées. Se référer à la documentation " +"des :ref:`bltin-types` et du module :mod:`collections`." #: ../Doc/faq/programming.rst:1051 msgid "" @@ -1304,6 +1632,14 @@ msgid "" "do sorting (and see the :ref:`sortinghowto` for examples of moderately " "advanced usage)." msgstr "" +"Quand la bibliothèque standard fournit une implémentation pour quelque " +"chose, il y a de fortes chances (même si ce n'est pas systématique) que " +"cette implémentation soit plus rapide que la votre. C'est d'autant plus vrai " +"pour les routines écrites en C, comme les routines natives et certaines " +"extensions de types. Par exemple, il faut utiliser la méthode native :meth:" +"`list.sort` ou la fonction :func:`sorted` similaire pour classer (et se " +"référer à la section :ref:`sortinghowto` pour des exemples d'utilisation " +"courante)." #: ../Doc/faq/programming.rst:1059 msgid "" @@ -1313,6 +1649,11 @@ msgid "" "especially under the form of tiny functions or methods (which are also often " "detrimental to readability)." msgstr "" +"Les abstractions ont tendance à créer des indirections et obligent " +"l'interpréteur à faire plus d'efforts. Si le niveau d'indirection dépasse le " +"quantité de travail effectif, le programme sera ralentit. Il faut toujours " +"éviter trop d'indirections, en particulier sous la forme de fonctions ou " +"méthodes trop petites (qui nuisent aussi souvent à la clarté du code)." #: ../Doc/faq/programming.rst:1065 msgid "" @@ -1325,16 +1666,29 @@ msgid "" "skills, you can also :ref:`write a C extension module ` " "yourself." msgstr "" +"Si vous atteignez les limites de ce que du Python « pur » permet de faire, " +"il y a des outils qui permettent d'aller plus loin. Par exemple, `Cython " +"`_ peut compiler une version légèrement modifiée de code " +"Python en une extension C et est disponible sur de nombreuses plate-formes. " +"Cython peut bénéficier de la compilation (et de l'annotation, optionnelle, " +"des types) pour rendre votre code beaucoup plus rapide que s'il était " +"interprété. Si vous avez confiance en vos capacités de programmation en C, " +"vous pouvez aussi :ref:`écrire un module d'extension en C` " +"vous-même." #: ../Doc/faq/programming.rst:1075 msgid "" "The wiki page devoted to `performance tips `_." msgstr "" +"La page wiki dédiée aux `astuces de performance `_." #: ../Doc/faq/programming.rst:1081 msgid "What is the most efficient way to concatenate many strings together?" msgstr "" +"Quelle est la manière la plus efficace de concaténer un grand nombre de " +"chaînes de caractères ?" #: ../Doc/faq/programming.rst:1083 msgid "" @@ -1343,16 +1697,26 @@ msgid "" "creates a new object. In the general case, the total runtime cost is " "quadratic in the total string length." msgstr "" +"Les objets :class:`str` et :class:`bytes` sont immuables, par conséquent " +"concaténer un grand nombre de chaînes de caractères entre elles n'est pas " +"très efficace car chaque concaténation crée un nouvel objet. Dans le cas " +"général, la complexité est quadratique par rapport à la taille totale de la " +"chaîne." #: ../Doc/faq/programming.rst:1088 msgid "" "To accumulate many :class:`str` objects, the recommended idiom is to place " "them into a list and call :meth:`str.join` at the end::" msgstr "" +"Pour mettre bout-à-bout un grand nombre d'objets :class:`str`, la technique " +"recommandée consiste à toutes les mettre dans une liste et appeler la " +"méthode :meth:`str.join` à la fin ::" #: ../Doc/faq/programming.rst:1096 msgid "(another reasonably efficient idiom is to use :class:`io.StringIO`)" msgstr "" +"(une autre technique relativement efficace consiste à utiliser :class:`io." +"StringIO`)" #: ../Doc/faq/programming.rst:1098 msgid "" @@ -1360,22 +1724,26 @@ msgid "" "extend a :class:`bytearray` object using in-place concatenation (the ``+=`` " "operator)::" msgstr "" +"Pour concaténer un grand nombre d'objets :class:`bytes`, la technique " +"recommandée consiste à étendre un objet :class:`bytearray` en utilisant la " +"concaténation en-place (l'opérateur ``+=``) ::" #: ../Doc/faq/programming.rst:1107 msgid "Sequences (Tuples/Lists)" -msgstr "Sequences (Tuples/Lists)" +msgstr "Séquences (n-uplets / listes)" #: ../Doc/faq/programming.rst:1110 msgid "How do I convert between tuples and lists?" -msgstr "Comment convertir les listes en tuples et inversement?" +msgstr "Comment convertir les listes en n-uplets et inversement ?" #: ../Doc/faq/programming.rst:1112 msgid "" "The type constructor ``tuple(seq)`` converts any sequence (actually, any " "iterable) into a tuple with the same items in the same order." msgstr "" -"Le constructeur de type ``tuple(seq)`` convertit toute séquence (en fait " -"tout itérable) en un tuple avec les mêmes éléments dans le même ordre…." +"Le constructeur de type ``tuple(seq)`` convertit toute séquence (plus " +"précisément, tout itérable) en un n-uplet avec les mêmes éléments dans le " +"même ordre." #: ../Doc/faq/programming.rst:1115 msgid "" @@ -1384,11 +1752,11 @@ msgid "" "copy but returns the same object, so it is cheap to call :func:`tuple` when " "you aren't sure that an object is already a tuple." msgstr "" -"Par exemple ``tuple([1, 2, 3])`` renvoi ``(1, 2, 3)`` et ``tuple('abc')`` " -"renvoi ``('a', 'b', 'c')``. Si l'argument est un tuple, cela ne crée pas une " -"copie, mais renvoi le même objet, ce qui fait de :func:`tuple` un fonction " -"économique à appeler quand vous ne savez pas si votre objet est déjà un " -"tuple." +"Par exemple ``tuple([1, 2, 3])`` renvoie ``(1, 2, 3)`` et ``tuple('abc')`` " +"renvoie ``('a', 'b', 'c')``. Si l'argument est un n-uplet, cela ne crée pas " +"de copie, mais renvoie le même objet, ce qui fait de :func:`tuple` une " +"fonction économique à appeler quand vous ne savez pas si votre objet est " +"déjà un n-uplet." #: ../Doc/faq/programming.rst:1120 msgid "" @@ -1405,7 +1773,7 @@ msgstr "" #: ../Doc/faq/programming.rst:1127 msgid "What's a negative index?" -msgstr "Qu'est-ce qu'un indexe négatif?" +msgstr "Qu'est-ce qu'un index négatif ?" #: ../Doc/faq/programming.rst:1129 msgid "" @@ -1416,10 +1784,10 @@ msgid "" "``seq[len(seq)-n]``." msgstr "" "Les séquences Python sont indexées avec des nombres positifs aussi bien que " -"négatifs. Pour les nombres positifs, 0 est le premier index, 1 est le " -"second, et ainsi de suite. Pour les indexes négatifs, ``-1`` est le dernier " -"index, ``-2`` est le pénultième (avant dernier), et ainsi de suite. On peut " -"aussi dire que ``seq[-n]`` est équivalent à ``seq[len(seq)-n]``." +"négatifs. Pour les nombres positifs, 0 est le premier indice, 1 est le " +"deuxième, et ainsi de suite. Pour les indices négatifs, ``-1`` est le " +"dernier index, ``-2`` est le pénultième (avant-dernier), et ainsi de suite. " +"On peut aussi dire que ``seq[-n]`` est équivalent à ``seq[len(seq)-n]``." #: ../Doc/faq/programming.rst:1134 msgid "" @@ -1427,20 +1795,20 @@ msgid "" "all of the string except for its last character, which is useful for " "removing the trailing newline from a string." msgstr "" -"Utiliser des indexes négatifs peut être très pratique. Par exemple " -"``S[:-1]`` indique la chaine entière a l'exception du dernier caractère, ce " -"qui est pratique pour retirer un caractère de fin de ligne en fin d'une " -"chaine." +"Utiliser des indices négatifs peut être très pratique. Par exemple " +"``S[:-1]`` représente la chaîne tout entière à l'exception du dernier " +"caractère, ce qui est pratique pour retirer un caractère de fin de ligne à " +"la fin d'une chaîne." #: ../Doc/faq/programming.rst:1140 msgid "How do I iterate over a sequence in reverse order?" -msgstr "Comment itérer à rebours sur une séquence?" +msgstr "Comment itérer à rebours sur une séquence ?" #: ../Doc/faq/programming.rst:1142 msgid "" "Use the :func:`reversed` built-in function, which is new in Python 2.4::" msgstr "" -"Utilisez la fonction embarquée :func:`reversed`, qui est apparue en Python " +"Utilisez la fonction native :func:`reversed`, qui a été introduite en Python " "2.4 ::" #: ../Doc/faq/programming.rst:1147 @@ -1448,8 +1816,8 @@ msgid "" "This won't touch your original sequence, but build a new copy with reversed " "order to iterate over." msgstr "" -"Cela ne modifiera pas votre séquence initiale, mais construira à la place " -"une copie en ordre inverse pour itérer dessus." +"Cela ne modifie pas la séquence initiale, mais construit à la place une " +"copie en ordre inverse pour itérer dessus." #: ../Doc/faq/programming.rst:1150 msgid "With Python 2.3, you can use an extended slice syntax::" @@ -1457,25 +1825,25 @@ msgstr "Avec Python 2.3 vous pouvez utiliser la syntaxe étendue de tranches :: #: ../Doc/faq/programming.rst:1157 msgid "How do you remove duplicates from a list?" -msgstr "Comment retirer les doublons d'une liste?" +msgstr "Comment retirer les doublons d'une liste ?" #: ../Doc/faq/programming.rst:1159 msgid "See the Python Cookbook for a long discussion of many ways to do this:" msgstr "" -"Lisez le Python Cookbook pour trouver une longue discussion sur les " -"nombreuses façons de faire cela:" +"Lisez le « livre de recettes » Python pour trouver une longue discussion sur " +"les nombreuses approches possibles :" #: ../Doc/faq/programming.rst:1161 msgid "https://code.activestate.com/recipes/52560/" -msgstr "" +msgstr "https://code.activestate.com/recipes/52560/" #: ../Doc/faq/programming.rst:1163 msgid "" "If you don't mind reordering the list, sort it and then scan from the end of " "the list, deleting duplicates as you go::" msgstr "" -"Si changer l'ordre de la liste ne vous dérange pas, commencez par trier " -"celle ci, puis parcourez la d'un bout à l'autre, en supprimant les doublons " +"Si changer l'ordre de la liste ne vous dérange pas, commencez par ordonner " +"celle-ci, puis parcourez-la d'un bout à l'autre, en supprimant les doublons " "trouvés en chemin ::" #: ../Doc/faq/programming.rst:1175 @@ -1492,12 +1860,12 @@ msgid "" "This converts the list into a set, thereby removing duplicates, and then " "back into a list." msgstr "" -"Ceci convertis la liste en un ensemble, ce qui supprime automatiquement les " +"Ceci convertit la liste en un ensemble, ce qui supprime automatiquement les " "doublons, puis la transforme à nouveau en liste." #: ../Doc/faq/programming.rst:1185 msgid "How do you make an array in Python?" -msgstr "Comment construire un tableau en Python?" +msgstr "Comment construire un tableau en Python ?" #: ../Doc/faq/programming.rst:1187 msgid "Use a list::" @@ -1509,7 +1877,7 @@ msgid "" "primary difference is that a Python list can contain objects of many " "different types." msgstr "" -"Les listes ont un cout équivalent à celui des tableau C ou Pascal; la " +"Les listes ont un coût équivalent à celui des tableaux C ou Pascal ; la " "principale différence est qu'une liste Python peut contenir des objets de " "différents types." @@ -1522,16 +1890,16 @@ msgid "" msgstr "" "Le module ``array`` fournit des méthodes pour créer des tableaux de types " "fixes dans une représentation compacte, mais ils sont plus lents à indexer " -"que les listes. Notez aussi que l'extension ``Numeric`` et d'autres, " -"fournissent différentes structures de types tableaux, avec des " +"que les listes. Notez aussi que l'extension ``Numeric`` (et d'autres) " +"fournissent différentes structures de type tableaux, avec des " "caractéristiques différentes." #: ../Doc/faq/programming.rst:1199 msgid "" "To get Lisp-style linked lists, you can emulate cons cells using tuples::" msgstr "" -"Pour obtenir des listes chainées de type Lisp, vous pouvez émuler les *cons " -"cells* en utilisant des tuples ::" +"Pour obtenir des listes chaînées à la sauce Lisp, vous pouvez émuler les " +"*cons cells* en utilisant des n-uplets ::" #: ../Doc/faq/programming.rst:1203 msgid "" @@ -1541,14 +1909,14 @@ msgid "" "it's usually a lot slower than using Python lists." msgstr "" "Si vous voulez pouvoir modifier les éléments, utilisez une liste plutôt " -"qu'un tuple. Ici la version équivalente au *car* de Lisp est " -"``lisp_list[0]`` et l'équivalent à *cdr* est ``list_lip[1]``. Ne faites ceci " -"que si vous êtes réellement sûr d'en avoir besoin, cette méthode est en " -"générale bien plus lente que les listes Python." +"qu'un tuple. Ici la version équivalente du *car* de Lisp est " +"``lisp_list[0]`` et l'équivalent de *cdr* est ``lisp_list[1]``. Ne faites " +"ceci que si vous êtes réellement sûr d'en avoir besoin, cette méthode est en " +"général bien plus lente que les listes Python." #: ../Doc/faq/programming.rst:1212 msgid "How do I create a multidimensional list?" -msgstr "Comment puis-je créer une liste à plusieurs dimensions?" +msgstr "Comment créer une liste à plusieurs dimensions ?" #: ../Doc/faq/programming.rst:1214 msgid "You probably tried to make a multidimensional array like this::" @@ -1558,12 +1926,13 @@ msgstr "" #: ../Doc/faq/programming.rst:1218 msgid "This looks correct if you print it:" -msgstr "" +msgstr "Elle semble correcte si on l'affiche :" #: ../Doc/faq/programming.rst:1229 msgid "But when you assign a value, it shows up in multiple places:" msgstr "" -"Mais quand vous assignez une valeur, elle apparait en de multiples endroits::" +"Mais quand vous affectez une valeur, celle-ci apparaît à plusieurs " +"endroits ::" #: ../Doc/faq/programming.rst:1241 msgid "" @@ -1572,46 +1941,51 @@ msgid "" "containing 3 references to the same list of length two. Changes to one row " "will show in all rows, which is almost certainly not what you want." msgstr "" -"La raison en est que dupliquer une liste en utilisant ``*`` ne crée pas de " -"copies, cela crée seulement des références aux objets existants. Le ``*3`` " -"crée une liste contenant trois références à la même liste de longueur deux. " -"Un changement dans une colonne apparaîtra donc dans toutes les colonnes. Ce " -"qui n'est de façon quasi certaine, pas ce que vous souhaitez." +"Dupliquer une liste en utilisant ``*`` ne crée en réalité pas de copie mais " +"seulement des références aux objets existants. Le ``*3`` crée une liste " +"contenant trois références à la même liste de longueur deux. Un changement " +"dans une colonne apparaîtra donc dans toutes les colonnes, ce qui n'est très " +"probablement pas ce que vous souhaitiez." #: ../Doc/faq/programming.rst:1246 msgid "" "The suggested approach is to create a list of the desired length first and " "then fill in each element with a newly created list::" msgstr "" -"L'approche suggérée est de créer une liste de la longueur désiré d'abords, " -"puis de remplir tous les éléments avec une chaîne nouvellement créée ::" +"L'approche suggérée est d'abord de créer une liste de la longueur désirée, " +"puis de remplir tous les éléments avec une nouvelle chaîne ::" #: ../Doc/faq/programming.rst:1253 msgid "" "This generates a list containing 3 different lists of length two. You can " "also use a list comprehension::" msgstr "" -"Cette liste générée contient trois listes différentes de longueur deux. Vous " -"pouvez aussi utilisez la notation de compréhension de listes ::" +"Cela génère une liste contenant elle-même trois listes distinctes, de " +"longueur deux. Vous pouvez aussi utiliser la syntaxe des listes en " +"compréhension ::" #: ../Doc/faq/programming.rst:1259 msgid "" "Or, you can use an extension that provides a matrix datatype; `NumPy `_ is the best known." msgstr "" +"Vous pouvez aussi utiliser une extension qui fournit un type matriciel " +"natif ; `NumPy `_ est la plus répandue." #: ../Doc/faq/programming.rst:1264 msgid "How do I apply a method to a sequence of objects?" -msgstr "Comment appliquer une méthode à une séquence d'objets?" +msgstr "Comment appliquer une méthode à une séquence d'objets ?" #: ../Doc/faq/programming.rst:1266 msgid "Use a list comprehension::" -msgstr "Utilisez une compréhension de liste ::" +msgstr "Utilisez une liste en compréhension ::" #: ../Doc/faq/programming.rst:1273 msgid "" "Why does a_tuple[i] += ['item'] raise an exception when the addition works?" msgstr "" +"Pourquoi a_tuple[i] += ['item'] lève-t'il une exception alors que " +"l'addition fonctionne ?" #: ../Doc/faq/programming.rst:1275 msgid "" @@ -1619,6 +1993,9 @@ msgid "" "operators are *assignment* operators, and the difference between mutable and " "immutable objects in Python." msgstr "" +"Ceci est dû à la combinaison de deux facteurs : le fait que les opérateurs " +"d'affectation incrémentaux sont des opérateurs d'*affectation* et à la " +"différence entre les objets muables et immuables en Python." #: ../Doc/faq/programming.rst:1279 msgid "" @@ -1626,6 +2003,9 @@ msgid "" "applied to elements of a tuple that point to mutable objects, but we'll use " "a ``list`` and ``+=`` as our exemplar." msgstr "" +"Cette discussion est valable, en général, quand des opérateurs d'affectation " +"incrémentale sont appliqués aux élément d'un n-uplet qui pointe sur des " +"objets muables, mais on prendra ``list`` et ``+=`` comme exemple." #: ../Doc/faq/programming.rst:1283 msgid "If you wrote::" @@ -1639,28 +2019,39 @@ msgid "" "to element ``0`` of the tuple, we get an error because we can't change what " "an element of a tuple points to." msgstr "" +"La cause de l'exception est claire : ``1`` est ajouté à l'objet " +"``a_tuple[0]`` qui pointe sur (``1``), ce qui produit l'objet résultant " +"``2``, mais, lorsque l'on tente d'affecter le résultat du calcul, ``2``, à " +"l'élément ``0`` du n-uplet, on obtient une erreur car il est impossible de " +"modifier la cible sur laquelle pointe un élément d'un n-uplet." #: ../Doc/faq/programming.rst:1297 msgid "" "Under the covers, what this augmented assignment statement is doing is " "approximately this::" msgstr "" +"Sous le capot, une instruction d'affectation incrémentale fait à peu près " +"ceci :" #: ../Doc/faq/programming.rst:1306 msgid "" "It is the assignment part of the operation that produces the error, since a " "tuple is immutable." msgstr "" +"C'est la partie de l'affectation de l'opération qui génère l'erreur, vu " +"qu'un n-uplet est immuable." #: ../Doc/faq/programming.rst:1309 msgid "When you write something like::" -msgstr "" +msgstr "Quand vous écrivez un code du style :" #: ../Doc/faq/programming.rst:1317 msgid "" "The exception is a bit more surprising, and even more surprising is the fact " "that even though there was an error, the append worked::" msgstr "" +"L'exception est un peu plus surprenante et, chose encore plus étrange, " +"malgré l'erreur, l'ajout a fonctionné ::" #: ../Doc/faq/programming.rst:1323 msgid "" @@ -1671,6 +2062,13 @@ msgid "" "calling ``extend`` on the list and returning the list. That's why we say " "that for lists, ``+=`` is a \"shorthand\" for ``list.extend``::" msgstr "" +"Pour comprendre ce qui se passe, il faut savoir que, premièrement, si un " +"objet implémente la méthode magique c, celle-ci est appelée quand " +"l'affectation incrémentale ``+=`` est exécutée et sa valeur de retour est " +"utilisée dans l'instruction d'affectation ; et que, deuxièmement, pour les " +"listes, ``__iadd__`` équivaut à appeler ``extend`` sur la liste et à " +"renvoyer celle-ci. C'est pour cette raison que l'on dit que pour les listes, " +"``+=`` est un \"raccourci\" pour ``list.extend``::" #: ../Doc/faq/programming.rst:1335 msgid "This is equivalent to::" @@ -1683,10 +2081,16 @@ msgid "" "assignment is a no-op, since it is a pointer to the same object that " "``a_list`` was previously pointing to, but the assignment still happens." msgstr "" +"L'objet sur lequel pointe ``a_list`` a été modifié et le pointeur vers " +"l'objet modifié est réaffecté à ``a_list``. *In fine*, l'affectation ne " +"change rien, puisque c'est un pointeur vers le même objet que sur lequel " +"pointait ``a_list``, mais l'affectation a tout de même lieu." #: ../Doc/faq/programming.rst:1345 msgid "Thus, in our tuple example what is happening is equivalent to::" msgstr "" +"Donc, dans notre exemple avec un n-uplet, il se passe quelque chose " +"équivalent à ::" #: ../Doc/faq/programming.rst:1353 msgid "" @@ -1695,14 +2099,17 @@ msgid "" "that final assignment still results in an error, because tuples are " "immutable." msgstr "" +"L'appel à ``__iadd__`` réussit et la liste est étendue, mais bien que " +"``result`` pointe sur le même objet que ``a_tuple[0]``, l'affectation finale " +"échoue car les n-uplets ne sont pas muables." #: ../Doc/faq/programming.rst:1359 msgid "" "I want to do a complicated sort: can you do a Schwartzian Transform in " "Python?" msgstr "" -"Je souhaite faire un tri compliqué: peut on faire une transformation de " -"Schwartz en Python?" +"Je souhaite faire un classement compliqué : peut on faire une transformation " +"de Schwartz en Python ?" #: ../Doc/faq/programming.rst:1361 msgid "" @@ -1711,23 +2118,26 @@ msgid "" "value\". In Python, use the ``key`` argument for the :meth:`list.sort` " "method::" msgstr "" +"Cette technique, attribuée à Randal Schwartz de la communauté Perl, ordonne " +"les éléments d'une liste à l'aide une transformation qui fait correspondre " +"chaque élément à sa \"valeur de tri\". En Python, ceci est géré par " +"l'argument ``key`` de la méthode :meth:`list.sort` ::" #: ../Doc/faq/programming.rst:1370 msgid "How can I sort one list by values from another list?" -msgstr "" -"Comment puis-je trier une liste en fonction des valeurs d'une autre liste?" +msgstr "Comment ordonner une liste en fonction des valeurs d'une autre liste ?" #: ../Doc/faq/programming.rst:1372 msgid "" "Merge them into an iterator of tuples, sort the resulting list, and then " "pick out the element you want. ::" msgstr "" -"Fusionnez les dans un itérateur de tuples, triez la liste obtenue, puis " -"choisissez l'élément que vous voulez. ::" +"Fusionnez-les dans un itérateur de n-uplets, ordonnez la liste obtenue, puis " +"choisissez l'élément que vous voulez ::" #: ../Doc/faq/programming.rst:1386 msgid "An alternative for the last step is::" -msgstr "Une alternative pour la dernière étape est ::" +msgstr "Vous pouvez remplacer la dernière étape par ::" #: ../Doc/faq/programming.rst:1391 msgid "" @@ -1739,14 +2149,15 @@ msgid "" "\"result.append\" requires an extra attribute lookup, and third, there's a " "speed reduction from having to make all those function calls." msgstr "" -"Si vous trouvez cela plus lisible, vous préférez peut-être utiliser ceci à " -"la place de la compréhension de la liste finale. Toutefois, ceci est presque " -"deux fois plus lent pour les longues listes. Pourquoi? Tout d'abord, " -"``append ()`` doit réaffecter la mémoire, et si il utilise quelques astuces " -"pour éviter de le faire à chaque fois, il doit encore le faire de temps en " -"temps, ce qui coûte assez cher. Deuxièmement, l'expression ``result.append`` " -"exige une recherche d'attribut supplémentaire, et enfin, tous ces appels de " -"fonction impactent la vitesse d'exécution." +"Si cela vous semble plus lisible, vous pouvez utiliser cette forme plutôt " +"qu'une liste en compréhension. Toutefois, ce code est presque deux fois plus " +"lent pour une liste de grande taille. Pourquoi ? Tout d'abord, parce que " +"``append()`` doit ré-allouer de la mémoire et, même si elle utilise quelques " +"astuces pour éviter d'effectuer la ré-allocation à chaque appel, elle doit " +"tout de même le faire de temps en temps, ce qui coûte assez cher. " +"Deuxièmement, parce que l'expression ``result.append`` fait un accès " +"supplémentaire à un attribut et, enfin, parce que tous ces appels de " +"fonctions réduisent la vitesse d'exécution." #: ../Doc/faq/programming.rst:1401 msgid "Objects" @@ -1778,16 +2189,17 @@ msgid "" "``OutlookMailbox`` that handle various specific mailbox formats." msgstr "" "Une classe peut être fondée sur une ou plusieurs autres classes, appelée sa " -"ou ses classes de base. Il hérite alors les attributs et les méthodes de ses " -"classes de base. Cela permet à un modèle d'objet d'être successivement " -"raffinés par héritage. Vous pourriez avoir une classe générique ``Mailbox`` " -"qui fournit des méthodes d'accès de base pour une boîte aux lettres, et sous-" -"classes telles que ``MboxMailbox``, ``MaildirMailbox``, ``OutlookMailbox`` " -"qui gèrent les différents formats de boîtes aux lettres spécifiques." +"(ou ses) classe(s) de base. Elle hérite alors des attributs et des méthodes " +"de ses classes de base. Cela permet à un modèle d'objet d'être " +"successivement raffiné par héritage. Vous pourriez avoir une classe " +"générique ``Mailbox``, qui fournit des méthodes d'accès de base pour une " +"boîte aux lettres, et des sous-classes telles que ``MboxMailbox``, " +"``MaildirMailbox``, ``OutlookMailbox`` qui gèrent les plusieurs formats " +"spécifiques de boîtes aux lettres." #: ../Doc/faq/programming.rst:1419 msgid "What is a method?" -msgstr "Qu'est-ce qu'une méthode?" +msgstr "Qu'est-ce qu'une méthode ?" #: ../Doc/faq/programming.rst:1421 msgid "" @@ -1795,13 +2207,13 @@ msgid "" "name(arguments...)``. Methods are defined as functions inside the class " "definition::" msgstr "" -"Une méthode est une fonction sur un objet ``x`` appelez normalement comme " -"``x.name(arguments…)``. Les méthodes sont définies comme des fonctions à " -"l'intérieur de la définition de classe ::" +"Une méthode est une fonction sur un objet ``x`` qu'on appelle de manière " +"générale sous la forme ``x.name(arguments…)``. Les méthodes sont définies " +"comme des fonctions à l'intérieur de la définition de classe ::" #: ../Doc/faq/programming.rst:1431 msgid "What is self?" -msgstr "Qu'est-ce que self?" +msgstr "Qu'est-ce que self ?" #: ../Doc/faq/programming.rst:1433 msgid "" @@ -1810,11 +2222,11 @@ msgid "" "c)`` for some instance ``x`` of the class in which the definition occurs; " "the called method will think it is called as ``meth(x, a, b, c)``." msgstr "" -"Self est simplement un nom conventionnel pour le premier argument d'une " -"méthode. Une méthode définie comme ``meth(self, a, b, c)`` doit être appelée " -"en tant que ``x.meth(a, b, c)``, pour une instance ``x`` de la classe dans " -"laquelle elle est définie, la méthode appelée considérera qu'elle est " -"appelée ``meth(x, a, b, c)``." +"Par convention, le premier argument d'une méthode est appelé self. Une " +"méthode ``meth(self, a, b, c)`` doit être appelée sous la forme ``x.meth(a, " +"b, c)`` où ``x`` est une instance de la classe dans laquelle cette méthode " +"est définie ; tout se passe comme si la méthode était appelée comme " +"``meth(x, a, b, c)``." #: ../Doc/faq/programming.rst:1438 msgid "See also :ref:`why-self`." @@ -1825,8 +2237,8 @@ msgid "" "How do I check if an object is an instance of a given class or of a subclass " "of it?" msgstr "" -"Comment puis-je vérifier si un objet est une instance d'une classe donnée ou " -"d'une sous-classe de celui-ci?" +"Comment vérifier si un objet est une instance d'une classe donnée ou d'une " +"sous-classe de celle-ci ?" #: ../Doc/faq/programming.rst:1444 msgid "" @@ -1837,11 +2249,11 @@ msgid "" "``isinstance(obj, str)`` or ``isinstance(obj, (int, float, complex))``." msgstr "" "Utilisez la fonction native ``isinstance(obj, cls)``. Vous pouvez vérifier " -"si un objet est une instance de n'importe lequel d'un certain nombre de " -"classes en fournissant un tuple à la place d'une seule classe, par exemple, " -"``isinstance(obj, (class1, class2, ...))``, et peut également vérifier si un " -"objet est l'un des types natifs de Python, par exemple, ``isinstance(obj, " -"str)`` ou ``isinstance(obj, (int, float, complex))``." +"qu'un objet est une instance de plusieurs classes à la fois en fournissant " +"un n-uplet à la place d'une seule classe, par exemple, ``isinstance(obj, " +"(class1, class2, ...))``. Vous pouvez également vérifier qu'un objet est " +"l'un des types natifs de Python, par exemple ``isinstance(obj, str)`` ou " +"``isinstance(obj, (int, float, complex))``." #: ../Doc/faq/programming.rst:1450 msgid "" @@ -1852,25 +2264,24 @@ msgid "" "and doing a different thing based on what class it is. For example, if you " "have a function that does something::" msgstr "" -"Notez que la plupart des programmes n'utilisent pas :func:`isInstance` sur " -"les classes définies par l'utilisateur, très souvent. Si vous développez " -"vous-même les classes, un style plus appropriée orientée objet est de " -"définir des méthodes sur les classes qui encapsulent un comportement " -"particulier, au lieu de vérifier la classe de l'objet et de faire quelque " -"chose de différent en fonction de sa classe. Par exemple, si vous avez une " -"fonction qui fait quelque chose ::" +"Notez que la plupart des programmes n'utilisent que rarement :func:" +"`isInstance` sur les classes définies par l'utilisateur. Si vous développez " +"vous-même des classes, une approche plus orientée-objet consiste définir des " +"méthodes sur les classes qui sont porteuses d'un comportement particulier, " +"plutôt que de vérifier la classe de l'objet et de faire un traitement ad-" +"hoc. Par exemple, si vous avez une fonction qui fait quelque chose ::" #: ../Doc/faq/programming.rst:1464 msgid "" "A better approach is to define a ``search()`` method on all the classes and " "just call it::" msgstr "" -"Une meilleure approche est de définir une méthode ``search()`` sur toutes " -"les classes et qu'il suffit d'appeler ::" +"Une meilleure approche est de définir une méthode ``search()`` dans toutes " +"les classes et qu'il suffit d'appeler de la manière suivante ::" #: ../Doc/faq/programming.rst:1479 msgid "What is delegation?" -msgstr "Qu'est-ce que la délégation?" +msgstr "Qu'est-ce que la délégation ?" #: ../Doc/faq/programming.rst:1481 msgid "" @@ -1880,12 +2291,12 @@ msgid "" "implementation of the method you're interested in changing and delegates all " "other methods to the corresponding method of ``x``." msgstr "" -"La délégation est une technique orientée objet (aussi appelé un modèle de " -"conception). Disons que vous avez un objet ``x`` et que vous souhaitez " -"modifier le comportement d'une seule de ses méthodes. Vous pouvez créer une " -"nouvelle classe qui fournit une nouvelle implémentation de la méthode qui " -"vous intéresse dans l'évolution et les délégués de toutes les autres " -"méthodes la méthode correspondante de ``x``." +"La délégation est une technique orientée objet (aussi appelée « patron de " +"conception). Prenons un objet ``x`` dont on souhaite modifier le " +"comportement d'une seule de ses méthodes. On peut créer une nouvelle classe " +"qui fournit une nouvelle implémentation de la méthode qui nous intéresse " +"dans l'évolution et qui délègue toute autre méthode à la méthode " +"correspondante de ``x``." #: ../Doc/faq/programming.rst:1487 msgid "" @@ -1942,11 +2353,11 @@ msgid "" "overrides it?" msgstr "" "Comment appeler une méthode définie dans une classe de base depuis une " -"classe dérivée qui la surcharge?" +"classe dérivée qui la surcharge ?" #: ../Doc/faq/programming.rst:1527 msgid "Use the built-in :func:`super` function::" -msgstr "Utiliser la fonction native :func:`super` ::" +msgstr "Utilisez la fonction native :func:`super` ::" #: ../Doc/faq/programming.rst:1533 msgid "" @@ -1956,18 +2367,18 @@ msgid "" "meth(self, arguments...)``. Here, ``Base.meth`` is an unbound method, so " "you need to provide the ``self`` argument." msgstr "" -"Pour version antérieure à 3.0, vous pouvez utiliser des classes classiques : " -"Pour une définition de classe telle que ``class Derived(Base): ...`` vous " -"pouvez appeler la méthode ``meth()`` défini dans ``Base`` (ou l'une des " -"classes de base de ``Base``) en faisant ``Base.meth(self, arguments...)``. " -"Ici, ``Base.meth`` est une méthode non liée, vous devez donc fournir " -"l'argument ``self``." +"Pour les versions antérieures à 3.0, vous pouvez utiliser des classes " +"classiques : pour une définition de classe comme ``class Derived(Base): ..." +"`` vous pouvez appeler la méthode ``meth()`` définie dans ``Base`` (ou l'une " +"des classes de base de ``Base``) en faisant ``Base.meth(self, " +"arguments...)``. Ici, ``Base.meth`` est une méthode non liée, il faut donc " +"fournir l'argument ``self``." #: ../Doc/faq/programming.rst:1541 msgid "How can I organize my code to make it easier to change the base class?" msgstr "" -"Comment puis-je organiser mon code pour permettre de changer la classe de " -"base plus facilement?" +"Comment organiser un code pour permettre de changer la classe de base plus " +"facilement ?" #: ../Doc/faq/programming.rst:1543 msgid "" @@ -1981,23 +2392,23 @@ msgstr "" "Vous pouvez définir un alias pour la classe de base, lui attribuer la classe " "de base réelle avant la définition de classe, et utiliser l'alias au long de " "votre classe. Ensuite, tout ce que vous devez changer est la valeur " -"attribuée à l'alias. Incidemment, cette astuce est également utile si vous " -"voulez décider dynamiquement (par exemple en fonction de la disponibilité " -"des ressources) la classe de base à utiliser. Exemple ::" +"attribuée à l'alias. Accessoirement, cette astuce est également utile si " +"vous voulez déterminer dynamiquement (par exemple en fonction de la " +"disponibilité des ressources) la classe de base à utiliser. Exemple ::" #: ../Doc/faq/programming.rst:1558 msgid "How do I create static class data and static class methods?" msgstr "" -"Comment puis-je créer des données statiques de classe et des méthodes " -"statiques de classe?" +"Comment créer des données statiques de classe et des méthodes statiques de " +"classe ?" #: ../Doc/faq/programming.rst:1560 msgid "" "Both static data and static methods (in the sense of C++ or Java) are " "supported in Python." msgstr "" -"Tant les données statiques que les méthodes statiques (dans le sens de C + + " -"ou Java) sont pris en charge en Python." +"Les données statiques et les méthodes statiques (au sens C++ ou Java) sont " +"prises en charge en Python." #: ../Doc/faq/programming.rst:1563 msgid "" @@ -2014,7 +2425,7 @@ msgid "" "``isinstance(c, C)`` holds, unless overridden by ``c`` itself or by some " "class on the base-class search path from ``c.__class__`` back to ``C``." msgstr "" -"``c.count`` se réfère également à ``C.count`` pour tout ``c`` telle que " +"``c.count`` se réfère également à ``C.count`` pour tout ``c`` tel que " "``isInstance (c, C)`` est vrai, sauf remplacement par ``c`` lui-même ou par " "une classe sur le chemin de recherche de classe de base de ``c.__class__`` " "jusqu'à ``C``." @@ -2026,15 +2437,15 @@ msgid "" "dict. Rebinding of a class-static data name must always specify the class " "whether inside a method or not::" msgstr "" -"Attention: dans une méthode de C, une affectation comme ``self.count = 42`` " -"crée une nouvelle instance et sans rapport avec le nom ``count`` dans dans " -"le dictionnaire de données de ``self``. La redéfinition d'une donnée " -"statique de classe doit toujours spécifier la classe que l'on soit à " -"l'intérieur d'une méthode ou non ::" +"Attention : dans une méthode de C, une affectation comme ``self.count = 42`` " +"crée une nouvelle instance sans rapport avec le nom ``count`` dans le " +"dictionnaire de données de ``self``. La redéfinition d'une donnée statique " +"de classe doit toujours spécifier la classe, que l'on soit à l'intérieur " +"d'une méthode ou non ::" #: ../Doc/faq/programming.rst:1586 msgid "Static methods are possible::" -msgstr "Les méthodes statiques sont possibles ::" +msgstr "Il est possible d'utiliser des méthodes statiques ::" #: ../Doc/faq/programming.rst:1594 msgid "" @@ -2055,19 +2466,19 @@ msgstr "" #: ../Doc/faq/programming.rst:1605 msgid "How can I overload constructors (or methods) in Python?" -msgstr "Comment puis-je surcharger les constructeurs (ou méthodes) en Python?" +msgstr "Comment surcharger les constructeurs (ou méthodes) en Python ?" #: ../Doc/faq/programming.rst:1607 msgid "" "This answer actually applies to all methods, but the question usually comes " "up first in the context of constructors." msgstr "" -"Cette réponse s'applique en fait à toutes les méthodes, mais la question " -"vient généralement en premier dans le contexte des constructeurs." +"Cette réponse s'applique en fait à toutes les méthodes, mais la question se " +"pose généralement dans le contexte des constructeurs." #: ../Doc/faq/programming.rst:1610 msgid "In C++ you'd write" -msgstr "In C++ you'd write" +msgstr "In C++, on écrirait" #: ../Doc/faq/programming.rst:1619 msgid "" @@ -2108,12 +2519,12 @@ msgid "" "``classname`` is the current class name with any leading underscores " "stripped." msgstr "" -"Les noms de variables commençant avec deux tirets bas sont «déformés», c'est " -"un moyen simple mais efficace de définir variables privées à une classe. " -"Tout identifiant de la forme ``__spam`` (commençant par au moins deux tirets " -"bas et se terminant par au plus un tiret bas) est textuellement remplacé par " -"``_classname__spam``, où ``classname`` est le nom de la classe en cours dont " -"les éventuels tirets bas ont été retirés." +"Les noms de variables commençant avec deux tirets bas sont « déformés », " +"c'est un moyen simple mais efficace de définir des variables privées à une " +"classe. Tout identifiant de la forme ``__spam`` (commençant par au moins " +"deux tirets bas et se terminant par au plus un tiret bas) est textuellement " +"remplacé par ``_classname__spam``, où ``classname`` est le nom de la classe " +"en cours sans les éventuels tirets bas du début." #: ../Doc/faq/programming.rst:1648 msgid "" @@ -2122,21 +2533,20 @@ msgid "" "the object's ``__dict__``. Many Python programmers never bother to use " "private variable names at all." msgstr "" -"Cela ne garantit pas la privauté de l'accès : un utilisateur extérieur peut " -"encore délibérément accéder à l'attribut ``_classname__spam``, et les " -"valeurs privées sont visibles dans l'objet ``__dict__``. De nombreux " -"programmeurs Python ne prennent jamais la peine d'utiliser des noms de " -"variable privée." +"Cela ne garantit aucune protection : un utilisateur extérieur peut encore " +"délibérément accéder à l'attribut ``_classname__spam`` et les valeurs " +"privées sont visibles dans l'objet ``__dict__``. De nombreux programmeurs " +"Python ne prennent jamais la peine d'utiliser des noms de variable privés." #: ../Doc/faq/programming.rst:1655 msgid "My class defines __del__ but it is not called when I delete the object." msgstr "" -"Ma classe définit ``__del__`` mais il n'est pas appelé lorsque je supprime " -"l'objet." +"Ma classe définit ``__del__`` mais elle n'est pas appelée lorsque je " +"supprime l'objet." #: ../Doc/faq/programming.rst:1657 msgid "There are several possible reasons for this." -msgstr "Il y a plusieurs raisons possibles pour cela." +msgstr "Il y a plusieurs explications possibles." #: ../Doc/faq/programming.rst:1659 msgid "" @@ -2144,9 +2554,9 @@ msgid "" "decrements the object's reference count, and if this reaches zero :meth:" "`__del__` is called." msgstr "" -"La commande *del* n'appelle pas forcément :meth:`__del__` --- il décrémente " -"simplement le compteur de références de l'objet, et si celui ci arrive à " -"zéro :meth:`__del__` est appelée." +"La commande *del* n'appelle pas forcément :meth:`__del__` — elle décrémente " +"simplement le compteur de références de l'objet et, si celui-ci arrive à " +"zéro, :meth:`__del__` est appelée." #: ../Doc/faq/programming.rst:1663 msgid "" @@ -2161,6 +2571,18 @@ msgid "" "run :func:`gc.collect` to force a collection, but there *are* pathological " "cases where objects will never be collected." msgstr "" +"Si la structure de données contient des références circulaires (e.g. un " +"arbre dans lequel chaque fils référence son père, et chaque père garde une " +"liste de ses fils), le compteur de références n'arrivera jamais à zéro. " +"Python exécute périodiquement un algorithme pour détecter ce genre de " +"cycles, mais il peut se passer un certain temps entre le moment où la " +"structure est référencée pour la dernière fois et l'appel du ramasse-" +"miettes, donc la méthode :meth:`__del__` peut être appelée à un moment " +"aléatoire et pas opportun. C'est gênant pour essayer reproduire un problème. " +"Pire, l'ordre dans lequel les méthodes :meth:`__del__` des objets sont " +"appelées est arbitraire. Il est possible de forcer l'appel du ramasse-" +"miettes avec la fonction :func:`gc.collect`, mais il existe certains cas où " +"les objets ne seront jamais nettoyés." #: ../Doc/faq/programming.rst:1674 msgid "" @@ -2171,6 +2593,13 @@ msgid "" "``close()`` and ``close()`` should make sure that it can be called more than " "once for the same object." msgstr "" +"Bien que le ramasse-miette de cycles existe, il est tout de même recommandé " +"de définir une méthode ``close()`` explicite sur des objets, et de l'appeler " +"quand leur cycle de vie s'achève. Cette méthode ``close()`` peut alors " +"supprimer les attributs qui référencent des sous-objets. Il vaut mieux ne " +"pas appeler la méthode :meth:`__del__` directement, mais la méthode :meth:" +"`__del__`devrait appeler la méthode ``close()`` et ``close()`` doit pouvoir " +"être appelée plusieurs fois sur le même objet." #: ../Doc/faq/programming.rst:1681 msgid "" @@ -2179,16 +2608,23 @@ msgid "" "reference count. Tree data structures, for instance, should use weak " "references for their parent and sibling references (if they need them!)." msgstr "" +"Une alternative pour éviter les références cycliques consiste à utiliser le " +"module :mod:`weakref`, qui permet de faire référence à des objets sans " +"incrémenter leur compteur de références. Par exemple, les structures " +"d'arbres devraient utiliser des références faibles entre pères et fils (si " +"nécessaire !)." #: ../Doc/faq/programming.rst:1694 msgid "" "Finally, if your :meth:`__del__` method raises an exception, a warning " "message is printed to :data:`sys.stderr`." msgstr "" +"Enfin, si la méthode :meth:`__del__` lève une exception, un message " +"d'avertissement s'affiche dans :data:`sys.stderr`." #: ../Doc/faq/programming.rst:1699 msgid "How do I get a list of all instances of a given class?" -msgstr "" +msgstr "Comment obtenir toutes les instances d'une classe ?" #: ../Doc/faq/programming.rst:1701 msgid "" @@ -2196,10 +2632,16 @@ msgid "" "type). You can program the class's constructor to keep track of all " "instances by keeping a list of weak references to each instance." msgstr "" +"Python ne tient pas de registre de toutes les instances d'une classe (ni de " +"n'importe quel type natif). Il est cependant possible de programmer le " +"constructeur de la classe de façon à tenir un tel registre, en maintenant " +"une liste de références faibles vers chaque instance." #: ../Doc/faq/programming.rst:1707 msgid "Why does the result of ``id()`` appear to be not unique?" msgstr "" +"Pourquoi le résultat de ``id()`` peut-il être le même pour deux objets " +"différents ?" #: ../Doc/faq/programming.rst:1709 msgid "" @@ -2209,6 +2651,11 @@ msgid "" "memory, the next freshly created object is allocated at the same position in " "memory. This is illustrated by this example:" msgstr "" +"La fonction native :func:`id` renvoie un entier dont l'unicité est garantie " +"durant toute la vie de l'objet. Vu qu'en CPython cet entier est en réalité " +"l'adresse mémoire de l'objet, il est fréquent qu'un nouvel objet soit alloué " +"à une adresse mémoire identique à celle d'un objet venant d'être supprimé. " +"Comme l'illustre le code suivant :" #: ../Doc/faq/programming.rst:1720 msgid "" @@ -2217,6 +2664,10 @@ msgid "" "objects whose id you want to examine are still alive, create another " "reference to the object:" msgstr "" +"Les deux identifiants appartiennent à des objets entiers créés juste avant " +"l'appel à ``id()`` et détruits immédiatement après. Pour s'assurer que les " +"objets dont on veut examiner les identifiants sont toujours en vie, créons " +"une nouvelle référence à l'objet :" #: ../Doc/faq/programming.rst:1733 msgid "Modules" @@ -2224,7 +2675,7 @@ msgstr "Modules" #: ../Doc/faq/programming.rst:1736 msgid "How do I create a .pyc file?" -msgstr "" +msgstr "Comment créer des fichiers ``.pyc`` ?" #: ../Doc/faq/programming.rst:1738 msgid "" @@ -2236,6 +2687,13 @@ msgid "" "file, and ends with ``.pyc``, with a middle component that depends on the " "particular ``python`` binary that created it. (See :pep:`3147` for details.)" msgstr "" +"Quand un module est importé pour la première fois (ou si le fichier source a " +"été modifié depuis la création du fichier compilé), un fichier ``.pyc`` " +"contenant le code précompilé est créé dans un sous-dossier ``__pycache__`` " +"du dossier contentant le fichier ``.py``. Le nom du fichier ``.pyc`` est " +"identique au fichier ``.py`` et se termine par ``.pyc``, avec une partie " +"centrale qui dépend du binaire ``python`` qui l'a créé (voir la :pep:`3147` " +"pour de plus amples précisions)." #: ../Doc/faq/programming.rst:1746 msgid "" @@ -2245,6 +2703,12 @@ msgid "" "example, if you develop as one user but run as another, such as if you are " "testing with a web server." msgstr "" +"Une des raisons pour lesquelles un fichier ``.pyc`` peut ne pas être créé " +"est un problème de droits sur le dossier qui contient le fichier source, ce " +"qui veut dire qu'il est impossible de créer le sous-dossier ``__pycache__``. " +"Ceci peut arriver, par exemple, si vous développez en tant qu'un certain " +"utilisateur, mais que le code est exécuté en tant qu'un autre utilisateur, " +"par exemple pour tester un serveur Web." #: ../Doc/faq/programming.rst:1751 msgid "" @@ -2254,6 +2718,11 @@ msgid "" "``__pycache__`` subdirectory and write the compiled module to that " "subdirectory." msgstr "" +"La création du fichier ``.pyc`` est automatique durant l'import d'un module " +"si Python est capable (en termes de droits, d'espace disque, etc) de créer " +"un sous-dossier ``__pycache__`` et d'écrire le module ainsi compilé dans ce " +"sous-répertoire, à moins que la variable d'environnement :envvar:" +"`PYTHONDONTWRITEBYTECODE` soit définie." #: ../Doc/faq/programming.rst:1756 msgid "" @@ -2264,6 +2733,12 @@ msgid "" "``xyz`` because ``xyz`` is imported, but no ``.pyc`` file will be created " "for ``foo`` since ``foo.py`` isn't being imported." msgstr "" +"Exécuter du Python dans un script de plus haut niveau n'est pas considéré " +"comme un import et le fichier ``.pyc`` n'est pas créé. Par exemple, si un " +"module de plus haut niveau ``foo.py`` importe un autre module ``xyz.py``, " +"alors à l'exécution de ``foo`` (en tapant ``python foo.py`` dans la " +"console), un fichier ``.pyc`` est créé pour ``xyz`` mais pas pour ``foo`` " +"car ``foo.py`` n'est pas importé." #: ../Doc/faq/programming.rst:1763 msgid "" @@ -2271,12 +2746,18 @@ msgid "" "pyc`` file for a module that is not imported -- you can, using the :mod:" "`py_compile` and :mod:`compileall` modules." msgstr "" +"Pour créer un fichier ``.pyc`` pour ``foo`` — c'est-à-dire créer un fichier " +"``.pyc`` pour un module qui n'est pas importé — il existe les modules :mod:" +"`py_compile` et :mod:`compileall`." #: ../Doc/faq/programming.rst:1767 msgid "" "The :mod:`py_compile` module can manually compile any module. One way is to " "use the ``compile()`` function in that module interactively::" msgstr "" +"Le module :mod:`py_compile` peut compiler n'importe quel module " +"manuellement. Il est ainsi possible d'appeler la fonction ``compile()`` de " +"manière interactive :" #: ../Doc/faq/programming.rst:1773 msgid "" @@ -2284,6 +2765,9 @@ msgid "" "location as ``foo.py`` (or you can override that with the optional parameter " "``cfile``)." msgstr "" +"Ces lignes écrivent le ``.pyc`` dans un sous-dossier ``__pycache__`` à côté " +"de ``foo.py`` (le paramètre optionnel ``cfile`` permet de changer ce " +"comportement)." #: ../Doc/faq/programming.rst:1777 msgid "" @@ -2292,10 +2776,14 @@ msgid "" "running ``compileall.py`` and providing the path of a directory containing " "Python files to compile::" msgstr "" +"Tous les fichiers d'un ou plusieurs dossiers peuvent aussi être compilés " +"avec le module :mod:`compileall`. C'est possible depuis l'invite de commande " +"en exécutant ``compileall.py`` avec le chemin du dossier contenant les " +"fichiers Python à compiler ::" #: ../Doc/faq/programming.rst:1786 msgid "How do I find the current module name?" -msgstr "" +msgstr "Comment obtenir le nom du module actuel ?" #: ../Doc/faq/programming.rst:1788 msgid "" @@ -2305,75 +2793,87 @@ msgid "" "importing them also provide a command-line interface or a self-test, and " "only execute this code after checking ``__name__``::" msgstr "" +"Un module peut déterminer son propre nom en examinant la variable globale " +"prédéfinie ``__name__``. Si celle-ci vaut ``'__main__'``, c'est que le " +"programme est exécuté comme un script. Beaucoup de modules qui doivent " +"normalement être importés pour pouvoir être utilisés fournissent aussi une " +"interface en ligne de commande ou un test automatique. Ils n'exécutent cette " +"portion du code qu'après avoir vérifié la valeur de ``__name__``::" #: ../Doc/faq/programming.rst:1803 msgid "How can I have modules that mutually import each other?" -msgstr "" +msgstr "Comment avoir des modules qui s'importent mutuellement ?" #: ../Doc/faq/programming.rst:1805 msgid "Suppose you have the following modules:" -msgstr "" +msgstr "Considérons les modules suivants :" #: ../Doc/faq/programming.rst:1807 msgid "foo.py::" -msgstr "" +msgstr "*foo.py* ::" #: ../Doc/faq/programming.rst:1812 msgid "bar.py::" -msgstr "" +msgstr "*bar.py* ::" #: ../Doc/faq/programming.rst:1817 msgid "The problem is that the interpreter will perform the following steps:" -msgstr "" +msgstr "Le problème réside dans les étapes que l'interpréteur va réaliser :" #: ../Doc/faq/programming.rst:1819 msgid "main imports foo" -msgstr "" +msgstr "*main* importe *foo*" #: ../Doc/faq/programming.rst:1820 msgid "Empty globals for foo are created" -msgstr "" +msgstr "Les variables globales (vides) de *foo* sont créées" #: ../Doc/faq/programming.rst:1821 msgid "foo is compiled and starts executing" -msgstr "" +msgstr "*foo* est compilé et commence à s'exécuter" #: ../Doc/faq/programming.rst:1822 msgid "foo imports bar" -msgstr "" +msgstr "*foo* importe *bar*" #: ../Doc/faq/programming.rst:1823 msgid "Empty globals for bar are created" -msgstr "" +msgstr "Les variables globales (vides) de *bar* sont créées" #: ../Doc/faq/programming.rst:1824 msgid "bar is compiled and starts executing" -msgstr "" +msgstr "*bar* est compilé et commence à s'exécuter" #: ../Doc/faq/programming.rst:1825 msgid "" "bar imports foo (which is a no-op since there already is a module named foo)" msgstr "" +"*bar* importe *foo* (en réalité, rien ne passe car il y a déjà un module " +"appelé *foo*)" #: ../Doc/faq/programming.rst:1826 msgid "bar.foo_var = foo.foo_var" -msgstr "" +msgstr "bar.foo_var = foo.foo_var" #: ../Doc/faq/programming.rst:1828 msgid "" "The last step fails, because Python isn't done with interpreting ``foo`` yet " "and the global symbol dictionary for ``foo`` is still empty." msgstr "" +"La dernière étape échoue car Python n'a pas fini d'interpréter ``foo`` et le " +"dictionnaire global des symboles de ``foo`` est encore vide." #: ../Doc/faq/programming.rst:1831 msgid "" "The same thing happens when you use ``import foo``, and then try to access " "``foo.foo_var`` in global code." msgstr "" +"Le même phénomène arrive quand on utilise ``import foo``, et qu'on essaye " +"ensuite d'accéder à ``foo.foo_var`` dans le code global." #: ../Doc/faq/programming.rst:1834 msgid "There are (at least) three possible workarounds for this problem." -msgstr "" +msgstr "Il y a (au moins) trois façons de contourner ce problème." #: ../Doc/faq/programming.rst:1836 msgid "" @@ -2383,58 +2883,77 @@ msgid "" "only. This means everything from an imported module is referenced as " "``.``." msgstr "" +"Guido van Rossum déconseille d'utiliser ``from import ...`` et de " +"mettre tout le code dans des fonctions. L'initialisation des variables " +"globales et des variables de classe ne doit utiliser que des constantes ou " +"des fonctions natives. Ceci implique que tout ce qui est fourni par un " +"module soit référencé par ``.``." #: ../Doc/faq/programming.rst:1841 msgid "" "Jim Roskind suggests performing steps in the following order in each module:" msgstr "" +"Jim Roskind recommande d'effectuer les étapes suivantes dans cet ordre dans " +"chaque module :" #: ../Doc/faq/programming.rst:1843 msgid "" "exports (globals, functions, and classes that don't need imported base " "classes)" msgstr "" +"les exportations (variables globales, fonctions et les classes qui ne " +"nécessitent d'importer des classes de base)" #: ../Doc/faq/programming.rst:1845 msgid "``import`` statements" -msgstr "" +msgstr "les instructions ``import``" #: ../Doc/faq/programming.rst:1846 msgid "" "active code (including globals that are initialized from imported values)." msgstr "" +"le code (avec les variables globales qui sont initialisées à partir de " +"valeurs importées)." #: ../Doc/faq/programming.rst:1848 msgid "" "van Rossum doesn't like this approach much because the imports appear in a " "strange place, but it does work." msgstr "" +"van Rossum désapprouve cette approche car les importations se trouvent à un " +"endroit bizarre, mais cela fonctionne." #: ../Doc/faq/programming.rst:1851 msgid "" "Matthias Urlichs recommends restructuring your code so that the recursive " "import is not necessary in the first place." msgstr "" +"Matthias Urlichs conseille de restructurer le code pour éviter les " +"importations récursives." #: ../Doc/faq/programming.rst:1854 msgid "These solutions are not mutually exclusive." -msgstr "" +msgstr "Ces solutions peuvent être combinées." #: ../Doc/faq/programming.rst:1858 msgid "__import__('x.y.z') returns ; how do I get z?" -msgstr "" +msgstr "__import__('x.y.z') renvoie ; comment accéder à z ?" #: ../Doc/faq/programming.rst:1860 msgid "" "Consider using the convenience function :func:`~importlib.import_module` " "from :mod:`importlib` instead::" msgstr "" +"Utilisez plutôt la fonction :func:`~importlib.import_module` de :mod:" +"`importlib` ::" #: ../Doc/faq/programming.rst:1867 msgid "" "When I edit an imported module and reimport it, the changes don't show up. " "Why does this happen?" msgstr "" +"Quand j'édite un module et que je le réimporte, je ne vois pas les " +"changements. Pourquoi ?" #: ../Doc/faq/programming.rst:1869 msgid "" @@ -2444,12 +2963,20 @@ msgid "" "module, the basic module would be parsed and re-parsed many times. To force " "re-reading of a changed module, do this::" msgstr "" +"Pour des raisons de performance et de cohérence, Python ne lit le fichier " +"d'un module que la première fois où celui-ci est importé. Si ce n'était pas " +"le cas, dans un programme composé d'un très grand nombre de modules qui " +"importent tous le même module de base, ce module de base serait analysé et " +"ré-analysé un très grand nombre de fois. Pour forcer la relecture d'un " +"module, il faut faire ::" #: ../Doc/faq/programming.rst:1879 msgid "" "Warning: this technique is not 100% fool-proof. In particular, modules " "containing statements like ::" msgstr "" +"Attention, cette technique ne marche pas systématiquement. En particulier, " +"les modules qui contiennent des instructions comme ::" #: ../Doc/faq/programming.rst:1884 msgid "" @@ -2458,12 +2985,18 @@ msgid "" "updated to use the new class definition. This can result in the following " "paradoxical behaviour::" msgstr "" +"continuent de fonctionner avec l'ancienne version des objets importés. Si le " +"module contient une définition de classe, le instances déjà existantes de " +"celle-ci ne sont *pas* mises à jour avec la nouvelle définition de la " +"classe. Ceci peut conduire au comportement paradoxal suivant :" #: ../Doc/faq/programming.rst:1897 msgid "" "The nature of the problem is made clear if you print out the \"identity\" of " "the class objects::" msgstr "" +"La nature du problème apparaît clairement en affichant « l'identité » des " +"objets de la classe ::" #~ msgid "Dictionaries" #~ msgstr "Dictionnaires"