# 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: 2021-09-23 16:16+0200\n" "PO-Revision-Date: 2017-11-07 22:52+0100\n" "Last-Translator: Julien Palard \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" #: library/__main__.rst:2 #, fuzzy msgid ":mod:`__main__` --- Top-level code environment" msgstr ":mod:`__main__` — Point d'entrée des scripts" #: library/__main__.rst:10 msgid "" "In Python, the special name ``__main__`` is used for two important " "constructs:" msgstr "" #: 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 "" #: library/__main__.rst:14 msgid "the ``__main__.py`` file in Python packages." msgstr "" #: library/__main__.rst:16 msgid "" "Both of these mechanisms are related to Python modules; how users interact " "with them and how they interact with each other. They are explained in " "detail below. If you're new to Python modules, see the tutorial section :" "ref:`tut-modules` for an introduction." msgstr "" #: library/__main__.rst:25 msgid "``__name__ == '__main__'``" msgstr "" #: library/__main__.rst:27 msgid "" "When a Python module or package is imported, ``__name__`` is set to the " "module's name. Usually, this is the name of the Python file itself without " "the ``.py`` extension::" msgstr "" #: library/__main__.rst:35 msgid "" "If the file is part of a package, ``__name__`` will also include the parent " "package's path::" msgstr "" #: 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 "" #: library/__main__.rst:46 msgid "What is the \"top-level code environment\"?" msgstr "" #: library/__main__.rst:48 msgid "" "``__main__`` is the name of the environment where top-level code is run. " "\"Top-level code\" is the first user-specified Python module that starts " "running. It's \"top-level\" because it imports all other modules that the " "program needs. Sometimes \"top-level code\" is called an *entry point* to " "the application." msgstr "" #: library/__main__.rst:53 msgid "The top-level code environment can be:" msgstr "" #: library/__main__.rst:55 msgid "the scope of an interactive prompt::" msgstr "" #: library/__main__.rst:60 msgid "the Python module passed to the Python interpreter as a file argument:" msgstr "" #: library/__main__.rst:67 msgid "" "the Python module or package passed to the Python interpreter with the :" "option:`-m` argument:" msgstr "" #: library/__main__.rst:75 msgid "Python code read by the Python interpreter from standard input:" msgstr "" #: library/__main__.rst:86 msgid "" "Python code passed to the Python interpreter with the :option:`-c` argument:" msgstr "" #: library/__main__.rst:97 msgid "" "In each of these situations, the top-level module's ``__name__`` is set to " "``'__main__'``." msgstr "" #: 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é ::" #: 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 "" #: library/__main__.rst:239 msgid "Idiomatic Usage" msgstr "" #: library/__main__.rst:118 msgid "" "Some modules contain code that is intended for script use only, like parsing " "command-line arguments or fetching data from standard input. When a module " "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 "" #: library/__main__.rst:123 msgid "" "This is where using the ``if __name__ == '__main__'`` code block comes in " "handy. Code within this block won't run unless the module is executed in the " "top-level environment." msgstr "" #: library/__main__.rst:127 msgid "" "Putting as few statements as possible in the block below ``if __name___ == " "'__main__'`` can improve code clarity and correctness. Most often, a " "function named ``main`` encapsulates the program's primary behavior::" msgstr "" #: library/__main__.rst:151 msgid "" "Note that if the module didn't encapsulate code inside the ``main`` function " "but instead put it directly within the ``if __name__ == '__main__'`` block, " "the ``phrase`` variable would be global to the entire module. This is error-" "prone as other functions within the module could be unintentionally using " "the global variable instead of a local name. A ``main`` function solves " "this problem." msgstr "" #: library/__main__.rst:158 msgid "" "Using a ``main`` function has the added benefit of the ``echo`` function " "itself being isolated and importable elsewhere. When ``echo.py`` is " "imported, the ``echo`` and ``main`` functions will be defined, but neither " "of them will be called, because ``__name__ != '__main__'``." msgstr "" #: library/__main__.rst:165 msgid "Packaging Considerations" msgstr "" #: library/__main__.rst:167 msgid "" "``main`` functions are often used to create command-line tools by specifying " "them as entry points for console scripts. When this is done, `pip `_ inserts the function call into a template script, where the " "return value of ``main`` is passed into :func:`sys.exit`. For example::" msgstr "" #: library/__main__.rst:175 msgid "" "Since the call to ``main`` is wrapped in :func:`sys.exit`, the expectation " "is that your function will return some value acceptable as an input to :func:" "`sys.exit`; typically, an integer or ``None`` (which is implicitly returned " "if your function does not have a return statement)." msgstr "" #: library/__main__.rst:180 msgid "" "By proactively following this convention ourselves, our module will have the " "same behavior when run directly (i.e. ``python3 echo.py``) as it will have " "if we later package it as a console script entry-point in a pip-installable " "package." msgstr "" #: library/__main__.rst:185 msgid "" "In particular, be careful about returning strings from your ``main`` " "function. :func:`sys.exit` will interpret a string argument as a failure " "message, so your program will have an exit code of ``1``, indicating " "failure, and the string will be written to :data:`sys.stderr`. The ``echo." "py`` example from earlier exemplifies using the ``sys.exit(main())`` " "convention." msgstr "" #: library/__main__.rst:193 msgid "" "`Python Packaging User Guide `_ contains a " "collection of tutorials and references on how to distribute and install " "Python packages with modern tools." msgstr "" #: library/__main__.rst:199 msgid "``__main__.py`` in Python Packages" msgstr "" #: library/__main__.rst:201 msgid "" "If you are not familiar with Python packages, see section :ref:`tut-" "packages` of the tutorial. Most commonly, the ``__main__.py`` file is used " "to provide a command-line interface for a package. Consider the following " "hypothetical package, \"bandclass\":" msgstr "" #: 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 "" #: library/__main__.rst:220 msgid "" "This command will cause ``__main__.py`` to run. How you utilize this " "mechanism will depend on the nature of the package you are writing, but in " "this hypothetical case, it might make sense to allow the teacher to search " "for students::" msgstr "" #: library/__main__.rst:233 msgid "" "Note that ``from .student import search_students`` is an example of a " "relative import. This import style must be used when referencing modules " "within a package. For more details, see :ref:`intra-package-references` in " "the :ref:`tut-modules` section of the tutorial." msgstr "" #: library/__main__.rst:241 msgid "" "The contents of ``__main__.py`` typically isn't fenced with ``if __name__ == " "'__main__'`` blocks. Instead, those files are kept short, functions to " "execute from other modules. Those other modules can then be easily unit-" "tested and are properly reusable." msgstr "" #: library/__main__.rst:246 msgid "" "If used, an ``if __name__ == '__main__'`` block will still work as expected " "for a ``__main__.py`` file within a package, because its ``__name__`` " "attribute will include the package's path if imported::" msgstr "" #: library/__main__.rst:254 msgid "" "This won't work for ``__main__.py`` files in the root directory of a .zip " "file though. Hence, for consistency, minimal ``__main__.py`` like the :mod:" "`venv` one mentioned above are preferred." msgstr "" #: library/__main__.rst:260 msgid "" "See :mod:`venv` for an example of a package with a minimal ``__main__.py`` " "in the standard library. It doesn't contain a ``if __name__ == '__main__'`` " "block. You can invoke it with ``python3 -m venv [directory]``." msgstr "" #: library/__main__.rst:264 msgid "" "See :mod:`runpy` for more details on the :option:`-m` flag to the " "interpreter executable." msgstr "" #: library/__main__.rst:267 msgid "" "See :mod:`zipapp` for how to run applications packaged as *.zip* files. In " "this case Python looks for a ``__main__.py`` file in the root directory of " "the archive." msgstr "" #: library/__main__.rst:274 msgid "``import __main__``" msgstr "" #: library/__main__.rst:276 msgid "" "Regardless of which module a Python program was started with, other modules " "running within that same program can import the top-level environment's " "scope (:term:`namespace`) by importing the ``__main__`` module. This " "doesn't import a ``__main__.py`` file but rather whichever module that " "received the special name ``'__main__'``." msgstr "" #: library/__main__.rst:282 msgid "Here is an example module that consumes the ``__main__`` namespace::" msgstr "" #: library/__main__.rst:300 msgid "Example usage of this module could be as follows::" msgstr "" #: library/__main__.rst:319 msgid "Now, if we started our program, the result would look like this:" msgstr "" #: library/__main__.rst:326 msgid "" "The exit code of the program would be 1, indicating an error. Uncommenting " "the line with ``my_name = \"Dinsdale\"`` fixes the program and now it exits " "with status code 0, indicating success:" msgstr "" #: library/__main__.rst:335 msgid "" "Note that importing ``__main__`` doesn't cause any issues with " "unintentionally running top-level code meant for script use which is put in " "the ``if __name__ == \"__main__\"`` block of the ``start`` module. Why does " "this work?" msgstr "" #: library/__main__.rst:339 msgid "" "Python inserts an empty ``__main__`` module in :attr:`sys.modules` at " "interpreter startup, and populates it by running top-level code. In our " "example this is the ``start`` module which runs line by line and imports " "``namely``. In turn, ``namely`` imports ``__main__`` (which is really " "``start``). That's an import cycle! Fortunately, since the partially " "populated ``__main__`` module is present in :attr:`sys.modules`, Python " "passes that to ``namely``. See :ref:`Special considerations for __main__ " "` in the import system's reference for details on how " "this works." msgstr "" #: 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 "" #: library/__main__.rst:364 msgid "" "Note that in this case the ``__main__`` scope doesn't contain a ``__file__`` " "attribute as it's interactive." msgstr "" #: library/__main__.rst:367 msgid "" "The ``__main__`` scope is used in the implementation of :mod:`pdb` and :mod:" "`rlcompleter`." msgstr "" #~ msgid "" #~ "``'__main__'`` is the name of the scope in which top-level code executes. " #~ "A module's __name__ is set equal to ``'__main__'`` when read from " #~ "standard input, a script, or from an interactive prompt." #~ msgstr "" #~ "``'__main__'`` est le nom du *scope* dans lequel le code s'exécute en " #~ "premier. Le nom d'un module (son *__name__*) vaut ``'__main__'`` " #~ "lorsqu'il est lu de l'entrée standard, lorsque c'est un script, ou une " #~ "invite interactive." #~ msgid "" #~ "For a package, the same effect can be achieved by including a ``__main__." #~ "py`` module, the contents of which will be executed when the module is " #~ "run with ``-m``." #~ msgstr "" #~ "Pour un paquet, le même effet peut être obtenu en utilisant un module " #~ "``__main__.py``, son contenu sera exécuté si le paquet est lancé via ``-" #~ "m``."