argparse.po

# 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:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Danial Behzadi <dani.behzi@ubuntu.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# arman mohebali <armanmohebali@outlook.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-01 14:41+0330\n"
"PO-Revision-Date: 2026-09-21 13:27+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid ":mod:`!argparse` --- Parser for command-line options, arguments and subcommands"
msgstr ":mod:`!argparse` --- پارسر برای گزینه‌ها، آرگومان‌ها و زیرفرمان‌های خط فرمان"

msgid "**Source code:** :source:`Lib/argparse.py`"
msgstr "**کد منبع:** :source:`Lib/argparse.py`"

msgid "While :mod:`!argparse` is the default recommended standard library module for implementing basic command line applications, authors with more exacting requirements for exactly how their command line applications behave may find it doesn't provide the necessary level of control. Refer to :ref:`choosing-an-argument-parser` for alternatives to consider when ``argparse`` doesn't support behaviors that the application requires (such as entirely disabling support for interspersed options and positional arguments, or accepting option parameter values that start with ``-`` even when they correspond to another defined option)."
msgstr "در حالی که :mod:`!argparse` به‌طور پیش‌فرض به‌عنوان ماژول کتابخانه استاندارد برای پیاده‌سازی برنامه‌های پایه خط فرمان توصیه می‌شود، نویسندگانی که الزامات دقیق‌تری درباره نحوه دقیق رفتار برنامه‌های خط فرمان خود دارند، ممکن است دریابند که این ماژول سطح کنترل لازم را فراهم نمی‌کند. برای جایگزین‌های قابل بررسی در مواردی که ``argparse`` از رفتارهای مورد نیاز برنامه پشتیبانی نمی‌کند، به :ref:`choosing-an-argument-parser` مراجعه کنید (مانند غیرفعال کردن کامل پشتیبانی از درهم‌آمیختن گزینه‌ها و آرگومان‌های جایگاهی، یا پذیرفتن مقادیر پارامتر گزینه‌ها که با ``-`` شروع می‌شوند، حتی زمانی که با گزینه تعریف‌شده دیگری مطابقت دارند)."

msgid "Tutorial"
msgstr "آموزش"

msgid "This page contains the API reference information. For a more gentle introduction to Python command-line parsing, have a look at the :ref:`argparse tutorial <argparse-tutorial>`."
msgstr "این صفحه حاوی اطلاعات مرجع API است. برای آشنایی ملایم‌تر با تجزیه‌ی خط فرمان در پایتون، به :ref:`آموزش argparse <argparse-tutorial>` نگاهی بیندازید."

msgid "The :mod:`!argparse` module makes it easy to write user-friendly command-line interfaces. The program defines what arguments it requires, and :mod:`!argparse` will figure out how to parse those out of :data:`sys.argv`.  The :mod:`!argparse` module also automatically generates help and usage messages.  The module will also issue errors when users give the program invalid arguments."
msgstr "ماژول :mod:`!argparse` نوشتن رابط‌های خط فرمان کاربرپسند را آسان می‌کند. برنامه آرگومان‌هایی را که نیاز دارد تعریف می‌کند، و :mod:`!argparse` نحوه‌ی تجزیه‌ی آن‌ها از :data:`sys.argv` را تشخیص می‌دهد. ماژول :mod:`!argparse` همچنین به‌طور خودکار پیام‌های راهنما و کاربرد را تولید می‌کند. این ماژول همچنین زمانی که کاربران آرگومان‌های نامعتبر به برنامه بدهند، خطا نشان می‌دهد."

msgid "The :mod:`!argparse` module's support for command-line interfaces is built around an instance of :class:`argparse.ArgumentParser`.  It is a container for argument specifications and has options that apply to the parser as whole::"
msgstr "پشتیبانی ماژول :mod:`!argparse` از رابط‌های خط فرمان بر پایه‌ی نمونه‌ای از :class:`argparse.ArgumentParser` ساخته شده است. این کلاس ظرفی برای مشخصات آرگومان‌ها است و گزینه‌هایی دارد که به پارسر به‌عنوان یک کل اعمال می‌شوند::"

msgid ""
"parser = argparse.ArgumentParser(\n"
"                    prog='ProgramName',\n"
"                    description='What the program does',\n"
"                    epilog='Text at the bottom of help')"
msgstr ""
"parser = argparse.ArgumentParser(\n"
"                    prog='ProgramName',\n"
"                    description='What the program does',\n"
"                    epilog='Text at the bottom of help')"

msgid "The :meth:`ArgumentParser.add_argument` method attaches individual argument specifications to the parser.  It supports positional arguments, options that accept values, and on/off flags::"
msgstr "متد :meth:`ArgumentParser.add_argument` مشخصات آرگومان‌ها را به‌صورت جداگانه به پارسر اضافه می‌کند. این متد از آرگومان‌های جایگاهی، گزینه‌هایی که مقدار می‌پذیرند و پرچم‌های روشن/خاموش پشتیبانی می‌کند::"

msgid ""
"parser.add_argument('filename')           # positional argument\n"
"parser.add_argument('-c', '--count')      # option that takes a value\n"
"parser.add_argument('-v', '--verbose',\n"
"                    action='store_true')  # on/off flag"
msgstr ""
"parser.add_argument('filename')           # positional argument\n"
"parser.add_argument('-c', '--count')      # option that takes a value\n"
"parser.add_argument('-v', '--verbose',\n"
"                    action='store_true')  # on/off flag"

msgid "The :meth:`ArgumentParser.parse_args` method runs the parser and places the extracted data in a :class:`argparse.Namespace` object::"
msgstr "متد :meth:`ArgumentParser.parse_args` پارسر را اجرا می‌کند و داده‌های استخراج‌شده را در یک شیء :class:`argparse.Namespace` قرار می‌دهد::"

msgid ""
"args = parser.parse_args()\n"
"print(args.filename, args.count, args.verbose)"
msgstr ""
"args = parser.parse_args()\n"
"print(args.filename, args.count, args.verbose)"

msgid "If you're looking for a guide about how to upgrade :mod:`optparse` code to :mod:`!argparse`, see :ref:`Upgrading Optparse Code <upgrading-optparse-code>`."
msgstr "اگر به دنبال راهنمایی درباره چگونگی ارتقای کد :mod:`optparse` به :mod:`!argparse` هستید، :ref:`ارتقای کد Optparse <upgrading-optparse-code>` را ببینید."

msgid "ArgumentParser objects"
msgstr "اشیای ArgumentParser"

msgid "Create a new :class:`ArgumentParser` object. All parameters should be passed as keyword arguments. Each parameter has its own more detailed description below, but in short they are:"
msgstr "یک شیء :class:`ArgumentParser` جدید ایجاد کنید. همه پارامترها باید به‌صورت آرگومان‌های کلیدواژه‌ای ارسال شوند. هر پارامتر توضیح مفصل‌تری در زیر دارد، اما به‌طور خلاصه آن‌ها عبارتند از:"

msgid "prog_ - The name of the program (default: generated from the ``__main__`` module attributes and ``sys.argv[0]``)"
msgstr "prog_ - نام برنامه (پیش‌فرض: از ویژگی‌های ماژول ``__main__`` و ``sys.argv[0]`` تولید می‌شود)"

msgid "usage_ - The string describing the program usage (default: generated from arguments added to parser)"
msgstr "usage_ - رشته‌ای که کاربرد برنامه را توصیف می‌کند (پیش‌فرض: از آرگومان‌های اضافه‌شده به پارسر تولید می‌شود)"

msgid "description_ - Text to display before the argument help (by default, no text)"
msgstr "description_ - متن برای نمایش پیش از راهنمای آرگومان (به‌طور پیش‌فرض، بدون متن)"

msgid "epilog_ - Text to display after the argument help (by default, no text)"
msgstr "epilog_ - متنی که پس از راهنمای آرگومان نمایش داده می‌شود (به‌طور پیش‌فرض، بدون متن)"

msgid "parents_ - A list of :class:`ArgumentParser` objects whose arguments should also be included"
msgstr "parents_ - فهرستی از اشیای :class:`ArgumentParser` که آرگومان‌های آن‌ها نیز باید گنجانده شوند"

msgid "formatter_class_ - A class for customizing the help output"
msgstr "formatter_class_ - کلاسی برای سفارشی‌سازی خروجی راهنما"

msgid "prefix_chars_ - The set of characters that prefix optional arguments (default: '-')"
msgstr "prefix_chars_ - مجموعه‌ای از نویسه‌ها که پیشوند آرگومان‌های اختیاری را تشکیل می‌دهند (پیش‌فرض: '-')"

msgid "fromfile_prefix_chars_ - The set of characters that prefix files from which additional arguments should be read (default: ``None``)"
msgstr "fromfile_prefix_chars_ - مجموعه‌ای از نویسه‌ها که پیشوند پرونده‌هایی هستند که آرگومان‌های اضافی باید از آن‌ها خوانده شوند (پیش‌فرض: ``None``)"

msgid "argument_default_ - The global default value for arguments (default: ``None``)"
msgstr "argument_default_ - مقدار پیش‌فرض سراسری برای آرگومان‌ها (پیش‌فرض: ``None``)"

msgid "conflict_handler_ - The strategy for resolving conflicting optionals (usually unnecessary)"
msgstr "conflict_handler_ - راهبرد رفع تعارض گزینه‌های اختیاری (معمولاً غیرضروری)"

msgid "add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)"
msgstr "add_help_ - افزودن گزینه ``-h/--help`` به پارسر (پیش‌فرض: ``True``)"

msgid "allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is unambiguous (default: ``True``)"
msgstr "allow_abbrev_ - اجازه می‌دهد گزینه‌های بلند مخفف شوند، مشروط بر اینکه مخفف بدون ابهام باشد (پیش‌فرض: ``True``)"

msgid "exit_on_error_ - Determines whether or not :class:`!ArgumentParser` exits with error info when an error occurs. (default: ``True``)"
msgstr "exit_on_error_ - تعیین می‌کند که آیا :class:`!ArgumentParser` هنگام بروز خطا همراه با اطلاعات خطا خارج می‌شود یا خیر. (پیش‌فرض: ``True``)"

msgid "suggest_on_error_ - Enables suggestions for mistyped argument choices and subparser names (default: ``True``)"
msgstr "suggest_on_error_ - پیشنهادها را برای انتخاب‌های آرگومان تایپ‌شده‌ی اشتباه و نام‌های زیرپارسر فعال می‌کند (پیش‌فرض: ``True``)"

msgid "color_ - Allow color output (default: ``True``)"
msgstr "color_ - اجازه دادن به خروجی رنگی (پیش‌فرض: ``True``)"

msgid "*allow_abbrev* parameter was added."
msgstr "پارامتر *allow_abbrev* افزوده شد."

msgid "In previous versions, *allow_abbrev* also disabled grouping of short flags such as ``-vv`` to mean ``-v -v``."
msgstr "در نسخه‌های پیشین، *allow_abbrev* گروه‌بندی پرچم‌های کوتاه مانند ``-vv`` به معنای ``-v -v`` را نیز غیرفعال می‌کرد."

msgid "*exit_on_error* parameter was added."
msgstr "پارامتر *exit_on_error* اضافه شد."

msgid "*suggest_on_error* and *color* parameters were added."
msgstr "پارامترهای *suggest_on_error* و *color* افزوده شدند."

msgid "*suggest_on_error* default changed to ``True``."
msgstr "مقدار پیش‌فرض *suggest_on_error* به ``True`` تغییر یافت."

msgid "The following sections describe how each of these are used."
msgstr "بخش‌های زیر چگونگی استفاده از هر یک از این موارد را شرح می‌دهند."

msgid "prog"
msgstr "prog"

msgid "By default, :class:`ArgumentParser` calculates the name of the program to display in help messages depending on the way the Python interpreter was run:"
msgstr "به‌طور پیش‌فرض، :class:`ArgumentParser` نام برنامه را برای نمایش در پیام‌های راهنما، بسته به شیوه‌ای که مفسر پایتون اجرا شده است، محاسبه می‌کند:"

msgid "The :func:`base name <os.path.basename>` of ``sys.argv[0]`` if a file was passed as argument."
msgstr ":func:`نام پایه <os.path.basename>` برای ``sys.argv[0]``، اگر پرونده‌ای به‌عنوان آرگومان داده شده باشد."

msgid "The Python interpreter name followed by ``sys.argv[0]`` if a directory or a zipfile was passed as argument."
msgstr "نام مفسر پایتون که پس از آن ``sys.argv[0]`` می‌آید، در صورتی که یک پوشه یا یک پرونده زیپ به‌عنوان آرگومان داده شده باشد."

msgid "The Python interpreter name followed by ``-m`` followed by the module or package name if the :option:`-m` option was used."
msgstr "نام مفسر پایتون، به‌دنبالِ ``-m`` و سپس نام ماژول یا بسته، در صورتی که گزینه‌ی :option:`-m` استفاده شده باشد."

msgid "This default is almost always desirable because it will make the help messages match the string that was used to invoke the program on the command line. However, to change this default behavior, another value can be supplied using the ``prog=`` argument to :class:`ArgumentParser`::"
msgstr "این پیش‌فرض تقریباً همیشه مطلوب است، زیرا باعث می‌شود پیام‌های راهنما با رشته‌ای که برنامه با آن در خط فرمان فراخوانی شده است مطابقت داشته باشند. با این حال، برای تغییر این رفتار پیش‌فرض، می‌توان مقدار دیگری را با استفاده از آرگومان ``prog=`` برای :class:`ArgumentParser`:: ارائه کرد:"

msgid ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"

msgid "Note that the program name, whether determined from ``sys.argv[0]``, from the ``__main__`` module attributes or from the ``prog=`` argument, is available to help messages using the ``%(prog)s`` format specifier."
msgstr "توجه داشته باشید که نام برنامه، چه از ``sys.argv[0]``، چه از ویژگی‌های ماژول ``__main__`` و چه از آرگومان ``prog=`` تعیین شده باشد، در پیام‌های راهنما از طریق مشخص‌کننده‌ی قالب ``%(prog)s`` در دسترس است."

msgid ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.add_argument('--foo', help='foo of the %(prog)s program')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   foo of the myprogram program"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='myprogram')\n"
">>> parser.add_argument('--foo', help='foo of the %(prog)s program')\n"
">>> parser.print_help()\n"
"usage: myprogram [-h] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   foo of the myprogram program"

msgid "The default ``prog`` value now reflects how ``__main__`` was actually executed, rather than always being ``os.path.basename(sys.argv[0])``."
msgstr "مقدار پیش‌فرض ``prog`` اکنون نشان می‌دهد که ``__main__`` واقعاً چگونه اجرا شده است، به‌جای آنکه همیشه ``os.path.basename(sys.argv[0])`` باشد."

msgid "usage"
msgstr "استفاده"

msgid "By default, :class:`ArgumentParser` calculates the usage message from the arguments it contains. The default message can be overridden with the ``usage=`` keyword argument::"
msgstr "به‌طور پیش‌فرض، :class:`ArgumentParser` پیام استفاده را بر اساس آرگومان‌های خود محاسبه می‌کند. پیام پیش‌فرض را می‌توان با آرگومان کلیدواژه‌ای ``usage=`` بازنویسی کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')\n"
">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"
">>> parser.add_argument('bar', nargs='+', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [options]\n"
"\n"
"positional arguments:\n"
" bar          bar help\n"
"\n"
"options:\n"
" -h, --help   show this help message and exit\n"
" --foo [FOO]  foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')\n"
">>> parser.add_argument('--foo', nargs='?', help='foo help')\n"
">>> parser.add_argument('bar', nargs='+', help='bar help')\n"
">>> parser.print_help()\n"
"usage: PROG [options]\n"
"\n"
"positional arguments:\n"
" bar          bar help\n"
"\n"
"options:\n"
" -h, --help   show this help message and exit\n"
" --foo [FOO]  foo help"

msgid "The ``%(prog)s`` format specifier is available to fill in the program name in your usage messages."
msgstr "مشخص‌کننده قالب ``%(prog)s`` برای جایگذاری نام برنامه در پیام‌های کاربرد شما در دسترس است."

msgid "When a custom usage message is specified for the main parser, you may also want to consider passing  the ``prog`` argument to :meth:`~ArgumentParser.add_subparsers` or the ``prog`` and the ``usage`` arguments to :meth:`~_SubParsersAction.add_parser`, to ensure consistent command prefixes and usage information across subparsers."
msgstr "هنگامی که پیام کاربرد سفارشی برای پارسر اصلی تعیین می‌شود، ممکن است بخواهید برای اطمینان از سازگاری پیشوندهای فرمان و اطلاعات کاربرد در میان پارسرهای فرعی، ارسال آرگومان ``prog`` به :meth:`~ArgumentParser.add_subparsers` یا آرگومان‌های ``prog`` و ``usage`` به :meth:`~_SubParsersAction.add_parser` را نیز در نظر بگیرید."

msgid "description"
msgstr "توضیحات"

msgid "Most calls to the :class:`ArgumentParser` constructor will use the ``description=`` keyword argument.  This argument gives a brief description of what the program does and how it works.  In help messages, the description is displayed between the command-line usage string and the help messages for the various arguments."
msgstr "در بیشتر فراخوانی‌های سازنده‌ی :class:`ArgumentParser`، از آرگومان کلیدواژه‌ای ``description=`` استفاده می‌شود. این آرگومان شرح مختصری از آنچه برنامه انجام می‌دهد و چگونگی کار آن ارائه می‌دهد. در پیام‌های راهنما، شرح بین رشته‌ی کاربرد خط فرمان و پیام‌های راهنمای آرگومان‌های مختلف نمایش داده می‌شود."

msgid "By default, the description will be line-wrapped so that it fits within the given space.  To change this behavior, see the formatter_class_ argument."
msgstr "به‌طور پیش‌فرض، سطرهای شرح شکسته می‌شوند تا در فضای داده‌شده بگنجند. برای تغییر این رفتار، آرگومان formatter_class_ را ببینید."

msgid "epilog"
msgstr "epilog"

msgid "Some programs like to display additional description of the program after the description of the arguments.  Such text can be specified using the ``epilog=`` argument to :class:`ArgumentParser`::"
msgstr "برخی برنامه‌ها تمایل دارند توضیحات تکمیلی برنامه را پس از توضیح آرگومان‌ها نمایش دهند. چنین متنی را می‌توان با استفاده از آرگومان ``epilog=`` برای :class:`ArgumentParser` مشخص کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     description='A foo that bars',\n"
"...     epilog=\"And that's how you'd foo a bar\")\n"
">>> parser.print_help()\n"
"usage: argparse.py [-h]\n"
"\n"
"A foo that bars\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"And that's how you'd foo a bar"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     description='A foo that bars',\n"
"...     epilog=\"And that's how you'd foo a bar\")\n"
">>> parser.print_help()\n"
"usage: argparse.py [-h]\n"
"\n"
"A foo that bars\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"And that's how you'd foo a bar"

msgid "As with the description_ argument, the ``epilog=`` text is by default line-wrapped, but this behavior can be adjusted with the formatter_class_ argument to :class:`ArgumentParser`."
msgstr "همانند آرگومان description_، متن ``epilog=`` به‌طور پیش‌فرض در عرض خط شکسته می‌شود، اما این رفتار را می‌توان با آرگومان formatter_class_ برای :class:`ArgumentParser` تنظیم کرد."

msgid "parents"
msgstr "والدین"

msgid "Sometimes, several parsers share a common set of arguments. Rather than repeating the definitions of these arguments, a single parser with all the shared arguments and passed to ``parents=`` argument to :class:`ArgumentParser` can be used.  The ``parents=`` argument takes a list of :class:`ArgumentParser` objects, collects all the positional and optional actions from them, and adds these actions to the :class:`ArgumentParser` object being constructed::"
msgstr "گاهی چند پارسر مجموعه‌ای مشترک از آرگومان‌ها دارند. به‌جای تکرار تعاریف این آرگومان‌ها، می‌توان از یک پارسر واحد استفاده کرد که همه‌ی آرگومان‌های مشترک را دارد و به‌عنوان مقدار آرگومان ``parents=`` به :class:`ArgumentParser` ارسال می‌شود. آرگومان ``parents=`` فهرستی از اشیاء :class:`ArgumentParser` را می‌پذیرد، همه‌ی کنش‌های جایگاهی و اختیاری (actions) را از آن‌ها جمع‌آوری می‌کند و این کنش‌ها را به شیء :class:`ArgumentParser` که در حال ساخت است اضافه می‌کند::"

msgid ""
">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"
">>> parent_parser.add_argument('--parent', type=int)\n"
"\n"
">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> foo_parser.add_argument('foo')\n"
">>> foo_parser.parse_args(['--parent', '2', 'XXX'])\n"
"Namespace(foo='XXX', parent=2)\n"
"\n"
">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> bar_parser.add_argument('--bar')\n"
">>> bar_parser.parse_args(['--bar', 'YYY'])\n"
"Namespace(bar='YYY', parent=None)"
msgstr ""
">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"
">>> parent_parser.add_argument('--parent', type=int)\n"
"\n"
">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> foo_parser.add_argument('foo')\n"
">>> foo_parser.parse_args(['--parent', '2', 'XXX'])\n"
"Namespace(foo='XXX', parent=2)\n"
"\n"
">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"
">>> bar_parser.add_argument('--bar')\n"
">>> bar_parser.parse_args(['--bar', 'YYY'])\n"
"Namespace(bar='YYY', parent=None)"

msgid "Note that most parent parsers will specify ``add_help=False``.  Otherwise, the :class:`ArgumentParser` will see two ``-h/--help`` options (one in the parent and one in the child) and raise an error."
msgstr "توجه داشته باشید که بیشتر پارسرهای والد ``add_help=False`` را تعیین می‌کنند. در غیر این صورت، :class:`ArgumentParser` دو گزینه ``-h/--help`` (یکی در والد و دیگری در فرزند) را می‌بیند و خطایی پرتاب می‌کند."

msgid "You must fully initialize the parsers before passing them via ``parents=``. If you change the parent parsers after the child parser, those changes will not be reflected in the child."
msgstr "شما باید پارسرها را پیش از انتقال آن‌ها از طریق ``parents=`` به‌طور کامل مقداردهی اولیه کنید. اگر پارسرهای والد را پس از پارسر فرزند تغییر دهید، آن تغییرات در فرزند بازتاب نخواهند یافت."

msgid "formatter_class"
msgstr "formatter_class"

msgid ":class:`ArgumentParser` objects allow the help formatting to be customized by specifying an alternate formatting class.  Currently, there are four such classes:"
msgstr "اشیای :class:`ArgumentParser` امکان سفارشی‌سازی قالب‌بندی راهنما را با مشخص کردن یک کلاس قالب‌بندی جایگزین فراهم می‌کنند. در حال حاضر، چهار کلاس از این دست وجود دارد:"

msgid ":class:`RawDescriptionHelpFormatter` and :class:`RawTextHelpFormatter` give more control over how textual descriptions are displayed. By default, :class:`ArgumentParser` objects line-wrap the description_ and epilog_ texts in command-line help messages::"
msgstr ":class:`RawDescriptionHelpFormatter` و :class:`RawTextHelpFormatter` کنترل بیشتری بر چگونگی نمایش توضیحات متنی فراهم می‌کنند. به‌طور پیش‌فرض، اشیاء :class:`ArgumentParser` متن‌های description_ و epilog_ را در پیام‌های راهنمای خط فرمان با شکستن سطرها قالب‌بندی می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     description='''this description\n"
"...         was indented weird\n"
"...             but that is okay''',\n"
"...     epilog='''\n"
"...             likewise for this epilog whose whitespace will\n"
"...         be cleaned up and whose words will be wrapped\n"
"...         across a couple lines''')\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"this description was indented weird but that is okay\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"likewise for this epilog whose whitespace will be cleaned up and whose words\n"
"will be wrapped across a couple lines"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     description='''this description\n"
"...         was indented weird\n"
"...             but that is okay''',\n"
"...     epilog='''\n"
"...             likewise for this epilog whose whitespace will\n"
"...         be cleaned up and whose words will be wrapped\n"
"...         across a couple lines''')\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"this description was indented weird but that is okay\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
"\n"
"likewise for this epilog whose whitespace will be cleaned up and whose words\n"
"will be wrapped across a couple lines"

msgid "Passing :class:`RawDescriptionHelpFormatter` as ``formatter_class=`` indicates that description_ and epilog_ are already correctly formatted and should not be line-wrapped::"
msgstr "ارسال :class:`RawDescriptionHelpFormatter` به‌عنوان ``formatter_class=`` نشان می‌دهد که description_ و epilog_ از قبل به‌درستی قالب‌بندی شده‌اند و نباید سطرهای آن‌ها شکسته شوند::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description=textwrap.dedent('''\\\n"
"...         Please do not mess up this text!\n"
"...         --------------------------------\n"
"...             I have indented it\n"
"...             exactly the way\n"
"...             I want it\n"
"...         '''))\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"Please do not mess up this text!\n"
"--------------------------------\n"
"   I have indented it\n"
"   exactly the way\n"
"   I want it\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description=textwrap.dedent('''\\\n"
"...         Please do not mess up this text!\n"
"...         --------------------------------\n"
"...             I have indented it\n"
"...             exactly the way\n"
"...             I want it\n"
"...         '''))\n"
">>> parser.print_help()\n"
"usage: PROG [-h]\n"
"\n"
"Please do not mess up this text!\n"
"--------------------------------\n"
"   I have indented it\n"
"   exactly the way\n"
"   I want it\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit"

msgid ":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help text, including argument descriptions. However, multiple newlines are replaced with one. If you wish to preserve multiple blank lines, add spaces between the newlines."
msgstr ":class:`RawTextHelpFormatter` فضای سفید را برای همه‌ی انواع متن‌های راهنما، از جمله توضیحات آرگومان‌ها حفظ می‌کند. با این حال، چندین خط جدید با یک خط جدید جایگزین می‌شوند. اگر می‌خواهید چندین خط خالی حفظ شوند، بین سطرهای جدید فاصله اضافه کنید."

msgid ":class:`ArgumentDefaultsHelpFormatter` automatically adds information about default values to each of the argument help messages::"
msgstr ":class:`ArgumentDefaultsHelpFormatter` به‌طور خودکار اطلاعات مربوط به مقادیر پیش‌فرض را به هر یک از پیام‌های راهنمای آرگومان اضافه می‌کند::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\n"
">>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo FOO] [bar ...]\n"
"\n"
"positional arguments:\n"
" bar         BAR! (default: [1, 2, 3])\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   FOO! (default: 42)"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\n"
">>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo FOO] [bar ...]\n"
"\n"
"positional arguments:\n"
" bar         BAR! (default: [1, 2, 3])\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" --foo FOO   FOO! (default: 42)"

msgid ":class:`MetavarTypeHelpFormatter` uses the name of the type_ argument for each argument as the display name for its values (rather than using the dest_ as the regular formatter does)::"
msgstr ":class:`MetavarTypeHelpFormatter` از نام آرگومان type_ برای هر آرگومان به‌عنوان نام نمایشی برای مقدارهای آن استفاده می‌کند (به‌جای استفاده از dest_ آن‌گونه که قالب‌بند معمولی انجام می‌دهد)::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.MetavarTypeHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', type=float)\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo int] float\n"
"\n"
"positional arguments:\n"
"  float\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo int"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     prog='PROG',\n"
"...     formatter_class=argparse.MetavarTypeHelpFormatter)\n"
">>> parser.add_argument('--foo', type=int)\n"
">>> parser.add_argument('bar', type=float)\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [--foo int] float\n"
"\n"
"positional arguments:\n"
"  float\n"
"\n"
"options:\n"
"  -h, --help  show this help message and exit\n"
"  --foo int"

msgid "prefix_chars"
msgstr "prefix_chars"

msgid "Most command-line options will use ``-`` as the prefix, e.g. ``-f/--foo``. Parsers that need to support different or additional prefix characters, e.g. for options like ``+f`` or ``/foo``, may specify them using the ``prefix_chars=`` argument to the :class:`ArgumentParser` constructor::"
msgstr "بیشتر گزینه‌های خط فرمان از ``-`` به‌عنوان پیشوند استفاده می‌کنند، برای مثال ``-f/--foo``. پارسرهایی که نیاز به پشتیبانی از نویسه‌های پیشوند متفاوت یا اضافی دارند، برای مثال برای گزینه‌هایی مانند ``+f`` یا ``/foo``، می‌توانند آن‌ها را با استفاده از آرگومان ``prefix_chars=`` در سازنده‌ی :class:`ArgumentParser` مشخص کنند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')\n"
">>> parser.add_argument('+f')\n"
">>> parser.add_argument('++bar')\n"
">>> parser.parse_args('+f X ++bar Y'.split())\n"
"Namespace(bar='Y', f='X')"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')\n"
">>> parser.add_argument('+f')\n"
">>> parser.add_argument('++bar')\n"
">>> parser.parse_args('+f X ++bar Y'.split())\n"
"Namespace(bar='Y', f='X')"

msgid "The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of characters that does not include ``-`` will cause ``-f/--foo`` options to be disallowed."
msgstr "مقدار پیش‌فرض آرگومان ``prefix_chars=`` برابر ``'-'`` است. ارائه مجموعه‌ای از نویسه‌ها که شامل ``-`` نباشد، باعث غیرمجاز شدن گزینه‌های ``-f/--foo`` می‌شود."

msgid "fromfile_prefix_chars"
msgstr "fromfile_prefix_chars"

msgid "Sometimes, when dealing with a particularly long argument list, it may make sense to keep the list of arguments in a file rather than typing it out at the command line.  If the ``fromfile_prefix_chars=`` argument is given to the :class:`ArgumentParser` constructor, then arguments that start with any of the specified characters will be treated as files, and will be replaced by the arguments they contain.  For example::"
msgstr "گاهی، هنگام کار با یک فهرست آرگومان بسیار طولانی، ممکن است منطقی باشد که فهرست آرگومان‌ها را در یک پرونده نگه دارید، به‌جای آن‌که آن را در خط فرمان تایپ کنید. اگر آرگومان ``fromfile_prefix_chars=`` به سازنده‌ی :class:`ArgumentParser` داده شود، آرگومان‌هایی که با هر یک از نویسه‌های مشخص‌شده آغاز می‌شوند، به‌عنوان پرونده در نظر گرفته می‌شوند و با آرگومان‌هایی که در بر دارند جایگزین می‌شوند. برای مثال::"

msgid ""
">>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:\n"
"...     fp.write('-f\\nbar')\n"
"...\n"
">>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\n"
">>> parser.add_argument('-f')\n"
">>> parser.parse_args(['-f', 'foo', '@args.txt'])\n"
"Namespace(f='bar')"
msgstr ""
">>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:\n"
"...     fp.write('-f\\nbar')\n"
"...\n"
">>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\n"
">>> parser.add_argument('-f')\n"
">>> parser.parse_args(['-f', 'foo', '@args.txt'])\n"
"Namespace(f='bar')"

msgid "Arguments read from a file must be one per line by default (but see also :meth:`~ArgumentParser.convert_arg_line_to_args`) and are treated as if they were in the same place as the original file referencing argument on the command line.  So in the example above, the expression ``['-f', 'foo', '@args.txt']`` is considered equivalent to the expression ``['-f', 'foo', '-f', 'bar']``."
msgstr "آرگومان‌های خوانده‌شده از یک پرونده باید به‌طور پیش‌فرض یکی در هر خط باشند (اما :meth:`~ArgumentParser.convert_arg_line_to_args` را نیز ببینید) و طوری با آن‌ها رفتار می‌شود که گویی در همان جایگاه آرگومان اصلی ارجاع‌دهنده به پرونده در خط فرمان قرار دارند. بنابراین در مثال بالا، عبارت ``['-f', 'foo', '@args.txt']`` معادل عبارت ``['-f', 'foo', '-f', 'bar']`` در نظر گرفته می‌شود."

msgid "Each line is treated as a single argument, so an empty line is read as an empty string (``''``)."
msgstr "هر خط به‌عنوان یک آرگومان واحد در نظر گرفته می‌شود، بنابراین یک خط خالی به‌عنوان یک رشته خالی (``''``) خوانده می‌شود."

msgid ":class:`ArgumentParser` uses :term:`filesystem encoding and error handler` to read the file containing arguments."
msgstr ":class:`ArgumentParser` از :term:`filesystem encoding and error handler` برای خواندن پرونده حاوی آرگومان‌ها استفاده می‌کند."

msgid "The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that arguments will never be treated as file references."
msgstr "مقدار پیش‌فرض آرگومان ``fromfile_prefix_chars=`` برابر ``None`` است، به این معنا که آرگومان‌ها هرگز به‌عنوان ارجاع به پرونده در نظر گرفته نمی‌شوند."

msgid ":class:`ArgumentParser` changed encoding and errors to read arguments files from default (e.g. :func:`locale.getpreferredencoding(False) <locale.getpreferredencoding>` and ``\"strict\"``) to the :term:`filesystem encoding and error handler`. Arguments file should be encoded in UTF-8 instead of ANSI Codepage on Windows."
msgstr ":class:`ArgumentParser` کدگذاری و خطاها را برای خواندن پرونده‌های آرگومان از پیش‌فرض (برای مثال :func:`locale.getpreferredencoding(False) <locale.getpreferredencoding>` و ``\"strict\"``) به :term:`کدگذاری و هندلر خطای سامانه فایل‌بندی <filesystem encoding and error handler>` تغییر داد. پرونده آرگومان‌ها باید در ویندوز به‌جای ANSI Codepage با UTF-8 کدگذاری شود."

msgid "argument_default"
msgstr "argument_default"

msgid "Generally, argument defaults are specified either by passing a default to :meth:`~ArgumentParser.add_argument` or by calling the :meth:`~ArgumentParser.set_defaults` methods with a specific set of name-value pairs.  Sometimes however, it may be useful to specify a single parser-wide default for arguments.  This can be accomplished by passing the ``argument_default=`` keyword argument to :class:`ArgumentParser`.  For example, to globally suppress attribute creation on :meth:`~ArgumentParser.parse_args` calls, we supply ``argument_default=SUPPRESS``::"
msgstr "به‌طور معمول، مقادیر پیش‌فرض آرگومان‌ها یا با ارسال یک مقدار پیش‌فرض به :meth:`~ArgumentParser.add_argument` یا با فراخوانی متد :meth:`~ArgumentParser.set_defaults` با مجموعه‌ای مشخص از جفت‌های نام-مقدار مشخص می‌شوند. با این حال، گاهی ممکن است مشخص کردن یک پیش‌فرض واحد در سطح پارسر برای آرگومان‌ها مفید باشد. این کار را می‌توان با ارسال آرگومان کلیدواژه‌ای ``argument_default=`` به :class:`ArgumentParser` انجام داد. برای مثال، برای جلوگیری به‌صورت سراسری از ایجاد ویژگی در فراخوانی‌های :meth:`~ArgumentParser.parse_args`، ``argument_default=SUPPRESS`` را قرار می‌دهیم::"

msgid ""
">>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar', nargs='?')\n"
">>> parser.parse_args(['--foo', '1', 'BAR'])\n"
"Namespace(bar='BAR', foo='1')\n"
">>> parser.parse_args([])\n"
"Namespace()"
msgstr ""
">>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n"
">>> parser.add_argument('--foo')\n"
">>> parser.add_argument('bar', nargs='?')\n"
">>> parser.parse_args(['--foo', '1', 'BAR'])\n"
"Namespace(bar='BAR', foo='1')\n"
">>> parser.parse_args([])\n"
"Namespace()"

msgid "allow_abbrev"
msgstr "allow_abbrev"

msgid "Normally, when you pass an argument list to the :meth:`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes abbreviations <prefix-matching>` of long options."
msgstr "به‌طور معمول، هنگامی که یک فهرست آرگومان را به متد :meth:`~ArgumentParser.parse_args` از یک :class:`ArgumentParser` ارسال می‌کنید، این متد برای گزینه‌های بلند :ref:`مخفف‌ها را می‌شناسد <prefix-matching>`."

msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
msgstr "این قابلیت را می‌توان با تنظیم ``allow_abbrev`` روی ``False`` غیرفعال کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)\n"
">>> parser.add_argument('--foobar', action='store_true')\n"
">>> parser.add_argument('--foonley', action='store_false')\n"
">>> parser.parse_args(['--foon'])\n"
"usage: PROG [-h] [--foobar] [--foonley]\n"
"PROG: error: unrecognized arguments: --foon"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)\n"
">>> parser.add_argument('--foobar', action='store_true')\n"
">>> parser.add_argument('--foonley', action='store_false')\n"
">>> parser.parse_args(['--foon'])\n"
"usage: PROG [-h] [--foobar] [--foonley]\n"
"PROG: error: unrecognized arguments: --foon"

msgid "conflict_handler"
msgstr "conflict_handler"

msgid ":class:`ArgumentParser` objects do not allow two actions with the same option string.  By default, :class:`ArgumentParser` objects raise an exception if an attempt is made to create an argument with an option string that is already in use::"
msgstr "اشیاء :class:`ArgumentParser` اجازه نمی‌دهند دو اکشن با رشته‌ی گزینه یکسان وجود داشته باشند. به‌طور پیش‌فرض، اشیاء :class:`ArgumentParser` در صورتی که تلاشی برای ایجاد آرگومانی با رشته‌ی گزینه‌ای که از قبل در حال استفاده است انجام شود، استثنایی پرتاب می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
"Traceback (most recent call last):\n"
" ..\n"
"ArgumentError: argument --foo: conflicting option string(s): --foo"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
"Traceback (most recent call last):\n"
" ..\n"
"ArgumentError: argument --foo: conflicting option string(s): --foo"

msgid "Sometimes (e.g. when using parents_) it may be useful to simply override any older arguments with the same option string.  To get this behavior, the value ``'resolve'`` can be supplied to the ``conflict_handler=`` argument of :class:`ArgumentParser`::"
msgstr "گاهی (مثلاً هنگام استفاده از parents_) ممکن است مفید باشد که هر آرگومان قدیمی‌تری با همان رشته‌ی گزینه به‌سادگی بازنویسی شود. برای دستیابی به این رفتار، می‌توان مقدار ``'resolve'`` را به آرگومان ``conflict_handler=`` در :class:`ArgumentParser` داد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-f FOO] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" -f FOO      old foo help\n"
" --foo FOO   new foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')\n"
">>> parser.add_argument('-f', '--foo', help='old foo help')\n"
">>> parser.add_argument('--foo', help='new foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [-h] [-f FOO] [--foo FOO]\n"
"\n"
"options:\n"
" -h, --help  show this help message and exit\n"
" -f FOO      old foo help\n"
" --foo FOO   new foo help"

msgid "Note that :class:`ArgumentParser` objects only remove an action if all of its option strings are overridden.  So, in the example above, the old ``-f/--foo`` action is retained as the ``-f`` action, because only the ``--foo`` option string was overridden."
msgstr "توجه داشته باشید که اشیاء :class:`ArgumentParser` یک اکشنرا فقط در صورتی حذف می‌کنند که همه رشته‌های گزینه (option strings) آن بازنویسی‌شده باشند. بنابراین، در مثال بالا، اکشن قدیمی ``-f/--foo`` به‌عنوان اکشن ``-f`` حفظ می‌شود، زیرا فقط رشته گزینه ``--foo`` بازنویسی‌شده است."

msgid "add_help"
msgstr "add_help"

msgid "By default, :class:`ArgumentParser` objects add an option which simply displays the parser's help message. If ``-h`` or ``--help`` is supplied at the command line, the :class:`!ArgumentParser` help will be printed."
msgstr "به‌طور پیش‌فرض، اشیای :class:`ArgumentParser` گزینه‌ای اضافه می‌کنند که صرفاً پیام راهنمای پارسر را نمایش می‌دهد. اگر ``-h`` یا ``--help`` در خط فرمان ارائه شود، راهنمای :class:`!ArgumentParser` چاپ خواهد شد."

msgid "Occasionally, it may be useful to disable the addition of this help option. This can be achieved by passing ``False`` as the ``add_help=`` argument to :class:`ArgumentParser`::"
msgstr "گاهی اوقات، ممکن است غیرفعال کردن افزودن این گزینه راهنما مفید باشد. این کار را می‌توان با ارسال ``False`` به‌عنوان آرگومان ``add_help=`` به :class:`ArgumentParser` انجام داد::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> parser.add_argument('--foo', help='foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO]\n"
"\n"
"options:\n"
" --foo FOO  foo help"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"
">>> parser.add_argument('--foo', help='foo help')\n"
">>> parser.print_help()\n"
"usage: PROG [--foo FOO]\n"
"\n"
"options:\n"
" --foo FOO  foo help"

msgid "The help option is typically ``-h/--help``. The exception to this is if the ``prefix_chars=`` is specified and does not include ``-``, in which case ``-h`` and ``--help`` are not valid options.  In this case, the first character in ``prefix_chars`` is used to prefix the help options::"
msgstr "گزینه راهنما معمولاً ``-h/--help`` است. استثنای این حالت زمانی است که ``prefix_chars=`` مشخص شده باشد و شامل ``-`` نباشد، که در این صورت ``-h`` و ``--help`` گزینه‌های معتبری نیستند. در این حالت، از اولین نویسه‌ی ``prefix_chars`` برای پیشوندگذاری گزینه‌های راهنما استفاده می‌شود::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')\n"
">>> parser.print_help()\n"
"usage: PROG [+h]\n"
"\n"
"options:\n"
"  +h, ++help  show this help message and exit"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')\n"
">>> parser.print_help()\n"
"usage: PROG [+h]\n"
"\n"
"options:\n"
"  +h, ++help  show this help message and exit"

msgid "exit_on_error"
msgstr "exit_on_error"

msgid "Normally, when you pass an invalid argument list to the :meth:`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it will print a *message* to :data:`sys.stderr` and exit with a status code of 2."
msgstr "به‌طور معمول، هنگامی که یک فهرست آرگومان‌های نامعتبر را به متد :meth:`~ArgumentParser.parse_args` از یک :class:`ArgumentParser` ارسال می‌کنید، *پیامی* را در :data:`sys.stderr` چاپ می‌کند و با کد وضعیت ۲ خارج می‌شود."

msgid "If the user would like to catch errors manually, the feature can be enabled by setting ``exit_on_error`` to ``False``::"
msgstr "اگر کاربر بخواهد خطاها را به‌صورت دستی بگیرد، می‌توان این قابلیت را با تنظیم ``exit_on_error`` روی ``False`` فعال کرد::"

msgid ""
">>> parser = argparse.ArgumentParser(exit_on_error=False)\n"
">>> parser.add_argument('--integers', type=int)\n"
"_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)\n"
">>> try:\n"
"...     parser.parse_args('--integers a'.split())\n"
"... except argparse.ArgumentError:\n"
"...     print('Catching an argumentError')\n"
"...\n"
"Catching an argumentError"
msgstr ""
">>> parser = argparse.ArgumentParser(exit_on_error=False)\n"
">>> parser.add_argument('--integers', type=int)\n"
"_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)\n"
">>> try:\n"
"...     parser.parse_args('--integers a'.split())\n"
"... except argparse.ArgumentError:\n"
"...     print('Catching an argumentError')\n"
"...\n"
"Catching an argumentError"

msgid "suggest_on_error"
msgstr "suggest_on_error"

msgid "By default, when a user passes an invalid argument choice or subparser name, :class:`ArgumentParser` will exit with error info and provide suggestions for mistyped arguments. The error message will list the permissible argument choices (if specified) or subparser names, along with a \"maybe you meant\" suggestion if a close match is found. Note that this only applies for arguments when the choices specified are strings::"
msgstr "به طور پیش‌فرض، هنگامی که کاربری یک انتخاب آرگومان یا نام زیرپارسر نامعتبر را ارسال کند، کلاس :class:`ArgumentParser` با اطلاعات خطا خارج می‌شود و پیشنهادهایی را برای آرگومان‌های اشتباه تایپ‌شده ارائه می‌دهد. پیام خطا انتخاب‌های مجاز آرگومان (در صورت مشخص شدن) یا نام‌های زیرپارسر را فهرست می‌کند، همراه با یک پیشنهاد «شاید منظور شما این بوده است» اگر تطبیق نزدیکی پیدا شود. توجه داشته باشید که این مورد تنها برای آرگومان‌هایی اعمال می‌شود که انتخاب‌های مشخص‌شده رشته باشند::"

msgid ""
">>> parser = argparse.ArgumentParser(suggest_on_error=True)\n"
">>> parser.add_argument('--action', choices=['debug', 'dryrun'])\n"
">>> parser.parse_args(['--action', 'debugg'])\n"
"usage: tester.py [-h] [--action {debug,dryrun}]\n"
"tester.py: error: argument --action: invalid choice: 'debugg', maybe you meant 'debug'? (choose from debug, dryrun)"
msgstr ""
">>> parser = argparse.ArgumentParser(suggest_on_error=True)\n"
">>> parser.add_argument('--action', choices=['debug', 'dryrun'])\n"
">>> parser.parse_args(['--action', 'debugg'])\n"
"usage: tester.py [-h] [--action {debug,dryrun}]\n"
"tester.py: error: argument --action: invalid choice: 'debugg', maybe you meant 'debug'? (choose from debug, dryrun)"

msgid "You can disable suggestions by setting ``suggest_on_error`` to ``False``."
msgstr "می‌توانید با تنظیم ``suggest_on_error`` روی ``False`` پیشنهادها را غیرفعال کنید."

msgid "Changed default value of ``suggest_on_error`` from ``False`` to ``True``."
msgstr "مقدار پیش‌فرض ``suggest_on_error`` از ``False`` به ``True`` تغییر یافت."

msgid "color"
msgstr "رنگ"

msgid "By default, the help message is printed in color using `ANSI escape sequences <https://en.wikipedia.org/wiki/ANSI_escape_code>`__. If you want plain text help messages, you can disable this :ref:`in your local environment <using-on-controlling-color>`, or in the argument parser itself by setting ``color`` to ``False``::"
msgstr "به‌طور پیش‌فرض، پیام راهنما با استفاده از `ANSI escape sequences <https://fa.wikipedia.org/wiki/کدهای_فرار_انسی>`__ به‌صورت رنگی چاپ می‌شود. اگر پیام‌های راهنما را به‌صورت متن ساده می‌خواهید، می‌توانید آن را :ref:`در محیط محلی خود <using-on-controlling-color>` یا در خود پارسر آرگومان با تنظیم ``color`` روی ``False`` غیرفعال کنید::"

msgid ""
">>> parser = argparse.ArgumentParser(description='Process some integers.',\n"
"...                                  color=False)\n"
">>> parser.add_argument('--action', choices=['sum', 'max'])\n"
">>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"
"...                     help='an integer for the accumulator')\n"
">>> parser.parse_args(['--help'])"
msgstr ""
">>> parser = argparse.ArgumentParser(description='Process some integers.',\n"
"...                                  color=False)\n"
">>> parser.add_argument('--action', choices=['sum', 'max'])\n"
">>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"
"...                     help='an integer for the accumulator')\n"
">>> parser.parse_args(['--help'])"

msgid "Note that when ``color=True``, colored output depends on both environment variables and terminal capabilities.  However, if ``color=False``, colored output is always disabled, even if environment variables like ``FORCE_COLOR`` are set."
msgstr "توجه داشته باشید که هنگامی که ``color=True`` باشد، خروجی رنگی هم به متغیرهای محیطی و هم به قابلیت‌های پایانه بستگی دارد. با این حال، اگر ``color=False`` باشد، خروجی رنگی همیشه غیرفعال است، حتی اگر متغیرهای محیطی مانند ``FORCE_COLOR`` تنظیم شده باشند."

msgid "To highlight inline code in your description, epilog, or argument ``help`` text, you can use single or double backticks::"
msgstr "برای برجسته‌سازی کد درون‌خطی در توضیحات، epilog، یا متن ``help`` آرگومان، می‌توانید از علامت‌های نقل‌قول معکوس تکی یا دوتایی استفاده کنید::"

msgid ""
">>> parser = argparse.ArgumentParser(\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description='Run ``python -m myapp`` to start.',\n"
"...     epilog='''Examples:\n"
"...   `python -m myapp --verbose`\n"
"...   ``python -m myapp --config settings.json``\n"
"... ''')\n"
">>> parser.add_argument('--foo', help='set the `foo` value')"
msgstr ""
">>> parser = argparse.ArgumentParser(\n"
"...     formatter_class=argparse.RawDescriptionHelpFormatter,\n"
"...     description='Run ``python -m myapp`` to start.',\n"
"...     epilog='''Examples:\n"
"...   `python -m myapp --verbose`\n"
"...   ``python -m myapp --config settings.json``\n"
"... ''')\n"
">>> parser.add_argument('--foo', help='set the `foo` value')"

msgid "When colors are enabled, the text inside backticks will be displayed in a distinct color to help examples stand out. When colors are disabled, backticks are preserved as-is, which is readable in plain text."
msgstr "هنگامی که رنگ‌ها فعال هستند، متن داخل نقل‌قول‌های معکوس با رنگ متمایزی نمایش داده می‌شود تا به برجسته شدن مثال‌ها کمک کند. هنگامی که رنگ‌ها غیرفعال هستند، نقل‌قول‌های معکوس دقیقاً به همان شکل حفظ می‌شوند که در متن ساده خوانا است."

msgid "The add_argument() method"
msgstr "متد add_argument()"

msgid "Define how a single command-line argument should be parsed.  Each parameter has its own more detailed description below, but in short they are:"
msgstr "تعریف می‌کند که یک آرگومان خط فرمان باید چگونه تجزیه شود. هر پارامتر در زیر توضیح مفصل‌تری دارد، اما به‌طور خلاصه عبارت‌اند از:"

msgid "`name or flags`_ - Either a name or a list of option strings, e.g. ``'foo'`` or ``'-f', '--foo'``."
msgstr "`name or flags`_ - یا یک نام یا فهرستی از رشته‌های گزینه، برای مثال ``'foo'`` یا ``'-f', '--foo'``."

msgid "action_ - The basic type of action to be taken when this argument is encountered at the command line."
msgstr "action_ - نوع پایه‌ی اکشنی که هنگام مواجهه با این آرگومان در خط فرمان انجام می‌شود."

msgid "nargs_ - The number of command-line arguments that should be consumed."
msgstr "nargs_ - تعداد آرگومان‌های خط فرمان که باید مصرف شوند."

msgid "const_ - A constant value required by some action_ and nargs_ selections."
msgstr "const_ - مقدار ثابتی که برخی انتخاب‌های action_ و nargs_ به آن نیاز دارند."

msgid "default_ - The value produced if the argument is absent from the command line and if it is absent from the namespace object."
msgstr "default_ - مقداری که اگر آرگومان در خط فرمان وجود نداشته باشد و در شیء فضای نام نیز غایب باشد، تولید می‌شود."

msgid "type_ - The type to which the command-line argument should be converted."
msgstr "type_ - نوعی که آرگومان خط فرمان باید به آن تبدیل شود."

msgid "choices_ - A sequence of the allowable values for the argument."
msgstr "choices_ - دنباله‌ای از مقادیر مجاز برای آرگومان."

msgid "required_ - Whether or not the command-line option may be omitted (optionals only)."
msgstr "required_ - اینکه آیا می‌توان گزینه خط فرمان را حذف کرد یا خیر (فقط گزینه‌های اختیاری)."

msgid "help_ - A brief description of what the argument does."
msgstr "help_ - شرحی مختصر از کاری که آرگومان انجام می‌دهد."

msgid "metavar_ - A name for the argument in usage messages."
msgstr "metavar_ - نامی برای آرگومان در پیام‌های کاربرد."

msgid "dest_ - The name of the attribute to be added to the object returned by :meth:`parse_args`."
msgstr "dest_ - نام ویژگی‌ای که به شیء برگردانده‌شده توسط :meth:`parse_args` افزوده می‌شود."

msgid "deprecated_ - Whether or not use of the argument is deprecated."
msgstr "deprecated_ - اینکه استفاده از آرگومان منسوخ است یا خیر."

msgid "The method returns an :class:`Action` object representing the argument."
msgstr "این متد یک شیء :class:`Action` برمی‌گرداند که نمایانگر آرگومان است."

msgid "name or flags"
msgstr "نام یا پرچم‌ها"

msgid "The :meth:`~ArgumentParser.add_argument` method must know whether an optional argument, like ``-f`` or ``--foo``, or a positional argument, like a list of filenames, is expected.  The first arguments passed to :meth:`~ArgumentParser.add_argument` must therefore be either a series of flags, or a simple argument name."
msgstr "متد :meth:`~ArgumentParser.add_argument` باید بداند که آیا یک آرگومان اختیاری، مانند ``-f`` یا ``--foo``، یا یک آرگومان جایگاهی، مانند فهرستی از نام پرونده‌ها، انتظار می‌رود. بنابراین اولین آرگومان‌های ارسال‌شده به :meth:`~ArgumentParser.add_argument` باید یا مجموعه‌ای از پرچم‌ها باشند یا یک نام آرگومان ساده."

msgid "For example, an optional argument could be created like::"
msgstr "برای مثال، می‌توان یک آرگومان اختیاری به این صورت ایجاد کرد::"

msgid ">>> parser.add_argument('-f', '--foo')"
msgstr ">>> parser.add_argument('-f', '--foo')"

msgid "while a positional argument could be created like::"
msgstr "در حالی که یک آرگومان جایگاهی را می‌توان به این شکل ایجاد کرد::"

msgid ">>> parser.add_argument('bar')"
msgstr ">>> parser.add_argument('bar')"

msgid "When :meth:`~ArgumentParser.parse_args` is called, optional arguments will be identified by the ``-`` prefix, and the remaining arguments will be assumed to be positional::"
msgstr "هنگامی که :meth:`~ArgumentParser.parse_args` فراخوانی می‌شود، آرگومان‌های اختیاری با پیشوند ``-`` شناسایی می‌شوند، و آرگومان‌های باقی‌مانده جایگاهی فرض می‌شوند::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['BAR'])\n"
"Namespace(bar='BAR', foo=None)\n"
">>> parser.parse_args(['BAR', '--foo', 'FOO'])\n"
"Namespace(bar='BAR', foo='FOO')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"usage: PROG [-h] [-f FOO] bar\n"
"PROG: error: the following arguments are required: bar"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('-f', '--foo')\n"
">>> parser.add_argument('bar')\n"
">>> parser.parse_args(['BAR'])\n"
"Namespace(bar='BAR', foo=None)\n"
">>> parser.parse_args(['BAR', '--foo', 'FOO'])\n"
"Namespace(bar='BAR', foo='FOO')\n"
">>> parser.parse_args(['--foo', 'FOO'])\n"
"usage: PROG [-h] [-f FOO] bar\n"
"PROG: error: the following arguments are required: bar"

msgid "By default, :mod:`!argparse` automatically handles the internal naming and display names of arguments, simplifying the process without requiring additional configuration. As such, you do not need to specify the dest_ and metavar_ parameters. For optional arguments, the dest_ parameter defaults to the argument name, with underscores ``_`` replacing hyphens ``-``. The metavar_ parameter defaults to the upper-cased name. For example::"
msgstr "به‌طور پیش‌فرض، :mod:`!argparse` نام‌گذاری داخلی و نام‌های نمایشی آرگومان‌ها را به‌طور خودکار مدیریت می‌کند و فرآیند را بدون نیاز به پیکربندی اضافی ساده می‌سازد. بنابراین، نیازی به مشخص کردن پارامترهای dest_ و metavar_ ندارید. برای آرگومان‌های اختیاری، پارامتر dest_ به‌طور پیش‌فرض برابر با نام آرگومان است، با جایگزینی زیرخط ``_`` به‌جای خط‌تیره ``-``. پارامتر metavar_ به‌طور پیش‌فرض برابر با نام با حروف بزرگ است. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo-bar')\n"
">>> parser.parse_args(['--foo-bar', 'FOO-BAR'])\n"
"Namespace(foo_bar='FOO-BAR')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo-bar FOO-BAR]\n"
"\n"
"optional arguments:\n"
" -h, --help  show this help message and exit\n"
" --foo-bar FOO-BAR"
msgstr ""
">>> parser = argparse.ArgumentParser(prog='PROG')\n"
">>> parser.add_argument('--foo-bar')\n"
">>> parser.parse_args(['--foo-bar', 'FOO-BAR'])\n"
"Namespace(foo_bar='FOO-BAR')\n"
">>> parser.print_help()\n"
"usage:  [-h] [--foo-bar FOO-BAR]\n"
"\n"
"optional arguments:\n"
" -h, --help  show this help message and exit\n"
" --foo-bar FOO-BAR"

msgid "action"
msgstr "action"

msgid ":class:`ArgumentParser` objects associate command-line arguments with actions.  These actions can do just about anything with the command-line arguments associated with them, though most actions simply add an attribute to the object returned by :meth:`~ArgumentParser.parse_args`.  The ``action`` keyword argument specifies how the command-line arguments should be handled. The supplied actions are:"
msgstr "اشیای :class:`ArgumentParser` آرگومان‌های خط فرمان را به اکشن‌ها مرتبط می‌کنند. این اکشن‌ها می‌توانند تقریباً هر کاری را با آرگومان‌های خط فرمان مرتبط با خود انجام دهند، اگرچه بیشتر اکشن‌ها صرفاً یک ویژگی به شیء برگردانده‌شده از :meth:`~ArgumentParser.parse_args` اضافه می‌کنند. آرگومان کلیدواژه‌ای ``action`` مشخص می‌کند که آرگومان‌های خط فرمان باید چگونه مدیریت شوند. اکشن‌های فراهم‌شده عبارت‌اند از:"

msgid "``'store'`` - This just stores the argument's value.  This is the default action."
msgstr "``'store'`` - این فقط مقدار آرگومان را ذخیره می‌کند. این اکشن پیش‌فرض است."

msgid "``'store_const'`` - This stores the value specified by the const_ keyword argument; note that the const_ keyword argument defaults to ``None``.  The ``'store_const'`` action is most commonly used with optional arguments that specify some sort of flag.  For example::"
msgstr "``'store_const'`` - این مقدار مشخص‌شده با آرگومان کلیدواژه‌ای const_ را ذخیره می‌کند؛ توجه داشته باشید که مقدار پیش‌فرض آرگومان کلیدواژه‌ای const_ برابر ``None`` است. اکشن ``'store_const'`` بیشتر با آرگومان‌های اختیاری استفاده می‌شود که نوعی پرچم را مشخص می‌کنند. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_const', const=42)\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(foo=42)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_const', const=42)\n"
">>> parser.parse_args(['--foo'])\n"
"Namespace(foo=42)"

msgid "``'store_true'`` and ``'store_false'`` - These are special cases of ``'store_const'`` that respectively store the values ``True`` and ``False`` with default values of ``False`` and ``True``::"
msgstr "``'store_true'`` و ``'store_false'`` - این‌ها موارد خاصی از ``'store_const'`` هستند که به‌ترتیب مقادیر ``True`` و ``False`` را با مقادیر پیش‌فرض ``False`` و ``True`` ذخیره می‌کنند::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('--bar', action='store_false')\n"
">>> parser.add_argument('--baz', action='store_false')\n"
">>> parser.parse_args('--foo --bar'.split())\n"
"Namespace(foo=True, bar=False, baz=True)"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='store_true')\n"
">>> parser.add_argument('--bar', action='store_false')\n"
">>> parser.add_argument('--baz', action='store_false')\n"
">>> parser.parse_args('--foo --bar'.split())\n"
"Namespace(foo=True, bar=False, baz=True)"

msgid "``'append'`` - This appends each argument value to a list. It is useful for allowing an option to be specified multiple times. If the default value is a non-empty list, the parsed value will start with the default list's elements and any values from the command line will be appended after those default values. Example usage::"
msgstr "``'append'`` - این عمل هر مقدار آرگومان را به یک فهرست اضافه می‌کند. این برای اجازه دادن به اینکه یک گزینه چندین بار مشخص شود، مفید است. اگر مقدار پیش‌فرض یک فهرست غیرخالی باشد، مقدار تجزیه‌شده با عناصر فهرست پیش‌فرض آغاز می‌شود و هر مقداری از خط فرمان پس از آن مقادیر پیش‌فرض اضافه می‌شود. نمونه استفاده::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='append', default=['0'])\n"
">>> parser.parse_args('--foo 1 --foo 2'.split())\n"
"Namespace(foo=['0', '1', '2'])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--foo', action='append', default=['0'])\n"
">>> parser.parse_args('--foo 1 --foo 2'.split())\n"
"Namespace(foo=['0', '1', '2'])"

msgid "``'append_const'`` - This appends the value specified by the const_ keyword argument to a list; note that the const_ keyword argument defaults to ``None``. The ``'append_const'`` action is typically useful when multiple arguments need to store constants to the same list. For example::"
msgstr "``'append_const'`` - این کنش مقدار مشخص‌شده توسط آرگومان کلیدواژه‌ای const_ را به یک فهرست الحاق می‌کند؛ توجه داشته باشید که مقدار پیش‌فرض آرگومان کلیدواژه‌ای const_ برابر ``None`` است. کنش ``'append_const'`` معمولاً زمانی مفید است که چند آرگومان نیاز دارند ثابت‌ها را در یک فهرست مشترک ذخیره کنند. برای مثال::"

msgid ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--str', dest='types', action='append_const', const=str)\n"
">>> parser.add_argument('--int', dest='types', action='append_const', const=int)\n"
">>> parser.parse_args('--str --int'.split())\n"
"Namespace(types=[<class 'str'>, <class 'int'>])"
msgstr ""
">>> parser = argparse.ArgumentParser()\n"
">>> parser.add_argument('--str', dest='types', action='append_const', const=str)\n"
">>> parser.add_argument('--int', dest='types', action='append_const', const=int)\n"
">>> parser.parse_args('--str --int'.split())\n"
"Namespace(types=[<class 'str'>, <class 'int'>])"

msgid "``'extend'`` - This appends each item from a multi-value argument to a list. The ``'extend'`` action is typically used with the nargs_ keyword argument value ``'+'`` or ``'*'``. Note that when nargs_ is ``None`` (the default) or ``'?'``, each character of the argument string will be appended to the list. Example usage::"
msgstr "``'extend'`` - این هر یک از آیتم‌های یک آرگومان چندمقداری را به یک فهرست اضافه می‌کند. اکشن  ``'extend'`` معمولاً همراه با مقدار ``'+'`` یا ``'*'`` برای آرگومان کلیدواژه‌ای nargs_ استفاده می‌شود. توجه داشته باشید که وقتی nargs_ برابر با ``None`` (پیش‌فرض) یا ``'?'`` باشد، هر نویسه‌ی رشته‌ی آرگومان به فهرست اضافه خواهد شد. نمونه کاربرد::"

msgid ""