errors.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:
# Ariyan Bolandi, 2025
# khosro azimi, 2025
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-28 04:13+0000\n"
"PO-Revision-Date: 2026-09-14 10:29+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 "Errors and Exceptions"
msgstr "خطاها و استثناها"

msgid "Until now error messages haven't been more than mentioned, but if you have tried out the examples you have probably seen some.  There are (at least) two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr "تا اینجا پیام‌های خطا فقط به صورت کوتاه ذکر شده‌اند، اما اگر مثال‌ها را امتحان کرده باشید احتمالاً برخی از آن‌ها را دیده‌اید. حداقل دو نوع متمایز از خطا وجود دارد: *خطاهای دستوری* «syntax errors» و *استثناها* «exceptions»."

msgid "Syntax Errors"
msgstr "خطاهای دستوری"

msgid "Syntax errors, also known as parsing errors, are perhaps the most common kind of complaint you get while you are still learning Python::"
msgstr "خطاهای دستوری، که به‌عنوان خطاهای پارسر «parsing errors» نیز شناخته می‌شوند، شاید رایج‌ترین نوع خطاهایی باشند که هنگام یادگیری پایتون با آن‌ها مواجه می‌شوید::"

msgid ""
">>> while True print('Hello world')\n"
"  File \"<stdin>\", line 1\n"
"    while True print('Hello world')\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> while True print('Hello world')\n"
"  File \"<stdin>\", line 1\n"
"    while True print('Hello world')\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

msgid "The parser repeats the offending line and displays little arrows pointing at the place where the error was detected.  Note that this is not always the place that needs to be fixed.  In the example, the error is detected at the function :func:`print`, since a colon (``':'``) is missing just before it."
msgstr ""
"پارسر «parser» خط مشکل‌دار را تکرار می‌کند و فلش‌های کوچکی را نشان می‌دهد که به جایی اشاره دارند که خطا در آن شناسایی شده است.\n"
"توجه داشته باشید که این همیشه همان جایی نیست که باید اصلاح شود.\n"
"در این مثال، خطا در تابع :func:`print` شناسایی شده است، زیرا دو نقطه (``':'``) درست قبل از آن وجود ندارد."

msgid "The file name (``<stdin>`` in our example) and line number are printed so you know where to look in case the input came from a file."
msgstr "نام پرونده (در مثال ما ``<stdin>``) و شماره خط چاپ می شوند تا اگر ورودی از یک پرونده آمده باشد، بدانید باید کجا را بررسی کنید."

msgid "Exceptions"
msgstr "استثنا ها"

msgid "Even if a statement or expression is syntactically correct, it may cause an error when an attempt is made to execute it. Errors detected during execution are called *exceptions* and are not unconditionally fatal: you will soon learn how to handle them in Python programs.  Most exceptions are not handled by programs, however, and result in error messages as shown here::"
msgstr "حتی اگر یک دستور یا عبارت از نظر دستوری «syntactically» درست باشد، ممکن است هنگام اجرای آن خطایی رخ دهد. خطاهایی که هنگام اجرا شناسایی می‌شوند «استثنا» «*exceptions*» نام دارند و الزاماً باعث توقف برنامه نمی‌شوند؛ به‌زودی خواهید آموخت چگونه آن‌ها را در برنامه‌های پایتون مدیریت کنید. با این حال، بیشتر استثناها در برنامه‌ها مدیریت نمی‌شوند و به پیام‌های خطا ختم می‌شوند، مانند چیزی که در اینجا نمایش داده شده است::"

msgid ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    10 * (1/0)\n"
"          ~^~\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    4 + spam*3\n"
"        ^^^^\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    '2' + 2\n"
"    ~~~~^~~\n"
"TypeError: can only concatenate str (not \"int\") to str"
msgstr ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    10 * (1/0)\n"
"          ~^~\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    4 + spam*3\n"
"        ^^^^\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    '2' + 2\n"
"    ~~~~^~~\n"
"TypeError: can only concatenate str (not \"int\") to str"

msgid "The last line of the error message indicates what happened. Exceptions come in different types, and the type is printed as part of the message: the types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:`TypeError`. The string printed as the exception type is the name of the built-in exception that occurred.  This is true for all built-in exceptions, but need not be true for user-defined exceptions (although it is a useful convention). Standard exception names are built-in identifiers (not reserved keywords)."
msgstr "آخرین خط از پیام خطا نشان می دهد که چه اتفاقی افتاده است. استثناها دارای انواع مختلفی هستند و نوع آنها به‌عنوان بخشی از پیام چاپ می شود: انواع موجود در مثال عبارتند از :exc:`ZeroDivisionError`، :exc:`NameError` و :exc:`TypeError`. رشته ای که به‌عنوان نوع استثنا چاپ می شود، نام استثنای توکار است که رخ داده است. این موضوع برای تمام استثناهای توکار صدق می کند، اما برای استثناهای تعریف شده توسط کاربر لزوماً صحیح نیست (گرچه این یک قاعده‌ی مفید محسوب می‌شود). نام های استثنای استاندارد شناسه های توکار هستند (نه کلمات کلیدواژه‌ای رزرو شده)."

msgid "The rest of the line provides detail based on the type of exception and what caused it."
msgstr "بخش باقی‌مانده‌ی خط، جزئیاتی را بسته به نوع استثنا «exception» و علت وقوع آن ارائه می‌دهد."

msgid "The preceding part of the error message shows the context where the exception occurred, in the form of a stack traceback. In general it contains a stack traceback listing source lines; however, it will not display lines read from standard input."
msgstr "بخش قبلی پیام خطا، زمینه‌ای را نشان می‌دهد که در آن استثنا رخ داده است، به‌صورت یک ردگیری پشته «stack traceback». به‌طور کلی، این بخش شامل ردگیری پشته‌ای است که سطرهایی از کد منبع را فهرست می‌کند؛ با این حال، سطرهایی که از ورودی استاندارد «standard input» خوانده شده‌اند در آن نمایش داده نمی‌شوند."

msgid ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ":ref:`bltin-exceptions` فهرستی از استثناهای توکار و معانی آن ها را ارائه می دهد."

msgid "Handling Exceptions"
msgstr "مدیریت استثناها"

msgid "It is possible to write programs that handle selected exceptions. Look at the following example, which asks the user for input until a valid integer has been entered, but allows the user to interrupt the program (using :kbd:`Control-C` or whatever the operating system supports); note that a user-generated interruption is signalled by raising the :exc:`KeyboardInterrupt` exception. ::"
msgstr "امکان نوشتن برنامه‌هایی وجود دارد که برخی از استثناها را مدیریت می‌کنند. به مثال زیر نگاه کنید که از کاربر ورودی می‌خواهد تا زمانی که یک عدد صحیح معتبر وارد شود، اما به کاربر اجازه می‌دهد برنامه را قطع کند (با فشردن :kbd:`Control-C` یا هر روشی که سیستم‌عامل پشتیبانی می‌کند)؛ توجه داشته باشید که قطع برنامه توسط کاربر با پرتاب استثنای :exc:`KeyboardInterrupt` مشخص می‌شود. ::"

msgid ""
">>> while True:\n"
"...     try:\n"
"...         x = int(input(\"Please enter a number: \"))\n"
"...         break\n"
"...     except ValueError:\n"
"...         print(\"Oops!  That was no valid number.  Try again...\")\n"
"..."
msgstr ""
">>> while True:\n"
"...     try:\n"
"...         x = int(input(\"Please enter a number: \"))\n"
"...         break\n"
"...     except ValueError:\n"
"...         print(\"Oops!  That was no valid number.  Try again...\")\n"
"..."

msgid "The :keyword:`try` statement works as follows."
msgstr "دستور :keyword:`try` به شکل زیر عمل می‌کند."

msgid "First, the *try clause* (the statement(s) between the :keyword:`try` and :keyword:`except` keywords) is executed."
msgstr "ابتدا بخش *try clause* (دستوری که بین کلیدواژه های :keyword:`try` و :keyword:`except` قرار دارد) اجرا می شود."

msgid "If no exception occurs, the *except clause* is skipped and execution of the :keyword:`try` statement is finished."
msgstr "اگر هیچ استثنایی رخ ندهد، *بخش except* نادیده گرفته می‌شود و اجرای دستور :keyword:`try` به پایان می‌رسد."

msgid "If an exception occurs during execution of the :keyword:`try` clause, the rest of the clause is skipped.  Then, if its type matches the exception named after the :keyword:`except` keyword, the *except clause* is executed, and then execution continues after the try/except block."
msgstr "اگر در طول اجرای بخش :keyword:`try` استثنایی رخ دهد، بقیه آن بخش نادیده گرفته می‌شود. سپس، اگر نوع استثنا با استثنایی که بعد از کلیدواژه :keyword:`except` آمده مطابقت داشته باشد، *بخش except* اجرا می‌شود و پس از آن اجرای برنامه بعد از بلوک try/except ادامه می‌یابد."

msgid "If an exception occurs which does not match the exception named in the *except clause*, it is passed on to outer :keyword:`try` statements; if no handler is found, it is an *unhandled exception* and execution stops with an error message."
msgstr "اگر استثنایی رخ دهد که با استثنای نام‌برده‌شده در *بند except* مطابقت نداشته باشد، به دستورهای :keyword:`try` بیرونی منتقل می‌شود. اگر هیچ هندلری پیدا نشود، آن استثنا یک *استثنای رسیدگی‌نشده* (unhandled exception) محسوب می‌شود و اجرای برنامه با نمایش یک پیام خطا متوقف خواهد شد."

msgid "A :keyword:`try` statement may have more than one *except clause*, to specify handlers for different exceptions.  At most one handler will be executed. Handlers only handle exceptions that occur in the corresponding *try clause*, not in other handlers of the same :keyword:`!try` statement.  An *except clause* may name multiple exceptions, for example::"
msgstr "یک دستور :keyword:`try` می‌تواند بیش از یک *بند except* داشته باشد تا برای استثناهای مختلف هندلرهای متفاوتی تعریف شود. در هر بار وقوع استثنا، حداکثر یکی از این هندلرها اجرا می‌شود. هر هندلر فقط استثناهایی را مدیریت می‌کند که در *بخش try* متناظر با آن رخ داده‌اند، نه استثناهایی که در سایر هندلرهای همان دستور :keyword:`!try` ایجاد شوند. همچنین یک *بند except* می‌تواند چندین استثنا را مشخص کند، برای مثال::"

msgid ""
"... except RuntimeError, TypeError, NameError:\n"
"...     pass"
msgstr ""
"... except RuntimeError, TypeError, NameError:\n"
"...     pass"

msgid "A class in an :keyword:`except` clause matches exceptions which are instances of the class itself or one of its derived classes (but not the other way around --- an *except clause* listing a derived class does not match instances of its base classes). For example, the following code will print B, C, D in that order::"
msgstr "کلاسی که در یک :keyword:`except` مشخص می‌شود، با استثناهایی مطابقت دارد که نمونه‌ای از همان کلاس یا یکی از زیرکلاس‌های آن باشند (اما برعکس آن صادق نیست؛ یعنی *بند except* که یک زیرکلاس را مشخص می‌کند، با نمونه‌های کلاس پایه‌ی آن مطابقت نخواهد داشت). برای مثال، کد زیر به‌ترتیب `B`، `C` و `D` را چاپ می‌کند::"

msgid ""
"class B(Exception):\n"
"    pass\n"
"\n"
"class C(B):\n"
"    pass\n"
"\n"
"class D(C):\n"
"    pass\n"
"\n"
"for cls in [B, C, D]:\n"
"    try:\n"
"        raise cls()\n"
"    except D:\n"
"        print(\"D\")\n"
"    except C:\n"
"        print(\"C\")\n"
"    except B:\n"
"        print(\"B\")"
msgstr ""
"class B(Exception):\n"
"    pass\n"
"\n"
"class C(B):\n"
"    pass\n"
"\n"
"class D(C):\n"
"    pass\n"
"\n"
"for cls in [B, C, D]:\n"
"    try:\n"
"        raise cls()\n"
"    except D:\n"
"        print(\"D\")\n"
"    except C:\n"
"        print(\"C\")\n"
"    except B:\n"
"        print(\"B\")"

msgid "Note that if the *except clauses* were reversed (with ``except B`` first), it would have printed B, B, B --- the first matching *except clause* is triggered."
msgstr "توجه کنید که اگر ترتیب *بندهای except* برعکس بود (یعنی ``except B`` در ابتدا قرار می‌گرفت)، خروجی `B`، `B`، `B` می‌شد؛ زیرا نخستین *بند except* که با استثنا مطابقت داشته باشد، اجرا می‌شود."

msgid "When an exception occurs, it may have associated values, also known as the exception's *arguments*. The presence and types of the arguments depend on the exception type."
msgstr "هنگامی که یک استثنا رخ می‌دهد، ممکن است مقادیر مرتبطی نیز همراه آن باشد که به آن‌ها *آرگومان‌های* استثنا گفته می‌شود. وجود و نوع این آرگومان‌ها به نوع استثنا بستگی دارد."

msgid "The *except clause* may specify a variable after the exception name.  The variable is bound to the exception instance which typically has an ``args`` attribute that stores the arguments. For convenience, builtin exception types define :meth:`~object.__str__` to print all the arguments without explicitly accessing ``.args``.  ::"
msgstr "*بند except* می‌تواند پس از نام استثنا، یک متغیر نیز مشخص کند. این متغیر به نمونه‌ی استثنا (exception instance) نسبت داده می‌شود که معمولاً دارای ویژگی ``args`` برای ذخیره‌ی آرگومان‌های استثنا است. برای راحتی، انواع توکار استثنا متد :meth:`~object.__str__` را طوری تعریف کرده‌اند که بدون نیاز به دسترسی مستقیم به ``.args``، همه‌ی آرگومان‌ها را چاپ کند.::"

msgid ""
">>> try:\n"
"...     raise Exception('spam', 'eggs')\n"
"... except Exception as inst:\n"
"...     print(type(inst))    # the exception type\n"
"...     print(inst.args)     # arguments stored in .args\n"
"...     print(inst)          # __str__ allows args to be printed directly,\n"
"...                          # but may be overridden in exception subclasses\n"
"...     x, y = inst.args     # unpack args\n"
"...     print('x =', x)\n"
"...     print('y =', y)\n"
"...\n"
"<class 'Exception'>\n"
"('spam', 'eggs')\n"
"('spam', 'eggs')\n"
"x = spam\n"
"y = eggs"
msgstr ""
">>> try:\n"
"...     raise Exception('spam', 'eggs')\n"
"... except Exception as inst:\n"
"...     print(type(inst))    # the exception type\n"
"...     print(inst.args)     # arguments stored in .args\n"
"...     print(inst)          # __str__ allows args to be printed directly,\n"
"...                          # but may be overridden in exception subclasses\n"
"...     x, y = inst.args     # unpack args\n"
"...     print('x =', x)\n"
"...     print('y =', y)\n"
"...\n"
"<class 'Exception'>\n"
"('spam', 'eggs')\n"
"('spam', 'eggs')\n"
"x = spam\n"
"y = eggs"

msgid "The exception's :meth:`~object.__str__` output is printed as the last part ('detail') of the message for unhandled exceptions."
msgstr "خروجی متد :meth:`~object.__str__` استثنا به‌عنوان آخرین بخش (بخش «جزئیات») پیام مربوط به استثناهای رسیدگی‌نشده چاپ می‌شود."

msgid ":exc:`BaseException` is the common base class of all exceptions. One of its subclasses, :exc:`Exception`, is the base class of all the non-fatal exceptions. Exceptions which are not subclasses of :exc:`Exception` are not typically handled, because they are used to indicate that the program should terminate. They include :exc:`SystemExit` which is raised by :meth:`sys.exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to interrupt the program."
msgstr ":exc:`BaseException` کلاس پایه‌ی مشترک همه‌ی استثناها است. یکی از زیرکلاس‌های آن، یعنی :exc:`Exception`، کلاس پایه‌ی تمام استثناهای غیرمرگبار است. استثناهایی که زیرکلاس :exc:`Exception` نیستند معمولاً مدیریت نمی‌شوند، زیرا برای نشان دادن این موضوع به‌کار می‌روند که برنامه باید خاتمه یابد. از جمله‌ی آن‌ها می‌توان به :exc:`SystemExit` که توسط :meth:`sys.exit` پرتاب می‌شود و :exc:`KeyboardInterrupt` که هنگام درخواست کاربر برای قطع اجرای برنامه پرتاب می‌شود، اشاره کرد."

msgid ":exc:`Exception` can be used as a wildcard that catches (almost) everything. However, it is good practice to be as specific as possible with the types of exceptions that we intend to handle, and to allow any unexpected exceptions to propagate on."
msgstr ":exc:`Exception` را می‌توان به‌عنوان یک الگوی وایلدکارد برای گرفتن (تقریباً) همه‌ی استثناها به‌کار برد. با این حال، بهتر است تا حد امکان نوع استثناهایی را که قصد مدیریت آن‌ها را داریم به‌طور دقیق مشخص کنیم و اجازه دهیم استثناهای غیرمنتظره به سطوح بالاتر منتقل شوند."

msgid "The most common pattern for handling :exc:`Exception` is to print or log the exception and then re-raise it (allowing a caller to handle the exception as well)::"
msgstr "رایج‌ترین الگوی مدیریت :exc:`Exception` این است که ابتدا استثنا چاپ یا ثبت (log) شود و سپس دوباره پرتاب گردد تا فراخواننده نیز بتواند در صورت نیاز آن را مدیریت کند::"

msgid ""
"import sys\n"
"\n"
"try:\n"
"    f = open('myfile.txt')\n"
"    s = f.readline()\n"
"    i = int(s.strip())\n"
"except OSError as err:\n"
"    print(\"OS error:\", err)\n"
"except ValueError:\n"
"    print(\"Could not convert data to an integer.\")\n"
"except Exception as err:\n"
"    print(f\"Unexpected {err=}, {type(err)=}\")\n"
"    raise"
msgstr ""
"import sys\n"
"\n"
"try:\n"
"    f = open('myfile.txt')\n"
"    s = f.readline()\n"
"    i = int(s.strip())\n"
"except OSError as err:\n"
"    print(\"OS error:\", err)\n"
"except ValueError:\n"
"    print(\"Could not convert data to an integer.\")\n"
"except Exception as err:\n"
"    print(f\"Unexpected {err=}, {type(err)=}\")\n"
"    raise"

msgid "The :keyword:`try` ... :keyword:`except` statement has an optional *else clause*, which, when present, must follow all *except clauses*.  It is useful for code that must be executed if the *try clause* does not raise an exception. For example::"
msgstr "دستور :keyword:`try` ... :keyword:`except` یک *بند else* اختیاری نیز دارد که در صورت وجود، باید پس از همه‌ی *بندهای except* قرار گیرد. این بند برای کدی مفید است که تنها در صورتی باید اجرا شود که *بخش try* هیچ استثنایی پرتاب نکرده باشد. برای مثال::"

msgid ""
"for arg in sys.argv[1:]:\n"
"    try:\n"
"        f = open(arg, 'r')\n"
"    except OSError:\n"
"        print('cannot open', arg)\n"
"    else:\n"
"        print(arg, 'has', len(f.readlines()), 'lines')\n"
"        f.close()"
msgstr ""
"for arg in sys.argv[1:]:\n"
"    try:\n"
"        f = open(arg, 'r')\n"
"    except OSError:\n"
"        print('cannot open', arg)\n"
"    else:\n"
"        print(arg, 'has', len(f.readlines()), 'lines')\n"
"        f.close()"

msgid "The use of the :keyword:`!else` clause is better than adding additional code to the :keyword:`try` clause because it avoids accidentally catching an exception that wasn't raised by the code being protected by the :keyword:`!try` ... :keyword:`!except` statement."
msgstr "استفاده از بند :keyword:`!else` بهتر از افزودن کد بیشتر به :keyword:`try` است، زیرا از این که به‌طور ناخواسته استثنایی که توسط کد محافظت‌شده با دستور :keyword:`!try` ... :keyword:`!except` پرتاب نشده است نیز گرفته شود، جلوگیری می‌کند."

msgid "Exception handlers do not handle only exceptions that occur immediately in the *try clause*, but also those that occur inside functions that are called (even indirectly) in the *try clause*. For example::"
msgstr "هندلرهای استثنا فقط استثناهایی را که مستقیماً در *بخش try* رخ می‌دهند مدیریت نمی‌کنند، بلکه استثناهایی را که درون توابعی که (حتی به‌طور غیرمستقیم) از *بخش try* فراخوانی شده‌اند نیز رخ می‌دهند، مدیریت می‌کنند. برای مثال::"

msgid ""
">>> def this_fails():\n"
"...     x = 1/0\n"
"...\n"
">>> try:\n"
"...     this_fails()\n"
"... except ZeroDivisionError as err:\n"
"...     print('Handling run-time error:', err)\n"
"...\n"
"Handling run-time error: division by zero"
msgstr ""
">>> def this_fails():\n"
"...     x = 1/0\n"
"...\n"
">>> try:\n"
"...     this_fails()\n"
"... except ZeroDivisionError as err:\n"
"...     print('Handling run-time error:', err)\n"
"...\n"
"Handling run-time error: division by zero"

msgid "Raising Exceptions"
msgstr "پرتاب استثناها"

msgid "The :keyword:`raise` statement allows the programmer to force a specified exception to occur. For example::"
msgstr "دستور :keyword:`raise` به برنامه‌نویس اجازه می‌دهد وقوع یک استثنای مشخص را به‌صورت اجباری پرتاب کند. برای مثال::"

msgid ""
">>> raise NameError('HiThere')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    raise NameError('HiThere')\n"
"NameError: HiThere"
msgstr ""
">>> raise NameError('HiThere')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    raise NameError('HiThere')\n"
"NameError: HiThere"

msgid "The sole argument to :keyword:`raise` indicates the exception to be raised. This must be either an exception instance or an exception class (a class that derives from :class:`BaseException`, such as :exc:`Exception` or one of its subclasses).  If an exception class is passed, it will be implicitly instantiated by calling its constructor with no arguments::"
msgstr "تنها آرگومان دستور :keyword:`raise` مشخص می‌کند که چه استثنایی باید پرتاب شود. این آرگومان باید یا یک نمونه‌ی استثنا باشد یا یک کلاس استثنا (کلاسی که از :class:`BaseException` مشتق شده باشد، مانند :exc:`Exception` یا یکی از زیرکلاس‌های آن). اگر یک کلاس استثنا ارسال شود، پایتون به‌طور ضمنی با فراخوانی سازنده‌ی آن بدون هیچ آرگومانی، یک نمونه از آن ایجاد می‌کند::"

msgid "raise ValueError  # shorthand for 'raise ValueError()'"
msgstr "raise ValueError  # کوتاه‌شده برای 'raise ValueError()'"

msgid "If you need to determine whether an exception was raised but don't intend to handle it, a simpler form of the :keyword:`raise` statement allows you to re-raise the exception::"
msgstr "اگر فقط لازم است تشخیص دهید که آیا استثنایی رخ داده است یا نه، اما قصد مدیریت آن را ندارید، می‌توانید از شکل ساده‌تری از دستور :keyword:`raise` برای پرتاب مجدد همان استثنا استفاده کنید::"

msgid ""
">>> try:\n"
"...     raise NameError('HiThere')\n"
"... except NameError:\n"
"...     print('An exception flew by!')\n"
"...     raise\n"
"...\n"
"An exception flew by!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise NameError('HiThere')\n"
"NameError: HiThere"
msgstr ""
">>> try:\n"
"...     raise NameError('HiThere')\n"
"... except NameError:\n"
"...     print('An exception flew by!')\n"
"...     raise\n"
"...\n"
"An exception flew by!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise NameError('HiThere')\n"
"NameError: HiThere"

msgid "Exception Chaining"
msgstr "زنجیره‌سازی استثناها"

msgid "If an unhandled exception occurs inside an :keyword:`except` section, it will have the exception being handled attached to it and included in the error message::"
msgstr "اگر درون یک بخش :keyword:`except` یک استثنای رسیدگی‌نشده رخ دهد، استثنایی که در حال مدیریت شدن بود به آن متصل می‌شود و در پیام خطا نیز نمایش داده خواهد شد::"

msgid ""
">>> try:\n"
"...     open(\"database.sqlite\")\n"
"... except OSError:\n"
"...     raise RuntimeError(\"unable to handle error\")\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    open(\"database.sqlite\")\n"
"    ~~~~^^^^^^^^^^^^^^^^^^^\n"
"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n"
"\n"
"During handling of the above exception, another exception occurred:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError(\"unable to handle error\")\n"
"RuntimeError: unable to handle error"
msgstr ""
">>> try:\n"
"...     open(\"database.sqlite\")\n"
"... except OSError:\n"
"...     raise RuntimeError(\"unable to handle error\")\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    open(\"database.sqlite\")\n"
"    ~~~~^^^^^^^^^^^^^^^^^^^\n"
"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n"
"\n"
"During handling of the above exception, another exception occurred:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError(\"unable to handle error\")\n"
"RuntimeError: unable to handle error"

msgid "To indicate that an exception is a direct consequence of another, the :keyword:`raise` statement allows an optional :keyword:`from<raise>` clause::"
msgstr "برای نشان دادن این که یک استثنا پیامد مستقیم استثنای دیگری است، دستور :keyword:`raise` یک بند اختیاری :keyword:`from<raise>` را در اختیار می‌گذارد::"

msgid ""
"# exc must be exception instance or None.\n"
"raise RuntimeError from exc"
msgstr ""
"# exc must be exception instance or None.\n"
"raise RuntimeError from exc"

msgid "This can be useful when you are transforming exceptions. For example::"
msgstr "این قابلیت زمانی مفید است که در حال تبدیل یک استثنا به استثنای دیگری باشید. برای مثال::"

msgid ""
">>> def func():\n"
"...     raise ConnectionError\n"
"...\n"
">>> try:\n"
"...     func()\n"
"... except ConnectionError as exc:\n"
"...     raise RuntimeError('Failed to open database') from exc\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    func()\n"
"    ~~~~^^\n"
"  File \"<stdin>\", line 2, in func\n"
"ConnectionError\n"
"\n"
"The above exception was the direct cause of the following exception:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError('Failed to open database') from exc\n"
"RuntimeError: Failed to open database"
msgstr ""
">>> def func():\n"
"...     raise ConnectionError\n"
"...\n"
">>> try:\n"
"...     func()\n"
"... except ConnectionError as exc:\n"
"...     raise RuntimeError('Failed to open database') from exc\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    func()\n"
"    ~~~~^^\n"
"  File \"<stdin>\", line 2, in func\n"
"ConnectionError\n"
"\n"
"The above exception was the direct cause of the following exception:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError('Failed to open database') from exc\n"
"RuntimeError: Failed to open database"

msgid "It also allows disabling automatic exception chaining using the ``from None`` idiom::"
msgstr "همچنین می‌توانید با استفاده از الگوی ``from None`` زنجیره‌سازی خودکار استثناها را غیرفعال کنید::"

msgid ""
">>> try:\n"
"...     open('database.sqlite')\n"
"... except OSError:\n"
"...     raise RuntimeError from None\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError from None\n"
"RuntimeError"
msgstr ""
">>> try:\n"
"...     open('database.sqlite')\n"
"... except OSError:\n"
"...     raise RuntimeError from None\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"    raise RuntimeError from None\n"
"RuntimeError"

msgid "For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr "برای اطلاعات بیشتر درباره‌ی سازوکار زنجیره‌سازی استثناها، به :ref:`bltin-exceptions` مراجعه کنید."

msgid "User-defined Exceptions"
msgstr "استثناهای تعریف شده توسط کاربر"

msgid "Programs may name their own exceptions by creating a new exception class (see :ref:`tut-classes` for more about Python classes).  Exceptions should typically be derived from the :exc:`Exception` class, either directly or indirectly."
msgstr "برنامه‌ها می‌توانند با ایجاد یک کلاس استثنای جدید، استثناهای اختصاصی خود را تعریف کنند (برای آشنایی بیشتر با کلاس‌های پایتون، به :ref:`tut-classes` مراجعه کنید). معمولاً استثناها باید، به‌صورت مستقیم یا غیرمستقیم، از کلاس :exc:`Exception` مشتق شوند."

msgid "Exception classes can be defined which do anything any other class can do, but are usually kept simple, often only offering a number of attributes that allow information about the error to be extracted by handlers for the exception."
msgstr "کلاس‌های استثنا می‌توانند هر کاری را انجام دهند که سایر کلاس‌ها قادر به انجام آن هستند، اما معمولاً ساده نگه داشته می‌شوند و اغلب تنها چند ویژگی (attribute) در اختیار می‌گذارند تا هندلرهای استثنا بتوانند اطلاعات مربوط به خطا را از آن‌ها استخراج کنند."

msgid "Most exceptions are defined with names that end in \"Error\", similar to the naming of the standard exceptions."
msgstr "نام بیشتر استثناها به «Error» ختم می‌شود؛ مشابه شیوه‌ی نام‌گذاری استثناهای استاندارد."

msgid "Many standard modules define their own exceptions to report errors that may occur in functions they define."
msgstr "بسیاری از ماژول‌های استاندارد، استثناهای اختصاصی خود را برای گزارش خطاهایی که ممکن است در توابعشان رخ دهد تعریف می‌کنند."

msgid "Defining Clean-up Actions"
msgstr "تعریف عملیات پاک‌سازی"

msgid "The :keyword:`try` statement has another optional clause which is intended to define clean-up actions that must be executed under all circumstances.  For example::"
msgstr "دستور :keyword:`try` یک بخش اختیاری دیگر نیز دارد که برای تعریف عملیات پاک‌سازی‌ای در نظر گرفته شده است که باید در هر شرایطی اجرا شوند. برای مثال::"

msgid ""
">>> try:\n"
"...     raise KeyboardInterrupt\n"
"... finally:\n"
"...     print('Goodbye, world!')\n"
"...\n"
"Goodbye, world!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise KeyboardInterrupt\n"
"KeyboardInterrupt"
msgstr ""
">>> try:\n"
"...     raise KeyboardInterrupt\n"
"... finally:\n"
"...     print('Goodbye, world!')\n"
"...\n"
"Goodbye, world!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise KeyboardInterrupt\n"
"KeyboardInterrupt"

msgid "If a :keyword:`finally` clause is present, the :keyword:`!finally` clause will execute as the last task before the :keyword:`try` statement completes. The :keyword:`!finally` clause runs whether or not the :keyword:`!try` statement produces an exception. The following points discuss more complex cases when an exception occurs:"
msgstr "اگر بخش :keyword:`finally` وجود داشته باشد، بخش :keyword:`!finally` به‌عنوان آخرین مرحله، پیش از پایان یافتن دستور :keyword:`try` اجرا می‌شود. بخش :keyword:`!finally` صرف‌نظر از اینکه بخش :keyword:`!try` استثنایی ایجاد کرده باشد یا نه، اجرا خواهد شد. نکات زیر حالت‌های پیچیده‌تر هنگام وقوع استثنا را توضیح می‌دهند:"

msgid "If an exception occurs during execution of the :keyword:`!try` clause, the exception may be handled by an :keyword:`except` clause. If the exception is not handled by an :keyword:`!except` clause, the exception is re-raised after the :keyword:`!finally` clause has been executed."
msgstr "اگر هنگام اجرای بخش :keyword:`!try` استثنایی رخ دهد، ممکن است توسط یک بخش :keyword:`except` مدیریت شود. اگر استثنا توسط بخش :keyword:`!except` مدیریت نشود، پس از اجرای بخش :keyword:`!finally` دوباره پرتاب (re-raise) خواهد شد."

msgid "An exception could occur during execution of an :keyword:`!except` or :keyword:`!else` clause. Again, the exception is re-raised after the :keyword:`!finally` clause has been executed."
msgstr "ممکن است هنگام اجرای بخش :keyword:`!except` یا :keyword:`!else` نیز استثنایی رخ دهد. در این حالت نیز، پس از اجرای بخش :keyword:`!finally`، استثنا دوباره پرتاب خواهد شد."

msgid "If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement, exceptions are not re-raised. This can be confusing and is therefore discouraged. From version 3.14 the compiler emits a :exc:`SyntaxWarning` for it (see :pep:`765`)."
msgstr "اگر بخش :keyword:`!finally` شامل یکی از دستورات :keyword:`break`، :keyword:`continue` یا :keyword:`return` باشد، استثناها دوباره پرتاب نخواهند شد. این رفتار ممکن است باعث سردرگمی شود و به همین دلیل استفاده از آن توصیه نمی‌شود. از نسخه‌ی ۳٫۱۴، کامپایلر برای این حالت یک :exc:`SyntaxWarning` نشان می‌دهد (به :pep:`765` مراجعه کنید)."

msgid "If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement, the :keyword:`!finally` clause will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :keyword:`!return` statement's execution."
msgstr "اگر دستور :keyword:`!try` به یکی از دستورات :keyword:`break`، :keyword:`continue` یا :keyword:`return` برسد، بخش :keyword:`!finally` درست پیش از اجرای دستور :keyword:`!break`، :keyword:`!continue` یا :keyword:`!return` اجرا خواهد شد."

msgid "If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the returned value will be the one from the :keyword:`!finally` clause's :keyword:`!return` statement, not the value from the :keyword:`!try` clause's :keyword:`!return` statement. This can be confusing and is therefore discouraged. From version 3.14 the compiler emits a :exc:`SyntaxWarning` for it (see :pep:`765`)."
msgstr "اگر بخش :keyword:`!finally` شامل یک دستور :keyword:`!return` باشد، مقدار بازگشتی همان مقداری خواهد بود که در دستور :keyword:`!return` داخل بخش :keyword:`!finally` مشخص شده است، نه مقداری که در دستور :keyword:`!return` داخل بخش :keyword:`!try` تعیین شده بود. این رفتار ممکن است باعث سردرگمی شود و به همین دلیل استفاده از آن توصیه نمی‌شود. از نسخه‌ی ۳٫۱۴، کامپایلر برای این حالت یک :exc:`SyntaxWarning` نشان می‌دهد (به :pep:`765` مراجعه کنید)."

msgid "For example::"
msgstr "برای مثال::"

msgid ""
">>> def bool_return():\n"
"...     try:\n"
"...         return True\n"
"...     finally:\n"
"...         return False\n"
"...\n"
">>> bool_return()\n"
"False"
msgstr ""
">>> def bool_return():\n"
"...     try:\n"
"...         return True\n"
"...     finally:\n"
"...         return False\n"
"...\n"
">>> bool_return()\n"
"False"

msgid "A more complicated example::"
msgstr "یک مثال پیچیده‌تر::"

msgid ""
">>> def divide(x, y):\n"
"...     try:\n"
"...         result = x / y\n"
"...     except ZeroDivisionError:\n"
"...         print(\"division by zero!\")\n"
"...     else:\n"
"...         print(\"result is\", result)\n"
"...     finally:\n"
"...         print(\"executing finally clause\")\n"
"...\n"
">>> divide(2, 1)\n"
"result is 2.0\n"
"executing finally clause\n"
">>> divide(2, 0)\n"
"division by zero!\n"
"executing finally clause\n"
">>> divide(\"2\", \"1\")\n"
"executing finally clause\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    divide(\"2\", \"1\")\n"
"    ~~~~~~^^^^^^^^^^\n"
"  File \"<stdin>\", line 3, in divide\n"
"    result = x / y\n"
"             ~~^~~\n"
"TypeError: unsupported operand type(s) for /: 'str' and 'str'"
msgstr ""
">>> def divide(x, y):\n"
"...     try:\n"
"...         result = x / y\n"
"...     except ZeroDivisionError:\n"
"...         print(\"division by zero!\")\n"
"...     else:\n"
"...         print(\"result is\", result)\n"
"...     finally:\n"
"...         print(\"executing finally clause\")\n"
"...\n"
">>> divide(2, 1)\n"
"result is 2.0\n"
"executing finally clause\n"
">>> divide(2, 0)\n"
"division by zero!\n"
"executing finally clause\n"
">>> divide(\"2\", \"1\")\n"
"executing finally clause\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    divide(\"2\", \"1\")\n"
"    ~~~~~~^^^^^^^^^^\n"
"  File \"<stdin>\", line 3, in divide\n"
"    result = x / y\n"
"             ~~^~~\n"
"TypeError: unsupported operand type(s) for /: 'str' and 'str'"

msgid "As you can see, the :keyword:`finally` clause is executed in any event.  The :exc:`TypeError` raised by dividing two strings is not handled by the :keyword:`except` clause and therefore re-raised after the :keyword:`!finally` clause has been executed."
msgstr "همان‌طور که می‌بینید، بخش :keyword:`finally` در هر صورت اجرا می‌شود. استثنای :exc:`TypeError` که در اثر تقسیم دو رشته پرتاب شده است، توسط بخش :keyword:`except` مدیریت نمی‌شود و بنابراین پس از اجرای بخش :keyword:`!finally` دوباره پرتاب می‌شود."

msgid "In real world applications, the :keyword:`finally` clause is useful for releasing external resources (such as files or network connections), regardless of whether the use of the resource was successful."
msgstr "در برنامه‌های واقعی، بخش :keyword:`finally` برای آزاد کردن منابع خارجی (مانند پرونده‌ها یا اتصال‌های شبکه) مفید است، صرف‌نظر از اینکه استفاده از آن منبع با موفقیت انجام شده باشد یا خیر."

msgid "Predefined Clean-up Actions"
msgstr "عملیات پاک‌سازی از پیش تعریف‌شده"

msgid "Some objects define standard clean-up actions to be undertaken when the object is no longer needed, regardless of whether or not the operation using the object succeeded or failed. Look at the following example, which tries to open a file and print its contents to the screen. ::"
msgstr "برخی اشیا عملیات پاک‌سازی استانداردی را تعریف می‌کنند که باید زمانی انجام شوند که آن شیء دیگر موردنیاز نباشد، صرف‌نظر از اینکه عملیات مربوط به آن موفق بوده یا شکست خورده باشد. به مثال زیر توجه کنید که تلاش می‌کند پرونده‌ای را باز کند و محتوای آن را روی صفحه نمایش دهد.::"

msgid ""
"for line in open(\"myfile.txt\"):\n"
"    print(line, end=\"\")"
msgstr ""
"for line in open(\"myfile.txt\"):\n"
"    print(line, end=\"\")"

msgid "The problem with this code is that it leaves the file open for an indeterminate amount of time after this part of the code has finished executing. This is not an issue in simple scripts, but can be a problem for larger applications. The :keyword:`with` statement allows objects like files to be used in a way that ensures they are always cleaned up promptly and correctly. ::"
msgstr "مشکل این کد این است که پس از پایان اجرای این بخش، پرونده را برای مدت نامشخصی باز نگه می‌دارد. در اسکریپت‌های ساده این موضوع معمولاً مشکلی ایجاد نمی‌کند، اما در برنامه‌های بزرگ‌تر می‌تواند دردسرساز باشد. دستور :keyword:`with` این امکان را فراهم می‌کند که از اشیایی مانند پرونده‌ها به‌گونه‌ای استفاده شود که همیشه به‌موقع و به‌درستی پاک‌سازی شوند.::"

msgid ""
"with open(\"myfile.txt\") as f:\n"
"    for line in f:\n"
"        print(line, end=\"\")"
msgstr ""
"with open(\"myfile.txt\") as f:\n"
"    for line in f:\n"
"        print(line, end=\"\")"

msgid "After the statement is executed, the file *f* is always closed, even if a problem was encountered while processing the lines. Objects which, like files, provide predefined clean-up actions will indicate this in their documentation."
msgstr "پس از اجرای این دستور، پرونده *f* همیشه بسته می‌شود، حتی اگر هنگام پردازش سطرهای پرونده مشکلی رخ داده باشد. اشیایی که مانند پرونده‌ها عملیات پاک‌سازی از پیش تعریف‌شده دارند، این موضوع را در مستندات خود ذکر می‌کنند."

msgid "Raising and Handling Multiple Unrelated Exceptions"
msgstr "پرتاب و مدیریت چندین استثنای نامربوط به هم"

msgid "There are situations where it is necessary to report several exceptions that have occurred. This is often the case in concurrency frameworks, when several tasks may have failed in parallel, but there are also other use cases where it is desirable to continue execution and collect multiple errors rather than raise the first exception."
msgstr "گاهی لازم است چندین استثنا که رخ داده‌اند به‌طور همزمان گزارش شوند. این وضعیت معمولاً در چارچوب‌های هم‌روندی (concurrency) پیش می‌آید؛ جایی که ممکن است چندین وظیفه به‌طور موازی شکست بخورند. البته موارد دیگری نیز وجود دارد که در آن‌ها ترجیح داده می‌شود اجرای برنامه ادامه پیدا کند و چندین خطا جمع‌آوری شوند، به‌جای اینکه با اولین استثنا متوقف شود."

msgid "The builtin :exc:`ExceptionGroup` wraps a list of exception instances so that they can be raised together. It is an exception itself, so it can be caught like any other exception. ::"
msgstr "استثنای توکار :exc:`ExceptionGroup` فهرستی از نمونه‌های استثنا را در خود نگه می‌دارد تا بتوان آن‌ها را به‌صورت گروهی پرتاب کرد. خود این کلاس نیز یک استثنا است، بنابراین مانند هر استثنای دیگری قابل مدیریت (catch) است.::"

msgid ""
">>> def f():\n"
"...     excs = [OSError('error 1'), SystemError('error 2')]\n"
"...     raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |     f()\n"
"  |     ~^^\n"
"  |   File \"<stdin>\", line 3, in f\n"
"  |     raise ExceptionGroup('there were problems', excs)\n"
"  | ExceptionGroup: there were problems (2 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | OSError: error 1\n"
"    +---------------- 2 ----------------\n"
"    | SystemError: error 2\n"
"    +------------------------------------\n"
">>> try:\n"
"...     f()\n"
"... except Exception as e:\n"
"...     print(f'caught {type(e)}: {e}')\n"
"...\n"
"caught <class 'ExceptionGroup'>: there were problems (2 sub-exceptions)\n"
">>>"
msgstr ""
">>> def f():\n"
"...     excs = [OSError('error 1'), SystemError('error 2')]\n"
"...     raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |     f()\n"
"  |     ~^^\n"
"  |   File \"<stdin>\", line 3, in f\n"
"  |     raise ExceptionGroup('there were problems', excs)\n"
"  | ExceptionGroup: there were problems (2 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | OSError: error 1\n"
"    +---------------- 2 ----------------\n"
"    | SystemError: error 2\n"
"    +------------------------------------\n"
">>> try:\n"
"...     f()\n"
"... except Exception as e:\n"
"...     print(f'caught {type(e)}: {e}')\n"
"...\n"
"caught <class 'ExceptionGroup'>: there were problems (2 sub-exceptions)\n"
">>>"

msgid "By using ``except*`` instead of ``except``, we can selectively handle only the exceptions in the group that match a certain type. In the following example, which shows a nested exception group, each ``except*`` clause extracts from the group exceptions of a certain type while letting all other exceptions propagate to other clauses and eventually to be reraised. ::"
msgstr "با استفاده از ``except*`` به‌جای ``except``، می‌توان فقط استثناهای موجود در گروه را که با یک نوع مشخص مطابقت دارند، به‌صورت انتخابی مدیریت کرد. در مثال زیر که یک گروه استثنای تودرتو را نشان می‌دهد، هر بخش ``except*`` استثناهای هم‌نوع را از گروه استخراج می‌کند و سایر استثناها را برای رسیدگی توسط بخش‌های دیگر عبور می‌دهد تا در نهایت دوباره پرتاب شوند.::"

msgid ""
">>> def f():\n"
"...     raise ExceptionGroup(\n"
"...         \"group1\",\n"
"...         [\n"
"...             OSError(1),\n"
"...             SystemError(2),\n"
"...             ExceptionGroup(\n"
"...                 \"group2\",\n"
"...                 [\n"
"...                     OSError(3),\n"
"...                     RecursionError(4)\n"
"...                 ]\n"
"...             )\n"
"...         ]\n"
"...     )\n"
"...\n"
">>> try:\n"
"...     f()\n"
"... except* OSError as e:\n"
"...     print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"...     print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 2, in <module>\n"
"  |     f()\n"
"  |     ~^^\n"
"  |   File \"<stdin>\", line 2, in f\n"
"  |     raise ExceptionGroup(\n"
"  |     ...<12 lines>...\n"
"  |     )\n"
"  | ExceptionGroup: group1 (1 sub-exception)\n"
"  +-+---------------- 1 ----------------\n"
"    | ExceptionGroup: group2 (1 sub-exception)\n"
"    +-+---------------- 1 ----------------\n"
"      | RecursionError: 4\n"
"      +------------------------------------\n"
">>>"
msgstr ""
">>> def f():\n"
"...     raise ExceptionGroup(\n"
"...         \"group1\",\n"
"...         [\n"
"...             OSError(1),\n"
"...             SystemError(2),\n"
"...             ExceptionGroup(\n"
"...                 \"group2\",\n"
"...                 [\n"
"...                     OSError(3),\n"
"...                     RecursionError(4)\n"
"...                 ]\n"
"...             )\n"
"...         ]\n"
"...     )\n"
"...\n"
">>> try:\n"
"...     f()\n"
"... except* OSError as e:\n"
"...     print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"...     print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 2, in <module>\n"
"  |     f()\n"
"  |     ~^^\n"
"  |   File \"<stdin>\", line 2, in f\n"
"  |     raise ExceptionGroup(\n"
"  |     ...<12 lines>...\n"
"  |     )\n"
"  | ExceptionGroup: group1 (1 sub-exception)\n"
"  +-+---------------- 1 ----------------\n"
"    | ExceptionGroup: group2 (1 sub-exception)\n"
"    +-+---------------- 1 ----------------\n"
"      | RecursionError: 4\n"
"      +------------------------------------\n"
">>>"

msgid "Note that the exceptions nested in an exception group must be instances, not types. This is because in practice the exceptions would typically be ones that have already been raised and caught by the program, along the following pattern::"
msgstr "توجه داشته باشید که استثناهای موجود در یک گروه استثنا باید نمونه (instance) باشند، نه خود کلاس‌های استثنا. دلیلش این است که در عمل، این استثناها معمولاً قبلاً توسط برنامه پرتاب و سپس مدیریت شده‌اند؛ مطابق الگویی مشابه زیر::"

#, fuzzy
#| msgid ""
#| ">>> excs = []\n"
#| "... for test in tests:\n"
#| "...     try:\n"
#| "...         test.run()\n"
#| "...     except Exception as e:\n"
#| "...         excs.append(e)\n"
#| "...\n"
#| ">>> if excs:\n"
#| "...    raise ExceptionGroup(\"Test Failures\", excs)\n"
#| "..."
msgid ""
">>> excs = []\n"
">>> for test in tests:\n"
"...     try:\n"
"...         test.run()\n"
"...     except Exception as e:\n"
"...         excs.append(e)\n"
"...\n"
">>> if excs:\n"
"...    raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."
msgstr ""
">>> excs = []\n"
"... for test in tests:\n"
"...     try:\n"
"...         test.run()\n"
"...     except Exception as e:\n"
"...         excs.append(e)\n"
"...\n"
">>> if excs:\n"
"...    raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."

msgid "Enriching Exceptions with Notes"
msgstr "افزودن یادداشت به استثناها"

msgid "When an exception is created in order to be raised, it is usually initialized with information that describes the error that has occurred. There are cases where it is useful to add information after the exception was caught. For this purpose, exceptions have a method ``add_note(note)`` that accepts a string and adds it to the exception's notes list. The standard traceback rendering includes all notes, in the order they were added, after the exception. ::"
msgstr "وقتی یک استثنا برای پرتاب شدن ساخته می‌شود، معمولاً با اطلاعاتی مقداردهی اولیه می‌شود که خطای رخ‌داده را توصیف می‌کنند. بااین‌حال، گاهی مفید است که پس از مدیریت (catch) شدن استثنا نیز اطلاعات بیشتری به آن افزوده شود. برای این منظور، استثناها متدی به نام ``add_note(note)`` دارند که یک رشته را دریافت کرده و آن را به فهرست یادداشت‌های استثنا اضافه می‌کند. نمایش استاندارد traceback همه‌ی این یادداشت‌ها را، به همان ترتیبی که اضافه شده‌اند، پس از اطلاعات استثنا نمایش می‌دهد.::"

msgid ""
">>> try:\n"
"...     raise TypeError('bad type')\n"
"... except Exception as e:\n"
"...     e.add_note('Add some information')\n"
"...     e.add_note('Add some more information')\n"
"...     raise\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise TypeError('bad type')\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"
msgstr ""
">>> try:\n"
"...     raise TypeError('bad type')\n"
"... except Exception as e:\n"
"...     e.add_note('Add some information')\n"
"...     e.add_note('Add some more information')\n"
"...     raise\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"    raise TypeError('bad type')\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"

msgid "For example, when collecting exceptions into an exception group, we may want to add context information for the individual errors. In the following each exception in the group has a note indicating when this error has occurred. ::"
msgstr "برای مثال، هنگام جمع‌آوری چند استثنا در یک گروه استثنا، ممکن است بخواهیم اطلاعات زمینه‌ای را به هر خطا اضافه کنیم. در مثال زیر، هر استثنای موجود در گروه یادداشتی دارد که مشخص می‌کند آن خطا در چه زمانی رخ داده است.::"

msgid ""
">>> def f():\n"
"...     raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"...     try:\n"
"...         f()\n"
"...     except Exception as e:\n"
"...         e.add_note(f'Happened in Iteration {i+1}')\n"
"...         excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |     raise ExceptionGroup('We have some problems', excs)\n"
"  | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 1\n"
"    +---------------- 2 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 2\n"
"    +---------------- 3 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 3\n"
"    +------------------------------------\n"
">>>"
msgstr ""
">>> def f():\n"
"...     raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"...     try:\n"
"...         f()\n"
"...     except Exception as e:\n"
"...         e.add_note(f'Happened in Iteration {i+1}')\n"
"...         excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |     raise ExceptionGroup('We have some problems', excs)\n"
"  | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 1\n"
"    +---------------- 2 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 2\n"
"    +---------------- 3 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |     f()\n"
"    |     ~^^\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    |     raise OSError('operation failed')\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 3\n"
"    +------------------------------------\n"
">>>"