Traduction de library/__main__.po (#1751)

Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com>

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 <julien@palard.fr>\n"
+"PO-Revision-Date: 2021-10-28 17:30+0200\n"
+"Last-Translator: Jean Abou Samra <jean@abou-samra.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 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 <https://pip.pypa.io/>`_ 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 <https://packaging.python.org/>`_ (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 <namespace>` 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 ""
 "<import-dunder-main>` 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. "