compound_stmts.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-30 04:13+0000\n"
"PO-Revision-Date: 2026-09-12 17:52+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 "Compound statements"
msgstr "دستورهای مرکب"

msgid "Compound statements contain (groups of) other statements; they affect or control the execution of those other statements in some way.  In general, compound statements span multiple lines, although in simple incarnations a whole compound statement may be contained in one line."
msgstr "دستورهای مرکب شامل (گروه‌هایی از) دستورهای دیگر می‌شوند؛ آن‌ها به‌نحوی اجرای آن دستورهای دیگر را تحت تأثیر قرار می‌دهند یا کنترل می‌کنند. به‌طور کلی، دستورهای مرکب چندین خط را در بر می‌گیرند، اگرچه در حالت‌های ساده ممکن است یک دستور مرکب کامل در یک خط جای بگیرد."

msgid "The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement traditional control flow constructs.  :keyword:`try` specifies exception handlers and/or cleanup code for a group of statements, while the :keyword:`with` statement allows the execution of initialization and finalization code around a block of code.  Function and class definitions are also syntactically compound statements."
msgstr "دستورهای :keyword:`if`، :keyword:`while` و :keyword:`for` ساختارهای کنترل جریان سنتی را پیاده‌سازی می‌کنند. :keyword:`try` هندلرهای استثنا و/یا کد پاک‌سازی را برای گروهی از دستورها تعیین می‌کند، در حالی که دستور :keyword:`with` امکان اجرای کد مقداردهی اولیه و نهایی‌سازی را پیرامون یک بلوک کد فراهم می‌کند. تعریف تابع و کلاس نیز از نظر سینتکسی دستورهای مرکب هستند."

msgid "A compound statement consists of one or more 'clauses.'  A clause consists of a header and a 'suite.'  The clause headers of a particular compound statement are all at the same indentation level. Each clause header begins with a uniquely identifying keyword and ends with a colon.  A suite is a group of statements controlled by a clause.  A suite can be one or more semicolon-separated simple statements on the same line as the header, following the header's colon, or it can be one or more indented statements on subsequent lines.  Only the latter form of a suite can contain nested compound statements; the following is illegal, mostly because it wouldn't be clear to which :keyword:`if` clause a following :keyword:`else` clause would belong::"
msgstr "یک دستور مرکب از یک یا چند «بند» تشکیل شده است. هر بند از یک سرآیند و یک «بدنه» تشکیل شده است. سرآیندهای بندها در یک دستور مرکب مشخص، همگی در یک سطح تورفتگی قرار دارند. هر سرآیند بند با کلیدواژه‌ای که به‌طور یکتا آن را مشخص می‌کند آغاز می‌شود و با یک دونقطه پایان می‌یابد. یک بدنه، گروهی از دستورها است که توسط یک بند کنترل می‌شود. یک بدنه می‌تواند یک یا چند دستور ساده‌ی جداشده با نقطه‌ویرگول در همان خط سرآیند و پس از دونقطه‌ی سرآیند باشد، یا می‌تواند یک یا چند دستور تورفته در سطرهای بعدی باشد. تنها شکل دوم یک بدنه می‌تواند شامل دستورهای مرکب تودرتو باشد؛ مورد زیر غیرمجاز است، بیشتر به این دلیل که مشخص نخواهد بود یک بند :keyword:`else` بعدی به کدام بند :keyword:`if` تعلق دارد::"

msgid "if test1: if test2: print(x)"
msgstr "if test1: if test2: print(x)"

msgid "Also note that the semicolon binds tighter than the colon in this context, so that in the following example, either all or none of the :func:`print` calls are executed::"
msgstr "همچنین توجه داشته باشید که در این زمینه، نقطه‌ویرگول اتصال قوی‌تری نسبت به دونقطه دارد، به‌طوری که در مثال زیر، یا همه‌ی فراخوانی‌های :func:`print` اجرا می‌شوند یا هیچ‌کدام::"

msgid "if x < y < z: print(x); print(y); print(z)"
msgstr "if x < y < z: print(x); print(y); print(z)"

msgid "Summarizing:"
msgstr "خلاصه‌سازی:"

msgid "Note that statements always end in a ``NEWLINE`` possibly followed by a ``DEDENT``.  Also note that optional continuation clauses always begin with a keyword that cannot start a statement, thus there are no ambiguities (the 'dangling :keyword:`else`' problem is solved in Python by requiring nested :keyword:`if` statements to be indented)."
msgstr "توجه داشته باشید که دستورها همیشه به ``NEWLINE`` ختم می‌شوند و ممکن است پس از آن یک ``DEDENT`` بیاید. همچنین توجه داشته باشید که بندهای ادامه‌ی اختیاری همیشه با کلیدواژه‌ای آغاز می‌شوند که نمی‌تواند یک دستور را آغاز کند، بنابراین هیچ ابهامی وجود ندارد (مشکل «:keyword:`else` معلق» در پایتون با الزام به تورفتگی دستورات :keyword:`if` تودرتو حل شده است)."

msgid "The formatting of the grammar rules in the following sections places each clause on a separate line for clarity."
msgstr "قالب‌بندی قواعد دستور زبان در بخش‌های زیر، برای وضوح هر بند را در یک خط جداگانه قرار می‌دهد."

msgid "The :keyword:`!if` statement"
msgstr "دستور :keyword:`!if`"

msgid "The :keyword:`if` statement is used for conditional execution:"
msgstr "دستور :keyword:`if` برای اجرای شرطی استفاده می‌شود:"

msgid "It selects exactly one of the suites by evaluating the expressions one by one until one is found to be true (see section :ref:`booleans` for the definition of true and false); then that suite is executed (and no other part of the :keyword:`if` statement is executed or evaluated).  If all expressions are false, the suite of the :keyword:`else` clause, if present, is executed."
msgstr "این دستور دقیقاً یکی از بدنه‌ها (suites) را با ارزیابی عبارت‌ها یکی‌یکی انتخاب می‌کند تا زمانی که یکی از آن‌ها درست یافت شود (برای تعریف درست و نادرست به بخش :ref:`booleans` مراجعه کنید)؛ سپس همان بدنه (suite) اجرا می‌شود (و هیچ بخش دیگری از دستور :keyword:`if` اجرا یا ارزیابی نمی‌شود). اگر همه عبارت‌ها نادرست باشند، بدنه بند :keyword:`else`، در صورت وجود، اجرا می‌شود."

msgid "The :keyword:`!while` statement"
msgstr "دستور :keyword:`!while`"

msgid "The :keyword:`while` statement is used for repeated execution as long as an expression is true:"
msgstr "دستور :keyword:`while` برای اجرای مکرر تا زمانی که یک عبارت درست باشد استفاده می‌شود:"

msgid "This repeatedly tests the expression and, if it is true, executes the first suite; if the expression is false (which may be the first time it is tested) the suite of the :keyword:`!else` clause, if present, is executed and the loop terminates."
msgstr "این عبارت را به‌طور مکرر آزمایش می‌کند و اگر درست باشد، بلوک اول را اجرا می‌کند؛ اگر عبارت نادرست باشد (که ممکن است اولین باری باشد که آزمایش می‌شود)، بلوکِ بند :keyword:`!else`، در صورت وجود، اجرا می‌شود و حلقه پایان می‌یابد."

msgid "A :keyword:`break` statement executed in the first suite terminates the loop without executing the :keyword:`!else` clause's suite.  A :keyword:`continue` statement executed in the first suite skips the rest of the suite and goes back to testing the expression."
msgstr "دستور :keyword:`break` که در اولین بدنه اجرا می‌شود، حلقه را بدون اجرای بدنه بند :keyword:`!else` پایان می‌دهد. دستور :keyword:`continue` که در اولین بدنه اجرا می‌شود، از بقیه‌ی بدنه می‌گذرد و به ارزیابی عبارت بازمی‌گردد."

msgid "The :keyword:`!for` statement"
msgstr "دستور :keyword:`!for`"

msgid "The :keyword:`for` statement is used to iterate over the elements of a sequence (such as a string, tuple or list) or other iterable object:"
msgstr "دستور :keyword:`for` برای پیمایش روی عناصر یک دنباله (مانند رشته، تاپل یا فهرست) یا یک شیء پیمایش‌پذیر دیگر استفاده می‌شود:"

msgid "The :token:`~python-grammar:starred_expression_list` expression is evaluated once; it should yield an :term:`iterable` object. An :term:`iterator` is created for that iterable. The first item provided by the iterator is then assigned to the target list using the standard rules for assignments (see :ref:`assignment`), and the suite is executed. This repeats for each item provided by the iterator. When the iterator is :term:`exhausted`, the suite in the :keyword:`!else` clause, if present, is executed, and the loop terminates."
msgstr "عبارت :token:`~python-grammar:starred_expression_list` یک بار ارزیابی می‌شود؛ باید یک شیء :term:`پیمایش‌پذیر <iterable>` تولید کند. یک :term:`پیمایش‌گر <iterator>` برای آن پیمایش‌پذیر ایجاد می‌شود. اولین آیتم ارائه شده توسط پیمایش‌گر سپس با استفاده از قواعد استاندارد انتساب (ببینید :ref:`assignment`) به فهرست هدف انتساب داده می‌شود، و بدنه اجرا می‌شود. این فرآیند برای هر آیتم ارائه شده توسط پیمایش‌گر تکرار می‌شود. وقتی پیمایش‌گر :term:`خالی <exhausted>` شود، بدنه در بند :keyword:`!else`، اگر وجود داشته باشد، اجرا می‌شود، و حلقه خاتمه می‌یابد."

msgid "A :keyword:`break` statement executed in the first suite terminates the loop without executing the :keyword:`!else` clause's suite.  A :keyword:`continue` statement executed in the first suite skips the rest of the suite and continues with the next item, or with the :keyword:`!else` clause if there is no next item."
msgstr "دستور :keyword:`break` که در اولین بدنه اجرا شود، حلقه را بدون اجرای بدنه بند :keyword:`!else` خاتمه می‌دهد. دستور :keyword:`continue` که در اولین بدنه اجرا شود، از بقیه‌ی بدنه می‌گذرد و با آیتم بعدی ادامه می‌یابد، یا اگر آیتم بعدی وجود نداشته باشد، با بند :keyword:`!else` ادامه می‌یابد."

msgid "The for-loop makes assignments to the variables in the target list. This overwrites all previous assignments to those variables including those made in the suite of the for-loop::"
msgstr "حلقه‌ی for انتساب‌هایی را به متغیرهای فهرست هدف انجام می‌دهد. این کار تمام انتساب‌های پیشین به آن متغیرها را بازنویسی می‌کند، از جمله انتساب‌هایی که در بدنه‌ی حلقه‌ی for انجام شده‌اند::"

msgid ""
"for i in range(10):\n"
"    print(i)\n"
"    i = 5             # this will not affect the for-loop\n"
"                      # because i will be overwritten with the next\n"
"                      # index in the range"
msgstr ""
"for i in range(10):\n"
"    print(i)\n"
"    i = 5             # this will not affect the for-loop\n"
"                      # because i will be overwritten with the next\n"
"                      # index in the range"

msgid "Names in the target list are not deleted when the loop is finished, but if the sequence is empty, they will not have been assigned to at all by the loop.  Hint: the built-in type :func:`range` represents immutable arithmetic sequences of integers. For instance, iterating ``range(3)`` successively yields 0, 1, and then 2."
msgstr "نام‌های موجود در فهرست هدف پس از پایان حلقه حذف نمی‌شوند، اما اگر دنباله خالی باشد، حلقه اصلاً به آن‌ها انتسابی نخواهد داد. نکته: نوع توکار :func:`range` بیانگر دنباله‌های حسابی تغییرناپذیر از اعداد صحیح است. برای نمونه، پیمایش ``range(3)`` به‌ترتیب ۰، ۱ و سپس ۲ را برمی‌گرداند."

msgid "Starred elements are now allowed in the expression list."
msgstr "عناصر ستاره‌دار اکنون در فهرست عبارت مجاز هستند."

msgid "The :keyword:`!try` statement"
msgstr "دستور :keyword:`!try`"

msgid "The :keyword:`!try` statement specifies exception handlers and/or cleanup code for a group of statements:"
msgstr "دستور :keyword:`!try` هندلرهای استثنا و/یا کد پاک‌سازی را برای گروهی از دستورها مشخص می‌کند:"

msgid "Additional information on exceptions can be found in section :ref:`exceptions`, and information on using the :keyword:`raise` statement to generate exceptions may be found in section :ref:`raise`."
msgstr "اطلاعات بیشتر درباره‌ی استثناها را می‌توانید در بخش :ref:`exceptions` پیدا کنید، و اطلاعات درباره‌ی استفاده از دستور :keyword:`raise` برای پرتاب استثناها را می‌توانید در بخش :ref:`پرتاب <raise>` پیدا کنید."

msgid "Support for optionally dropping grouping parentheses when using multiple exception types. See :pep:`758`."
msgstr "پشتیبانی از حذف اختیاری پرانتزهای گروه‌بندی هنگام استفاده از چندین نوع استثنا. به :pep:`758` مراجعه کنید."

msgid ":keyword:`!except` clause"
msgstr "بند :keyword:`!except`"

msgid "The :keyword:`!except` clause(s) specify one or more exception handlers. When no exception occurs in the :keyword:`try` clause, no exception handler is executed. When an exception occurs in the :keyword:`!try` suite, a search for an exception handler is started. This search inspects the :keyword:`!except` clauses in turn until one is found that matches the exception. An expression-less :keyword:`!except` clause, if present, must be last; it matches any exception."
msgstr "بند(های) :keyword:`!except` یک یا چند هندلری استثنا را مشخص می‌کنند. هنگامی که هیچ استثنایی در بند :keyword:`try` رخ نمی‌دهد، هیچ هندلری استثنایی اجرا نمی‌شود. هنگامی که استثنایی در بلوک :keyword:`!try` رخ می‌دهد، جست‌وجو برای یافتن یک هندلری استثنا آغاز می‌شود. این جست‌وجو بندهای :keyword:`!except` را به‌ترتیب بررسی می‌کند تا بندی یافت شود که با استثنا مطابقت دارد. بند :keyword:`!except` فاقد عبارت، در صورت وجود، باید آخرین بند باشد؛ این بند با هر استثنایی مطابقت دارد."

msgid "For an :keyword:`!except` clause with an expression, the expression must evaluate to an exception type or a tuple of exception types. Parentheses can be dropped if multiple exception types are provided and the ``as`` clause is not used. The raised exception matches an :keyword:`!except` clause whose expression evaluates to the class or a :term:`non-virtual base class <abstract base class>` of the exception object, or to a tuple that contains such a class."
msgstr "برای بند :keyword:`!except` همراه با یک عبارت، عبارت باید به یک نوع استثنا یا تاپلی از انواع استثنا ارزیابی شود. اگر چند نوع استثنا ارائه‌شده باشد و از بند ``as`` استفاده نشده باشد، می‌توان پرانتزها را حذف کرد. استثنای پرتاب‌شده با یک بند :keyword:`!except` مطابقت دارد که عبارت آن به کلاس شیء استثنا یا یک :term:`کلاس پایه غیرمجازی <abstract base class>` برای آن، یا به تاپلی حاوی چنین کلاسی ارزیابی می‌شود."

msgid "If no :keyword:`!except` clause matches the exception, the search for an exception handler continues in the surrounding code and on the invocation stack.  [#]_"
msgstr "اگر هیچ بند :keyword:`!except` با استثنا مطابقت نداشته باشد، جست‌وجو برای هندلر استثنا در کد پیرامونی و روی پشته فراخوانی ادامه می‌یابد.  [#]_"

msgid "If the evaluation of an expression in the header of an :keyword:`!except` clause raises an exception, the original search for a handler is canceled and a search starts for the new exception in the surrounding code and on the call stack (it is treated as if the entire :keyword:`try` statement raised the exception)."
msgstr "اگر ارزیابی یک عبارت در سرآیند یک بند :keyword:`!except` باعث پرتاب یک استثنا شود، جست‌وجوی اصلی برای یک هندلر لغو می‌شود و جست‌وجویی برای استثنای جدید در کد پیرامونی و روی پشته فراخوانی آغاز می‌شود (با آن به‌گونه‌ای رفتار می‌شود که گویی کل دستور :keyword:`try` آن استثنا را پرتاب کرده است)."

msgid "When a matching :keyword:`!except` clause is found, the exception is assigned to the target specified after the :keyword:`!as` keyword in that :keyword:`!except` clause, if present, and the :keyword:`!except` clause's suite is executed. All :keyword:`!except` clauses must have an executable block. When the end of this block is reached, execution continues normally after the entire :keyword:`try` statement. (This means that if two nested handlers exist for the same exception, and the exception occurs in the :keyword:`!try` clause of the inner handler, the outer handler will not handle the exception.)"
msgstr "هنگامی که یک بند :keyword:`!except` منطبق پیدا شود، در صورت وجود، استثنا به هدفی که پس از کلیدواژه :keyword:`!as` در آن بند :keyword:`!except` مشخص شده است انتساب می‌یابد و بدنه‌ی بند :keyword:`!except` اجرا می‌شود. همه‌ی بندهای :keyword:`!except` باید یک بلوک قابل‌اجرا داشته باشند. هنگامی که به پایان این بلوک برسیم، اجرا به‌صورت عادی پس از کل دستور :keyword:`try` ادامه می‌یابد. (این بدان معناست که اگر دو هندلری تودرتو برای یک استثنا وجود داشته باشند و استثنا در بند :keyword:`!try` هندلری داخلی رخ دهد، هندلری بیرونی آن استثنا را مدیریت نخواهد کرد.)"

msgid "When an exception has been assigned using ``as target``, it is cleared at the end of the :keyword:`!except` clause.  This is as if::"
msgstr "هنگامی که یک استثنا با استفاده از ``as target`` اختصاص داده شده باشد، در پایان بند :keyword:`!except` پاک می‌شود. این چنین است که::"

msgid ""
"except E as N:\n"
"    foo"
msgstr ""
"except E as N:\n"
"    foo"

msgid "was translated to::"
msgstr "به‌صورت زیر ترجمه شد::"

msgid ""
"except E as N:\n"
"    try:\n"
"        foo\n"
"    finally:\n"
"        del N"
msgstr ""
"except E as N:\n"
"    try:\n"
"        foo\n"
"    finally:\n"
"        del N"

msgid "This means the exception must be assigned to a different name to be able to refer to it after the :keyword:`!except` clause. Exceptions are cleared because with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs."
msgstr "این بدان معناست که برای اینکه بتوانید پس از بند :keyword:`!except` به استثنا ارجاع دهید، باید آن را به نام دیگری اختصاص دهید. استثناها پاک می‌شوند، زیرا همراه با ردگیری پشته‌ی پیوست‌شده به آن‌ها، یک چرخه‌ی ارجاع با فریم پشته تشکیل می‌دهند و همه‌ی متغیرهای محلی آن فریم را تا وقوع زباله‌روبی بعدی زنده نگه می‌دارند."

msgid "Before an :keyword:`!except` clause's suite is executed, the exception is stored in the :mod:`sys` module, where it can be accessed from within the body of the :keyword:`!except` clause by calling :func:`sys.exception`. When leaving an exception handler, the exception stored in the :mod:`sys` module is reset to its previous value::"
msgstr "پیش از اجرای بدنه‌ی بند :keyword:`!except`، استثنا در ماژول :mod:`sys` ذخیره می‌شود، جایی که می‌توان از درون بدنه‌ی بند :keyword:`!except` با فراخوانی :func:`sys.exception` به آن دسترسی داشت. هنگام خروج از یک هندلر استثنا، استثنا ذخیره‌شده در ماژول :mod:`sys` به مقدار پیشین خود بازنشانی می‌شود::"

msgid ""
">>> print(sys.exception())\n"
"None\n"
">>> try:\n"
"...     raise TypeError\n"
"... except:\n"
"...     print(repr(sys.exception()))\n"
"...     try:\n"
"...          raise ValueError\n"
"...     except:\n"
"...         print(repr(sys.exception()))\n"
"...     print(repr(sys.exception()))\n"
"...\n"
"TypeError()\n"
"ValueError()\n"
"TypeError()\n"
">>> print(sys.exception())\n"
"None"
msgstr ""
">>> print(sys.exception())\n"
"None\n"
">>> try:\n"
"...     raise TypeError\n"
"... except:\n"
"...     print(repr(sys.exception()))\n"
"...     try:\n"
"...          raise ValueError\n"
"...     except:\n"
"...         print(repr(sys.exception()))\n"
"...     print(repr(sys.exception()))\n"
"...\n"
"TypeError()\n"
"ValueError()\n"
"TypeError()\n"
">>> print(sys.exception())\n"
"None"

msgid ":keyword:`!except*` clause"
msgstr "بند :keyword:`!except*`"

msgid "The :keyword:`!except*` clause(s) specify one or more handlers for groups of exceptions (:exc:`BaseExceptionGroup` instances). A :keyword:`try` statement can have either :keyword:`except` or :keyword:`!except*` clauses, but not both. The exception type for matching is mandatory in the case of :keyword:`!except*`, so ``except*:`` is a syntax error. The type is interpreted as in the case of :keyword:`!except`, but matching is performed on the exceptions contained in the group that is being handled. A :exc:`TypeError` is raised if a matching type is a subclass of :exc:`!BaseExceptionGroup`, because that would have ambiguous semantics."
msgstr "بند(های) :keyword:`!except*` یک یا چند هندلر برای گروه‌های استثنا (نمونه‌های :exc:`BaseExceptionGroup`) مشخص می‌کنند. یک دستور :keyword:`try` می‌تواند دارای بندهای :keyword:`except` یا :keyword:`!except*` باشد، اما نه هر دو. نوع استثنا برای تطبیق در مورد :keyword:`!except*` الزامی است، بنابراین ``except*:`` یک خطای نحوی است. این نوع همانند حالت :keyword:`!except` تفسیر می‌شود، اما تطبیق بر استثناهای موجود در گروهی که مدیریت می‌شود انجام می‌شود. اگر نوع مورد تطبیق، زیرکلاسی از :exc:`!BaseExceptionGroup` باشد، یک :exc:`TypeError` پرتاب می‌شود، زیرا این حالت دارای معناشناسی مبهمی خواهد بود."

msgid "When an exception group is raised in the try block, each :keyword:`!except*` clause splits (see :meth:`~BaseExceptionGroup.split`) it into the subgroups of matching and non-matching exceptions. If the matching subgroup is not empty, it becomes the handled exception (the value returned from :func:`sys.exception`) and assigned to the target of the :keyword:`!except*` clause (if there is one). Then, the body of the :keyword:`!except*` clause executes. If the non-matching subgroup is not empty, it is processed by the next :keyword:`!except*` in the same manner. This continues until all exceptions in the group have been matched, or the last :keyword:`!except*` clause has run."
msgstr "هنگامی که یک گروه استثنا در بلوک try پرتاب می‌شود، هر بند :keyword:`!except*` آن را (به :meth:`~BaseExceptionGroup.split` مراجعه کنید) به زیرگروه‌هایی از استثناهای منطبق و غیرمنطبق تقسیم می‌کند. اگر زیرگروه منطبق خالی نباشد، به استثنای مدیریت‌شده (مقدار بازگشتی از :func:`sys.exception`) تبدیل می‌شود و به هدف بند :keyword:`!except*` (در صورت وجود) انتساب می‌یابد. سپس بدنه بند :keyword:`!except*` اجرا می‌شود. اگر زیرگروه غیرمنطبق خالی نباشد، به همان شیوه توسط بند :keyword:`!except*` بعدی پردازش می‌شود. این روند ادامه می‌یابد تا همه استثناهای موجود در گروه منطبق شده باشند، یا آخرین بند :keyword:`!except*` اجرا شده باشد."

msgid "After all :keyword:`!except*` clauses execute, the group of unhandled exceptions is merged with any exceptions that were raised or re-raised from within :keyword:`!except*` clauses. This merged exception group propagates on::"
msgstr "پس از اجرای همه‌ی بندهای :keyword:`!except*`، گروه استثناهای مدیریت‌نشده با هر استثنایی که از درون بندهای :keyword:`!except*` پرتاب یا دوباره پرتاب شده است، ادغام می‌شود. این گروه استثنای ادغام‌شده منتشر می‌شود::"

msgid ""
">>> try:\n"
"...     raise ExceptionGroup(\"eg\",\n"
"...         [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"
"... except* TypeError as e:\n"
"...     print(f'caught {type(e)} with nested {e.exceptions}')\n"
"... except* OSError as e:\n"
"...     print(f'caught {type(e)} with nested {e.exceptions}')\n"
"...\n"
"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"
"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<doctest default[0]>\", line 2, in <module>\n"
"  |     raise ExceptionGroup(\"eg\",\n"
"  |         [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"
"  | ExceptionGroup: eg (1 sub-exception)\n"
"  +-+---------------- 1 ----------------\n"
"    | ValueError: 1\n"
"    +------------------------------------"
msgstr ""
">>> try:\n"
"...     raise ExceptionGroup(\"eg\",\n"
"...         [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"
"... except* TypeError as e:\n"
"...     print(f'caught {type(e)} with nested {e.exceptions}')\n"
"... except* OSError as e:\n"
"...     print(f'caught {type(e)} with nested {e.exceptions}')\n"
"...\n"
"caught <class 'ExceptionGroup'> with nested (TypeError(2),)\n"
"caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<doctest default[0]>\", line 2, in <module>\n"
"  |     raise ExceptionGroup(\"eg\",\n"
"  |         [ValueError(1), TypeError(2), OSError(3), OSError(4)])\n"
"  | ExceptionGroup: eg (1 sub-exception)\n"
"  +-+---------------- 1 ----------------\n"
"    | ValueError: 1\n"
"    +------------------------------------"

msgid "If the exception raised from the :keyword:`try` block is not an exception group and its type matches one of the :keyword:`!except*` clauses, it is caught and wrapped by an exception group with an empty message string. This ensures that the type of the target ``e`` is consistently :exc:`BaseExceptionGroup`::"
msgstr "اگر استثنایی که از بلوک :keyword:`try` پرتاب می‌شود، یک گروه استثنا نباشد و نوع آن با یکی از بندهای :keyword:`!except*` مطابقت داشته باشد، آن استثنا گرفته می‌شود و در یک گروه استثنا با رشته پیام خالی پیچیده می‌شود. این امر تضمین می‌کند که نوع هدف ``e`` همواره :exc:`BaseExceptionGroup` باشد::"

msgid ""
">>> try:\n"
"...     raise BlockingIOError\n"
"... except* BlockingIOError as e:\n"
"...     print(repr(e))\n"
"...\n"
"ExceptionGroup('', (BlockingIOError(),))"
msgstr ""
">>> try:\n"
"...     raise BlockingIOError\n"
"... except* BlockingIOError as e:\n"
"...     print(repr(e))\n"
"...\n"
"ExceptionGroup('', (BlockingIOError(),))"

msgid ":keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear in an :keyword:`!except*` clause."
msgstr ":keyword:`break`، :keyword:`continue` و :keyword:`return` نمی‌توانند در یک بند :keyword:`!except*` ظاهر شوند."

msgid ":keyword:`!else` clause"
msgstr "بند :keyword:`!else`"

msgid "The optional :keyword:`!else` clause is executed if the control flow leaves the :keyword:`try` suite, no exception was raised, and no :keyword:`return`, :keyword:`continue`, or :keyword:`break` statement was executed.  Exceptions in the :keyword:`!else` clause are not handled by the preceding :keyword:`except` clauses."
msgstr "بند اختیاری :keyword:`!else` زمانی اجرا می‌شود که جریان کنترل از بلوک :keyword:`try` خارج شود، هیچ استثنایی پرتاب نشده باشد، و هیچ دستور :keyword:`return`، :keyword:`continue` یا :keyword:`break` اجرا نشده باشد. استثناهای بند :keyword:`!else` توسط بندهای :keyword:`except` پیشین مدیریت نمی‌شوند."

msgid ":keyword:`!finally` clause"
msgstr "بند :keyword:`!finally`"

msgid "If :keyword:`!finally` is present, it specifies a 'cleanup' handler.  The :keyword:`try` clause is executed, including any :keyword:`except` and :keyword:`else <except_else>` clauses. If an exception occurs in any of the clauses and is not handled, the exception is temporarily saved. The :keyword:`!finally` clause is executed.  If there is a saved exception it is re-raised at the end of the :keyword:`!finally` clause. If the :keyword:`!finally` clause raises another exception, the saved exception is set as the context of the new exception. If the :keyword:`!finally` clause executes a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement, the saved exception is discarded. For example, this function returns 42."
msgstr "اگر :keyword:`!finally` وجود داشته باشد، یک هندلری «پاک‌سازی» را مشخص می‌کند. بند :keyword:`try` اجرا می‌شود، از جمله هر بند :keyword:`except` و :keyword:`else <except_else>`. اگر استثنایی در هر یک از بندها رخ دهد و رسیدگی نشود، استثنا به‌طور موقت ذخیره می‌شود. بند :keyword:`!finally` اجرا می‌شود. اگر استثنای ذخیره‌شده‌ای وجود داشته باشد، در پایان بند :keyword:`!finally` دوباره پرتاب می‌شود. اگر بند :keyword:`!finally` استثنای دیگری پرتاب کند، استثنای ذخیره‌شده به‌عنوان زمینه‌ی استثنای جدید تنظیم می‌شود. اگر بند :keyword:`!finally` دستور :keyword:`return`، :keyword:`break` یا :keyword:`continue` را اجرا کند، استثنای ذخیره‌شده دور انداخته می‌شود. برای مثال، این تابع ۴۲ را برمی‌گرداند."

msgid ""
"def f():\n"
"    try:\n"
"        1/0\n"
"    finally:\n"
"        return 42"
msgstr ""
"def f():\n"
"    try:\n"
"        1/0\n"
"    finally:\n"
"        return 42"

msgid "The exception information is not available to the program during execution of the :keyword:`!finally` clause."
msgstr "اطلاعات استثنا در حین اجرای بند :keyword:`!finally` در دسترس برنامه نیست."

msgid "When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!finally` statement, the :keyword:`!finally` clause is also executed 'on the way out.'"
msgstr "هرگاه یک دستور :keyword:`return`، :keyword:`break` یا :keyword:`continue` در بلوک :keyword:`try` یک دستور :keyword:`!try`...\\ :keyword:`!finally` اجرا شود، بند :keyword:`!finally` نیز «در مسیر خروج» اجرا می‌شود."

msgid "The return value of a function is determined by the last :keyword:`return` statement executed.  Since the :keyword:`!finally` clause always executes, a :keyword:`!return` statement executed in the :keyword:`!finally` clause will always be the last one executed. The following function returns 'finally'."
msgstr "مقدار برگشتی یک تابع بر اساس آخرین دستور :keyword:`return` ای که اجرا می‌شود تعیین می‌شود. از آن‌جا که بند :keyword:`!finally` همیشه اجرا می‌شود، یک دستور :keyword:`!return` که در بند :keyword:`!finally` اجرا شود، همیشه آخرین دستوری خواهد بود که اجرا می‌شود. تابع زیر 'finally' را برمی‌گرداند."

msgid ""
"def foo():\n"
"    try:\n"
"        return 'try'\n"
"    finally:\n"
"        return 'finally'"
msgstr ""
"def foo():\n"
"    try:\n"
"        return 'try'\n"
"    finally:\n"
"        return 'finally'"

msgid "Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :keyword:`!finally` clause due to a problem with the implementation."
msgstr "پیش از Python 3.8، استفاده از دستور :keyword:`continue` در بند :keyword:`!finally` به دلیل مشکلی در پیاده‌سازی غیرمجاز بود."

msgid "The compiler emits a :exc:`SyntaxWarning` when a :keyword:`return`, :keyword:`break` or :keyword:`continue` appears in a :keyword:`!finally` block (see :pep:`765`)."
msgstr "کامپایلر زمانی که یک :keyword:`return`، :keyword:`break` یا :keyword:`continue` در یک بلوک :keyword:`!finally` ظاهر شود، یک :exc:`SyntaxWarning` نشان می‌دهد (به :pep:`765` مراجعه کنید)."

msgid "The :keyword:`!with` statement"
msgstr "دستور :keyword:`!with`"

msgid "The :keyword:`with` statement is used to wrap the execution of a block with methods defined by a context manager (see section :ref:`context-managers`). This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:`finally` usage patterns to be encapsulated for convenient reuse."
msgstr "دستور :keyword:`with` برای دربرگرفتن اجرای یک بلوک با متدهای تعریف‌شده توسط یک مدیر زمینه استفاده می‌شود (به بخش :ref:`context-managers` مراجعه کنید). این کار امکان کپسوله‌سازی الگوهای رایج استفاده از :keyword:`try`...\\ :keyword:`except`...\\ :keyword:`finally` را برای استفاده مجدد آسان فراهم می‌کند."

msgid "The execution of the :keyword:`with` statement with one \"item\" proceeds as follows:"
msgstr "اجرای دستور :keyword:`with` با یک «آیتم» به صورت زیر انجام می‌شود:"

msgid "The context expression (the expression given in the :token:`~python-grammar:with_item`) is evaluated to obtain a context manager."
msgstr "عبارت زمینه (عبارتی که در :token:`~python-grammar:with_item` داده شده است) ارزیابی می‌شود تا یک مدیر زمینه به دست آید."

msgid "The context manager's :meth:`~object.__enter__` is loaded for later use."
msgstr ":meth:`~object.__enter__` مدیر زمینه برای استفاده‌ی بعدی دریافت و ذخیره می‌شود."

msgid "The context manager's :meth:`~object.__exit__` is loaded for later use."
msgstr "متد :meth:`~object.__exit__` مدیر زمینه برای استفاده بعدی بارگذاری می‌شود."

msgid "The context manager's :meth:`~object.__enter__` method is invoked."
msgstr "متد :meth:`~object.__enter__` مدیر زمینه فراخوانی می‌شود."

msgid "If a target was included in the :keyword:`with` statement, the return value from :meth:`~object.__enter__` is assigned to it."
msgstr "اگر هدفی در دستور :keyword:`with` گنجانده شده باشد، مقدار بازگشتی از :meth:`~object.__enter__` به آن انتساب داده می‌شود."

msgid "The :keyword:`with` statement guarantees that if the :meth:`~object.__enter__` method returns without an error, then :meth:`~object.__exit__` will always be called. Thus, if an error occurs during the assignment to the target list, it will be treated the same as an error occurring within the suite would be. See step 7 below."
msgstr "دستور :keyword:`with` تضمین می‌کند که اگر متد :meth:`~object.__enter__` بدون خطا بازگشت کند، آنگاه :meth:`~object.__exit__` همیشه فراخوانی خواهد شد. بنابراین، اگر در حین انتساب به فهرست هدف خطایی رخ دهد، با آن همان‌گونه رفتار خواهد شد که با خطایی درون بلوک رفتار می‌شود. مرحله ۷ در زیر را ببینید."

msgid "The suite is executed."
msgstr "این بدنه اجرا می‌شود."

msgid "The context manager's :meth:`~object.__exit__` method is invoked.  If an exception caused the suite to be exited, its type, value, and traceback are passed as arguments to :meth:`~object.__exit__`. Otherwise, three :const:`None` arguments are supplied."
msgstr "متد :meth:`~object.__exit__` مدیر زمینه فراخوانی می‌شود. اگر استثنایی باعث خروج از بلوک شده باشد، نوع، مقدار و ردگیری پشته آن به‌عنوان آرگومان به :meth:`~object.__exit__` ارسال می‌شوند. در غیر این صورت، سه آرگومان :const:`None` داده می‌شود."

msgid "If the suite was exited due to an exception, and the return value from the :meth:`~object.__exit__` method was false, the exception is reraised.  If the return value was true, the exception is suppressed, and execution continues with the statement following the :keyword:`with` statement."
msgstr "اگر اجرای بدنه به دلیل یک استثنا متوقف شد و مقدار بازگشتی از متد :meth:`~object.__exit__` نادرست بود، استثنا دوباره پرتاب می‌شود. اگر مقدار بازگشتی درست بود، استثنا سرکوب می‌شود و اجرا با دستور پس از دستور :keyword:`with` ادامه می‌یابد."

msgid "If the suite was exited for any reason other than an exception, the return value from :meth:`~object.__exit__` is ignored, and execution proceeds at the normal location for the kind of exit that was taken."
msgstr "اگر به هر دلیلی به‌جز یک استثنا از بلوک خارج شده باشد، مقدار بازگشتی از :meth:`~object.__exit__` نادیده گرفته می‌شود و اجرا در محل عادی برای نوع خروجی که رخ داده است ادامه می‌یابد."

msgid "The following code::"
msgstr "کد زیر::"

msgid ""
"with EXPRESSION as TARGET:\n"
"    SUITE"
msgstr ""
"with EXPRESSION as TARGET:\n"
"    SUITE"

msgid "is semantically equivalent to::"
msgstr "از نظر معنایی معادل است با::"

msgid ""
"manager = (EXPRESSION)\n"
"enter = manager.__enter__\n"
"exit = manager.__exit__\n"
"value = enter()\n"
"hit_except = False\n"
"\n"
"try:\n"
"    TARGET = value\n"
"    SUITE\n"
"except:\n"
"    hit_except = True\n"
"    if not exit(*sys.exc_info()):\n"
"        raise\n"
"finally:\n"
"    if not hit_except:\n"
"        exit(None, None, None)"
msgstr ""
"manager = (EXPRESSION)\n"
"enter = manager.__enter__\n"
"exit = manager.__exit__\n"
"value = enter()\n"
"hit_except = False\n"
"\n"
"try:\n"
"    TARGET = value\n"
"    SUITE\n"
"except:\n"
"    hit_except = True\n"
"    if not exit(*sys.exc_info()):\n"
"        raise\n"
"finally:\n"
"    if not hit_except:\n"
"        exit(None, None, None)"

msgid "except that implicit :ref:`special method lookup <special-lookup>` is used for :meth:`~object.__enter__` and :meth:`~object.__exit__`."
msgstr "با این تفاوت که از :ref:`جست‌وجوی متد ویژه <special-lookup>` به‌صورت ضمنی برای :meth:`~object.__enter__` و :meth:`~object.__exit__` استفاده می‌شود."

msgid "With more than one item, the context managers are processed as if multiple :keyword:`with` statements were nested::"
msgstr "با بیش از یک آیتم، مدیران زمینه به گونه‌ای پردازش می‌شوند که گویی چندین دستور :keyword:`with` تودرتو شده‌اند::"

msgid ""
"with A() as a, B() as b:\n"
"    SUITE"
msgstr ""
"with A() as a, B() as b:\n"
"    SUITE"

msgid ""
"with A() as a:\n"
"    with B() as b:\n"
"        SUITE"
msgstr ""
"with A() as a:\n"
"    with B() as b:\n"
"        SUITE"

msgid "You can also write multi-item context managers in multiple lines if the items are surrounded by parentheses. For example::"
msgstr "همچنین می‌توانید مدیرهای زمینه با چند آیتم را در چند خط بنویسید، اگر آیتم‌ها داخل پرانتز قرار داشته باشند. برای مثال::"

msgid ""
"with (\n"
"    A() as a,\n"
"    B() as b,\n"
"):\n"
"    SUITE"
msgstr ""
"with (\n"
"    A() as a,\n"
"    B() as b,\n"
"):\n"
"    SUITE"

msgid "Support for multiple context expressions."
msgstr "پشتیبانی از چند عبارت زمینه."

msgid "Support for using grouping parentheses to break the statement in multiple lines."
msgstr "پشتیبانی از استفاده از پرانتزهای گروه‌بندی برای شکستن دستور در چند خط."

msgid ":pep:`343` - The \"with\" statement"
msgstr ":pep:`343` - دستور «with»"

msgid "The specification, background, and examples for the Python :keyword:`with` statement."
msgstr "مشخصات، پیش‌زمینه و نمونه‌هایی برای دستور :keyword:`with` پایتون."

msgid "The :keyword:`!match` statement"
msgstr "دستور :keyword:`!match`"

msgid "The match statement is used for pattern matching.  Syntax:"
msgstr "دستور match برای تطبیق الگو استفاده می‌شود.  سینتکس:"

msgid "This section uses single quotes to denote :ref:`soft keywords <soft-keywords>`."
msgstr "این بخش از علامت‌های نقل‌قول تکی برای نشان دادن :ref:`کلیدواژه‌های نرم <soft-keywords>` استفاده می‌کند."

msgid "Pattern matching takes a pattern as input (following ``case``) and a subject value (following ``match``).  The pattern (which may contain subpatterns) is matched against the subject value.  The outcomes are:"
msgstr "تطبیق الگو یک الگو را به‌عنوان ورودی می‌گیرد (پس از ``case``) و یک مقدار موضوع را (پس از ``match``). الگو (که ممکن است شامل زیرالگوها باشد) با مقدار موضوع تطبیق داده می‌شود. نتایج عبارت‌اند از:"

msgid "A match success or failure (also termed a pattern success or failure)."
msgstr "موفقیت یا شکست در تطابق (که به آن موفقیت یا شکست الگو نیز گفته می‌شود)."

msgid "Possible binding of matched values to a name.  The prerequisites for this are further discussed below."
msgstr "امکان انتساب مقادیر تطبیق‌یافته به یک نام. پیش‌نیازهای این موضوع در ادامه بیشتر بحث شده است."

msgid "The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-keywords>`."
msgstr "کلیدواژه‌های ``match`` و ``case`` :ref:`کلیدواژه‌های نرم <soft-keywords>` هستند."

msgid ":pep:`634` -- Structural Pattern Matching: Specification"
msgstr ":pep:`634` -- تطبیق الگوی ساختاری: مشخصات"

msgid ":pep:`636` -- Structural Pattern Matching: Tutorial"
msgstr ":pep:`636` -- تطبیق الگوی ساختاری: آموزش"

msgid "Overview"
msgstr "نمای کلی"

msgid "Here's an overview of the logical flow of a match statement:"
msgstr "در اینجا نمای کلی از جریان منطقی یک دستور match آمده است:"

msgid "The subject expression ``subject_expr`` is evaluated and a resulting subject value obtained. If the subject expression contains a comma, a tuple is constructed using :ref:`the standard rules <typesseq-tuple>`."
msgstr "عبارت موضوعی ``subject_expr`` ارزیابی می‌شود و مقدار موضوعی حاصل به دست می‌آید. اگر عبارت موضوعی شامل کاما باشد، یک تاپل با استفاده از :ref:`قوانین استاندارد <typesseq-tuple>` ساخته می‌شود."

msgid "Each pattern in a ``case_block`` is attempted to match with the subject value. The specific rules for success or failure are described below. The match attempt can also bind some or all of the standalone names within the pattern. The precise pattern binding rules vary per pattern type and are specified below.  **Name bindings made during a successful pattern match outlive the executed block and can be used after the match statement**."
msgstr "هر الگو در یک ``case_block`` برای تطابق با مقدار موضوع آزمایش می‌شود. قواعد خاص موفقیت یا شکست در زیر توضیح داده شده است. تلاش تطابق همچنین می‌تواند برخی یا همه‌ی نام‌های مستقل درون الگو را مقید کند. قواعد دقیق مقیدسازی الگو بر حسب نوع الگو متفاوت است و در زیر مشخص شده است.  **مقیدسازی‌های نام ایجادشده در طی یک تطابق موفق الگو، پس از اجرای بلوک باقی می‌مانند و می‌توانند پس از دستور match استفاده شوند**."

msgid "During failed pattern matches, some subpatterns may succeed.  Do not rely on bindings being made for a failed match.  Conversely, do not rely on variables remaining unchanged after a failed match.  The exact behavior is dependent on implementation and may vary.  This is an intentional decision made to allow different implementations to add optimizations."
msgstr "در حین تطبیق‌های ناموفق الگو، ممکن است برخی از زیرالگوها موفق شوند. به انجام انتساب‌ها در یک تطبیق ناموفق اتکا نکنید. برعکس، به بدون تغییر ماندن متغیرها پس از یک تطبیق ناموفق اتکا نکنید. رفتار دقیق به پیاده‌سازی بستگی دارد و ممکن است متفاوت باشد. این یک تصمیم عمدی است تا پیاده‌سازی‌های مختلف بتوانند بهینه‌سازی‌هایی را اضافه کنند."

msgid "If the pattern succeeds, the corresponding guard (if present) is evaluated. In this case all name bindings are guaranteed to have happened."
msgstr "اگر الگو با موفقیت تطابق یابد، نگهبان (guard) متناظر (در صورت وجود) ارزیابی می‌شود. در این حالت تضمین می‌شود که همه‌ی پیوندهای نام (name bindings) انجام شده‌اند."

msgid "If the guard evaluates as true or is missing, the ``block`` inside ``case_block`` is executed."
msgstr "اگر نگهبان (guard) به‌صورت درست ارزیابی شود یا وجود نداشته باشد، ``block`` داخل ``case_block`` اجرا می‌شود."

msgid "Otherwise, the next ``case_block`` is attempted as described above."
msgstr "در غیر این صورت، ``case_block`` بعدی همان‌طور که در بالا توضیح داده شد، آزموده می‌شود."

msgid "If there are no further case blocks, the match statement is completed."
msgstr "اگر بلوک‌های case دیگری وجود نداشته باشند، دستور match کامل می‌شود."

msgid "Users should generally never rely on a pattern being evaluated.  Depending on implementation, the interpreter may cache values or use other optimizations which skip repeated evaluations."
msgstr "کاربران به‌طور کلی هرگز نباید به ارزیابی شدن یک الگو تکیه کنند. بسته به پیاده‌سازی، مفسر ممکن است مقادیر را در نهانگاه ذخیره کند یا از بهینه‌سازی‌های دیگری استفاده کند که از ارزیابی‌های مکرر صرف‌نظر می‌کنند."

msgid "A sample match statement::"
msgstr "نمونه‌ای از دستور match::"

msgid ""
">>> flag = False\n"
">>> match (100, 200):\n"
"...    case (100, 300):  # Mismatch: 200 != 300\n"
"...        print('Case 1')\n"
"...    case (100, 200) if flag:  # Successful match, but guard fails\n"
"...        print('Case 2')\n"
"...    case (100, y):  # Matches and binds y to 200\n"
"...        print(f'Case 3, y: {y}')\n"
"...    case _:  # Pattern not attempted\n"
"...        print('Case 4, I match anything!')\n"
"...\n"
"Case 3, y: 200"
msgstr ""
">>> flag = False\n"
">>> match (100, 200):\n"
"...    case (100, 300):  # Mismatch: 200 != 300\n"
"...        print('Case 1')\n"
"...    case (100, 200) if flag:  # Successful match, but guard fails\n"
"...        print('Case 2')\n"
"...    case (100, y):  # Matches and binds y to 200\n"
"...        print(f'Case 3, y: {y}')\n"
"...    case _:  # Pattern not attempted\n"
"...        print('Case 4, I match anything!')\n"
"...\n"
"Case 3, y: 200"

msgid "In this case, ``if flag`` is a guard.  Read more about that in the next section."
msgstr "در این حالت، ``if flag`` یک نگهبان (guard) است. در بخش بعدی بیشتر درباره‌ی آن بخوانید."

msgid "Guards"
msgstr "نگهبان‌ها (Guards)"

msgid "A ``guard`` (which is part of the ``case``) must succeed for code inside the ``case`` block to execute.  It takes the form: :keyword:`if` followed by an expression."
msgstr "یک ``guard`` (که بخشی از ``case`` است) باید برقرار باشد تا کد داخل بلوک ``case`` اجرا شود. شکل آن به این صورت است: :keyword:`if` و به دنبال آن یک عبارت."

msgid "The logical flow of a ``case`` block with a ``guard`` follows:"
msgstr "جریان منطقی یک بلوک ``case`` دارای ``guard`` به این صورت است:"

msgid "Check that the pattern in the ``case`` block succeeded.  If the pattern failed, the ``guard`` is not evaluated and the next ``case`` block is checked."
msgstr "بررسی کنید که الگوی موجود در بلوک ``case`` موفق بوده است. اگر الگو ناموفق بود، ``guard`` ارزیابی نمی‌شود و بلوک ``case`` بعدی بررسی می‌شود."

msgid "If the pattern succeeded, evaluate the ``guard``."
msgstr "اگر الگو موفقیت‌آمیز بود، ``guard`` ارزیابی می‌شود."

msgid "If the ``guard`` condition evaluates as true, the case block is selected."
msgstr "اگر حاصل ارزیابی شرط ``guard`` درست باشد، بلوک case انتخاب می‌شود."

msgid "If the ``guard`` condition evaluates as false, the case block is not selected."
msgstr "اگر حاصل ارزیابی شرط ``guard`` نادرست باشد، بلوک case انتخاب نمی‌شود."

msgid "If the ``guard`` raises an exception during evaluation, the exception bubbles up."
msgstr "اگر ``guard`` در حین ارزیابی استثنایی را پرتاب کند، آن استثنا به بالا منتشر می‌شود."

msgid "Guards are allowed to have side effects as they are expressions.  Guard evaluation must proceed from the first to the last case block, one at a time, skipping case blocks whose pattern(s) don't all succeed. (I.e., guard evaluation must happen in order.) Guard evaluation must stop once a case block is selected."
msgstr "نگهبان‌ها (guards) مجازند اثرات جانبی داشته باشند، زیرا عبارت هستند. ارزیابی نگهبان باید از اولین تا آخرین بلوک case، یکی‌یکی پیش برود و بلوک‌های case را که همه‌ی الگوهای آن‌ها موفق نمی‌شوند، رد کند. (یعنی ارزیابی نگهبان باید به‌ترتیب انجام شود.) ارزیابی نگهبان باید پس از انتخاب یک بلوک case متوقف شود."

msgid "Irrefutable Case Blocks"
msgstr "بلوک‌های case غیرقابل‌انکار"

msgid "An irrefutable case block is a match-all case block.  A match statement may have at most one irrefutable case block, and it must be last."
msgstr "یک بلوک case غیرقابل‌انکار (irrefutable case block)، یک بلوک case تطبیق همه (match-all case block) است. یک دستور match می‌تواند حداکثر یک بلوک case غیرقابل‌انکار داشته باشد، و آن باید آخرین باشد."

msgid "A case block is considered irrefutable if it has no guard and its pattern is irrefutable.  A pattern is considered irrefutable if we can prove from its syntax alone that it will always succeed.  Only the following patterns are irrefutable:"
msgstr "یک بلوک case در صورتی غیرقابل‌رد در نظر گرفته می‌شود که هیچ شرط محافظی (guard) نداشته باشد و الگوی آن غیرقابل‌رد باشد. یک الگو در صورتی غیرقابل‌رد در نظر گرفته می‌شود که بتوان تنها از روی سینتکس آن اثبات کرد که همیشه موفق می‌شود. تنها الگوهای زیر غیرقابل‌رد هستند:"

msgid ":ref:`as-patterns` whose left-hand side is irrefutable"
msgstr ":ref:`as-patterns` که سمت چپ آن‌ها غیرقابل‌انکار است"

msgid ":ref:`or-patterns` containing at least one irrefutable pattern"
msgstr ":ref:`or-patterns` شامل دست‌کم یک الگوی انکارناپذیر (irrefutable pattern)"

msgid ":ref:`capture-patterns`"
msgstr ":ref:`capture-patterns`"

msgid ":ref:`wildcard-patterns`"
msgstr ":ref:`wildcard-patterns`"

msgid "parenthesized irrefutable patterns"
msgstr "الگوهای غیرقابل‌انکار داخل پرانتز"

msgid "Patterns"
msgstr "الگوها"

msgid "This section uses grammar notations beyond standard EBNF:"
msgstr "این بخش از نمادگذاری‌های گرامری فراتر از EBNF استاندارد استفاده می‌کند:"

msgid "the notation ``SEP.RULE+`` is shorthand for ``RULE (SEP RULE)*``"
msgstr "نماد ``SEP.RULE+`` شکل کوتاهی از ``RULE (SEP RULE)*`` است"

msgid "the notation ``!RULE`` is shorthand for a negative lookahead assertion"
msgstr "نماد ``!RULE`` خلاصه‌ای برای ادعای پیش‌نگر منفی (negative lookahead assertion) است"

msgid "The top-level syntax for ``patterns`` is:"
msgstr "سینتکس سطح بالا برای ``patterns`` عبارت است از:"

msgid "The descriptions below will include a description \"in simple terms\" of what a pattern does for illustration purposes (credits to Raymond Hettinger for a document that inspired most of the descriptions). Note that these descriptions are purely for illustration purposes and **may not** reflect the underlying implementation.  Furthermore, they do not cover all valid forms."
msgstr "توصیف‌های زیر برای مقاصد توضیحی، شامل توضیحی «به زبان ساده» درباره‌ی عملکرد یک الگو خواهند بود (با قدردانی از Raymond Hettinger برای سندی که الهام‌بخش بیشتر این توصیف‌ها بود). توجه داشته باشید که این توصیف‌ها صرفاً جنبه‌ی توضیحی دارند و **ممکن است** پیاده‌سازی زیربنایی را بازتاب ندهند. علاوه بر این، آن‌ها همه‌ی صورت‌های معتبر را پوشش نمی‌دهند."

msgid "OR Patterns"
msgstr "الگوهای OR"

msgid "An OR pattern is two or more patterns separated by vertical bars ``|``.  Syntax:"
msgstr "الگوی OR شامل دو یا چند الگو است که با سطرهای عمودی ``|`` از هم جدا شده‌اند. سینتکس:"

msgid "Only the final subpattern may be :ref:`irrefutable <irrefutable_case>`, and each subpattern must bind the same set of names to avoid ambiguity."
msgstr "فقط آخرین زیرالگو می‌تواند :ref:`irrefutable <irrefutable_case>` باشد و هر زیرالگو باید برای جلوگیری از ابهام، مجموعه‌ای یکسان از نام‌ها را مقید کند."

msgid "An OR pattern matches each of its subpatterns in turn to the subject value, until one succeeds.  The OR pattern is then considered successful.  Otherwise, if none of the subpatterns succeed, the OR pattern fails."
msgstr "یک الگوی OR هر یک از زیرالگوهای خود را به‌نوبت با مقدار موضوع تطبیق می‌دهد، تا یکی موفق شود. در این صورت، الگوی OR موفق در نظر گرفته می‌شود. در غیر این صورت، اگر هیچ‌یک از زیرالگوها موفق نشوند، الگوی OR ناموفق می‌شود."

msgid "In simple terms, ``P1 | P2 | ...`` will try to match ``P1``, if it fails it will try to match ``P2``, succeeding immediately if any succeeds, failing otherwise."
msgstr "به بیان ساده، ``P1 | P2 | ...`` تلاش می‌کند ``P1`` را تطبیق دهد، اگر ناموفق باشد، تلاش می‌کند ``P2`` را تطبیق دهد، و در صورت موفقیت هر یک، بلافاصله موفق می‌شود، در غیر این صورت ناموفق می‌شود."

msgid "AS Patterns"
msgstr "الگوهای AS"

msgid "An AS pattern matches an OR pattern on the left of the :keyword:`as` keyword against a subject.  Syntax:"
msgstr "یک الگوی AS، الگوی OR در سمت چپ کلیدواژه :keyword:`as` را با یک موضوع تطبیق می‌دهد. سینتکس:"

msgid "If the OR pattern fails, the AS pattern fails.  Otherwise, the AS pattern binds the subject to the name on the right of the as keyword and succeeds. ``capture_pattern`` cannot be a ``_``."
msgstr "اگر الگوی OR شکست بخورد، الگوی AS نیز شکست می‌خورد. در غیر این صورت، الگوی AS موضوع را به نام سمت راست کلیدواژه as مقید می‌کند و موفق می‌شود. ``capture_pattern`` نمی‌تواند ``_`` باشد."

msgid "In simple terms ``P as NAME`` will match with ``P``, and on success it will set ``NAME = <subject>``."
msgstr "به بیان ساده، ``P as NAME`` با ``P`` تطابق خواهد داشت و در صورت موفقیت، ``NAME = <subject>`` را تنظیم خواهد کرد."

msgid "Literal Patterns"
msgstr "الگوهای لفظی"

msgid "A literal pattern corresponds to most :ref:`literals <literals>` in Python.  Syntax:"
msgstr "یک الگوی لفظی (literal pattern) با بیشتر :ref:`مقادیر لفظی <literals>` در پایتون مطابقت دارد.  سینتکس:"

msgid "The rule ``strings`` and the token ``NUMBER`` are defined in the :doc:`standard Python grammar <./grammar>`.  Triple-quoted strings are supported.  Raw strings and byte strings are supported.  :ref:`f-strings` and :ref:`t-strings` are not supported."
msgstr "قاعده‌ی ``strings`` و توکن ``NUMBER`` در :doc:`دستور زبان استاندارد پایتون <./grammar>` تعریف شده‌اند. رشته‌های سه‌نقل‌قولی پشتیبانی می‌شوند. رشته‌های خام و رشته‌های بایتی پشتیبانی می‌شوند. :ref:`f-strings` و :ref:`t-strings` پشتیبانی نمی‌شوند."

msgid "The forms ``signed_number '+' NUMBER`` and ``signed_number '-' NUMBER`` are for expressing :ref:`complex numbers <imaginary>`; they require a real number on the left and an imaginary number on the right. E.g. ``3 + 4j``."
msgstr "قالب‌های ``signed_number '+' NUMBER`` و ``signed_number '-' NUMBER`` برای بیان :ref:`اعداد مختلط <imaginary>` هستند؛ سمت چپ باید یک عدد حقیقی و سمت راست باید یک عدد موهومی باشد. مثلاً ``3 + 4j``."

msgid "In simple terms, ``LITERAL`` will succeed only if ``<subject> == LITERAL``. For the singletons ``None``, ``True`` and ``False``, the :keyword:`is` operator is used."
msgstr "به بیان ساده، ``LITERAL`` تنها در صورتی موفق می‌شود که ``<subject> == LITERAL`` باشد. برای مقادیر تک‌نمونه ``None``، ``True`` و ``False``، از عملگر :keyword:`is` استفاده می‌شود."

msgid "Capture Patterns"
msgstr "الگوهای ثبت‌کننده"

msgid "A capture pattern binds the subject value to a name. Syntax:"
msgstr "یک الگوی ثبت‌کننده (capture pattern)، مقدار موضوع را به یک نام مقید می‌کند. سینتکس:"

msgid "A single underscore ``_`` is not a capture pattern (this is what ``!'_'`` expresses). It is instead treated as a :token:`~python-grammar:wildcard_pattern`."
msgstr "یک زیرخط تکی ``_`` یک الگوی ثبت‌کننده نیست (این همان چیزی است که ``!'_'`` بیان می‌کند). در عوض، به‌عنوان یک :token:`~python-grammar:wildcard_pattern` در نظر گرفته می‌شود."

msgid "In a given pattern, a given name can only be bound once.  E.g. ``case x, x: ...`` is invalid while ``case [x] | x: ...`` is allowed."
msgstr "در یک الگوی مشخص، یک نام مشخص فقط می‌تواند یک بار مقید شود. برای مثال ``case x, x: ...`` نامعتبر است، در حالی که ``case [x] | x: ...`` مجاز است."

msgid "Capture patterns always succeed.  The binding follows scoping rules established by the assignment expression operator in :pep:`572`; the name becomes a local variable in the closest containing function scope unless there's an applicable :keyword:`global` or :keyword:`nonlocal` statement."
msgstr "الگوهای ثبت‌کننده (capture patterns) همیشه موفق می‌شوند. این پیوند از قواعد محدوده تعیین‌شده توسط عملگر عبارت انتساب در :pep:`572` پیروی می‌کند؛ نام به یک متغیر محلی در نزدیک‌ترین محدوده تابع دربرگیرنده تبدیل می‌شود، مگر اینکه یک دستور :keyword:`global` یا :keyword:`nonlocal` قابل‌اعمال وجود داشته باشد."

msgid "In simple terms ``NAME`` will always succeed and it will set ``NAME = <subject>``."
msgstr "به بیان ساده، ``NAME`` همیشه موفق خواهد بود و باعث می‌شود ``NAME = <subject>`` تنظیم شود."

msgid "Wildcard Patterns"
msgstr "الگوهای وایلدکارد"

msgid "A wildcard pattern always succeeds (matches anything) and binds no name.  Syntax:"
msgstr "یک الگوی وایلدکارد (wildcard pattern) همیشه موفق است (با هر چیزی تطابق دارد) و هیچ نامی را مقید نمی‌کند. سینتکس:"

msgid "``_`` is a :ref:`soft keyword <soft-keywords>` within any pattern, but only within patterns.  It is an identifier, as usual, even within ``match`` subject expressions, ``guard``\\ s, and ``case`` blocks."
msgstr "``_`` در هر الگویی یک :ref:`کلیدواژه نرم <soft-keywords>` است، اما فقط در داخل الگوها. این، مطابق معمول، یک شناسه است، حتی در عبارت‌های موضوع ``match``، ``guard``\\ها و بلوک‌های ``case``."

msgid "In simple terms, ``_`` will always succeed."
msgstr "به بیان ساده، ``_`` همیشه موفق خواهد بود."

msgid "Value Patterns"
msgstr "الگوهای مقدار"

msgid "A value pattern represents a named value in Python. Syntax:"
msgstr "الگوی مقدار، یک مقدار نام‌دار را در پایتون نشان می‌دهد. سینتکس:"

msgid "The dotted name in the pattern is looked up using standard Python :ref:`name resolution rules <resolve_names>`.  The pattern succeeds if the value found compares equal to the subject value (using the ``==`` equality operator)."
msgstr "نام نقطه‌دار در الگو با استفاده از :ref:`قواعد حل نام <resolve_names>` استاندارد پایتون جستجو می‌شود. الگو زمانی موفق است که مقدار یافت‌شده در مقایسه با مقدار موضوع برابر باشد (با استفاده از عملگر برابری ``==``)."

msgid "In simple terms ``NAME1.NAME2`` will succeed only if ``<subject> == NAME1.NAME2``"
msgstr "به بیان ساده، ``NAME1.NAME2`` تنها در صورتی موفق می‌شود که ``<subject> == NAME1.NAME2``"

msgid "If the same value occurs multiple times in the same match statement, the interpreter may cache the first value found and reuse it rather than repeat the same lookup.  This cache is strictly tied to a given execution of a given match statement."
msgstr "اگر یک مقدار یکسان چندین بار در یک دستور match یکسان رخ دهد، مفسر ممکن است اولین مقدار یافت‌شده را در نهانگاه ذخیره کند و به جای تکرار همان جست‌وجو، دوباره از آن استفاده کند. این نهانگاه کاملاً به یک اجرای معین از یک دستور match معین وابسته است."

msgid "Group Patterns"
msgstr "الگوهای گروهی"

msgid "A group pattern allows users to add parentheses around patterns to emphasize the intended grouping.  Otherwise, it has no additional syntax. Syntax:"
msgstr "الگوی گروهی به کاربران اجازه می‌دهد تا برای تأکید بر گروه‌بندی موردنظر، پرانتزها را اطراف الگوها اضافه کنند. در غیر این صورت، سینتکس اضافی ندارد. سینتکس:"

msgid "In simple terms ``(P)`` has the same effect as ``P``."
msgstr "به بیان ساده، ``(P)`` همان اثر ``P`` را دارد."

msgid "Sequence Patterns"
msgstr "الگوهای دنباله‌ای"

msgid "A sequence pattern contains several subpatterns to be matched against sequence elements. The syntax is similar to the unpacking of a list or tuple."
msgstr "یک الگوی دنباله‌ای شامل چندین الگوی فرعی برای تطبیق با عناصر دنباله است. سینتکس آن مشابه واگشایی یک فهرست یا تاپل است."

msgid "There is no difference if parentheses  or square brackets are used for sequence patterns (i.e. ``(...)`` vs ``[...]`` )."
msgstr "استفاده از پرانتز یا کروشه برای الگوهای دنباله‌ای هیچ تفاوتی ندارد (یعنی ``(...)`` در مقابل ``[...]``)."

msgid "A single pattern enclosed in parentheses without a trailing comma (e.g. ``(3 | 4)``) is a :ref:`group pattern <group-patterns>`. While a single pattern enclosed in square brackets (e.g. ``[3 | 4]``) is still a sequence pattern."
msgstr "یک الگوی واحد که داخل پرانتز قرار گرفته باشد و ویرگول انتهایی نداشته باشد (برای مثال ``(3 | 4)``) یک :ref:`الگوی گروه <group-patterns>` است. در حالی که یک الگوی واحد که داخل کروشه قرار گرفته باشد (برای مثال ``[3 | 4]``) همچنان یک الگوی دنباله است."

msgid "At most one star subpattern may be in a sequence pattern.  The star subpattern may occur in any position. If no star subpattern is present, the sequence pattern is a fixed-length sequence pattern; otherwise it is a variable-length sequence pattern."
msgstr "حداکثر یک زیرالگوی ستاره‌ای می‌تواند در یک الگوی دنباله وجود داشته باشد. زیرالگوی ستاره‌ای می‌تواند در هر جایگاهی رخ دهد. اگر هیچ زیرالگوی ستاره‌ای وجود نداشته باشد، الگوی دنباله یک الگوی دنباله با طول ثابت است؛ در غیر این صورت یک الگوی دنباله با طول متغیر است."

msgid "The following is the logical flow for matching a sequence pattern against a subject value:"
msgstr "جریان منطقی برای تطبیق یک الگوی دنباله‌ای با یک مقدار موضوع به شرح زیر است:"

msgid "If the subject value is not a sequence [#]_, the sequence pattern fails."
msgstr "اگر مقدار موضوع یک دنباله نباشد [#]_، الگوی دنباله شکست می‌خورد."

msgid "If the subject value is an instance of ``str``, ``bytes`` or ``bytearray`` the sequence pattern fails."
msgstr "اگر مقدار موضوع، نمونه‌ای از ``str``، ``bytes`` یا ``bytearray`` باشد، الگوی دنباله شکست می‌خورد."

msgid "The subsequent steps depend on whether the sequence pattern is fixed or variable-length."
msgstr "مراحل بعدی به این بستگی دارد که الگوی دنباله با طول ثابت باشد یا با طول متغیر."

msgid "If the sequence pattern is fixed-length:"
msgstr "اگر الگوی دنباله طول ثابت داشته باشد:"

msgid "If the length of the subject sequence is not equal to the number of subpatterns, the sequence pattern fails"
msgstr "اگر طول دنباله‌ی موضوع با تعداد الگوهای فرعی برابر نباشد، الگوی دنباله‌ای شکست می‌خورد"

msgid "Subpatterns in the sequence pattern are matched to their corresponding items in the subject sequence from left to right.  Matching stops as soon as a subpattern fails.  If all subpatterns succeed in matching their corresponding item, the sequence pattern succeeds."
msgstr "زیرالگوهای موجود در الگوی دنباله، از چپ به راست با آیتم‌های متناظر خود در دنباله‌ی موضوع تطبیق داده می‌شوند. تطبیق به محض اینکه یک زیرالگو شکست بخورد، متوقف می‌شود. اگر همه‌ی زیرالگوها در تطبیق آیتم متناظر خود موفق شوند، الگوی دنباله موفق می‌شود."

msgid "Otherwise, if the sequence pattern is variable-length:"
msgstr "در غیر این صورت، اگر الگوی دنباله با طول متغیر باشد:"

msgid "If the length of the subject sequence is less than the number of non-star subpatterns, the sequence pattern fails."
msgstr "اگر طول دنباله‌ی موضوع کمتر از تعداد زیرالگوهای غیرستاره‌ای باشد، الگوی دنباله‌ای شکست می‌خورد."

msgid "The leading non-star subpatterns are matched to their corresponding items as for fixed-length sequences."
msgstr "زیرالگوهای غیرستاره‌ای ابتدایی، همان‌طور که برای دنباله‌های با طول ثابت انجام می‌شود، با آیتم‌های متناظر خود تطبیق داده می‌شوند."

msgid "If the previous step succeeds, the star subpattern matches a list formed of the remaining subject items, excluding the remaining items corresponding to non-star subpatterns following the star subpattern."
msgstr "اگر مرحله‌ی پیشین با موفقیت انجام شود، زیرالگوی ستاره‌ای با فهرستی تشکیل‌شده از آیتم‌های باقی‌مانده‌ی موضوع مطابقت دارد، به‌جز آیتم‌های باقی‌مانده‌ای که با زیرالگوهای غیرستاره‌ای پس از زیرالگوی ستاره‌ای متناظر هستند."

msgid "Remaining non-star subpatterns are matched to their corresponding subject items, as for a fixed-length sequence."
msgstr "زیرالگوهای غیرستاره‌ای باقی‌مانده، مانند یک دنباله با طول ثابت، با آیتم‌های متناظر موضوع مطابقت داده می‌شوند."

msgid "The length of the subject sequence is obtained via :func:`len` (i.e. via the :meth:`~object.__len__` protocol). This length may be cached by the interpreter in a similar manner as :ref:`value patterns <value-patterns>`."
msgstr "طول دنباله‌ی موضوع از طریق :func:`len` (یعنی از طریق پروتکل :meth:`~object.__len__`) به دست می‌آید. ممکن است مفسر این طول را به شیوه‌ای مشابه :ref:`الگوهای مقدار <value-patterns>` در نهانگاه ذخیره کند."

msgid "In simple terms ``[P1, P2, P3,`` ... ``, P<N>]`` matches only if all the following happens:"
msgstr "به زبان ساده ``[P1, P2, P3,`` ... ``, P<N>]`` تنها در صورتی مطابقت می‌کند که همه موارد زیر رخ دهد:"

msgid "check ``<subject>`` is a sequence"
msgstr "بررسی کنید که ``<subject>`` یک دنباله است"

msgid "``len(subject) == <N>``"
msgstr "``len(subject) == <N>``"

msgid "``P1`` matches ``<subject>[0]`` (note that this match can also bind names)"
msgstr "``P1`` با ``<subject>[0]`` مطابقت دارد (توجه کنید که این تطابق همچنین می‌تواند نام‌ها را مقید کند)"

msgid "``P2`` matches ``<subject>[1]`` (note that this match can also bind names)"
msgstr "``P2`` با ``<subject>[1]`` مطابقت دارد (توجه داشته باشید که این تطبیق می‌تواند نام‌ها را نیز مقید کند)"

msgid "... and so on for the corresponding pattern/element."
msgstr "... و به همین ترتیب برای الگو/المان متناظر."

msgid "Mapping Patterns"
msgstr "الگوهای نگاشت"

msgid "A mapping pattern contains one or more key-value patterns.  The syntax is similar to the construction of a dictionary. Syntax:"
msgstr "یک الگوی نگاشت شامل یک یا چند الگوی کلید-مقدار است. سینتکس آن شبیه به ساخت یک دیکشنری است. سینتکس:"

msgid "At most one double star pattern may be in a mapping pattern.  The double star pattern must be the last subpattern in the mapping pattern."
msgstr "حداکثر یک الگوی دو ستاره می‌تواند در یک الگوی نگاشت وجود داشته باشد. الگوی دو ستاره باید آخرین زیرالگو در الگوی نگاشت باشد."

msgid "Duplicate keys in mapping patterns are disallowed. Duplicate literal keys will raise a :exc:`SyntaxError`. Two keys that otherwise have the same value will raise a :exc:`ValueError` at runtime."
msgstr "کلیدهای تکراری در الگوهای نگاشت مجاز نیستند. کلیدهای لفظی تکراری باعث پرتاب یک :exc:`SyntaxError` می‌شوند. دو کلیدی که در غیر این صورت مقدار یکسانی دارند، در ران‌تایم یک :exc:`ValueError` پرتاب می‌کنند."

msgid "The following is the logical flow for matching a mapping pattern against a subject value:"
msgstr "جریان منطقی برای تطبیق یک الگوی نگاشت (mapping pattern) با یک مقدار موضوع (subject value) به‌صورت زیر است:"

msgid "If the subject value is not a mapping [#]_,the mapping pattern fails."
msgstr "اگر مقدار موضوع یک نگاشت [#]_ نباشد، الگوی نگاشت شکست می‌خورد."

msgid "If every key given in the mapping pattern is present in the subject mapping, and the pattern for each key matches the corresponding item of the subject mapping, the mapping pattern succeeds."
msgstr "اگر هر کلید داده‌شده در الگوی نگاشت در نگاشت موضوع وجود داشته باشد و الگوی مربوط به هر کلید با آیتم متناظرِ نگاشت موضوع مطابقت داشته باشد، الگوی نگاشت موفق می‌شود."

msgid "If duplicate keys are detected in the mapping pattern, the pattern is considered invalid. A :exc:`SyntaxError` is raised for duplicate literal values; or a :exc:`ValueError` for named keys of the same value."
msgstr "اگر کلیدهای تکراری در الگوی نگاشت شناسایی شوند، آن الگو نامعتبر در نظر گرفته می‌شود. برای مقادیر لفظی تکراری، استثنای :exc:`SyntaxError` پرتاب می‌شود؛ یا برای کلیدهای نام‌دار با مقدار یکسان، استثنای :exc:`ValueError` پرتاب می‌شود."

msgid "Key-value pairs are matched using the two-argument form of the mapping subject's ``get()`` method.  Matched key-value pairs must already be present in the mapping, and not created on-the-fly via :meth:`~object.__missing__` or :meth:`~object.__getitem__`."
msgstr "جفت‌های کلید-مقدار با استفاده از شکل دو آرگومانی متد ``get()`` موضوع‌ی نگاشت تطبیق داده می‌شوند. جفت‌های کلید-مقدار تطبیق‌داده‌شده باید از قبل در نگاشت موجود باشند و به‌صورت آنی از طریق :meth:`~object.__missing__` یا :meth:`~object.__getitem__` ایجاد نشده باشند."

msgid "In simple terms ``{KEY1: P1, KEY2: P2, ... }`` matches only if all the following happens:"
msgstr "به زبان ساده ``{KEY1: P1, KEY2: P2, ... }`` فقط در صورتی مطابقت دارد که همه‌ی موارد زیر رخ دهد:"

msgid "check ``<subject>`` is a mapping"
msgstr "بررسی می‌کند که ``<subject>`` یک نگاشت است"

msgid "``KEY1 in <subject>``"
msgstr "``KEY1 in <subject>``"

msgid "``P1`` matches ``<subject>[KEY1]``"
msgstr "``P1`` با ``<subject>[KEY1]`` مطابقت دارد"

msgid "... and so on for the corresponding KEY/pattern pair."
msgstr "... و به همین ترتیب برای جفت KEY/الگوی متناظر."

msgid "Class Patterns"
msgstr "الگوهای کلاس"

msgid "A class pattern represents a class and its positional and keyword arguments (if any).  Syntax:"
msgstr "الگوی کلاس، یک کلاس و آرگومان‌های جایگاهی و کلیدواژه‌ای آن (در صورت وجود) را نشان می‌دهد. سینتکس:"

msgid "The same keyword should not be repeated in class patterns."
msgstr "کلیدواژه‌ی یکسان نباید در الگوهای کلاس تکرار شود."

msgid "The following is the logical flow for matching a class pattern against a subject value:"
msgstr "روند منطقی تطبیق یک الگوی کلاس با یک مقدار موضوع به شرح زیر است:"

msgid "If ``name_or_attr`` is not an instance of the builtin :class:`type` , raise :exc:`TypeError`."
msgstr "اگر ``name_or_attr`` نمونه‌ای از :class:`type` توکار نباشد، :exc:`TypeError` پرتاب می‌شود."

msgid "If the subject value is not an instance of ``name_or_attr`` (tested via :func:`isinstance`), the class pattern fails."
msgstr "اگر مقدار موضوع، نمونه‌ای از ``name_or_attr`` نباشد (که از طریق :func:`isinstance` آزمایش می‌شود)، الگوی کلاس شکست می‌خورد."

msgid "If no pattern arguments are present, the pattern succeeds.  Otherwise, the subsequent steps depend on whether keyword or positional argument patterns are present."
msgstr "اگر هیچ آرگومان الگویی وجود نداشته باشد، الگو موفق می‌شود. در غیر این صورت، مراحل بعدی به این بستگی دارد که الگوهای آرگومان کلیدواژه‌ای یا جایگاهی وجود داشته باشند."

msgid "For a number of built-in types (specified below), a single positional subpattern is accepted which will match the entire subject; for these types keyword patterns also work as for other types."
msgstr "برای تعدادی از انواع توکار (که در زیر مشخص شده‌اند)، یک زیرالگوی جایگاهی واحد پذیرفته می‌شود که با کل موضوع مطابقت خواهد داشت؛ برای این انواع، الگوهای کلیدواژه‌ای نیز مانند سایر انواع عمل می‌کنند."

msgid "If only keyword patterns are present, they are processed as follows, one by one:"
msgstr "اگر فقط الگوهای کلیدواژه‌ای وجود داشته باشند، آن‌ها به‌صورت زیر، یکی‌یکی پردازش می‌شوند:"

msgid "The keyword is looked up as an attribute on the subject."
msgstr "کلیدواژه به‌عنوان یک ویژگی روی موضوع جست‌وجو می‌شود."

msgid "If this raises an exception other than :exc:`AttributeError`, the exception bubbles up."
msgstr "اگر این عمل باعث پرتاب استثنایی به‌جز :exc:`AttributeError` شود، استثنا به بالا منتشر می‌شود."

msgid "If this raises :exc:`AttributeError`, the class pattern has failed."
msgstr "اگر این :exc:`AttributeError` را پرتاب کند، الگوی کلاس شکست خورده است."

msgid "Else, the subpattern associated with the keyword pattern is matched against the subject's attribute value.  If this fails, the class pattern fails; if this succeeds, the match proceeds to the next keyword."
msgstr "در غیر این صورت، زیرالگوی مرتبط با الگوی کلیدواژه‌ای با مقدار ویژگی موضوع تطبیق داده می‌شود. اگر این تطبیق شکست بخورد، الگوی کلاس شکست می‌خورد؛ اگر موفق باشد، تطبیق به کلیدواژه بعدی ادامه می‌یابد."

msgid "If all keyword patterns succeed, the class pattern succeeds."
msgstr "اگر همه‌ی الگوهای کلیدواژه‌ای موفق شوند، الگوی کلاس موفق می‌شود."

msgid "If any positional patterns are present, they are converted to keyword patterns using the :data:`~object.__match_args__` attribute on the class ``name_or_attr`` before matching:"
msgstr "اگر الگوهای جایگاهی وجود داشته باشند، آن‌ها پیش از تطبیق، با استفاده از ویژگی :data:`~object.__match_args__` در کلاس ``name_or_attr`` به الگوهای کلیدواژه‌ای تبدیل می‌شوند:"

msgid "The equivalent of ``getattr(cls, \"__match_args__\", ())`` is called."
msgstr "معادل ``getattr(cls, \"__match_args__\", ())`` فراخوانی می‌شود."

msgid "If this raises an exception, the exception bubbles up."
msgstr "اگر این کار استثناای پرتاب کند، استثنا به بالا منتشر می‌شود."

msgid "If the returned value is not a tuple, the conversion fails and :exc:`TypeError` is raised."
msgstr "اگر مقدار بازگشتی یک تاپل نباشد، تبدیل شکست می‌خورد و :exc:`TypeError` پرتاب می‌شود."

msgid "If there are more positional patterns than ``len(cls.__match_args__)``, :exc:`TypeError` is raised."
msgstr "اگر الگوهای جایگاهی بیشتری نسبت به ``len(cls.__match_args__)`` وجود داشته باشد، استثنای :exc:`TypeError` پرتاب می‌شود."

msgid "Otherwise, positional pattern ``i`` is converted to a keyword pattern using ``__match_args__[i]`` as the keyword.  ``__match_args__[i]`` must be a string; if not :exc:`TypeError` is raised."
msgstr "در غیر این صورت، الگوی جایگاهی ``i`` با استفاده از ``__match_args__[i]`` به‌عنوان کلیدواژه، به یک الگوی کلیدواژه‌ای تبدیل می‌شود. ``__match_args__[i]`` باید یک رشته باشد؛ در غیر این صورت :exc:`TypeError` پرتاب می‌شود."

msgid "If there are duplicate keywords, :exc:`TypeError` is raised."
msgstr "در صورت وجود کلیدواژه‌های تکراری، :exc:`TypeError` پرتاب می‌شود."

msgid ":ref:`class-pattern-matching`"
msgstr ":ref:`class-pattern-matching`"

msgid "Once all positional patterns have been converted to keyword patterns, the match proceeds as if there were only keyword patterns."
msgstr "پس از اینکه همه‌ی الگوهای جایگاهی به الگوهای کلیدواژه‌ای تبدیل شدند، تطبیق به‌گونه‌ای ادامه می‌یابد که گویی فقط الگوهای کلیدواژه‌ای وجود دارند."

msgid "For the following built-in types the handling of positional subpatterns is different:"
msgstr "برای انواع توکار زیر، نحوه‌ی مدیریت زیرالگوهای جایگاهی متفاوت است:"

msgid ":class:`bool`"
msgstr ":class:`bool`"

msgid ":class:`bytearray`"
msgstr ":class:`bytearray`"

msgid ":class:`bytes`"
msgstr ":class:`bytes`"

msgid ":class:`dict`"
msgstr ":class:`dict`"

msgid ":class:`float`"
msgstr ":class:`float`"

msgid ":class:`frozendict`"
msgstr ":class:`frozendict`"

msgid ":class:`frozenset`"
msgstr ":class:`frozenset`"

msgid ":class:`int`"
msgstr ":class:`int`"

msgid ":class:`list`"
msgstr ":class:`list`"

msgid ":class:`set`"
msgstr ":class:`set`"

msgid ":class:`str`"
msgstr ":class:`str`"

msgid ":class:`tuple`"
msgstr ":class:`tuple`"

msgid "These classes accept a single positional argument, and the pattern there is matched against the whole object rather than an attribute. For example ``int(0|1)`` matches the value ``0``, but not the value ``0.0``."
msgstr "این کلاس‌ها یک آرگومان جایگاهی می‌پذیرند و الگوی موجود در آن با کل شیء تطبیق داده می‌شود، نه با یک ویژگی. برای مثال ``int(0|1)`` با مقدار ``0`` مطابقت دارد، اما با مقدار ``0.0`` مطابقت ندارد."

msgid "In simple terms ``CLS(P1, attr=P2)`` matches only if the following happens:"
msgstr "به بیان ساده ``CLS(P1, attr=P2)`` تنها در صورتی تطابق دارد که مورد زیر رخ دهد:"

msgid "``isinstance(<subject>, CLS)``"
msgstr "``isinstance(<subject>, CLS)``"

msgid "convert ``P1`` to a keyword pattern using ``CLS.__match_args__``"
msgstr "تبدیل ``P1`` به یک الگوی کلیدواژه‌ای با استفاده از ``CLS.__match_args__``"

msgid "For each keyword argument ``attr=P2``:"
msgstr "برای هر آرگومان کلیدواژه‌ای ``attr=P2``:"

msgid "``hasattr(<subject>, \"attr\")``"
msgstr "``hasattr(<subject>, \"attr\")``"

msgid "``P2`` matches ``<subject>.attr``"
msgstr "``P2`` با ``<subject>.attr`` مطابقت دارد"

msgid "... and so on for the corresponding keyword argument/pattern pair."
msgstr "... و به همین ترتیب برای جفت آرگومان کلیدواژه‌ای/الگوی متناظر."

msgid "Function definitions"
msgstr "تعاریف تابع"

msgid "A function definition defines a user-defined function object (see section :ref:`types`):"
msgstr "تعریف تابع، یک شیء تابع تعریف‌شده توسط کاربر را تعریف می‌کند (بخش :ref:`types` را ببینید):"

msgid "A function definition is an executable statement.  Its execution binds the function name in the current local namespace to a function object (a wrapper around the executable code for the function).  This function object contains a reference to the current global namespace as the global namespace to be used when the function is called."
msgstr "تعریف یک تابع، یک دستور قابل‌اجرا است. اجرای آن، نام تابع را در فضای نام محلی به یک شیء تابع (دربرگیرنده‌ای برای کد قابل‌اجرای تابع) پیوند می‌دهد. این شیء تابع شامل ارجاعی به فضای نام سراسری جاری به‌عنوان فضای نام سراسری است که هنگام فراخوانی تابع استفاده می‌شود."

msgid "The function definition does not execute the function body; this gets executed only when the function is called. [#]_"
msgstr "تعریف تابع، بدنه‌ی تابع را اجرا نمی‌کند؛ این کار تنها زمانی انجام می‌شود که تابع فراخوانی شود. [#]_"

msgid "A function definition may be wrapped by one or more :term:`decorator` expressions. Decorator expressions are evaluated when the function is defined, in the scope that contains the function definition.  The result must be a callable, which is invoked with the function object as the only argument. The returned value is bound to the function name instead of the function object.  Multiple decorators are applied in nested fashion. For example, the following code ::"
msgstr "تعریف یک تابع ممکن است با یک یا چند عبارت :term:`دکوراتور <decorator>` پوشانده شود. عبارات دکوراتور هنگامی که تابع تعریف می‌شود، در محدوده‌ای که شامل تعریف تابع است، ارزیابی می‌شوند. نتیجه باید یک شیء فراخوانی‌پذیر باشد که با شیء تابع به‌عنوان تنها آرگومان فراخوانی می‌شود. مقدار بازگشتی به‌جای شیء تابع، به نام تابع اختصاص می‌یابد. چندین دکوراتور به‌صورت تودرتو اعمال می‌شوند. برای مثال، کد زیر ::"

msgid ""
"@f1(arg)\n"
"@f2\n"
"def func(): pass"
msgstr ""
"@f1(arg)\n"
"@f2\n"
"def func(): pass"

msgid "is roughly equivalent to ::"
msgstr "تقریباً معادل است با ::"