argparse.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# jerrychen <jerrychen.ee@gmail.com>, 2016
# Evan Gui <clown.gui@gmail.com>, 2016
# Liang-Bo Wang <me@liang2.tw>, 2016
# Adrian Liaw <adrianliaw2000@gmail.com>, 2018
# Phil Lin <linooohon@gmail.com>, 2022
# Matt Wang <mattwang44@gmail.com>, 2023
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-12-29 11:18+0000\n"
"PO-Revision-Date: 2023-12-11 17:33+0800\n"
"Last-Translator: Matt Wang <mattwang44@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.0.1\n"

#: ../../howto/argparse.rst:5
msgid "Argparse Tutorial"
msgstr "Argparse 教學"

#: ../../howto/argparse.rst:0
msgid "author"
msgstr "作者"

#: ../../howto/argparse.rst:7
msgid "Tshepang Mbambo"
msgstr "Tshepang Mbambo"

#: ../../howto/argparse.rst:11
msgid ""
"This tutorial is intended to be a gentle introduction to :mod:`argparse`, "
"the recommended command-line parsing module in the Python standard library."
msgstr ""
"本教學旨在簡要介紹 :mod:`argparse` 這個 Python 標準函式庫中推薦的命令列剖析模"
"組。"

#: ../../howto/argparse.rst:16
msgid ""
"The standard library includes two other libraries directly related to "
"command-line parameter processing: the lower level :mod:`optparse` module "
"(which may require more code to configure for a given application, but also "
"allows an application to request behaviors that ``argparse`` doesn't "
"support), and the very low level :mod:`getopt` (which specifically serves as "
"an equivalent to the :c:func:`!getopt` family of functions available to C "
"programmers). While neither of those modules is covered directly in this "
"guide, many of the core concepts in ``argparse`` first originated in "
"``optparse``, so some aspects of this tutorial will also be relevant to "
"``optparse`` users."
msgstr ""
"標準函式庫包含另外兩個與命令列參數處理直接相關的函式庫：較低階的 :mod:"
"`optparse` 模組（可能需要更多程式碼來為給定應用程式設定，但也允許應用程式要"
"求 ``argparse`` 不支援的行為），以及非常低階的 :mod:`getopt`\\ （專門用作 C "
"程式設計師可用的 :c:func:`!getopt` 函式系列的等價）。雖然這個指南並未直接涵蓋"
"這些模組，但 ``argparse`` 的許多核心概念最初來自於 ``optparse``，因此本教學的"
"某些部分也適用於 ``optparse`` 使用者。"

#: ../../howto/argparse.rst:29
msgid "Concepts"
msgstr "概念"

#: ../../howto/argparse.rst:31
msgid ""
"Let's show the sort of functionality that we are going to explore in this "
"introductory tutorial by making use of the :command:`ls` command:"
msgstr ""
"讓我們透過使用 :command:`ls` 指令來展示我們將在本介紹教學中探索的功能類型："

#: ../../howto/argparse.rst:34
msgid ""
"$ ls\n"
"cpython  devguide  prog.py  pypy  rm-unused-function.patch\n"
"$ ls pypy\n"
"ctypes_configure  demo  dotviewer  include  lib_pypy  lib-python ...\n"
"$ ls -l\n"
"total 20\n"
"drwxr-xr-x 19 wena wena 4096 Feb 18 18:51 cpython\n"
"drwxr-xr-x  4 wena wena 4096 Feb  8 12:04 devguide\n"
"-rwxr-xr-x  1 wena wena  535 Feb 19 00:05 prog.py\n"
"drwxr-xr-x 14 wena wena 4096 Feb  7 00:59 pypy\n"
"-rw-r--r--  1 wena wena  741 Feb 18 01:01 rm-unused-function.patch\n"
"$ ls --help\n"
"Usage: ls [OPTION]... [FILE]...\n"
"List information about the FILEs (the current directory by default).\n"
"Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.\n"
"..."
msgstr ""
"$ ls\n"
"cpython  devguide  prog.py  pypy  rm-unused-function.patch\n"
"$ ls pypy\n"
"ctypes_configure  demo  dotviewer  include  lib_pypy  lib-python ...\n"
"$ ls -l\n"
"total 20\n"
"drwxr-xr-x 19 wena wena 4096 Feb 18 18:51 cpython\n"
"drwxr-xr-x  4 wena wena 4096 Feb  8 12:04 devguide\n"
"-rwxr-xr-x  1 wena wena  535 Feb 19 00:05 prog.py\n"
"drwxr-xr-x 14 wena wena 4096 Feb  7 00:59 pypy\n"
"-rw-r--r--  1 wena wena  741 Feb 18 01:01 rm-unused-function.patch\n"
"$ ls --help\n"
"Usage: ls [OPTION]... [FILE]...\n"
"List information about the FILEs (the current directory by default).\n"
"Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.\n"
"..."

#: ../../howto/argparse.rst:53
msgid "A few concepts we can learn from the four commands:"
msgstr "我們可以從這四個命令中學到一些概念："

#: ../../howto/argparse.rst:55
msgid ""
"The :command:`ls` command is useful when run without any options at all. It "
"defaults to displaying the contents of the current directory."
msgstr ""
":command:`ls` 命令即便在沒有任何選項的情況下執行仍非常有用。它預設顯示目前目"
"錄的內容。"

#: ../../howto/argparse.rst:58
msgid ""
"If we want beyond what it provides by default, we tell it a bit more. In "
"this case, we want it to display a different directory, ``pypy``. What we "
"did is specify what is known as a positional argument. It's named so because "
"the program should know what to do with the value, solely based on where it "
"appears on the command line. This concept is more relevant to a command "
"like :command:`cp`, whose most basic usage is ``cp SRC DEST``. The first "
"position is *what you want copied,* and the second position is *where you "
"want it copied to*."
msgstr ""
"如果我們想要看到比它預設提供更多的內容，我們也需要多告訴它一點。在本例中，我"
"們希望它顯示不同的目錄 ``pypy``，我們做的是指定所謂的位置引數。之所以如此命名"
"是因為程式應該只根據該值在命令列中出現的位置來知道如何處理該值。這個概念與 :"
"command:`cp` 這樣的指令更相關，其最基本的用法是 ``cp SRC DEST``。第一個是\\ *"
"你想要複製的位置*，第二個是\\ *你想要複製過去的位置*。"

#: ../../howto/argparse.rst:67
msgid ""
"Now, say we want to change behaviour of the program. In our example, we "
"display more info for each file instead of just showing the file names. The "
"``-l`` in that case is known as an optional argument."
msgstr ""
"現在假設我們想要改變程式的行為。在我們的範例中，我們顯示每個檔案的更多資訊，"
"而不僅是顯示檔案名稱。在這種情況下，``-l`` 被稱為可選引數。"

#: ../../howto/argparse.rst:71
msgid ""
"That's a snippet of the help text. It's very useful in that you can come "
"across a program you have never used before, and can figure out how it works "
"simply by reading its help text."
msgstr ""
"這是幫助文字的片段。它非常有用，因為當你遇到以前從未使用過的程式時，只需閱讀"
"其幫助文字即可了解它的工作原理。"

#: ../../howto/argparse.rst:77
msgid "The basics"
msgstr "基本用法"

#: ../../howto/argparse.rst:79
msgid "Let us start with a very simple example which does (almost) nothing::"
msgstr "讓我們從一個非常簡單的例子開始，它（幾乎）什麼都不做： ::"

#: ../../howto/argparse.rst:81
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.parse_args()"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.parse_args()"

#: ../../howto/argparse.rst:85 ../../howto/argparse.rst:193
#: ../../howto/argparse.rst:214
msgid "Following is a result of running the code:"
msgstr "程式碼執行結果如下："

#: ../../howto/argparse.rst:87
msgid ""
"$ python prog.py\n"
"$ python prog.py --help\n"
"usage: prog.py [-h]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"$ python prog.py --verbose\n"
"usage: prog.py [-h]\n"
"prog.py: error: unrecognized arguments: --verbose\n"
"$ python prog.py foo\n"
"usage: prog.py [-h]\n"
"prog.py: error: unrecognized arguments: foo"
msgstr ""
"$ python prog.py\n"
"$ python prog.py --help\n"
"usage: prog.py [-h]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"$ python prog.py --verbose\n"
"usage: prog.py [-h]\n"
"prog.py: error: unrecognized arguments: --verbose\n"
"$ python prog.py foo\n"
"usage: prog.py [-h]\n"
"prog.py: error: unrecognized arguments: foo"

#: ../../howto/argparse.rst:102 ../../howto/argparse.rst:259
#: ../../howto/argparse.rst:303
msgid "Here is what is happening:"
msgstr "這是發生的事情："

#: ../../howto/argparse.rst:104
msgid ""
"Running the script without any options results in nothing displayed to "
"stdout. Not so useful."
msgstr "執行不帶任何選項的腳本不會在標準輸出中顯示任何內容。不太有用。"

#: ../../howto/argparse.rst:107
msgid ""
"The second one starts to display the usefulness of the :mod:`argparse` "
"module. We have done almost nothing, but already we get a nice help message."
msgstr ""
"第二個開始能夠顯現 :mod:`argparse` 模組的有用之處。我們幾乎什麼也沒做，但我們"
"已經收到了一個很好的幫助訊息。"

#: ../../howto/argparse.rst:110
msgid ""
"The ``--help`` option, which can also be shortened to ``-h``, is the only "
"option we get for free (i.e. no need to specify it). Specifying anything "
"else results in an error. But even then, we do get a useful usage message, "
"also for free."
msgstr ""
"``--help`` 選項也可以縮寫為 ``-h``，是我們能隨意獲得的唯一選項（即無需指定"
"它）。指定任何其他內容都會導致錯誤。但即便如此，我們也還是輕鬆地獲得了有用的"
"使用資訊。"

#: ../../howto/argparse.rst:117
msgid "Introducing Positional arguments"
msgstr "位置引數的介紹"

#: ../../howto/argparse.rst:119
msgid "An example::"
msgstr "例如： ::"

#: ../../howto/argparse.rst:121
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"echo\")\n"
"args = parser.parse_args()\n"
"print(args.echo)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"echo\")\n"
"args = parser.parse_args()\n"
"print(args.echo)"

#: ../../howto/argparse.rst:127
msgid "And running the code:"
msgstr "執行這段程式碼："

#: ../../howto/argparse.rst:129
msgid ""
"$ python prog.py\n"
"usage: prog.py [-h] echo\n"
"prog.py: error: the following arguments are required: echo\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] echo\n"
"\n"
"positional arguments:\n"
"  echo\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"$ python prog.py foo\n"
"foo"
msgstr ""
"$ python prog.py\n"
"usage: prog.py [-h] echo\n"
"prog.py: error: the following arguments are required: echo\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] echo\n"
"\n"
"positional arguments:\n"
"  echo\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"$ python prog.py foo\n"
"foo"

#: ../../howto/argparse.rst:145
msgid "Here is what's happening:"
msgstr "這是會發生的事情："

#: ../../howto/argparse.rst:147
msgid ""
"We've added the :meth:`~ArgumentParser.add_argument` method, which is what "
"we use to specify which command-line options the program is willing to "
"accept. In this case, I've named it ``echo`` so that it's in line with its "
"function."
msgstr ""
"我們新增了 :meth:`~ArgumentParser.add_argument` 方法，我們用它來指定程式願意"
"接受哪些命令列選項。在本例中，我將其命名為 ``echo``，以便與其功能一致。"

#: ../../howto/argparse.rst:151
msgid "Calling our program now requires us to specify an option."
msgstr "現在呼叫我們的程式時需要指定一個選項。"

#: ../../howto/argparse.rst:153
msgid ""
"The :meth:`~ArgumentParser.parse_args` method actually returns some data "
"from the options specified, in this case, ``echo``."
msgstr ""
":meth:`~ArgumentParser.parse_args` 方法實際上從指定的選項中回傳一些資料，在本"
"例中為 ``echo``。"

#: ../../howto/argparse.rst:156
msgid ""
"The variable is some form of 'magic' that :mod:`argparse` performs for free "
"(i.e. no need to specify which variable that value is stored in). You will "
"also notice that its name matches the string argument given to the method, "
"``echo``."
msgstr ""
"該變數是某種形式的「魔法」，:mod:`argparse` 可以自由執行（即無需指定該值儲存"
"在哪個變數中）。你還會注意到，它的名稱與提供給方法 ``echo`` 的字串引數相符。"

#: ../../howto/argparse.rst:161
msgid ""
"Note however that, although the help display looks nice and all, it "
"currently is not as helpful as it can be. For example we see that we got "
"``echo`` as a positional argument, but we don't know what it does, other "
"than by guessing or by reading the source code. So, let's make it a bit more "
"useful::"
msgstr ""
"但請注意，儘管幫助顯示看起來不錯，但它目前還沒有發揮出應有的用處。例如，我們"
"看到 ``echo`` 作為位置引數，但除了猜測或閱讀原始程式碼之外，我們不知道它的作"
"用。那麼，我們來讓它變得更有用一點： ::"

#: ../../howto/argparse.rst:166
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"echo\", help=\"echo the string you use here\")\n"
"args = parser.parse_args()\n"
"print(args.echo)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"echo\", help=\"echo the string you use here\")\n"
"args = parser.parse_args()\n"
"print(args.echo)"

#: ../../howto/argparse.rst:172
msgid "And we get:"
msgstr "然後我們得到："

#: ../../howto/argparse.rst:174
msgid ""
"$ python prog.py -h\n"
"usage: prog.py [-h] echo\n"
"\n"
"positional arguments:\n"
"  echo        echo the string you use here\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit"
msgstr ""
"$ python prog.py -h\n"
"usage: prog.py [-h] echo\n"
"\n"
"positional arguments:\n"
"  echo        echo the string you use here\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit"

#: ../../howto/argparse.rst:185
msgid "Now, how about doing something even more useful::"
msgstr "現在來做一些更有用處的事情： ::"

#: ../../howto/argparse.rst:187
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", help=\"display a square of a given "
"number\")\n"
"args = parser.parse_args()\n"
"print(args.square**2)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", help=\"display a square of a given "
"number\")\n"
"args = parser.parse_args()\n"
"print(args.square**2)"

#: ../../howto/argparse.rst:195
msgid ""
"$ python prog.py 4\n"
"Traceback (most recent call last):\n"
"  File \"prog.py\", line 5, in <module>\n"
"    print(args.square**2)\n"
"TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'"
msgstr ""
"$ python prog.py 4\n"
"Traceback (most recent call last):\n"
"  File \"prog.py\", line 5, in <module>\n"
"    print(args.square**2)\n"
"TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'"

#: ../../howto/argparse.rst:203
msgid ""
"That didn't go so well. That's because :mod:`argparse` treats the options we "
"give it as strings, unless we tell it otherwise. So, let's tell :mod:"
"`argparse` to treat that input as an integer::"
msgstr ""
"進展不太順利。這是因為，除非我們另有說明，:mod:`argparse` 會將我們給它的選項"
"視為字串。因此，讓我們告訴 :mod:`argparse` 將該輸入視為整數： ::"

#: ../../howto/argparse.rst:207
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", help=\"display a square of a given "
"number\",\n"
"                    type=int)\n"
"args = parser.parse_args()\n"
"print(args.square**2)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", help=\"display a square of a given "
"number\",\n"
"                    type=int)\n"
"args = parser.parse_args()\n"
"print(args.square**2)"

#: ../../howto/argparse.rst:216
msgid ""
"$ python prog.py 4\n"
"16\n"
"$ python prog.py four\n"
"usage: prog.py [-h] square\n"
"prog.py: error: argument square: invalid int value: 'four'"
msgstr ""
"$ python prog.py 4\n"
"16\n"
"$ python prog.py four\n"
"usage: prog.py [-h] square\n"
"prog.py: error: argument square: invalid int value: 'four'"

#: ../../howto/argparse.rst:224
msgid ""
"That went well. The program now even helpfully quits on bad illegal input "
"before proceeding."
msgstr "順利進展。現在該程式甚至可以在繼續操作之前因錯誤的非法輸入而退出。"

#: ../../howto/argparse.rst:229
msgid "Introducing Optional arguments"
msgstr "可選引數的介紹"

#: ../../howto/argparse.rst:231
msgid ""
"So far we have been playing with positional arguments. Let us have a look on "
"how to add optional ones::"
msgstr "到目前為止，我們一直在討論位置引數。我們來看看如何新增可選引數： ::"

#: ../../howto/argparse.rst:234
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"--verbosity\", help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"if args.verbosity:\n"
"    print(\"verbosity turned on\")"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"--verbosity\", help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"if args.verbosity:\n"
"    print(\"verbosity turned on\")"

#: ../../howto/argparse.rst:241 ../../howto/argparse.rst:287
#: ../../howto/argparse.rst:403 ../../howto/argparse.rst:437
msgid "And the output:"
msgstr "接者是結果："

#: ../../howto/argparse.rst:243
msgid ""
"$ python prog.py --verbosity 1\n"
"verbosity turned on\n"
"$ python prog.py\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] [--verbosity VERBOSITY]\n"
"\n"
"options:\n"
"  -h, --help            show this help message and exit\n"
"  --verbosity VERBOSITY\n"
"                        increase output verbosity\n"
"$ python prog.py --verbosity\n"
"usage: prog.py [-h] [--verbosity VERBOSITY]\n"
"prog.py: error: argument --verbosity: expected one argument"
msgstr ""
"$ python prog.py --verbosity 1\n"
"verbosity turned on\n"
"$ python prog.py\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] [--verbosity VERBOSITY]\n"
"\n"
"options:\n"
"  -h, --help            show this help message and exit\n"
"  --verbosity VERBOSITY\n"
"                        increase output verbosity\n"
"$ python prog.py --verbosity\n"
"usage: prog.py [-h] [--verbosity VERBOSITY]\n"
"prog.py: error: argument --verbosity: expected one argument"

#: ../../howto/argparse.rst:261
msgid ""
"The program is written so as to display something when ``--verbosity`` is "
"specified and display nothing when not."
msgstr ""
"程式被編寫為在指定 ``--verbosity`` 時顯示一些內容，並在未指定時不顯示任何內"
"容。"

#: ../../howto/argparse.rst:264
msgid ""
"To show that the option is actually optional, there is no error when running "
"the program without it. Note that by default, if an optional argument isn't "
"used, the relevant variable, in this case ``args.verbosity``, is given "
"``None`` as a value, which is the reason it fails the truth test of the :"
"keyword:`if` statement."
msgstr ""
"為了表示該選項實際上是可選的，沒使用它來執行程式並不會出現錯誤。請注意，預設"
"情況下，如果未使用可選引數，則相關變數（在本例中為 ``args.verbosity``）將被賦"
"予 ``None`` 作為值，這就是它未能通過 :keyword:`if` 陳述式真值測試的原因。"

#: ../../howto/argparse.rst:270
msgid "The help message is a bit different."
msgstr "幫助訊息有點不同。"

#: ../../howto/argparse.rst:272
msgid ""
"When using the ``--verbosity`` option, one must also specify some value, any "
"value."
msgstr "當使用 ``--verbosity`` 選項時必須要指定一些值，任何值都可以。"

#: ../../howto/argparse.rst:275
msgid ""
"The above example accepts arbitrary integer values for ``--verbosity``, but "
"for our simple program, only two values are actually useful, ``True`` or "
"``False``. Let's modify the code accordingly::"
msgstr ""
"在上面的例子中，``--verbosity`` 接受任意的整數，但對我們的程式來說只接受兩個"
"輸入值， ``True`` 或 ``False``。所以我們來修改一下程式碼使其符合： ::"

#: ../../howto/argparse.rst:279
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"--verbose\", help=\"increase output verbosity\",\n"
"                    action=\"store_true\")\n"
"args = parser.parse_args()\n"
"if args.verbose:\n"
"    print(\"verbosity turned on\")"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"--verbose\", help=\"increase output verbosity\",\n"
"                    action=\"store_true\")\n"
"args = parser.parse_args()\n"
"if args.verbose:\n"
"    print(\"verbosity turned on\")"

#: ../../howto/argparse.rst:289
msgid ""
"$ python prog.py --verbose\n"
"verbosity turned on\n"
"$ python prog.py --verbose 1\n"
"usage: prog.py [-h] [--verbose]\n"
"prog.py: error: unrecognized arguments: 1\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] [--verbose]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --verbose   increase output verbosity"
msgstr ""
"$ python prog.py --verbose\n"
"verbosity turned on\n"
"$ python prog.py --verbose 1\n"
"usage: prog.py [-h] [--verbose]\n"
"prog.py: error: unrecognized arguments: 1\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] [--verbose]\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --verbose   increase output verbosity"

#: ../../howto/argparse.rst:305
msgid ""
"The option is now more of a flag than something that requires a value. We "
"even changed the name of the option to match that idea. Note that we now "
"specify a new keyword, ``action``, and give it the value ``\"store_true\"``. "
"This means that, if the option is specified, assign the value ``True`` to "
"``args.verbose``. Not specifying it implies ``False``."
msgstr ""
"這個選項現在更像是一個旗標，而不是需要值的東西。我們甚至更改了選項的名稱以符"
"合這個想法。請注意，我們現在指定一個新的關鍵字 ``action``，並為其指定值 "
"``\"store_true\"``。這意味著，如果指定了該選項，則將值 ``True`` 指派給 "
"``args.verbose``。不指定它代表為 ``False``。"

#: ../../howto/argparse.rst:312
msgid ""
"It complains when you specify a value, in true spirit of what flags actually "
"are."
msgstr "當你指定一個值時，它會本著旗標的實際精神來抱怨。"

#: ../../howto/argparse.rst:315
msgid "Notice the different help text."
msgstr "請注意不同的幫助文字。"

#: ../../howto/argparse.rst:319
msgid "Short options"
msgstr "短選項"

#: ../../howto/argparse.rst:321
msgid ""
"If you are familiar with command line usage, you will notice that I haven't "
"yet touched on the topic of short versions of the options. It's quite "
"simple::"
msgstr ""
"如果你熟悉命令列用法，你會注意到我尚未提及選項的簡短版本。這很簡單： ::"

#: ../../howto/argparse.rst:325
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"-v\", \"--verbose\", help=\"increase output "
"verbosity\",\n"
"                    action=\"store_true\")\n"
"args = parser.parse_args()\n"
"if args.verbose:\n"
"    print(\"verbosity turned on\")"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"-v\", \"--verbose\", help=\"increase output "
"verbosity\",\n"
"                    action=\"store_true\")\n"
"args = parser.parse_args()\n"
"if args.verbose:\n"
"    print(\"verbosity turned on\")"

#: ../../howto/argparse.rst:333
msgid "And here goes:"
msgstr "而這為："

#: ../../howto/argparse.rst:335
msgid ""
"$ python prog.py -v\n"
"verbosity turned on\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] [-v]\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  -v, --verbose  increase output verbosity"
msgstr ""
"$ python prog.py -v\n"
"verbosity turned on\n"
"$ python prog.py --help\n"
"usage: prog.py [-h] [-v]\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  -v, --verbose  increase output verbosity"

#: ../../howto/argparse.rst:346
msgid "Note that the new ability is also reflected in the help text."
msgstr "請注意，新功能也反映在幫助文字中。"

#: ../../howto/argparse.rst:350
msgid "Combining Positional and Optional arguments"
msgstr "組合位置引數和可選引數"

#: ../../howto/argparse.rst:352
msgid "Our program keeps growing in complexity::"
msgstr "我們的程式的複雜性不斷增加： ::"

#: ../../howto/argparse.rst:354
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbose\", action=\"store_true\",\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbose:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbose\", action=\"store_true\",\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbose:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:367
msgid "And now the output:"
msgstr "然後現在的輸出結果："

#: ../../howto/argparse.rst:369
msgid ""
"$ python prog.py\n"
"usage: prog.py [-h] [-v] square\n"
"prog.py: error: the following arguments are required: square\n"
"$ python prog.py 4\n"
"16\n"
"$ python prog.py 4 --verbose\n"
"the square of 4 equals 16\n"
"$ python prog.py --verbose 4\n"
"the square of 4 equals 16"
msgstr ""
"$ python prog.py\n"
"usage: prog.py [-h] [-v] square\n"
"prog.py: error: the following arguments are required: square\n"
"$ python prog.py 4\n"
"16\n"
"$ python prog.py 4 --verbose\n"
"the square of 4 equals 16\n"
"$ python prog.py --verbose 4\n"
"the square of 4 equals 16"

#: ../../howto/argparse.rst:381
msgid "We've brought back a positional argument, hence the complaint."
msgstr "我們帶回了位置引數，因而被抱怨。"

#: ../../howto/argparse.rst:383
msgid "Note that the order does not matter."
msgstr "請注意，順序並不重要。"

#: ../../howto/argparse.rst:385
msgid ""
"How about we give this program of ours back the ability to have multiple "
"verbosity values, and actually get to use them::"
msgstr ""
"我們讓這個程式擁有多個訊息詳細級別 (verbosity) 之值的能力，並實際使用它"
"們： ::"

#: ../../howto/argparse.rst:388
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", type=int,\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity == 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity == 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", type=int,\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity == 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity == 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:405
msgid ""
"$ python prog.py 4\n"
"16\n"
"$ python prog.py 4 -v\n"
"usage: prog.py [-h] [-v VERBOSITY] square\n"
"prog.py: error: argument -v/--verbosity: expected one argument\n"
"$ python prog.py 4 -v 1\n"
"4^2 == 16\n"
"$ python prog.py 4 -v 2\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 -v 3\n"
"16"
msgstr ""
"$ python prog.py 4\n"
"16\n"
"$ python prog.py 4 -v\n"
"usage: prog.py [-h] [-v VERBOSITY] square\n"
"prog.py: error: argument -v/--verbosity: expected one argument\n"
"$ python prog.py 4 -v 1\n"
"4^2 == 16\n"
"$ python prog.py 4 -v 2\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 -v 3\n"
"16"

#: ../../howto/argparse.rst:419
msgid ""
"These all look good except the last one, which exposes a bug in our program. "
"Let's fix it by restricting the values the ``--verbosity`` option can "
"accept::"
msgstr ""
"除了最後一個外都看起來正常，它透露了我們程式中的一個錯誤。我們可透過限制 ``--"
"verbosity`` 選項可以接受的值來修復它： ::"

#: ../../howto/argparse.rst:422
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", type=int, choices=[0, 1, 2],\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity == 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity == 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", type=int, choices=[0, 1, 2],\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity == 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity == 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:439
msgid ""
"$ python prog.py 4 -v 3\n"
"usage: prog.py [-h] [-v {0,1,2}] square\n"
"prog.py: error: argument -v/--verbosity: invalid choice: 3 (choose from 0, "
"1, 2)\n"
"$ python prog.py 4 -h\n"
"usage: prog.py [-h] [-v {0,1,2}] square\n"
"\n"
"positional arguments:\n"
"  square                display a square of a given number\n"
"\n"
"options:\n"
"  -h, --help            show this help message and exit\n"
"  -v, --verbosity {0,1,2}\n"
"                        increase output verbosity"
msgstr ""
"$ python prog.py 4 -v 3\n"
"usage: prog.py [-h] [-v {0,1,2}] square\n"
"prog.py: error: argument -v/--verbosity: invalid choice: 3 (choose from 0, "
"1, 2)\n"
"$ python prog.py 4 -h\n"
"usage: prog.py [-h] [-v {0,1,2}] square\n"
"\n"
"positional arguments:\n"
"  square                display a square of a given number\n"
"\n"
"options:\n"
"  -h, --help            show this help message and exit\n"
"  -v, --verbosity {0,1,2}\n"
"                        increase output verbosity"

#: ../../howto/argparse.rst:455
msgid ""
"Note that the change also reflects both in the error message as well as the "
"help string."
msgstr "請注意，更改也會反映在錯誤訊息和幫助字串中。"

#: ../../howto/argparse.rst:458
msgid ""
"Now, let's use a different approach of playing with verbosity, which is "
"pretty common. It also matches the way the CPython executable handles its "
"own verbosity argument (check the output of ``python --help``)::"
msgstr ""
"現在，讓我們使用另一種常見方法來玩玩訊息詳細級別。它也與 CPython 執行檔處理其"
"自身訊息詳細級別引數的方式相符（請見 ``python --help`` 的輸出）： ::"

#: ../../howto/argparse.rst:462
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display the square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity == 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity == 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display the square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity == 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity == 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:477
msgid ""
"We have introduced another action, \"count\", to count the number of "
"occurrences of specific options."
msgstr "我們已經介紹過另一個操作 \"count\" 用來計算指定的選項出現的次數。"

#: ../../howto/argparse.rst:481
msgid ""
"$ python prog.py 4\n"
"16\n"
"$ python prog.py 4 -v\n"
"4^2 == 16\n"
"$ python prog.py 4 -vv\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 --verbosity --verbosity\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 -v 1\n"
"usage: prog.py [-h] [-v] square\n"
"prog.py: error: unrecognized arguments: 1\n"
"$ python prog.py 4 -h\n"
"usage: prog.py [-h] [-v] square\n"
"\n"
"positional arguments:\n"
"  square           display a square of a given number\n"
"\n"
"options:\n"
"  -h, --help       show this help message and exit\n"
"  -v, --verbosity  increase output verbosity\n"
"$ python prog.py 4 -vvv\n"
"16"
msgstr ""
"$ python prog.py 4\n"
"16\n"
"$ python prog.py 4 -v\n"
"4^2 == 16\n"
"$ python prog.py 4 -vv\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 --verbosity --verbosity\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 -v 1\n"
"usage: prog.py [-h] [-v] square\n"
"prog.py: error: unrecognized arguments: 1\n"
"$ python prog.py 4 -h\n"
"usage: prog.py [-h] [-v] square\n"
"\n"
"positional arguments:\n"
"  square           display a square of a given number\n"
"\n"
"options:\n"
"  -h, --help       show this help message and exit\n"
"  -v, --verbosity  increase output verbosity\n"
"$ python prog.py 4 -vvv\n"
"16"

#: ../../howto/argparse.rst:506
msgid ""
"Yes, it's now more of a flag (similar to ``action=\"store_true\"``) in the "
"previous version of our script. That should explain the complaint."
msgstr ""
"是的，現在它更像是我們上一版腳本中的旗標（類似於 "
"``action=\"store_true\"``），這應該可以解釋抱怨的原因。"

#: ../../howto/argparse.rst:509
msgid "It also behaves similar to \"store_true\" action."
msgstr "它的行為也類似 \"store_true\" 操作。"

#: ../../howto/argparse.rst:511
msgid ""
"Now here's a demonstration of what the \"count\" action gives. You've "
"probably seen this sort of usage before."
msgstr "現在這裡示範了 \"count\" 動作的作用。你可能以前見過這種用法。"

#: ../../howto/argparse.rst:514
msgid ""
"And if you don't specify the ``-v`` flag, that flag is considered to have "
"``None`` value."
msgstr "如果你不指定 ``-v`` 旗標，則該旗標被視為具有 ``None`` 值。"

#: ../../howto/argparse.rst:517
msgid ""
"As should be expected, specifying the long form of the flag, we should get "
"the same output."
msgstr "正如預期的那樣，指定長形式旗標，我們應該得到相同的輸出。"

#: ../../howto/argparse.rst:520
msgid ""
"Sadly, our help output isn't very informative on the new ability our script "
"has acquired, but that can always be fixed by improving the documentation "
"for our script (e.g. via the ``help`` keyword argument)."
msgstr ""
"遺憾的是，我們的幫助輸出對於我們腳本獲得的新功能並沒有提供太多資訊，但我們都"
"可以透過改進腳本的文件來解決這個問題（例如：透過 ``help`` 關鍵字引數）。"

#: ../../howto/argparse.rst:524
msgid "That last output exposes a bug in our program."
msgstr "最後的輸出透露了我們程式中的一個錯誤。"

#: ../../howto/argparse.rst:527
msgid "Let's fix::"
msgstr "讓我們來解決問題： ::"

#: ../../howto/argparse.rst:529
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"\n"
"# bugfix: replace == with >=\n"
"if args.verbosity >= 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity >= 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"\n"
"# bugfix: replace == with >=\n"
"if args.verbosity >= 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity >= 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:546
msgid "And this is what it gives:"
msgstr "這就是它給出的："

#: ../../howto/argparse.rst:548
msgid ""
"$ python prog.py 4 -vvv\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 -vvvv\n"
"the square of 4 equals 16\n"
"$ python prog.py 4\n"
"Traceback (most recent call last):\n"
"  File \"prog.py\", line 11, in <module>\n"
"    if args.verbosity >= 2:\n"
"TypeError: '>=' not supported between instances of 'NoneType' and 'int'"
msgstr ""
"$ python prog.py 4 -vvv\n"
"the square of 4 equals 16\n"
"$ python prog.py 4 -vvvv\n"
"the square of 4 equals 16\n"
"$ python prog.py 4\n"
"Traceback (most recent call last):\n"
"  File \"prog.py\", line 11, in <module>\n"
"    if args.verbosity >= 2:\n"
"TypeError: '>=' not supported between instances of 'NoneType' and 'int'"

#: ../../howto/argparse.rst:561
msgid ""
"First output went well, and fixes the bug we had before. That is, we want "
"any value >= 2 to be as verbose as possible."
msgstr ""
"第一次輸出順利進行，並修復了我們之前遇到的錯誤。也就是說，我們希望任何 >= 2 "
"的值都盡可能詳細。"

#: ../../howto/argparse.rst:564
msgid "Third output not so good."
msgstr "第三個輸出不太好。"

#: ../../howto/argparse.rst:566
msgid "Let's fix that bug::"
msgstr "我們來修復這個錯誤： ::"

#: ../../howto/argparse.rst:568
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\", default=0,\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity >= 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity >= 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"square\", type=int,\n"
"                    help=\"display a square of a given number\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\", default=0,\n"
"                    help=\"increase output verbosity\")\n"
"args = parser.parse_args()\n"
"answer = args.square**2\n"
"if args.verbosity >= 2:\n"
"    print(f\"the square of {args.square} equals {answer}\")\n"
"elif args.verbosity >= 1:\n"
"    print(f\"{args.square}^2 == {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:583
msgid ""
"We've just introduced yet another keyword, ``default``. We've set it to "
"``0`` in order to make it comparable to the other int values. Remember that "
"by default, if an optional argument isn't specified, it gets the ``None`` "
"value, and that cannot be compared to an int value (hence the :exc:"
"`TypeError` exception)."
msgstr ""
"我們剛剛引入了另一個關鍵字 ``default``。我們將其設為 ``0``，以便使其與其他 "
"int 值進行比較。請記住，預設情況下，如果未指定可選引數，它將獲得 ``None`` "
"值，並且不能與 int 值進行比較（因此會出現 :exc:`TypeError` 例外）。"

#: ../../howto/argparse.rst:590
msgid "And:"
msgstr "而且："

#: ../../howto/argparse.rst:592
msgid ""
"$ python prog.py 4\n"
"16"
msgstr ""
"$ python prog.py 4\n"
"16"

#: ../../howto/argparse.rst:597
msgid ""
"You can go quite far just with what we've learned so far, and we have only "
"scratched the surface. The :mod:`argparse` module is very powerful, and "
"we'll explore a bit more of it before we end this tutorial."
msgstr ""
"僅憑我們迄今為止所學到的知識就可以做到很多事情了，不過其實這樣只有學到一點皮"
"毛而已。:mod:`argparse` 模組非常強大，在結束本教學之前我們會對它進行更多探"
"索。"

#: ../../howto/argparse.rst:604
msgid "Getting a little more advanced"
msgstr "更進階一點"

#: ../../howto/argparse.rst:606
msgid ""
"What if we wanted to expand our tiny program to perform other powers, not "
"just squares::"
msgstr "如果我們想擴充我們的小程式來執行其他次方的運算，而不僅是平方： ::"

#: ../../howto/argparse.rst:609
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\", default=0)\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"if args.verbosity >= 2:\n"
"    print(f\"{args.x} to the power {args.y} equals {answer}\")\n"
"elif args.verbosity >= 1:\n"
"    print(f\"{args.x}^{args.y} == {answer}\")\n"
"else:\n"
"    print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\", default=0)\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"if args.verbosity >= 2:\n"
"    print(f\"{args.x} to the power {args.y} equals {answer}\")\n"
"elif args.verbosity >= 1:\n"
"    print(f\"{args.x}^{args.y} == {answer}\")\n"
"else:\n"
"    print(answer)"

#: ../../howto/argparse.rst:623 ../../howto/argparse.rst:661
#: ../../howto/argparse.rst:877
msgid "Output:"
msgstr "結果："

#: ../../howto/argparse.rst:625
msgid ""
"$ python prog.py\n"
"usage: prog.py [-h] [-v] x y\n"
"prog.py: error: the following arguments are required: x, y\n"
"$ python prog.py -h\n"
"usage: prog.py [-h] [-v] x y\n"
"\n"
"positional arguments:\n"
"  x                the base\n"
"  y                the exponent\n"
"\n"
"options:\n"
"  -h, --help       show this help message and exit\n"
"  -v, --verbosity\n"
"$ python prog.py 4 2 -v\n"
"4^2 == 16"
msgstr ""
"$ python prog.py\n"
"usage: prog.py [-h] [-v] x y\n"
"prog.py: error: the following arguments are required: x, y\n"
"$ python prog.py -h\n"
"usage: prog.py [-h] [-v] x y\n"
"\n"
"positional arguments:\n"
"  x                the base\n"
"  y                the exponent\n"
"\n"
"options:\n"
"  -h, --help       show this help message and exit\n"
"  -v, --verbosity\n"
"$ python prog.py 4 2 -v\n"
"4^2 == 16"

#: ../../howto/argparse.rst:644
msgid ""
"Notice that so far we've been using verbosity level to *change* the text "
"that gets displayed. The following example instead uses verbosity level to "
"display *more* text instead::"
msgstr ""
"請注意，到目前為止，我們一直在使用詳細級別來\\ *更改*\\ 顯示的文字。以下範例"
"使用詳細級別來顯示\\ *更多*\\ 文字： ::"

#: ../../howto/argparse.rst:648
msgid ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\", default=0)\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"if args.verbosity >= 2:\n"
"    print(f\"Running '{__file__}'\")\n"
"if args.verbosity >= 1:\n"
"    print(f\"{args.x}^{args.y} == \", end=\"\")\n"
"print(answer)"
msgstr ""
"import argparse\n"
"parser = argparse.ArgumentParser()\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"parser.add_argument(\"-v\", \"--verbosity\", action=\"count\", default=0)\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"if args.verbosity >= 2:\n"
"    print(f\"Running '{__file__}'\")\n"
"if args.verbosity >= 1:\n"
"    print(f\"{args.x}^{args.y} == \", end=\"\")\n"
"print(answer)"

#: ../../howto/argparse.rst:663
msgid ""
"$ python prog.py 4 2\n"
"16\n"
"$ python prog.py 4 2 -v\n"
"4^2 == 16\n"
"$ python prog.py 4 2 -vv\n"
"Running 'prog.py'\n"
"4^2 == 16"
msgstr ""
"$ python prog.py 4 2\n"
"16\n"
"$ python prog.py 4 2 -v\n"
"4^2 == 16\n"
"$ python prog.py 4 2 -vv\n"
"Running 'prog.py'\n"
"4^2 == 16"

#: ../../howto/argparse.rst:677
msgid "Specifying ambiguous arguments"
msgstr "指定不明確的引數"

#: ../../howto/argparse.rst:679
msgid ""
"When there is ambiguity in deciding whether an argument is positional or for "
"an argument, ``--`` can be used to tell :meth:`~ArgumentParser.parse_args` "
"that everything after that is a positional argument::"
msgstr ""
"當決定一個引數是位置引數還是引數會有歧義，可以使用 ``--`` 來告訴 :meth:"
"`~ArgumentParser.parse_args` 之後的所有內容都是位置引數： ::"

#: ../../howto/argparse.rst:683
msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-n', nargs='+')\n"
">>> parser.add_argument('args', nargs='*')\n"
"\n"
">>> # ambiguous, so parse_args assumes it's an option\n"
">>> parser.parse_args(['-f'])\n"
"usage: PROG [-h] [-n N [N ...]] [args ...]\n"
"PROG: error: unrecognized arguments: -f\n"
"\n"
">>> parser.parse_args(['--', '-f'])\n"
"Namespace(args=['-f'], n=None)\n"
"\n"
">>> # ambiguous, so the -n option greedily accepts arguments\n"
">>> parser.parse_args(['-n', '1', '2', '3'])\n"
"Namespace(args=[], n=['1', '2', '3'])\n"
"\n"
">>> parser.parse_args(['-n', '1', '--', '2', '3'])\n"
"Namespace(args=['2', '3'], n=['1'])"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-n', nargs='+')\n"
">>> parser.add_argument('args', nargs='*')\n"
"\n"
">>> # ambiguous, so parse_args assumes it's an option\n"
">>> parser.parse_args(['-f'])\n"
"usage: PROG [-h] [-n N [N ...]] [args ...]\n"
"PROG: error: unrecognized arguments: -f\n"
"\n"
">>> parser.parse_args(['--', '-f'])\n"
"Namespace(args=['-f'], n=None)\n"
"\n"
">>> # ambiguous, so the -n option greedily accepts arguments\n"
">>> parser.parse_args(['-n', '1', '2', '3'])\n"
"Namespace(args=[], n=['1', '2', '3'])\n"
"\n"
">>> parser.parse_args(['-n', '1', '--', '2', '3'])\n"
"Namespace(args=['2', '3'], n=['1'])"

#: ../../howto/argparse.rst:704
msgid "Conflicting options"
msgstr "相互衝突的選項"

#: ../../howto/argparse.rst:706
msgid ""
"So far, we have been working with two methods of an :class:`argparse."
"ArgumentParser` instance. Let's introduce a third one, :meth:"
"`~ArgumentParser.add_mutually_exclusive_group`. It allows for us to specify "
"options that conflict with each other. Let's also change the rest of the "
"program so that the new functionality makes more sense: we'll introduce the "
"``--quiet`` option, which will be the opposite of the ``--verbose`` one::"
msgstr ""
"到目前為止，我們一直在使用 :class:`argparse.ArgumentParser` 實例的兩種方法。"
"讓我們介紹第三個，:meth:`~ArgumentParser.add_mutually_exclusive_group`，它允"
"許我們指定彼此衝突的選項。我們還可以更改程式的其餘部分，以使得新功能更有意"
"義：我們將引入 ``--quiet`` 選項，該選項與 ``--verbose`` 選項相反： ::"

#: ../../howto/argparse.rst:714
msgid ""
"import argparse\n"
"\n"
"parser = argparse.ArgumentParser()\n"
"group = parser.add_mutually_exclusive_group()\n"
"group.add_argument(\"-v\", \"--verbose\", action=\"store_true\")\n"
"group.add_argument(\"-q\", \"--quiet\", action=\"store_true\")\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"\n"
"if args.quiet:\n"
"    print(answer)\n"
"elif args.verbose:\n"
"    print(f\"{args.x} to the power {args.y} equals {answer}\")\n"
"else:\n"
"    print(f\"{args.x}^{args.y} == {answer}\")"
msgstr ""
"import argparse\n"
"\n"
"parser = argparse.ArgumentParser()\n"
"group = parser.add_mutually_exclusive_group()\n"
"group.add_argument(\"-v\", \"--verbose\", action=\"store_true\")\n"
"group.add_argument(\"-q\", \"--quiet\", action=\"store_true\")\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"\n"
"if args.quiet:\n"
"    print(answer)\n"
"elif args.verbose:\n"
"    print(f\"{args.x} to the power {args.y} equals {answer}\")\n"
"else:\n"
"    print(f\"{args.x}^{args.y} == {answer}\")"

#: ../../howto/argparse.rst:732
msgid ""
"Our program is now simpler, and we've lost some functionality for the sake "
"of demonstration. Anyways, here's the output:"
msgstr ""
"我們的程式現在更簡單了，我們因為功能展示失去了一些功能，但無論如何，以下這是"
"輸出："

#: ../../howto/argparse.rst:735
msgid ""
"$ python prog.py 4 2\n"
"4^2 == 16\n"
"$ python prog.py 4 2 -q\n"
"16\n"
"$ python prog.py 4 2 -v\n"
"4 to the power 2 equals 16\n"
"$ python prog.py 4 2 -vq\n"
"usage: prog.py [-h] [-v | -q] x y\n"
"prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose\n"
"$ python prog.py 4 2 -v --quiet\n"
"usage: prog.py [-h] [-v | -q] x y\n"
"prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose"
msgstr ""
"$ python prog.py 4 2\n"
"4^2 == 16\n"
"$ python prog.py 4 2 -q\n"
"16\n"
"$ python prog.py 4 2 -v\n"
"4 to the power 2 equals 16\n"
"$ python prog.py 4 2 -vq\n"
"usage: prog.py [-h] [-v | -q] x y\n"
"prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose\n"
"$ python prog.py 4 2 -v --quiet\n"
"usage: prog.py [-h] [-v | -q] x y\n"
"prog.py: error: argument -q/--quiet: not allowed with argument -v/--verbose"

#: ../../howto/argparse.rst:750
msgid ""
"That should be easy to follow. I've added that last output so you can see "
"the sort of flexibility you get, i.e. mixing long form options with short "
"form ones."
msgstr ""
"這應該很容易理解。我新增了最後一個輸出，以便看到所獲得的靈活性，即可以混合長"
"形式與短形式選項。"

#: ../../howto/argparse.rst:754
msgid ""
"Before we conclude, you probably want to tell your users the main purpose of "
"your program, just in case they don't know::"
msgstr ""
"在我們結束之前，你可能想告訴使用者你的程式的主要目的，以防他們不知道： ::"

#: ../../howto/argparse.rst:757
msgid ""
"import argparse\n"
"\n"
"parser = argparse.ArgumentParser(description=\"calculate X to the power of "
"Y\")\n"
"group = parser.add_mutually_exclusive_group()\n"
"group.add_argument(\"-v\", \"--verbose\", action=\"store_true\")\n"
"group.add_argument(\"-q\", \"--quiet\", action=\"store_true\")\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"\n"
"if args.quiet:\n"
"    print(answer)\n"
"elif args.verbose:\n"
"    print(f\"{args.x} to the power {args.y} equals {answer}\")\n"
"else:\n"
"    print(f\"{args.x}^{args.y} == {answer}\")"
msgstr ""
"import argparse\n"
"\n"
"parser = argparse.ArgumentParser(description=\"calculate X to the power of "
"Y\")\n"
"group = parser.add_mutually_exclusive_group()\n"
"group.add_argument(\"-v\", \"--verbose\", action=\"store_true\")\n"
"group.add_argument(\"-q\", \"--quiet\", action=\"store_true\")\n"
"parser.add_argument(\"x\", type=int, help=\"the base\")\n"
"parser.add_argument(\"y\", type=int, help=\"the exponent\")\n"
"args = parser.parse_args()\n"
"answer = args.x**args.y\n"
"\n"
"if args.quiet:\n"
"    print(answer)\n"
"elif args.verbose:\n"
"    print(f\"{args.x} to the power {args.y} equals {answer}\")\n"
"else:\n"
"    print(f\"{args.x}^{args.y} == {answer}\")"

#: ../../howto/argparse.rst:775
msgid ""
"Note that slight difference in the usage text. Note the ``[-v | -q]``, which "
"tells us that we can either use ``-v`` or ``-q``, but not both at the same "
"time:"
msgstr ""
"請注意用法文字中的細微差別。注意 ``[-v | -q]``，它告訴我們可以使用 ``-v`` 或 "
"``-q``，但不能同時使用："

#: ../../howto/argparse.rst:779 ../../howto/argparse.rst:806
msgid ""
"$ python prog.py --help\n"
"usage: prog.py [-h] [-v | -q] x y\n"
"\n"
"calculate X to the power of Y\n"
"\n"
"positional arguments:\n"
"  x              the base\n"
"  y              the exponent\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  -v, --verbose\n"
"  -q, --quiet"
msgstr ""
"$ python prog.py --help\n"
"usage: prog.py [-h] [-v | -q] x y\n"
"\n"
"calculate X to the power of Y\n"
"\n"
"positional arguments:\n"
"  x              the base\n"
"  y              the exponent\n"
"\n"
"options:\n"
"  -h, --help     show this help message and exit\n"
"  -v, --verbose\n"
"  -q, --quiet"

#: ../../howto/argparse.rst:797
msgid "How to translate the argparse output"
msgstr "如何翻譯 argparse 輸出"

#: ../../howto/argparse.rst:799
msgid ""
"The output of the :mod:`argparse` module such as its help text and error "
"messages are all made translatable using the :mod:`gettext` module. This "
"allows applications to easily localize messages produced by :mod:`argparse`. "
"See also :ref:`i18n-howto`."
msgstr ""
":mod:`argparse` 模組的輸出，例如幫助文字和錯誤訊息，都可以透過使用 :mod:"
"`gettext` 模組進行翻譯。這允許應用程式能輕鬆本地化 :mod:`argparse` 生成的訊"
"息。另請參閱 :ref:`i18n-howto`。"

#: ../../howto/argparse.rst:804
msgid "For instance, in this :mod:`argparse` output:"
msgstr "例如，在此 :mod:`argparse` 輸出中："

#: ../../howto/argparse.rst:822
msgid ""
"The strings ``usage:``, ``positional arguments:``, ``options:`` and ``show "
"this help message and exit`` are all translatable."
msgstr ""
"字串 ``usage:``、``positional arguments:``、``options:`` 和 ``show this help "
"message and exit`` 都是可被翻譯的。"

#: ../../howto/argparse.rst:825
msgid ""
"In order to translate these strings, they must first be extracted into a ``."
"po`` file. For example, using `Babel <https://babel.pocoo.org/>`__, run this "
"command:"
msgstr ""
"為了翻譯這些字串，必須先將它們提取到 ``.po`` 檔案中。例如，使用 `Babel "
"<https://babel.pocoo.org/>`__ 並執行下列命令："

#: ../../howto/argparse.rst:829
msgid "$ pybabel extract -o messages.po /usr/lib/python3.12/argparse.py"
msgstr "$ pybabel extract -o messages.po /usr/lib/python3.12/argparse.py"

#: ../../howto/argparse.rst:833
msgid ""
"This command will extract all translatable strings from the :mod:`argparse` "
"module and output them into a file named ``messages.po``. This command "
"assumes that your Python installation is in ``/usr/lib``."
msgstr ""
"此命令將從 :mod:`argparse` 模組中提取出所有可翻譯的字串，並將它們輸出到名為 "
"``messages.po`` 的檔案中。這個指令假設你的 Python 是安裝在 ``/usr/lib`` 中。"

#: ../../howto/argparse.rst:837
msgid ""
"You can find out the location of the :mod:`argparse` module on your system "
"using this script::"
msgstr "你可以使用以下腳本找到 :mod:`argparse` 模組在系統上的位置： ::"

#: ../../howto/argparse.rst:840
msgid ""
"import argparse\n"
"print(argparse.__file__)"
msgstr ""
"import argparse\n"
"print(argparse.__file__)"

#: ../../howto/argparse.rst:843
msgid ""
"Once the messages in the ``.po`` file are translated and the translations "
"are installed using :mod:`gettext`, :mod:`argparse` will be able to display "
"the translated messages."
msgstr ""
"一旦翻譯了 ``.po`` 檔案中的訊息並使用 :mod:`gettext` 安裝了翻譯，:mod:"
"`argparse` 將能夠顯示翻譯後的訊息。"

#: ../../howto/argparse.rst:847
msgid ""
"To translate your own strings in the :mod:`argparse` output, use :mod:"
"`gettext`."
msgstr "若要在 :mod:`argparse` 輸出中翻譯你自己的字串，請使用 :mod:`gettext`。"

#: ../../howto/argparse.rst:850
msgid "Custom type converters"
msgstr ""

#: ../../howto/argparse.rst:852
msgid ""
"The :mod:`argparse` module allows you to specify custom type converters for "
"your command-line arguments. This allows you to modify user input before "
"it's stored in the :class:`argparse.Namespace`. This can be useful when you "
"need to pre-process the input before it is used in your program."
msgstr ""

#: ../../howto/argparse.rst:857
msgid ""
"When using a custom type converter, you can use any callable that takes a "
"single string argument (the argument value) and returns the converted value. "
"However, if you need to handle more complex scenarios, you can use a custom "
"action class with the **action** parameter instead."
msgstr ""

#: ../../howto/argparse.rst:862
msgid ""
"For example, let's say you want to handle arguments with different prefixes "
"and process them accordingly::"
msgstr ""

#: ../../howto/argparse.rst:865
msgid ""
"import argparse\n"
"\n"
"parser = argparse.ArgumentParser(prefix_chars='-+')\n"
"\n"
"parser.add_argument('-a', metavar='<value>', action='http://github.com/append',\n"
"                    type=lambda x: ('-', x))\n"
"parser.add_argument('+a', metavar='<value>', action='http://github.com/append',\n"
"                    type=lambda x: ('+', x))\n"
"\n"
"args = parser.parse_args()\n"
"print(args)"
msgstr ""
"import argparse\n"
"\n"
"parser = argparse.ArgumentParser(prefix_chars='-+')\n"
"\n"
"parser.add_argument('-a', metavar='<value>', action='http://github.com/append',\n"
"                    type=lambda x: ('-', x))\n"
"parser.add_argument('+a', metavar='<value>', action='http://github.com/append',\n"
"                    type=lambda x: ('+', x))\n"
"\n"
"args = parser.parse_args()\n"
"print(args)"

#: ../../howto/argparse.rst:879
msgid ""
"$ python prog.py -a value1 +a value2\n"
"Namespace(a=[('-', 'value1'), ('+', 'value2')])"
msgstr ""
"$ python prog.py -a value1 +a value2\n"
"Namespace(a=[('-', 'value1'), ('+', 'value2')])"

#: ../../howto/argparse.rst:884
msgid "In this example, we:"
msgstr "在這個範例當中，我們："

#: ../../howto/argparse.rst:886
msgid ""
"Created a parser with custom prefix characters using the ``prefix_chars`` "
"parameter."
msgstr ""

#: ../../howto/argparse.rst:889
msgid ""
"Defined two arguments, ``-a`` and ``+a``, which used the ``type`` parameter "
"to create custom type converters to store the value in a tuple with the "
"prefix."
msgstr ""

#: ../../howto/argparse.rst:892
msgid ""
"Without the custom type converters, the arguments would have treated the ``-"
"a`` and ``+a`` as the same argument, which would have been undesirable. By "
"using custom type converters, we were able to differentiate between the two "
"arguments."
msgstr ""

#: ../../howto/argparse.rst:897
msgid "Conclusion"
msgstr "結論"

#: ../../howto/argparse.rst:899
msgid ""
"The :mod:`argparse` module offers a lot more than shown here. Its docs are "
"quite detailed and thorough, and full of examples. Having gone through this "
"tutorial, you should easily digest them without feeling overwhelmed."
msgstr ""
":mod:`argparse` 模組提供的功能比此篇內容的要多得多。它的文件非常詳細與透徹並"
"有很多範例。讀完本教學後，你應該可以輕鬆消化它們，而不會感到不知所措。"