modules.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-08-24 09:01+0200\n"
"PO-Revision-Date: 2020-04-27 22:54+0200\n"
"Last-Translator: Julien Palard <julien@palard.fr>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\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.3\n"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: tutorial/modules.rst:115
msgid ""
"If the module name is followed by :keyword:`!as`, then the name following :"
"keyword:`!as` is bound directly to the imported module."
msgstr ""
"Si le nom du module est suivi par :keyword:`!as`, alors le nom suivant :"
"keyword:`!as` est directement lié au module importé."

#: tutorial/modules.rst:124
msgid ""
"This is effectively importing the module in the same way that ``import "
"fibo`` will do, with the only difference of it being available as ``fib``."
msgstr ""
"Dans les faits, le module est importé de la même manière qu'avec ``import "
"fibo``, la seule différence est qu'il sera disponible sous le nom de ``fib``."

#: tutorial/modules.rst:127
msgid ""
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr "C'est aussi valide en utilisant :keyword:`from`, et a le même effet ::"

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

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

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

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

#: tutorial/modules.rst:160
msgid ""
"you can make the file usable as a script as well as an importable module, "
"because the code that parses the command line only runs if the module is "
"executed as the \"main\" file:"
msgstr ""
"vous pouvez rendre le fichier utilisable comme script aussi bien que comme "
"module importable, car le code qui analyse la ligne de commande n'est lancé "
"que si le module est exécuté comme fichier « main » :"

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

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

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

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

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

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

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

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

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

#: tutorial/modules.rst:212
msgid "\"Compiled\" Python files"
msgstr "Fichiers Python « compilés »"

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

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

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

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

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

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

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

#: tutorial/modules.rst:251
msgid ""
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
msgstr ""
"vous trouvez plus de détails sur ce processus, ainsi qu'un organigramme des "
"décisions, dans la :pep:`3147`."

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

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

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

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

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

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

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

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

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

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

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

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

#: tutorial/modules.rst:429
msgid ""
"When importing the package, Python searches through the directories on ``sys."
"path`` looking for the package subdirectory."
msgstr ""
"Lorsqu'il importe des paquets, Python cherche dans chaque dossier de ``sys."
"path`` un sous-dossier du nom du paquet."

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

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

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

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

#: tutorial/modules.rst:453
msgid ""
"This also loads the submodule :mod:`echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""
"charge aussi le sous-module :mod:`echo` et le rend disponible sans avoir à "
"indiquer le préfixe du paquet. Il peut donc être utilisé comme ceci ::"

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

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

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

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

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

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

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

#: tutorial/modules.rst:505
msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`sound` package."
msgstr ""
"Cela signifie que ``from sound.effects import *`` importe les trois sous-"
"modules explicitement désignés du paquet :mod:`sound`."

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

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

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

#: tutorial/modules.rst:530
msgid ""
"Remember, there is nothing wrong with using ``from package import "
"specific_submodule``!  In fact, this is the recommended notation unless the "
"importing module needs to use submodules with the same name from different "
"packages."
msgstr ""
"Rappelez-vous que rien ne vous empêche d'utiliser ``from paquet import "
"sous_module_specifique`` ! C'est d'ailleurs la manière recommandée, à moins "
"que le module qui fait les importations ait besoin de sous-modules ayant le "
"même nom mais provenant de paquets différents."

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

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

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

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

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

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

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

#: tutorial/modules.rst:573
msgid "Footnotes"
msgstr "Notes"

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