From 5084a5c86a6ad23f6fd6bae80d5b04d11a1c3bb1 Mon Sep 17 00:00:00 2001 From: Jean-Abou-Samra <37271310+Jean-Abou-Samra@users.noreply.github.com> Date: Fri, 29 Oct 2021 08:37:05 +0200 Subject: [PATCH] Traduction de library/__main__.po (#1751) Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> --- library/__main__.po | 183 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 160 insertions(+), 23 deletions(-) diff --git a/library/__main__.po b/library/__main__.po index 9c809683..1150d8d3 100644 --- a/library/__main__.po +++ b/library/__main__.po @@ -6,34 +6,38 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-09-23 16:16+0200\n" -"PO-Revision-Date: 2017-11-07 22:52+0100\n" -"Last-Translator: Julien Palard \n" +"PO-Revision-Date: 2021-10-28 17:30+0200\n" +"Last-Translator: Jean Abou Samra \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 3.0\n" #: library/__main__.rst:2 -#, fuzzy msgid ":mod:`__main__` --- Top-level code environment" -msgstr ":mod:`__main__` — Point d'entrée des scripts" +msgstr ":mod:`__main__` — Environnement d'exécution principal" #: library/__main__.rst:10 msgid "" "In Python, the special name ``__main__`` is used for two important " "constructs:" msgstr "" +"En Python, le nom ``__main__`` a une fonction particulière. Il intervient " +"dans deux cas :" #: library/__main__.rst:12 msgid "" "the name of the top-level environment of the program, which can be checked " "using the ``__name__ == '__main__'`` expression; and" msgstr "" +"c'est le nom de l'environnement d'exécution principal, ce qui donne lieu au " +"test courant ``__name__ == '__main__'`` ;" #: library/__main__.rst:14 msgid "the ``__main__.py`` file in Python packages." -msgstr "" +msgstr "c'est aussi le nom du fichier ``__main__.py`` dans les paquets Python." #: library/__main__.rst:16 msgid "" @@ -42,10 +46,15 @@ msgid "" "detail below. If you're new to Python modules, see the tutorial section :" "ref:`tut-modules` for an introduction." msgstr "" +"Les deux sont liés aux modules Python, à la manière de s'en servir en tant " +"qu'utilisateur et à la manière dont ils interagissent entre eux. Cette page " +"contient des détails sur les modules Python. Si vous ne les avez jamais " +"utilisés, commencez par la section qui leur est consacrée dans le " +"tutoriel : :ref:`tut-modules`." #: library/__main__.rst:25 msgid "``__name__ == '__main__'``" -msgstr "" +msgstr "``__name__ == '__main__'``" #: library/__main__.rst:27 msgid "" @@ -53,22 +62,29 @@ msgid "" "module's name. Usually, this is the name of the Python file itself without " "the ``.py`` extension::" msgstr "" +"Lorsqu'un module ou un paquet Python est importé, son attribut ``__name__`` " +"est défini à son nom, qui est la plupart du temps le nom du fichier qui le " +"contient sans l'extension ``.py`` :" #: library/__main__.rst:35 msgid "" "If the file is part of a package, ``__name__`` will also include the parent " "package's path::" msgstr "" +"Si le fichier fait partie d'un paquet, ``__name__`` donne tout le chemin " +"d'accès :" #: library/__main__.rst:42 msgid "" "However, if the module is executed in the top-level code environment, its " "``__name__`` is set to the string ``'__main__'``." msgstr "" +"En revanche, si le module est exécuté dans l'environnement d'exécution " +"principal, la variable ``__name__`` vaut ``'__main__'``." #: library/__main__.rst:46 msgid "What is the \"top-level code environment\"?" -msgstr "" +msgstr "Qu'est-ce que l'« environnement d'exécution principal » ?" #: library/__main__.rst:48 msgid "" @@ -78,62 +94,73 @@ msgid "" "program needs. Sometimes \"top-level code\" is called an *entry point* to " "the application." msgstr "" +"L'environnement principal a pour nom ``__main__``. Il s'agit du premier " +"module Python dont l'exécution a été demandée par l'utilisateur final. On le " +"qualifie de principal car c'est lui qui importe tous les autres modules " +"nécessités par le programme. On l'appelle parfois le point d'entrée de " +"l'application." #: library/__main__.rst:53 msgid "The top-level code environment can be:" -msgstr "" +msgstr "L'environnement principal peut prendre diverses formes :" #: library/__main__.rst:55 msgid "the scope of an interactive prompt::" -msgstr "" +msgstr "l'environnement d'une invite de commande interactive :" #: library/__main__.rst:60 msgid "the Python module passed to the Python interpreter as a file argument:" msgstr "" +"le module passé directement en tant que fichier à la commande de " +"l'interpréteur Python :" #: library/__main__.rst:67 msgid "" "the Python module or package passed to the Python interpreter with the :" "option:`-m` argument:" msgstr "" +"le module ou paquet passé à l'interpréteur avec l'option :option:`-m` :" +# Minuscule car toujours dans la même énumération, ignorez l'avertissement que Poedit affiche à cause de la majuscule à « Python ». #: library/__main__.rst:75 msgid "Python code read by the Python interpreter from standard input:" -msgstr "" +msgstr "le code lu par l'interpréteur depuis l'entrée standard :" #: library/__main__.rst:86 msgid "" "Python code passed to the Python interpreter with the :option:`-c` argument:" -msgstr "" +msgstr "le code passé à l'interpréteur avec l'option :option:`-c` :" #: library/__main__.rst:97 msgid "" "In each of these situations, the top-level module's ``__name__`` is set to " "``'__main__'``." msgstr "" +"Dans chacun de ces cas, l'attribut ``__name__`` du module principal est mis " +"à ``'__main__'``." #: library/__main__.rst:100 -#, fuzzy msgid "" "As a result, a module can discover whether or not it is running in the top-" "level environment by checking its own ``__name__``, which allows a common " "idiom for conditionally executing code when the module is not initialized " "from an import statement::" msgstr "" -"Un module peut découvrir s'il est exécuté dans le *scope* principal en " -"vérifiant son ``__name__``, ce qui permet typiquement d'exécuter du code " -"lorsque le module est exécuté avec ``python -m`` mais pas lorsqu'il est " -"importé ::" +"Un module peut donc savoir s'il est exécuté dans l'environnement principal " +"en vérifiant son ``__name__``, ce qui permet typiquement d'exécuter du code " +"lorsque le module est initialisé d'une manière autre que l'importation ::" #: library/__main__.rst:111 msgid "" "For a more detailed look at how ``__name__`` is set in all situations, see " "the tutorial section :ref:`tut-modules`." msgstr "" +"Pour plus de détails sur la manière dont ``__name__`` est défini dans les " +"divers cas, voir la section :ref:`tut-modules` dans le tutoriel." #: library/__main__.rst:239 msgid "Idiomatic Usage" -msgstr "" +msgstr "Utilisation idiomatique" #: library/__main__.rst:118 msgid "" @@ -142,6 +169,11 @@ msgid "" "like this were to be imported from a different module, for example to unit " "test it, the script code would unintentionally execute as well." msgstr "" +"Il arrive qu'un module contienne du code qui ne doit s'exécuter que lorsque " +"le module est utilisé comme script. On peut penser à l'analyse des arguments " +"passés en ligne de commande, ou bien à la lecture de l'entrée standard. Il " +"ne faudrait pas que ces opérations soient effectuées lorsque le module est " +"importé depuis un autre module, comme pour les tests." #: library/__main__.rst:123 msgid "" @@ -149,6 +181,9 @@ msgid "" "handy. Code within this block won't run unless the module is executed in the " "top-level environment." msgstr "" +"C'est dans ces situations que sert la construction ``if __name__ == " +"'__main__'``. Le code mis à l'intérieur du bloc n'est exécuté que si le " +"module est dans l'environnement principal." #: library/__main__.rst:127 msgid "" @@ -156,6 +191,10 @@ msgid "" "'__main__'`` can improve code clarity and correctness. Most often, a " "function named ``main`` encapsulates the program's primary behavior::" msgstr "" +"Il vaut mieux mettre aussi peu de code que possible sous le ``if __name__ == " +"'__main__'`` pour garder le code clair et limiter les risques d'erreur. La " +"plupart du temps, on écrit une fonction ``main`` qui contient tout le code " +"spécifique à l'utilisation comme script :" #: library/__main__.rst:151 msgid "" @@ -166,6 +205,11 @@ msgid "" "the global variable instead of a local name. A ``main`` function solves " "this problem." msgstr "" +"Si, dans le module ci-dessus, le code de ``main`` était placé directement " +"dans le ``if __name__ == '__main__'``, la variable ``phrase`` serait " +"globale, et d'autres fonctions pourraient s'en servir par erreur à la place " +"d'une variable locale. Encapsuler le code dans la fonction ``main`` évite " +"cet ennui." #: library/__main__.rst:158 msgid "" @@ -174,10 +218,14 @@ msgid "" "imported, the ``echo`` and ``main`` functions will be defined, but neither " "of them will be called, because ``__name__ != '__main__'``." msgstr "" +"De plus, la fonction ``echo`` est elle-même séparée du reste, et on peut " +"l'importer dans un autre module. Le fait d'importer ``echo.py`` définit les " +"fonctions ``main`` et ``echo``, mais n'en appelle aucune, puisque " +"``__name__ != '__main__'``." #: library/__main__.rst:165 msgid "Packaging Considerations" -msgstr "" +msgstr "Considérations liées à l'empaquetage" #: library/__main__.rst:167 msgid "" @@ -186,6 +234,12 @@ msgid "" "pip.pypa.io/>`_ inserts the function call into a template script, where the " "return value of ``main`` is passed into :func:`sys.exit`. For example::" msgstr "" +"Les fonctions ``main`` servent souvent à créer des outils qui s'exécutent en " +"ligne de commande. Les scripts sont ajoutés au système à l'aide de points " +"d'entrée, qui demandent à `pip `_ de créer un " +"exécutable. Il le fait en insérant un appel à la fonction à l'intérieur d'un " +"modèle prédéfini où la valeur qu'elle renvoie est passée directement à :func:" +"`sys.exit` :" #: library/__main__.rst:175 msgid "" @@ -194,6 +248,11 @@ msgid "" "`sys.exit`; typically, an integer or ``None`` (which is implicitly returned " "if your function does not have a return statement)." msgstr "" +"Puisque l'appel de ``main`` est encapsulé dans :func:`sys.exit`, ``main`` " +"doit renvoyer une valeur qui convienne comme argument à :func:`sys.exit`, " +"par exemple un code de retour sous forme d'entier. La valeur ``None`` est " +"également acceptée, et c'est d'ailleurs celle que renvoie la fonction si " +"elle se termine sans rencontrer d'instruction ``return``." #: library/__main__.rst:180 msgid "" @@ -202,6 +261,10 @@ msgid "" "if we later package it as a console script entry-point in a pip-installable " "package." msgstr "" +"Il est utile de se conformer à cette convention. De cette manière, le module " +"se comporte de la même manière s'il est distribué comme script à l'aide des " +"points d'entrée que lorsqu'il est exécuté directement (avec ``python3 echo." +"py``)." #: library/__main__.rst:185 msgid "" @@ -212,6 +275,11 @@ msgid "" "py`` example from earlier exemplifies using the ``sys.exit(main())`` " "convention." msgstr "" +"En particulier, mieux vaut éviter de renvoyer une chaîne de caractères " +"depuis la fonction ``main``. En effet, si :func:`sys.exit` reçoit une " +"chaîne, elle l'interprète comme un message d'erreur, qu'elle affiche sur :" +"data:`sys.stderr` avant de terminer le programme avec le code de retour 1 " +"(erreur). L'exemple de ``echo.py`` ci-dessus montre la pratique recommandée." #: library/__main__.rst:193 msgid "" @@ -219,10 +287,13 @@ msgid "" "collection of tutorials and references on how to distribute and install " "Python packages with modern tools." msgstr "" +"Le `guide de l'empaquetage en Python `_ (en " +"anglais) contient plusieurs tutoriels et documents de référence autour de la " +"distribution et de l'installation de paquets Python avec des outils modernes." #: library/__main__.rst:199 msgid "``__main__.py`` in Python Packages" -msgstr "" +msgstr "Le fichier ``__main__.py`` dans les paquets Python" #: library/__main__.rst:201 msgid "" @@ -231,12 +302,19 @@ msgid "" "to provide a command-line interface for a package. Consider the following " "hypothetical package, \"bandclass\":" msgstr "" +"Si vous n'êtes pas familier des paquets Python, lisez :ref:`tut-packages` " +"dans le tutoriel. Un fichier ``__main__.py`` permet à un paquet de définir " +"une interface en ligne de commande. Prenons pour exemple un paquet nommé " +"*bandclass* :" #: library/__main__.rst:213 msgid "" "``__main__.py`` will be executed when the package itself is invoked directly " "from the command line using the :option:`-m` flag. For example:" msgstr "" +"Le fichier ``__main__.py`` qu'il contient s'exécute lorsque le paquet est " +"appelé depuis la ligne de commande avec l'option :option:`-m` de " +"l'interpréteur, comme ceci :" #: library/__main__.rst:220 msgid "" @@ -245,6 +323,10 @@ msgid "" "this hypothetical case, it might make sense to allow the teacher to search " "for students::" msgstr "" +"Cette commande lance l'exécution de ``__main__.py``. Il vous appartient, en " +"tant que concepteur du paquet, de déterminer ce qu'elle doit faire. Dans " +"notre exemple, elle pourrait rechercher un étudiant dans une base de " +"données ::" #: library/__main__.rst:233 msgid "" @@ -253,6 +335,10 @@ msgid "" "within a package. For more details, see :ref:`intra-package-references` in " "the :ref:`tut-modules` section of the tutorial." msgstr "" +"Remarquez l'importation ``from .student import search_students``. Le point " +"avant ``student`` sert à rendre le chemin ``student`` relatif à la position " +"du module qui l'importe. Pour plus d'informations, voir :ref:`intra-package-" +"references` dans la section :ref:`tut-modules` du tutoriel." #: library/__main__.rst:241 msgid "" @@ -261,6 +347,10 @@ msgid "" "execute from other modules. Those other modules can then be easily unit-" "tested and are properly reusable." msgstr "" +"En général, on ne met pas le code de ``__main__.py`` dans un bloc ``if " +"__name__ == '__main__'``. Il vaut mieux définir toutes les fonctions utiles " +"dans d'autres modules et réduire la taille du fichier ``__main__.py`` au " +"minimum. Il est alors plus facile de tester et réutiliser ces autres modules." #: library/__main__.rst:246 msgid "" @@ -268,6 +358,10 @@ msgid "" "for a ``__main__.py`` file within a package, because its ``__name__`` " "attribute will include the package's path if imported::" msgstr "" +"Cependant, un ``if __name__ == '__main__'``, s'il est présent dans le " +"``__main__.py``, fonctionne correctement. En effet, si ``__main__.py`` est " +"importé depuis autre module, son attribut ``__name__`` contient, avant " +"``__main__``, le nom du paquet dont il fait partie :" #: library/__main__.rst:254 msgid "" @@ -275,6 +369,9 @@ msgid "" "file though. Hence, for consistency, minimal ``__main__.py`` like the :mod:" "`venv` one mentioned above are preferred." msgstr "" +"Malgré tout, cela ne fonctionne pas pour les fichiers ``__main__.py`` à la " +"racine d'une archive ZIP. Aussi est-il préférable d'écrire des ``__main__." +"py`` dans le style minimal de celui de :mod:`venv` mentionné ci-dessous." #: library/__main__.rst:260 msgid "" @@ -282,12 +379,18 @@ msgid "" "in the standard library. It doesn't contain a ``if __name__ == '__main__'`` " "block. You can invoke it with ``python3 -m venv [directory]``." msgstr "" +"Le module :mod:`venv` de la bibliothèque standard est un exemple de paquet " +"contenant un fichier ``__main__.py`` minimal, sans ``if __name__ == " +"'__main__'``. Il s'appelle avec la commande :samp:`python3 -m venv {dossier}" +"`." #: library/__main__.rst:264 msgid "" "See :mod:`runpy` for more details on the :option:`-m` flag to the " "interpreter executable." msgstr "" +"La documentation du module :mod:`runpy` fournit une description complète de " +"l'option :option:`-m` de l'interpréteur." #: library/__main__.rst:267 msgid "" @@ -295,10 +398,13 @@ msgid "" "this case Python looks for a ``__main__.py`` file in the root directory of " "the archive." msgstr "" +"Le module :mod:`zipapp` exécute des applications emballées dans une archive " +"ZIP. Dans ce cas, l'interpréteur recherche un fichier ``__main__.py`` à la " +"racine de l'archive." #: library/__main__.rst:274 msgid "``import __main__``" -msgstr "" +msgstr "``import __main__``" #: library/__main__.rst:276 msgid "" @@ -308,18 +414,23 @@ msgid "" "doesn't import a ``__main__.py`` file but rather whichever module that " "received the special name ``'__main__'``." msgstr "" +"Quel que soit le module principal d'un programme, les autres modules peuvent " +"accéder à l':term:`espace de nommage ` dans lequel il s'exécute " +"en important le module spécial ``__main__``. Celui-ci ne correspond pas " +"forcément à un fichier ``__main__.py``. Il s'agit simplement du module qui a " +"reçu le nom ``'__main__'``." #: library/__main__.rst:282 msgid "Here is an example module that consumes the ``__main__`` namespace::" -msgstr "" +msgstr "Voici un exemple d'utilisation du module ``__main__`` :" #: library/__main__.rst:300 msgid "Example usage of this module could be as follows::" -msgstr "" +msgstr "Ce code s'utilise comme ceci :" #: library/__main__.rst:319 msgid "Now, if we started our program, the result would look like this:" -msgstr "" +msgstr "Le programme ci-dessus donne la sortie :" #: library/__main__.rst:326 msgid "" @@ -327,6 +438,10 @@ msgid "" "the line with ``my_name = \"Dinsdale\"`` fixes the program and now it exits " "with status code 0, indicating success:" msgstr "" +"Son code de retour est 1, ce qui signifie une erreur. En supprimant la " +"marque de commentaire en début de ligne ``my_name = \"Dinsdale\"``, le " +"programme est corrigé, et renvoie au système le code 0 car il n'y a plus " +"d'erreur :" #: library/__main__.rst:335 msgid "" @@ -335,6 +450,10 @@ msgid "" "the ``if __name__ == \"__main__\"`` block of the ``start`` module. Why does " "this work?" msgstr "" +"On pourrait s'attendre à un problème au moment de l'importation de " +"``__main__`` : cela ne provoque-t-il pas l'exécution anticipée du code de " +"script sous ``if __name__ == '__main__'`` dans le module principal " +"``start`` ?" #: library/__main__.rst:339 msgid "" @@ -348,24 +467,42 @@ msgid "" "` in the import system's reference for details on how " "this works." msgstr "" +"En fait, le déroulement de l'exécution est le suivant : au lancement de " +"l'interpréteur, un module ``__main__`` initialement vide est inséré dans :" +"attr:`sys.modules`. Il se remplit au fur et à mesure de l'exécution du code " +"principal. Dans notre exemple, le module principal est ``start``, qui " +"s'exécute ligne par ligne et en vient à importer ``namely``. Or ``namely``, " +"à son tour, importe ``__main__``, c'est-à-dire en fait ``start``. On a donc " +"une importation cyclique. Puisque le module ``__main__`` est déjà présent " +"dans :attr:`sys.modules`, bien qu'encore incomplet, il est directement passé " +"à ``namely`` sans réimportation. La section :ref:`import-dunder-main` dans " +"le document de référence du système d'importation explique plus avant ce " +"fonctionnement." #: library/__main__.rst:348 msgid "" "The Python REPL is another example of a \"top-level environment\", so " "anything defined in the REPL becomes part of the ``__main__`` scope::" msgstr "" +"L'interpréteur interactif est un autre environnement d'exécution principal " +"possible. Toute variable qui y est définie appartient à l'espace de nommage " +"``__main__`` :" #: library/__main__.rst:364 msgid "" "Note that in this case the ``__main__`` scope doesn't contain a ``__file__`` " "attribute as it's interactive." msgstr "" +"Dans ce cas, il n'y a pas de variable ``__file__``, puisque cela n'a pas de " +"sens dans le mode interactif." #: library/__main__.rst:367 msgid "" "The ``__main__`` scope is used in the implementation of :mod:`pdb` and :mod:" "`rlcompleter`." msgstr "" +"Le module ``__main__`` est notamment employé dans les implémentations de :" +"mod:`pdb` et :mod:`rlcompleter`." #~ msgid "" #~ "``'__main__'`` is the name of the scope in which top-level code executes. "