argparse.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2023, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2023
#
#,fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.11\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-09-15 14:42+0000\n"
"PO-Revision-Date: 2023-05-24 02:11+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2023\n"
"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

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

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

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

#:../../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""
"There are two other modules that fulfill the same task, namely :mod:`getopt`"
" (an equivalent for ``getopt()`` from the C language) and the deprecated "
":mod:`optparse`. Note also that :mod:`argparse` is based on :mod:`optparse`,"
" and therefore very similar in terms of usage."
msgstr""
"还有另外两个模块可以完成同样的任务，即 :mod:`getopt` (等价于 C 语言中的 ``getopt()``) 和已被弃用的 "
":mod:`optparse`。 还要注意 :mod:`argparse` 是基于 :mod:`optparse` 的，因此用法与其非常相似。"

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

#:../../howto/argparse.rst:26
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:48
msgid"A few concepts we can learn from the four commands:"
msgstr"我们可以从这四个命令中学到几个概念："

#:../../howto/argparse.rst:50
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:53
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:62
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:66
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:72
msgid"The basics"
msgstr"基础"

#:../../howto/argparse.rst:74
msgid"Let us start with a very simple example which does (almost) nothing::"
msgstr"让我们从一个简单到（几乎）什么也做不了的例子开始："

#:../../howto/argparse.rst:80../../howto/argparse.rst:188
#:../../howto/argparse.rst:209
msgid"Following is a result of running the code:"
msgstr"以下是该代码的运行结果："

#:../../howto/argparse.rst:97../../howto/argparse.rst:254
#:../../howto/argparse.rst:298
msgid"Here is what is happening:"
msgstr"程序运行情况如下："

#:../../howto/argparse.rst:99
msgid""
"Running the script without any options results in nothing displayed to "
"stdout. Not so useful."
msgstr"在没有任何选项的情况下运行脚本不会在标准输出显示任何内容。这没有什么用处。"

#:../../howto/argparse.rst:102
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:105
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:112
msgid"Introducing Positional arguments"
msgstr"位置参数介绍"

#:../../howto/argparse.rst:114
msgid"An example::"
msgstr"举个例子："

#:../../howto/argparse.rst:122
msgid"And running the code:"
msgstr"运行此程序："

#:../../howto/argparse.rst:140
msgid"Here is what's happening:"
msgstr"程序运行情况如下："

#:../../howto/argparse.rst:142
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:146
msgid"Calling our program now requires us to specify an option."
msgstr"现在调用我们的程序必须要指定一个选项。"

#:../../howto/argparse.rst:148
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:151
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:156
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:167
msgid"And we get:"
msgstr"然后我们得到："

#:../../howto/argparse.rst:180
msgid"Now, how about doing something even more useful::"
msgstr"现在，来做一些更有用的事情："

#:../../howto/argparse.rst:198
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:219
msgid""
"That went well. The program now even helpfully quits on bad illegal input "
"before proceeding."
msgstr"做得不错。当这个程序在收到错误的无效的输入时，它甚至能在执行计算之前先退出，还能显示很有帮助的错误信息。"

#:../../howto/argparse.rst:224
msgid"Introducing Optional arguments"
msgstr"可选参数介绍"

#:../../howto/argparse.rst:226
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:236../../howto/argparse.rst:282
#:../../howto/argparse.rst:398../../howto/argparse.rst:432
msgid"And the output:"
msgstr"和输出："

#:../../howto/argparse.rst:256
msgid""
"The program is written so as to display something when ``--verbosity`` is "
"specified and display nothing when not."
msgstr"这一程序被设计为当指定 ``--verbosity`` 选项时显示某些东西，否则不显示。"

#:../../howto/argparse.rst:259
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:265
msgid"The help message is a bit different."
msgstr"帮助信息有点不同。"

#:../../howto/argparse.rst:267
msgid""
"When using the ``--verbosity`` option, one must also specify some value, any"
" value."
msgstr"使用 ``--verbosity`` 选项时，必须指定一个值，但可以是任何值。"

#:../../howto/argparse.rst:270
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:300
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:307
msgid""
"It complains when you specify a value, in true spirit of what flags actually"
" are."
msgstr"当你为其指定一个值时，它会报错，符合作为标志的真正的精神。"

#:../../howto/argparse.rst:310
msgid"Notice the different help text."
msgstr"留意不同的帮助文字。"

#:../../howto/argparse.rst:314
msgid"Short options"
msgstr"短选项"

#:../../howto/argparse.rst:316
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:328
msgid"And here goes:"
msgstr"效果就像这样："

#:../../howto/argparse.rst:341
msgid"Note that the new ability is also reflected in the help text."
msgstr"可以注意到，这一新的能力也反映在帮助文本里。"

#:../../howto/argparse.rst:345
msgid"Combining Positional and Optional arguments"
msgstr"结合位置参数和可选参数"

#:../../howto/argparse.rst:347
msgid"Our program keeps growing in complexity::"
msgstr"我们的程序变得越来越复杂了："

#:../../howto/argparse.rst:362
msgid"And now the output:"
msgstr"接着是输出："

#:../../howto/argparse.rst:376
msgid"We've brought back a positional argument, hence the complaint."
msgstr"我们带回了一个位置参数，结果发生了报错。"

#:../../howto/argparse.rst:378
msgid"Note that the order does not matter."
msgstr"注意顺序无关紧要。"

#:../../howto/argparse.rst:380
msgid""
"How about we give this program of ours back the ability to have multiple "
"verbosity values, and actually get to use them::"
msgstr"给我们的程序加上接受多个冗长度的值，然后实际来用用："

#:../../howto/argparse.rst:414
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""
"除了最后一个，看上去都不错。最后一个暴露了我们的程序中有一个 bug。我们可以通过限制 ``--verbosity`` 选项可以接受的值来修复它："

#:../../howto/argparse.rst:450
msgid""
"Note that the change also reflects both in the error message as well as the "
"help string."
msgstr"注意这一改变同时反应在错误信息和帮助信息里。"

#:../../howto/argparse.rst:453
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:472
msgid""
"We have introduced another action, \"count\", to count the number of "
"occurrences of specific options."
msgstr"我们引入了另一种动作 \"count\"，来统计特定选项出现的次数。"

#:../../howto/argparse.rst:501
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:504
msgid"It also behaves similar to \"store_true\" action."
msgstr"它也表现得与 “store_true” 的行为相似。"

#:../../howto/argparse.rst:506
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:509
msgid""
"And if you don't specify the ``-v`` flag, that flag is considered to have "
"``None`` value."
msgstr"如果你不添加 ``-v`` 标志，这一标志的值会是 ``None``。"

#:../../howto/argparse.rst:512
msgid""
"As should be expected, specifying the long form of the flag, we should get "
"the same output."
msgstr"如期望的那样，添加该标志的长形态能够获得相同的输出。"

#:../../howto/argparse.rst:515
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:519
msgid"That last output exposes a bug in our program."
msgstr"最后一个输出暴露了我们程序中的一个 bug。"

#:../../howto/argparse.rst:522
msgid"Let's fix::"
msgstr"让我们修复一下："

#:../../howto/argparse.rst:541
msgid"And this is what it gives:"
msgstr"这是它给我们的输出："

#:../../howto/argparse.rst:556
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"第一组输出很好，修复了之前的 bug。也就是说，我们希望任何 >= 2 的值尽可能详尽。"

#:../../howto/argparse.rst:559
msgid"Third output not so good."
msgstr"第三组输出并不理想。"

#:../../howto/argparse.rst:561
msgid"Let's fix that bug::"
msgstr"让我们修复那个 bug："

#:../../howto/argparse.rst:578
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`` "
"来让它可以与其他整数值相互比较。记住，默认情况下如果一个可选参数没有被指定，它的值会是 ``None``，并且它不能和整数值相比较（所以产生了 "
":exc:`TypeError` 异常）。"

#:../../howto/argparse.rst:585
msgid"And:"
msgstr"然后："

#:../../howto/argparse.rst:592
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:599
msgid"Getting a little more advanced"
msgstr"进行一些小小的改进"

#:../../howto/argparse.rst:601
msgid""
"What if we wanted to expand our tiny program to perform other powers, not "
"just squares::"
msgstr"如果我们想扩展我们的简短程序来执行其他幂次的运算，而不仅是乘方::"

#:../../howto/argparse.rst:618../../howto/argparse.rst:656
msgid"Output:"
msgstr"输出："

#:../../howto/argparse.rst:639
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:670
msgid"Conflicting options"
msgstr"矛盾的选项"

#:../../howto/argparse.rst:672
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:698
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:716
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:720
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:741
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:763
msgid"How to translate the argparse output"
msgstr"如何翻译 argparse 的输出"

#:../../howto/argparse.rst:765
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:770
msgid"For instance, in this :mod:`argparse` output:"
msgstr"例如，在这个 :mod:`argparse` 输出中:"

#:../../howto/argparse.rst:788
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:791
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:799
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:803
msgid""
"You can find out the location of the :mod:`argparse` module on your system "
"using this script::"
msgstr"你可以使用以下脚本查找 :mod:`argparse` 模块在系统中的位置："

#:../../howto/argparse.rst:809
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:813
msgid""
"To translate your own strings in the :mod:`argparse` output, use "
":mod:`gettext`."
msgstr"要翻译在 :mod:`argparse` 输出中的字符串，请使用 :mod:`gettext`。"

#:../../howto/argparse.rst:816
msgid"Conclusion"
msgstr"后记"

#:../../howto/argparse.rst:818
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` 模块还提供了更多功能。 它的文档相当详细和完整，包含大量示例。 "
"完成这个教程之后，你应该能毫不困难地阅读该文档。"