# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# Inada Naoki <songofacandy@gmail.com>, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-13 15:10+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: Inada Naoki <songofacandy@gmail.com>, 2026\n"

"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: ja\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/__main__.rst:2

msgid ":mod:`!__main__` --- Top-level code environment"

msgstr ":mod:`!__main__` --- トップレベルのコード環境"

#: ../../library/__main__.rst:10

msgid ""

"In Python, the special name ``__main__`` is used for two important "

"constructs:"

msgstr ""

"Python では、 ``__main__`` という特別な名前が次の二つの重要な用途で使われま"

"す:"

#: ../../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 ""

"プログラムのトップレベル環境の名前。\n"

"``__name__ == '__main__'`` という式でチェックすることができる。"

#: ../../library/__main__.rst:14

msgid "the ``__main__.py`` file in Python packages."

msgstr "Python パッケージにおける ``__main__.py`` ファイル。"

#: ../../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 ""

"どちらも Python のモジュールに関わる機能です。\n"

"１つ目はユーザーがどうモジュールを使うか、２つ目はモジュールとモジュールがど"

"うやりとりするかに関係します。\n"

"詳細は以下で説明します。\n"

"Python モジュールがどういうものかについては、 :ref:`tut-modules` を参照してく"

"ださい。"

#: ../../library/__main__.rst:25

msgid "``__name__ == '__main__'``"

msgstr "``__name__ == '__main__'``"

#: ../../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 ""

"Python モジュールやパッケージがインポートされるとき、 ``__name__`` の値はその"

"モジュールの名前となります。\n"

"通常、インポートされる Python ファイル自体のファイル名から拡張子 ``.py`` を除"

"いたものとなります::"

#: ../../library/__main__.rst:31

msgid ""

">>> import configparser\n"

">>> configparser.__name__\n"

"'configparser'"

msgstr ""

#: ../../library/__main__.rst:35

msgid ""

"If the file is part of a package, ``__name__`` will also include the parent "

"package's path::"

msgstr ""

"インポートされるファイルがパッケージの一部である場合は、 ``__name__`` にはそ"

"のパッケージのパスも含まれます::"

#: ../../library/__main__.rst:38

msgid ""

">>> from concurrent.futures import process\n"

">>> process.__name__\n"

"'concurrent.futures.process'"

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 ""

"しかし、モジュールがトップレベルのスクリプト環境で実行される場合は、 "

"``__name__`` が ``'__main__'`` という文字列になります。"

#: ../../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 ""

"``__main__`` は、トップレベルのコードが実行される環境の名前です。 \"トップレ"

"ベルのコード\" は、実行を開始する最初のユーザー指定の Python モジュールです。"

"これは、このモジュールがプログラムに必要なすべての他のモジュールをインポート"

"するために、 \"トップレベル\" なのです。時折、 \"トップレベルのコード\" は、"

"アプリケーションには *エントリーポイント* と呼ばれます。"

#: ../../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:57

msgid ""

">>> __name__\n"

"'__main__'"

msgstr ""

#: ../../library/__main__.rst:60

msgid "the Python module passed to the Python interpreter as a file argument:"

msgstr "Python インタープリタにファイル引数として渡される Python モジュール:"

#: ../../library/__main__.rst:62

msgid ""

"$ python helloworld.py\n"

"Hello, world!"

msgstr ""

#: ../../library/__main__.rst:67

msgid ""

"the Python module or package passed to the Python interpreter with the :"

"option:`-m` argument:"

msgstr ""

"Python インタープリタにPython :option:`-m` オプションとして渡される Python モ"

"ジュールまたはパッケージ:"

#: ../../library/__main__.rst:70

msgid ""

"$ python -m tarfile\n"

"usage: tarfile.py [-h] [-v] (...)"

msgstr ""

#: ../../library/__main__.rst:75

msgid "Python code read by the Python interpreter from standard input:"

msgstr "標準入力から Python インタープリタが読み込む Python コード:"

#: ../../library/__main__.rst:77

msgid ""

"$ echo \"import this\" | python\n"

"The Zen of Python, by Tim Peters\n"

"\n"

"Beautiful is better than ugly.\n"

"Explicit is better than implicit.\n"

"..."

msgstr ""

#: ../../library/__main__.rst:86

msgid ""

"Python code passed to the Python interpreter with the :option:`-c` argument:"

msgstr ""

"Python インタープリタに :option:`-c` オプションで渡される Python コード:"

#: ../../library/__main__.rst:88

msgid ""

"$ python -c \"import this\"\n"

"The Zen of Python, by Tim Peters\n"

"\n"

"Beautiful is better than ugly.\n"

"Explicit is better than implicit.\n"

"..."

msgstr ""

#: ../../library/__main__.rst:97

msgid ""

"In each of these situations, the top-level module's ``__name__`` is set to "

"``'__main__'``."

msgstr ""

"上記それぞれの場合で、トップレベルのモジュールの ``__name__`` の値が "

"``'__main__'`` となります。"

#: ../../library/__main__.rst:100

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 ""

"これにより、 ``__name__`` をチェックすれば各モジュールは自分がトップレベル環"

"境で実行されているかどうかを知ることができます。\n"

"このことから、モジュールが import 文で初期化された場合以外の場合でのみコード"

"を実行するため、次のコードがしばしば用いられます::"

#: ../../library/__main__.rst:105

msgid ""

"if __name__ == '__main__':\n"

" # Execute when the module is not initialized from an import statement.\n"

" ..."

msgstr ""

#: ../../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 ""

"あらゆる場合に ``__name__`` の値がどうセットされるのかについて、詳しくは"

"チュートリアルの :ref:`tut-modules` セクションを参照してください。"

#: ../../library/__main__.rst:116 ../../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. If a module "

"like this was imported from a different module, for example to unit test it, "

"the script code would unintentionally execute as well."

msgstr ""

"一部のモジュールでは、コマンドライン引数をパースしたり標準入力からデータを取"

"得したなど、スクリプト用途のみのコードが含まれています。\n"

"このようなモジュールが、例えばユニットテストのため、別のモジュールからイン"

"ポートされると、そのスクリプト用コードが意図に反して実行されてしまいます。"

#: ../../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 ""

"``if __name__ == '__main__'`` というコードは、このようなときに役立ちます。\n"

"このブロックの中にあるコードは、当該のモジュールがトップレベル環境で実行され"

"ていない限り、実行されません。"

#: ../../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 ""

"``if __name__ == '__main__'`` の下のブロックにあるコードはできるだけ少なくし"

"た方が、コードの分かりやすさや正確さにつながります。\n"

"最もよくあるのが、プログラムの主要な処理を ``main`` 関数の中にカプセル化する"

"ことです::"

#: ../../library/__main__.rst:131

msgid ""

"# echo.py\n"

"\n"

"import shlex\n"

"import sys\n"

"\n"

"def echo(phrase: str) -> None:\n"

" \"\"\"A dummy wrapper around print.\"\"\"\n"

" # for demonstration purposes, you can imagine that there is some\n"

" # valuable and reusable logic inside this function\n"

" print(phrase)\n"

"\n"

"def main() -> int:\n"

" \"\"\"Echo the input arguments to standard output\"\"\"\n"

" phrase = shlex.join(sys.argv)\n"

" echo(phrase)\n"

" return 0\n"

"\n"

"if __name__ == '__main__':\n"

" sys.exit(main()) # next section explains the use of sys.exit"

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 ""

"注意すべき点として、もし ``main`` 関数内のコードをカプセル化せず ``if "

"__name__ == '__main__'`` の下に直接書いた場合、 ``phrase`` 変数はモジュール全"

"体からグローバルにアクセスできてしまいます。\n"

"モジュール内の他の関数が意図せずローカル変数ではなくそのグローバル変数を使用"

"してしまう可能性があるため、ミスにつながります。\n"

"``main`` 関数を用意することでこの問題は解決できます。"

#: ../../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 ""

"``main`` 関数を使うことのもう一つのメリットとして、 ``echo`` 関数が分離し、別"

"の場所からインポートできるようになることです。\n"

"``echo.py`` がインポートされるとき、 ``echo`` 関数と ``main`` 関数が定義され"

"ますが、 ``__name__ != '__main__'`` であるため、どちらの関数も呼び出されませ"

"ん。"

#: ../../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 <https://"

"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 ""

#: ../../library/__main__.rst:173

msgid "sys.exit(main())"

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. ``python 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 <https://packaging.python.org/>`_ 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:206

msgid ""

"bandclass\n"

" ├── __init__.py\n"

" ├── __main__.py\n"

" └── student.py"

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:216

msgid "$ python -m bandclass"

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:225

msgid ""

"# bandclass/__main__.py\n"

"\n"

"import sys\n"

"from .student import search_students\n"

"\n"

"student_name = sys.argv[1] if len(sys.argv) >= 2 else ''\n"

"print(f'Found student: {search_students(student_name)}')"

msgstr ""

#: ../../library/__main__.rst:233

msgid ""

"Note that ``from .student import search_students`` is an example of a "

"relative import. This import style can 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 content of ``__main__.py`` typically isn't fenced with an ``if __name__ "

"== '__main__'`` block. Instead, those files are kept short and import "

"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:250

msgid ""

">>> import asyncio.__main__\n"

">>> asyncio.__main__.__name__\n"

"'asyncio.__main__'"

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, a minimal ``__main__.py`` "

"without a ``__name__`` check is 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 ``python -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 "``import __main__``"

#: ../../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:284

msgid ""

"# namely.py\n"

"\n"

"import __main__\n"

"\n"

"def did_user_define_their_name():\n"

" return 'my_name' in dir(__main__)\n"

"\n"

"def print_user_name():\n"

" if not did_user_define_their_name():\n"

" raise ValueError('Define the variable `my_name`!')\n"

"\n"

" print(__main__.my_name)"

msgstr ""

#: ../../library/__main__.rst:297

msgid "Example usage of this module could be as follows::"

msgstr ""

#: ../../library/__main__.rst:299

msgid ""

"# start.py\n"

"\n"

"import sys\n"

"\n"

"from namely import print_user_name\n"

"\n"

"# my_name = \"Dinsdale\"\n"

"\n"

"def main():\n"

" try:\n"

" print_user_name()\n"

" except ValueError as ve:\n"

" return str(ve)\n"

"\n"

"if __name__ == \"__main__\":\n"

" sys.exit(main())"

msgstr ""

#: ../../library/__main__.rst:316

msgid "Now, if we started our program, the result would look like this:"

msgstr ""

#: ../../library/__main__.rst:318

msgid ""

"$ python start.py\n"

"Define the variable `my_name`!"

msgstr ""

#: ../../library/__main__.rst:323

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:327

msgid ""

"$ python start.py\n"

"Dinsdale"

msgstr ""

#: ../../library/__main__.rst:332

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:336

msgid ""

"Python inserts an empty ``__main__`` module in :data:`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 :data:`sys.modules`, Python "

"passes that to ``namely``. See :ref:`Special considerations for __main__ "

"<import-dunder-main>` in the import system's reference for details on how "

"this works."

msgstr ""

#: ../../library/__main__.rst:345

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:348

msgid ""

">>> import namely\n"

">>> namely.did_user_define_their_name()\n"

"False\n"

">>> namely.print_user_name()\n"

"Traceback (most recent call last):\n"

"...\n"

"ValueError: Define the variable `my_name`!\n"

">>> my_name = 'Jabberwocky'\n"

">>> namely.did_user_define_their_name()\n"

"True\n"

">>> namely.print_user_name()\n"

"Jabberwocky"

msgstr ""

#: ../../library/__main__.rst:361

msgid ""

"The ``__main__`` scope is used in the implementation of :mod:`pdb` and :mod:"

"`rlcompleter`."

msgstr ""