# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001 Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # # Translators: # python-doc bot, 2025 # Maciej Olko , 2025 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-03-25 14:54+0000\n" "PO-Revision-Date: 2025-09-16 00:02+0000\n" "Last-Translator: Maciej Olko , 2025\n" "Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Language: pl\n" "Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && " "(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && " "n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n" msgid "Errors and Exceptions" msgstr "Błędy i wyjątki" 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 "" "Do tej pory wiadomości o błędach były tylko wspomniane, ale jeśli " "próbowałaś(-łeś) przykładów to pewnie udało ci się na nie natknąć. Występują " "(przynajmniej) dwa charakterystyczne typy błędów: *błędy składni* (syntax " "errors) oraz *wyjątki* (exceptions)." msgid "Syntax Errors" msgstr "Błędy składni" 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 "" "Błędy składni, znane również jako błędy parsowania, są prawdopodobnie " "najczęstszym rodzajem skarg, które pojawiają się podczas nauki Pythona::" msgid "" ">>> while True print('Hello world')\n" " File \"\", line 1\n" " while True print('Hello world')\n" " ^^^^^\n" "SyntaxError: invalid syntax" msgstr "" ">>> while True print('Witaj świecie')\n" " File \"\", line 1\n" " while True print('Witaj świecie')\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 powtarza błędną linię i wyświetla małe strzałki wskazujące miejsce, w " "którym wykryto błąd. Należy pamiętać, że nie zawsze jest to miejsce, które " "wymaga naprawy. W przykładzie błąd jest wykryty na funkcji :func:`print`, " "ponieważ brakuje tuż przed nią dwukropka (``':'``)." msgid "" "The file name (```` in our example) and line number are printed so " "you know where to look in case the input came from a file." msgstr "" "Nazwa pliku (```` w naszym przykładzie) i numer linii są drukowane, " "abyś wiedział(a), gdzie szukać, w przypadku, gdy dane wejściowe pochodzą z " "pliku." msgid "Exceptions" msgstr "Wyjątki" 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 "" "Nawet jeśli instrukcja lub wyrażenie jest poprawne składniowo, może ona " "wywołać błąd podczas próby jej wykonania. Błędy zauważone podczas wykonania " "programu są nazywane *wyjątkami* (exceptions) i nie zawsze są " "niedopuszczalne: już niedługo nauczysz w jaki sposób je obsługiwać. " "Większość wyjątków nie jest jednak obsługiwana przez program przez co " "wyświetlane są informacje o błędzie jak pokazano poniżej::" msgid "" ">>> 10 * (1/0)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 10 * (1/0)\n" " ~^~\n" "ZeroDivisionError: division by zero\n" ">>> 4 + spam*3\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 4 + spam*3\n" " ^^^^\n" "NameError: name 'spam' is not defined\n" ">>> '2' + 2\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \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 \"\", line 1, in \n" " 10 * (1/0)\n" " ~^~\n" "ZeroDivisionError: division by zero\n" ">>> 4 + spam*3\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " 4 + spam*3\n" " ^^^^\n" "NameError: name 'spam' is not defined\n" ">>> '2' + 2\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \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 "" "Ostatni wiersz komunikatu o błędzie wskazuje, co się stało. Wyjątki " "występują w różnych typach, a typ jest drukowany jako część komunikatu: typy " "w przykładzie to :exc:`ZeroDivisionError`, :exc:`NameError` i :exc:" "`TypeError`. Ciąg wydrukowany jako typ wyjątku jest nazwą wbudowanego " "wyjątku, który wystąpił. Jest to prawdą dla wszystkich wbudowanych " "wyjątków, ale nie musi być prawdą dla wyjątków zdefiniowanych przez " "użytkownika (choć jest to przydatna konwencja). Standardowe nazwy wyjątków " "są wbudowanymi identyfikatorami (nie zarezerwowanymi słowami kluczowymi)." msgid "" "The rest of the line provides detail based on the type of exception and what " "caused it." msgstr "" "Pozostała część linii dostarcza szczegółów na temat typu wyjątku oraz " "informacji, co go spowodowało." 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 "" "Wcześniejsza część komunikatu o błędzie pokazuje kontekst, w którym wystąpił " "wyjątek, w postaci śladu stosu. Ogólnie rzecz biorąc, zawiera on ślad stosu " "z listą linii źródłowych; jednak nie wyświetli linii odczytanych ze " "standardowego wejścia." msgid "" ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings." msgstr ":ref:`bltin-exceptions` wymienia wbudowane wyjątki i ich znaczenie." msgid "Handling Exceptions" msgstr "Obsługa wyjątków" 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 "" "Możliwe jest pisanie programów, które obsługują wybrane wyjątki. Spójrzmy na " "poniższy przykład, który prosi użytkownika o wprowadzenie danych, dopóki nie " "zostanie wprowadzona poprawna liczba całkowita, ale pozwala użytkownikowi na " "przerwanie programu (przy użyciu :kbd:`Control-C` lub czegokolwiek innego " "obsługiwanego przez system operacyjny); zauważ, że przerwanie wygenerowane " "przez użytkownika jest sygnalizowane przez podniesienie wyjątku :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(\"Proszę podaj liczbę: \"))\n" "... break\n" "... except ValueError:\n" "... print(\"Ups! To nie była poprawna liczba. Spróbuj ponownie..." "\")\n" "..." msgid "The :keyword:`try` statement works as follows." msgstr "Instrukcja :keyword:`try` działa następująco." msgid "" "First, the *try clause* (the statement(s) between the :keyword:`try` and :" "keyword:`except` keywords) is executed." msgstr "" "W pierwszej kolejności wykonywane są instrukcje pod klauzulą *try* - " "pomiędzy słowami kluczowymi :keyword:`try` i :keyword:`except`." msgid "" "If no exception occurs, the *except clause* is skipped and execution of the :" "keyword:`try` statement is finished." msgstr "" "Jeżeli nie wystąpi żaden wyjątek, klauzula *except* jest pomijana i zostaje " "zakończone wykonywanie instrukcji :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 "" "Jeśli wyjątek wystąpi podczas wykonywania klauzuli :keyword:`try`, reszta " "klauzuli jest pomijana. Następnie, jeśli jego typ pasuje do wyjątku " "nazwanego po słowie kluczowym :keyword:`except`, wykonywana jest *klauzula " "except*, a następnie wykonanie jest kontynuowane po bloku 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 "" "Jeśli wystąpi wyjątek, który nie pasuje do wyjątku nazwanego w *klauzuli " "except*, jest on przekazywany do zewnętrznych instrukcji :keyword:`try`; " "jeśli nie zostanie znaleziona obsługa, jest to *nieobsłużony wyjątek* i " "wykonanie zatrzymuje się z komunikatem błędu." 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 "" msgid "" "... except RuntimeError, TypeError, NameError:\n" "... pass" msgstr "" 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 "" "Klasa w klauzuli :keyword:`except` obsługuje wyjątki, które są instancjami " "samej klasy lub jednej z jej klas pochodnych (ale nie na odwrót --- " "*klauzula except* wymieniająca klasę pochodną nie obsłuży instancji jej klas " "bazowych). Na przykład, poniższy kod wypisze B, C, D w tej kolejności::" 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 "" "Zauważ, że jeśli *klauzule except* byłyby odwrócone (z ``except B`` na " "pierwszym miejscu), wypisane zostałoby B, B, B --- uruchamiana jest pierwsza " "pasująca *klauzula 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 "" "Gdy wystąpi wyjątek, może on mieć powiązane wartości, znane również jako " "*argumenty* wyjątku. Obecność i typy argumentów zależą od typu wyjątku." 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 "" "*Klauzula except* może określać nazwę zmiennej po nazwie wyjątku. Zmienna " "jest powiązana z instancją wyjątku, która zazwyczaj posiada atrybut ``args`` " "przechowujący argumenty. Dla wygody, typy wyjątków wbudowanych definiują :" "meth:`~object.__str__` drukującą wszystkie argumenty bez odwoływania się do " "``.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" "\n" "('spam', 'eggs')\n" "('spam', 'eggs')\n" "x = spam\n" "y = eggs" msgstr "" ">>> try:\n" "... raise Exception('konserwa', 'jajka')\n" "... except Exception as inst:\n" "... print(type(inst)) # typ wyjątku\n" "... print(inst.args) # argumenty przechowywane w .args\n" "... print(inst) # metoda __str__ pozwala na wypisanie args " "bezpośrednio,\n" "... # ale jej definicja może być nadpisana w " "klasach dziedziczących\n" "... x, y = inst.args # rozpakowanie argumentów\n" "... print('x =', x)\n" "... print('y =', y)\n" "...\n" "\n" "('konserwa', 'jajka')\n" "('konserwa', 'jajka')\n" "x = konserwa\n" "y = jajka" msgid "" "The exception's :meth:`~object.__str__` output is printed as the last part " "('detail') of the message for unhandled exceptions." msgstr "" "Dane wyjściowe metody :meth:`~object.__str__` wyjątku są drukowane jako " "ostatnia część ('szczegóły') komunikatu dla nieobsłużonych wyjątków." 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` jest wspólną klasą bazową wszystkich wyjątków. Jedna z " "jej podklas, :exc:`Exception`, jest klasą bazową wszystkich nie-fatalnych " "wyjątków. Wyjątki, które nie są podklasami :exc:`Exception` nie są zazwyczaj " "obsługiwane, ponieważ są używane do wskazania, że program powinien się " "zakończyć. Obejmują one :exc:`SystemExit`, który jest rzucany przez :meth:" "`sys.exit` i :exc:`KeyboardInterrupt`, które są rzucane, gdy użytkownik chce " "przerwać program." 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` może być używany jako symbol wieloznaczny, który " "przechwytuje (prawie) wszystko. Dobrą praktyką jest jednak jak " "najdokładniejsze określenie typów wyjątków, które zamierzamy obsługiwać, i " "umożliwienie propagacji wszelkim nieoczekiwanym wyjątkom." 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 "" "Najczęstszym wzorcem obsługi :exc:`Exception` jest drukowanie lub " "umieszczenie wyjątku w logach, a następnie ponowne rzucenie go (umożliwiając " "również obsługę wyjątku funkcji, w której znajduje się wywołanie)::" 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('moj_plik.txt')\n" " s = f.readline()\n" " i = int(s.strip())\n" "except OSError as err:\n" " print(\"Błąd OS:\", err)\n" "except ValueError:\n" " print(\"Nie udało się przekonwertować danych na liczbę całkowitą.\")\n" "except Exception as err:\n" " print(f\"Nieoczekiwany {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 "" "Instrukcja :keyword:`try` … :keyword:`except` posiada opcjonalną *klauzulę " "else*, która, gdy jest obecna, musi następować po wszystkich *klauzulach " "except*. Jest to przydatne w przypadku kodu, który musi zostać wykonany, " "jeśli *klauzula try* nie rzuci wyjątku. Na przykład::" 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('nie mogę otworzyć', arg)\n" " else:\n" " print(arg, 'ma', len(f.readlines()), 'linii')\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 "" "Użycie klauzuli :keyword:`!else` jest lepsze niż dodanie dodatkowego kodu do " "klauzuli :keyword:`try`, ponieważ pozwala uniknąć przypadkowego wychwycenia " "wyjątku, który nie został rzucony przez kod chroniony instrukcją :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 "" "Instrukcja `try` … `catch` nie obsługuje tylko wyjątków, które występują " "bezpośrednio w *klauzuli try*, ale także te, które występują wewnątrz " "funkcji, które są wywoływane (nawet pośrednio) w *klauzuli try*. Na " "przykład::" 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('Błąd w czasie wykonania:', err)\n" "...\n" "Błąd w czasie wykonania: division by zero" msgid "Raising Exceptions" msgstr "Rzucanie wyjątków" msgid "" "The :keyword:`raise` statement allows the programmer to force a specified " "exception to occur. For example::" msgstr "" "Instrukcja :keyword:`raise` pozwala programiście wymusić wystąpienie " "żądanego wyjątku. Na przykład::" msgid "" ">>> raise NameError('HiThere')\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " raise NameError('HiThere')\n" "NameError: HiThere" msgstr "" ">>> raise NameError('CześćiCzołem')\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " raise NameError('CześćiCzołem')\n" "NameError: CześćiCzołem" 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 "" "Jedyny argument do :keyword:`raise` wskazuje wyjątek, który ma być rzucony. " "Musi to być albo instancja wyjątku, albo klasa wyjątku (klasa dziedzicząca " "z :class:`BaseException`, taka jak :exc:`Exception` lub jedna z jej " "podklas). Jeśli przekazana zostanie klasa wyjątku, zostanie ona niejawnie " "zainicjowana przez wywołanie jej konstruktora bez argumentów::" msgid "raise ValueError # shorthand for 'raise ValueError()'" msgstr "raise ValueError # skrót dla '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 "" "Jeśli chcesz rozpoznać, czy wyjątek został rzucony, ale nie zamierzasz go " "obsługiwać, prostsza forma instrukcji :keyword:`raise` pozwala na ponowne " "rzucenie wyjątku::" 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 \"\", line 2, in \n" " raise NameError('HiThere')\n" "NameError: HiThere" msgstr "" ">>> try:\n" "... raise NameError('CześćiCzołem')\n" "... except NameError:\n" "... print('Przeleciał wyjątek!')\n" "... raise\n" "...\n" "Przeleciał wyjątek!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise NameError('CześćiCzołem')\n" "NameError: CześćiCzołem" msgid "Exception Chaining" msgstr "Łańcuch wyjątków" 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 "" "Jeśli nieobsłużony wyjątek wystąpi wewnątrz sekcji :keyword:`except`, " "zostanie do niego dołączony obsługiwany wyjątek i uwzględniony w komunikacie " "o błędzie::" 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 \"\", line 2, in \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 \"\", line 4, in \n" " raise RuntimeError(\"unable to handle error\")\n" "RuntimeError: unable to handle error" msgstr "" ">>> try:\n" "... open(\"bazadanych.sqlite\")\n" "... except OSError:\n" "... raise RuntimeError(\"nie da się obsłużyć błędu\")\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " open(\"bazadanych.sqlite\")\n" " ~~~~^^^^^^^^^^^^^^^^^^^^^\n" "FileNotFoundError: [Errno 2] No such file or directory: 'bazadanych.sqlite'\n" "\n" "During handling of the above exception, another exception occurred:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError(\"nie da się obsłużyć błędu\")\n" "RuntimeError: nie da się obsłużyć błędu" msgid "" "To indicate that an exception is a direct consequence of another, the :" "keyword:`raise` statement allows an optional :keyword:`from` clause::" msgstr "" "Aby wskazać, że wyjątek jest bezpośrednią konsekwencją innego, instrukcja :" "keyword:`raise` dopuszcza opcjonalną klauzulę :keyword:`from`::" msgid "" "# exc must be exception instance or None.\n" "raise RuntimeError from exc" msgstr "" "# exc musi być instancją klasy Exception albo mieć wartość None\n" "raise RuntimeError from exc" msgid "This can be useful when you are transforming exceptions. For example::" msgstr "Może to być przydatne podczas przekształcania wyjątków. Na przykład::" 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 \"\", line 2, in \n" " func()\n" " ~~~~^^\n" " File \"\", 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 \"\", line 4, in \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('Nie udało się otworzyć bazy danych') from exc\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " func()\n" " ~~~~^^\n" " File \"\", 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 \"\", line 4, in \n" " raise RuntimeError('Nie udało się otworzyć bazy danych') from exc\n" "RuntimeError: Nie udało się otworzyć bazy danych" msgid "" "It also allows disabling automatic exception chaining using the ``from " "None`` idiom::" msgstr "" "Umożliwia również wyłączenie automatycznego łączenia wyjątków przy użyciu " "idiomu ``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 \"\", line 4, in \n" " raise RuntimeError from None\n" "RuntimeError" msgstr "" ">>> try:\n" "... open('bazadanych.sqlite')\n" "... except OSError:\n" "... raise RuntimeError from None\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" " raise RuntimeError from None\n" "RuntimeError" msgid "" "For more information about chaining mechanics, see :ref:`bltin-exceptions`." msgstr "" "Więcej informacji na temat mechaniki łączenia w łańcuchy można znaleźć w " "rozdziale :ref:`bltin-exceptions`." msgid "User-defined Exceptions" msgstr "Wyjątki zdefiniowane przez użytkownika" 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 "" "Programy mogą nazywać własne wyjątki, tworząc nową klasę wyjątków (więcej " "informacji na temat klas Python można znaleźć w rozdziale :ref:`tut-" "classes`). Wyjątki powinny zazwyczaj dziedziczyć z klasy :exc:`Exception`, " "bezpośrednio lub pośrednio." 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 "" "Można zdefiniować klasy wyjątków, które robią wszystko, co może zrobić każda " "inna klasa, ale zwykle są one proste, często oferując tylko kilka atrybutów, " "które pozwalają na wyodrębnienie informacji o błędzie przez kod obsługi " "wyjątku." msgid "" "Most exceptions are defined with names that end in \"Error\", similar to the " "naming of the standard exceptions." msgstr "" "Większość wyjątków ma nazwy kończące się na „Error”, podobnie jak w " "przypadku standardowych wyjątków." msgid "" "Many standard modules define their own exceptions to report errors that may " "occur in functions they define." msgstr "" "Wiele standardowych modułów definiuje własne wyjątki w celu zgłaszania " "błędów, które mogą wystąpić w zdefiniowanych w nich funkcjach." msgid "Defining Clean-up Actions" msgstr "Definiowanie działań porządkujących" 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 "" "Instrukcja :keyword:`try` ma inną opcjonalną klauzulę, która jest " "przeznaczona do definiowania działań porządkujących, które muszą być " "wykonane w każdych okolicznościach. Na przykład::" msgid "" ">>> try:\n" "... raise KeyboardInterrupt\n" "... finally:\n" "... print('Goodbye, world!')\n" "...\n" "Goodbye, world!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise KeyboardInterrupt\n" "KeyboardInterrupt" msgstr "" ">>> try:\n" "... raise KeyboardInterrupt\n" "... finally:\n" "... print('Do widzenia, świecie!')\n" "...\n" "Do widzenia, świecie!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \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 "" "Jeśli klauzula :keyword:`finally` jest obecna, klauzula :keyword:`!finally` " "wykona się jako ostatnie zadanie przed zakończeniem instrukcji :keyword:" "`try`. Klauzula :keyword:`!finally` uruchomi się niezależnie od tego, czy " "instrukcja :keyword:`!try` spowoduje wyjątek. Poniższe punkty omawiają " "bardziej złożone przypadki wystąpienia wyjątku:" 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 "" "Jeśli podczas wykonywania klauzuli :keyword:`!try` wystąpi wyjątek, może on " "zostać obsłużony przez klauzulę :keyword:`except`. Jeśli wyjątek nie " "zostanie obsłużony przez klauzulę :keyword:`!except`, zostanie on ponownie " "rzucony po wykonaniu klauzuli :keyword:`!finally`." 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 "" "Wyjątek może wystąpić podczas wykonywania klauzul :keyword:`!except` lub :" "keyword:`!else`. Ponownie, wyjątek jest ponownie rzucany po wykonaniu " "klauzuli :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 "" "Jeśli klauzula :keyword:`!finally` wykonuje :keyword:`break`, :keyword:" "`continue` lub instrukcję :keyword:`return`, wyjątki nie są dalej rzucane. " "Może to być mylące i dlatego jest odradzane. Od wersji 3.14 kompilator " "emituje :exc:`SyntaxWarning` dla takich przypadków (patrz :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 "" "Jeśli instrukcja :keyword:`!try` osiągnie instrukcję :keyword:`break`, :" "keyword:`continue` lub :keyword:`return`, klauzula :keyword:`!finally` " "wykona się tuż przed wykonaniem instrukcji :keyword:`!break`, :keyword:`!" "continue` lub :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 "" "Jeśli klauzula :keyword:`!finally` zawiera instrukcję :keyword:`!return`, " "zwróconą wartością będzie ta z instrukcji :keyword:`!return` klauzuli :" "keyword:`!finally`, a nie wartość z instrukcji :keyword:`!return` klauzuli :" "keyword:`!try`. Może to być mylące i dlatego jest odradzane. Od wersji 3.14 " "kompilator emituje :exc:`SyntaxWarning` dla takich przypadków (patrz :pep:" "`765`)." msgid "For example::" msgstr "Na przykład::" 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 "Bardziej skomplikowany przykład::" 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 \"\", line 1, in \n" " divide(\"2\", \"1\")\n" " ~~~~~~^^^^^^^^^^\n" " File \"\", 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(\"dzielenie przez zero!\")\n" "... else:\n" "... print(\"wynik to\", result)\n" "... finally:\n" "... print(\"wykonywanie klauzuli finally\")\n" "...\n" ">>> divide(2, 1)\n" "wynik to 2.0\n" "wykonywanie klauzuli finally\n" ">>> divide(2, 0)\n" "dzielenie przez zero!\n" "wykonywanie klauzuli finally\n" ">>> divide(\"2\", \"1\")\n" "wykonywanie klauzuli finally\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " divide(\"2\", \"1\")\n" " ~~~~~~^^^^^^^^^^\n" " File \"\", 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 "" "Jak widać, klauzula :keyword:`finally` jest wykonywana w każdym przypadku. :" "exc:`TypeError` rzucony przez dzielenie dwóch ciągów znaków nie jest " "obsłużony przez klauzulę :keyword:`except` i dlatego jest ponownie rzucony " "po wykonaniu klauzuli :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 "" "W prawdziwych aplikacjach, klauzula :keyword:`finally` jest przydatna do " "zwalniania zewnętrznych zasobów (takich jak pliki lub połączenia sieciowe), " "niezależnie od tego, czy użycie zasobu zakończyło się powodzeniem." msgid "Predefined Clean-up Actions" msgstr "Predefiniowane akcje porządkujące" 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 "" "Niektóre obiekty definiują standardowe akcje porządkujące, które mają zostać " "podjęte, gdy obiekt nie jest już potrzebny, niezależnie od tego, czy " "operacja przy użyciu obiektu powiodła się, czy nie. Spójrz na poniższy " "przykład, który próbuje otworzyć plik i wydrukować jego zawartość na " "ekranie::" msgid "" "for line in open(\"myfile.txt\"):\n" " print(line, end=\"\")" msgstr "" "for line in open(\"moj_plik.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 "" "Problem z tym kodem polega na tym, że pozostawia on plik otwarty przez " "nieokreślony czas po zakończeniu wykonywania tej części kodu. Nie jest to " "problemem w prostych skryptach, ale może być problemem dla większych " "aplikacjach. Instrukcja :keyword:`with` pozwala na używanie obiektów takich " "jak pliki w sposób, który zapewnia, że są one zawsze czyszczone szybko i " "poprawnie::" msgid "" "with open(\"myfile.txt\") as f:\n" " for line in f:\n" " print(line, end=\"\")" msgstr "" "with open(\"moj_plik.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 "" "Po wykonaniu instrukcji, plik *f* jest zawsze zamykany, nawet jeśli " "napotkano problem podczas przetwarzania linii. Obiekty, które, podobnie jak " "pliki, zapewniają predefiniowane akcje czyszczenia, wskażą to w swojej " "dokumentacji." msgid "Raising and Handling Multiple Unrelated Exceptions" msgstr "Rzucanie i obsługa wielu niepowiązanych wyjątków" 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 "" "Istnieją sytuacje, w których konieczne jest zgłoszenie kilku wyjątków, które " "wystąpiły. Dzieje się tak często w przypadku frameworków współbieżności, gdy " "kilka zadań może zakończyć się niepowodzeniem równolegle, ale istnieją " "również inne przypadki użycia, w których pożądane jest kontynuowanie " "wykonywania i zbieranie wielu błędów zamiast rzucenia pierwszego wyjątku." 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 "" "Wbudowana :exc:`ExceptionGroup` zawiera listę instancji wyjątków, dzięki " "czemu mogą one być rzucone razem. Sama w sobie jest wyjątkiem, więc może być " "przechwycona jak każdy inny wyjątek::" 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 \"\", line 1, in \n" " | f()\n" " | ~^^\n" " | File \"\", 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 : there were problems (2 sub-exceptions)\n" ">>>" msgstr "" 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 "" "Używając ``except*`` zamiast ``except``, możemy selektywnie obsługiwać tylko " "te wyjątki w grupie, które pasują do określonego typu. W poniższym " "przykładzie, który pokazuje zagnieżdżoną grupę wyjątków, każda klauzula " "``except*`` wyodrębnia z grupy wyjątki określonego typu, pozwalając " "wszystkim innym wyjątkom propagować się do innych klauzul i ostatecznie być " "ponownie zgłaszanymi. ::" 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 \"\", line 2, in \n" " | f()\n" " | ~^^\n" " | File \"\", 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" "... \"grupa1\",\n" "... [\n" "... OSError(1),\n" "... SystemError(2),\n" "... ExceptionGroup(\n" "... \"grupa2\",\n" "... [\n" "... OSError(3),\n" "... RecursionError(4)\n" "... ]\n" "... )\n" "... ]\n" "... )\n" "...\n" ">>> try:\n" "... f()\n" "... except* OSError as e:\n" "... print(\"Były OSErrors\")\n" "... except* SystemError as e:\n" "... print(\"Były SystemErrors\")\n" "...\n" "Były OSErrors\n" "Były SystemErrors\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 2, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise ExceptionGroup(\n" " | ...<12 lines>...\n" " | )\n" " | ExceptionGroup: grupa1 (1 sub-exception)\n" " +-+---------------- 1 ----------------\n" " | ExceptionGroup: grupa2 (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 "" "Należy pamiętać, że wyjątki zagnieżdżone w grupie wyjątków muszą być " "instancjami, a nie typami. Wynika to z faktu, że w praktyce wyjątki są " "zazwyczaj tymi, które zostały już rzucone i przechwycone przez program, " "zgodnie z następującym wzorcem::" 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(\"Niepowodzenia testów\", excs)\n" "..." msgid "Enriching Exceptions with Notes" msgstr "Wzbogacanie wyjątków o notatki" 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 "" "Gdy wyjątek jest tworzony w celu rzucenia, jest on zwykle inicjowany " "informacjami opisującymi błąd, który wystąpił. Istnieją przypadki, w których " "przydatne jest dodanie informacji po przechwyceniu wyjątku. W tym celu " "wyjątki mają metodę ``add_note(note)``, która akceptuje ciąg znaków i dodaje " "go do listy notatek wyjątku. Standardowe renderowanie tracebacku zawiera " "wszystkie notatki, w kolejności, w jakiej zostały dodane, po wyjątku. ::" 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 \"\", line 2, in \n" " raise TypeError('bad type')\n" "TypeError: bad type\n" "Add some information\n" "Add some more information\n" ">>>" msgstr "" ">>> try:\n" "... raise TypeError('zły typ')\n" "... except Exception as e:\n" "... e.add_note('Dodaj trochę informacji')\n" "... e.add_note('Dodaj jeszcze trochę informacji')\n" "... raise\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " raise TypeError('zły typ')\n" "TypeError: zły typ\n" "Dodaj trochę informacji\n" "Dodaj jeszcze trochę informacji\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 "" "Na przykład zbierając wyjątki w grupę wyjątków, możemy chcieć dodać " "informacje kontekstowe dla poszczególnych błędów. Poniżej każdy wyjątek w " "grupie ma notatkę wskazującą, kiedy wystąpił. ::" 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 \"\", line 1, in \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 \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", 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 \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", 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 \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", 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('operacja się nie udała')\n" "...\n" ">>> excs = []\n" ">>> for i in range(3):\n" "... try:\n" "... f()\n" "... except Exception as e:\n" "... e.add_note(f'Zdarzyło się w iteracji {i+1}')\n" "... excs.append(e)\n" "...\n" ">>> raise ExceptionGroup('Mamy jakieś problemy', excs)\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | raise ExceptionGroup('Mamy jakieś problemy', excs)\n" " | ExceptionGroup: Mamy jakieś problemy (3 sub-exceptions)\n" " +-+---------------- 1 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operacja się nie udała')\n" " | OSError: operacja się nie udała\n" " | Zdarzyło się w iteracji 1\n" " +---------------- 2 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operacja się nie udała')\n" " | OSError: operacja się nie udała\n" " | Zdarzyło się w iteracji 2\n" " +---------------- 3 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | f()\n" " | ~^^\n" " | File \"\", line 2, in f\n" " | raise OSError('operacja się nie udała')\n" " | OSError: operacja się nie udała\n" " | Zdarzyło się w iteracji 3\n" " +------------------------------------\n" ">>>"