8. Σφάλματα και Εξαιρέσεις¶
Μέχρι τώρα τα μηνύματα σφαλμάτων (error messages) δεν ήταν περισσότερα από όσα αναφέρθηκαν, αλλά αν έχετε δοκιμάσει τα παραδείγματα, πιθανότατα έχετε δει μερικά. Υπάρχουν (τουλάχιστον) δύο διαφορετικά είδη σφαλμάτων: syntax errors (συντακτικά σφάλματα) και exceptions (εξαιρέσεις).
8.1. Syntax Errors (Συντακτικά Σφάλματα)¶
Τα syntax errors, γνωστά και ως parsing errors, είναι ίσως το πιο συνηθισμένο είδος παραπόνου που λαμβάνετε ενώ εξακολουθείτε να μαθαίνετε Python:
>>> while True print('Hello world')
File "<stdin>", line 1
while True print('Hello world')
^^^^^
SyntaxError: invalid syntax
Ο αναλυτής επαναλαμβάνει την παραβατική γραμμή και εμφανίζει μικρά βέλη που δείχνουν προς το μέρος όπου που εντοπίστηκε το σφάλμα. Σημειώστε ότι αυτό δεν είναι πάντα το μέρος που πρέπει να διορθωθεί. Στο παράδειγμα, το σφάλμα εντοπίζεται στη συνάρτηση print()
, καθώς λείπει μια άνω και κάτω τελεία (':'
) ακριβώς πριν από αυτήν.
Το όνομα αρχείου (<stdin>
στο παράδειγμά μας) και ο αριθμός γραμμής εκτυπώνονται, ώστε να να γνωρίζετε πού να ψάξετε σε περίπτωση που η είσοδος προήλθε από αρχείο.
8.2. Exceptions (Εξαιρέσεις)¶
Ακόμη και αν μια πρόταση ή μια έκφραση είναι συντακτικά σωστή, μπορεί να προκαλέσει σφάλμα όταν γίνεται προσπάθεια εκτέλεσης της. Τα σφάλματα που εντοπίζονται κατά την εκτέλεση ονομάζονται εξαιρέσεις και δεν είναι άνευ όρων μοιραία (fatal): σύντομα θα μάθετε πως να τα χειρίζεστε σε προγράμματα Python. Ωστόσο, οι περισσότερες εξαιρέσεις δεν αντιμετωπίζονται από προγράμματα και οδηγούν σε μηνύματα σφάλματος όπως φαίνεται εδώ:
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
10 * (1/0)
~^~
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
4 + spam*3
^^^^
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
'2' + 2
~~~~^~~
TypeError: can only concatenate str (not "int") to str
Η τελευταία γραμμή του μηνύματος σφάλματος υποδεικνύει τι συνέβη. Οι εξαιρέσεις υπάρχουν σε διαφορετικούς τύπους και ο τύπος εκτυπώνεται ως μέρος του μηνύματος: οι τύποι στο παράδειγμα είναι ZeroDivisionError
, NameError
και TypeError
. Η συμβολοσειρά που εκτυπώνεται ως τύπος εξαίρεσης είναι όνομα της ενσωματωμένης εξαίρεσης που προέκυψε. Αυτό ισχύει για όλες τις ενσωματωμένες (built-in) εξαιρέσεις, αλλά δεν χρειάζεται να ισχύει για εξαιρέσεις που ορίζονται από το χρήστη (αν και είναι μια χρήσιμη σύμβαση). Οι standard εξαιρέσεις είναι ενσωματωμένα (built-in) αναγνωριστικά (όχι δεσμευμένες λέξεις-κλειδιά).
Η υπόλοιπη γραμμή παρέχει λεπτομέρειες με βάση τον τύπο της εξαίρεσης και το τι την προκάλεσε.
Το προηγούμενο μέρος του μηνύματος σφάλματος εμφανίζει το περιβάλλον όπου συνέβη η εξαίρεση, με τη μορφή ανίχνευσης στοίβας. Γενικά περιέχει μια στοίβα ανίχνευσης γραμμών πηγής∙ ωστόσο, δεν θα εμφανίζει γραμμές που διαβάζονται από standard είσοδο.
Το Built-in Exceptions παραθέτει τις ενσωματωμένες εξαιρέσεις και τις έννοιές τους.
8.3. Διαχείριση Εξαιρέσεων¶
Είναι δυνατό να γραφτεί κώδικας που χειρίζεται επιλεγμένες εξαιρέσεις. Κοιτάξτε το ακόλουθο παράδειγμα, το οποίο ζητά από τον χρήστη να εισάγει έναν έγκυρο ακέραιο αριθμό, αλλά επιτρέπει στον χρήστη να διακόψει το πρόγραμμα (χρησιμοποιώντας Control-C ή ό,τι υποστηρίζει το λειτουργικό σύστημα)· σημειώστε ότι μια διακοπή που δημιουργείται από τον χρήστη σηματοδοτείται κάνοντας raise την εξαίρεση KeyboardInterrupt
.
>>> while True:
... try:
... x = int(input("Please enter a number: "))
... break
... except ValueError:
... print("Oops! That was no valid number. Try again...")
...
Η δήλωση try
λειτουργεί ως εξής.
Πρώτον, εκτελείται η try clause (η πρόταση(εις) μεταξύ των λέξεων-κλειδιών
try
andexcept
).Εάν δεν προκύψει εξαίρεση, η except clause παραλείπεται και η εκτέλεση της πρότασης
try
ολοκληρώνεται.Εάν παρουσιαστεί μια εξαίρεση κατά την εκτέλεση της πρότασης
try
, η υπόλοιπη πρόταση παραλείπεται. Στη συνέχεια, εάν ο τύπος της ταιριάζει με την εξαίρεση που ονομάζεται από τη λέξη-κλειδίexcept
, η except clause εκτελείται, και στη συνέχεια η εκτέλεση συνεχίζεται μετά το μπλοκ try/except.Εάν προκύψει μια εξαίρεση που δεν ταιριάζει με την εξαίρεση που αναφέρεται στην except clause, μεταβιβάζεται σε εξωτερικές εντολές
try
· εάν δεν βρεθεί κανένας χειριστής, είναι μια unhandled exception και η εκτέλεση σταματά με μήνυμα σφάλματος.
Μια πρόταση try
μπορεί να έχει περισσότερες από μία except clause, για να καθορίσει χειριστές για διαφορετικές εξαιρέσεις. Το πολύ ένας χειριστής θα εκτελεστεί. Οι χειριστές χειρίζονται μόνο εξαιρέσεις που εμφανίζονται στην αντίστοιχη try clause, όχι σε άλλους χειριστές της ίδιας πρότασης try
. Μια except clause μπορεί να ονομάσει πολλαπλές εξαιρέσεις ως πλειάδα (tuple) σε παρένθεση, για παράδειγμα:
... except (RuntimeError, TypeError, NameError):
... pass
Μια κλάση σε μια πρόταση except
ταιριάζει με εξαιρέσεις που είναι στιγμιότυπα της ίδιας της κλάσης ή μιας από τις παραγόμενες κλάσεις της (αλλά όχι το αντίστροφο — μια except clause που παραθέτει μια παράγωγη κλάση δεν ταιριάζει με τις παρουσίες των βασικών της κλάσεων). Για παράδειγμα, ο ακόλουθος κώδικας θα εκτυπώσει τα B, C, D με αυτή τη σειρά:
class B(Exception):
pass
class C(B):
pass
class D(C):
pass
for cls in [B, C, D]:
try:
raise cls()
except D:
print("D")
except C:
print("C")
except B:
print("B")
Σημειώστε ότι εάν οι except clauses είχαν αντιστραφεί (με το except B
πρώτα), θα είχε εκτυπωθεί B, B, B — ενεργοποιείται η πρώτη αντιστοίχιση except clause.
Όταν προκύπτει μια εξαίρεση, μπορεί να έχει συσχετισμένες τιμές, γνωστές και ως ορίσματα της εξαίρεσης. Η παρουσία και οι τύποι των ορισμάτων εξαρτώνται από τον τύπο εξαίρεσης.
Το except clause μπορεί να καθορίσει μια μεταβλητή μετά το όνομα της εξαίρεσης. Η μεταβλητή συνδέεται με το στιγμιότυπο της εξαίρεσης η οποία συνήθως έχει ένα χαρακτηριστικό args
που αποθηκεύει τα ορίσματα. Για ευκολία, οι ενσωματωμένοι (builtin) τύποι εξαίρεσης ορίζουν __str__()
για να εκτυπώσετε όλα τα ορίσματα χωρίς ρητή πρόσβαση στο .args
.
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print(type(inst)) # the exception type
... print(inst.args) # arguments stored in .args
... print(inst) # __str__ allows args to be printed directly,
... # but may be overridden in exception subclasses
... x, y = inst.args # unpack args
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs
Η έξοδος της εξαίρεσης __str__()
εκτυπώνεται ως το τελευταίο μέρος (“λεπτομέρεια”) του μηνύματος για μη χειριζόμενες εξαιρέσεις.
Η BaseException
είναι η κοινή βασική κλάση όλων των εξαιρέσεων. Μια από τις υποκατηγορίες της, Exception
, είναι η βασική κλάση όλων των μη μοιραίων εξαιρέσεων. Εξαιρέσεις που δεν είναι υποκλάσεις του Exception
δεν αντιμετωπίζονται συνήθως, επειδή χρησιμοποιούνται για να υποδείξουν ότι το πρόγραμμα πρέπει να τερματιστεί. Περιλαμβάνουν το SystemExit
το οποίο αυξάνεται από το sys.exit()
και το KeyboardInterrupt
το οποίο γίνεται raise όταν ο χρήστης επιθυμεί να διακόψει την εκτέλεση του προγράμματος.
Η Exception
μπορεί να χρησιμοποιηθεί ως μπαλαντέρ που πιάνει (σχεδόν) τα πάντα. Ωστόσο, είναι καλή πρακτική να είμαστε όσο το δυνατόν πιο συγκεκριμένοι με τους τύπους εξαιρέσεων που σκοπεύουμε να χειριστούμε και να επιτρέπουμε τυχόν απροσδόκητες εξαιρέσεις που εξαπλώνονται.
Το πιο κοινό μοτίβο για το χειρισμό Exception
είναι να εκτυπώσετε ή να καταγράψετε την εξαίρεση και στη συνέχεια να την επαναφέρετε (επιτρέποντας σε έναν καλούντα να χειριστεί και την εξαίρεση):
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error:", err)
except ValueError:
print("Could not convert data to an integer.")
except Exception as err:
print(f"Unexpected {err=}, {type(err)=}")
raise
Η πρόταση try
… except
έχει ένα προαιρετικό else clause, το οποίο, όταν υπάρχει, πρέπει να ακολουθεί όλες τις except clauses. Είναι χρήσιμο για κώδικα που πρέπει να εκτελεστεί εάν το try clause δεν κάνει raise μια εξαίρεση. Για παράδειγμα:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except OSError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
Η χρήση της πρότασης else
είναι καλύτερη από την προσθήκη πρόσθετου κώδικα στην πρόταση try
, επειδή αποφεύγει την κατά λάθος σύλληψη μιας εξαίρεσης που δεν προέκυψε από τον κώδικα που προστατεύεται από την πρόταση try
… except
.
Οι χειριστές εξαιρέσεων δεν χειρίζονται μόνο τις εξαιρέσεις που εμφανίζονται αμέσως στη try clause, αλλά και εκείνες που εμφανίζονται μέσα σε συναρτήσεις που καλούνται (ακόμη και έμμεσα) στην try clause. Για παράδειγμα:
>>> def this_fails():
... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError as err:
... print('Handling run-time error:', err)
...
Handling run-time error: division by zero
8.4. Raising Εξαιρέσεων¶
Η δήλωση raise
επιτρέπει στον προγραμματιστή να αναγκάσει να εμφανιστεί μια καθορισμένη εξαίρεση. Για παράδειγμα:
>>> raise NameError('HiThere')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
raise NameError('HiThere')
NameError: HiThere
Το μοναδικό όρισμα στο raise
υποδεικνύει την εξαίρεση που πρέπει να γίνει raise. Αυτή πρέπει να είναι είτε μια παρουσία εξαίρεσης ή μια εξαίρεση κλάση (μια κλάση που προέρχεται από BaseException
, όπως Exception
ή μία από τις υποκλάσεις της). Εάν περάσει μια κλάση εξαίρεσης, θα δημιουργηθεί σιωπηρά καλώντας τον constructor της χωρίς ορίσματα:
κάνει raise ένα ValueError # συντομογραφία για το 'raise ValueError()'
Εάν πρέπει να προσδιορίσετε εάν έχει εγγραφεί μια εξαίρεση, αλλά δεν σκοπεύετε να τη χειριστείτε, μια απλούστερη μορφή της δήλωσης raise
σας επιτρέπει να κάνετε ξανά raise την εξαίρεση:
>>> try:
... raise NameError('HiThere')
... except NameError:
... print('An exception flew by!')
... raise
...
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise NameError('HiThere')
NameError: HiThere
8.5. Αλυσιδωτές Εξαιρέσεις¶
Εάν παρουσιαστεί μια μη χειριζόμενη (unhandled) εξαίρεση μέσα σε μια ενότητα except
, θα επισυνάψει την εξαίρεση που θα χειριστεί και θα συμπεριληφθεί στο μήνυμα σφάλματος:
>>> try:
... open("database.sqlite")
... except OSError:
... raise RuntimeError("unable to handle error")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
open("database.sqlite")
~~~~^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError("unable to handle error")
RuntimeError: unable to handle error
Για να υποδείξετε ότι μια εξαίρεση είναι άμεση συνέπεια μιας άλλης, η πρόταση raise
επιτρέπει μια προαιρετική πρόταση from
:
# Το exc πρέπει να είναι παράδειγμα εξαίρεσης ή None.
κάνει raise το RuntimeError από exc
Αυτό μπορεί να είναι χρήσιμο όταν μετασχηματίζεται εξαιρέσεις. Για παράδειγμα:
>>> def func():
... raise ConnectionError
...
>>> try:
... func()
... except ConnectionError as exc:
... raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
func()
~~~~^^
File "<stdin>", line 2, in func
ConnectionError
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError('Failed to open database') from exc
RuntimeError: Failed to open database
Επιτρέπει επίσης την απενεργοποίηση της αυτόματης αλυσίδας εξαιρέσεων χρησιμοποιώντας from None
idiom:
>>> try:
... open('database.sqlite')
... except OSError:
... raise RuntimeError from None
...
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
raise RuntimeError from None
RuntimeError
Για περισσότερες πληροφορίες σχετικά με την μηχανική αλυσίδων, δείτε Built-in Exceptions.
8.6. Εξαιρέσεις που καθορίζονται από το χρήστη¶
Τα προγράμματα μπορούν να ονομάσουν τις δικές τους εξαιρέσεις δημιουργώντας μια νέα κλάση εξαιρέσεων (δείτε Κλάσεις για περισσότερα σχετικά με τις κλάσεις Python). Οι εξαιρέσεις θα πρέπει συνήθως να προέρχονται από την κλάση Exception
, είτε άμεσα είτε έμμεσα.
Μπορούν να οριστούν κλάσεις εξαίρεσης που κάνουν οτιδήποτε μπορεί να κάνει οποιαδήποτε άλλη κλάση, αλλά συνήθως διατηρούνται απλές, συχνά προσφέρουν μόνο έναν αριθμό χαρακτηριστικών που επιτρέπουν την εξαγωγή πληροφοριών σχετικά με το σφάλμα από τους χειριστές για την εξαίρεση.
Οι περισσότερες εξαιρέσεις ορίζονται με ονόματα που τελειώνουν σε «Error», παρόμοια με την ονομασία των τυπικών εξαιρέσεων.
Πολλά standard modules ορίζουν τις δικές τους εξαιρέσεις για την αναφορά σφαλμάτων που μπορεί να προκύψουν σε συναρτήσεις που ορίζουν.
8.7. Καθορισμός ενεργειών καθαρισμού¶
Η δήλωση try
έχει μια άλλη προαιρετική πρόταση που προορίζεται να ορίσει ενέργειες καθαρισμού που πρέπει να εκτελεστούν υπό οποιεσδήποτε συνθήκες. Για παράδειγμα:
>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise KeyboardInterrupt
KeyboardInterrupt
Εάν υπάρχει μια πρόταση finally
, η πρόταση finally
θα εκτελεστεί ως η τελευταία εργασία πριν από την ολοκλήρωση της πρότασης try
. Η πρόταση finally
εκτελείται είτε όχι η πρόταση try
παράγει μια εξαίρεση. Τα ακόλουθα σημεία συζητούν πιο περίπλοκες περιπτώσεις όταν εμφανίζεται μια εξαίρεση:
Εάν παρουσιαστεί μια εξαίρεση κατά την εκτέλεση της πρότασης
try
, η εξαίρεση μπορεί να αντιμετωπιστεί από μια πρότασηexcept
, Εάν η εξαίρεση δεν αντιμετωπίζεται από μια πρότασηexcept
, η εξαίρεση γίνεται ξανά raise μετά την εκτέλεση της πρότασηςfinally
.Μια εξαίρεση θα μπορούσε να προκύψει κατά την εκτέλεση μιας πρότασης
except
ήelse
. Και πάλι, η εξαίρεση τίθεται ξανά μετά την εκτέλεση της πρότασηςfinally
.Εάν η πρόταση
finally
εκτελέσει μια πρότασηbreak
,continue
ήreturn
, οι εξαιρέσεις δεν γίνονται raise εκ νέου. Αυτό μπορεί να προκαλέσει σύγχυση και ως εκ τούτου αποθαρρύνεται. Από την έκδοση 3.14, ο μεταγλωττιστής εκπέμπει μιαSyntaxWarning
για αυτό (δείτε PEP 765).Εάν η πρόταση
try
φτάσει σε μια δήλωσηbreak
,continue
ήreturn
, η πρότασηfinally
θα εκτελεστεί ακριβώς πριν από ταbreak
,continue
orreturn
της εκτέλεσης της δήλωσης.Εάν μια πρόταση
finally
περιλαμβάνει μια δήλωσηreturn
, η τιμή που επιστρέφεται θα είναι αυτή από την πρότασηfinally
της δήλωσης τηςreturn
, και όχι η τιμή από τη δήλωσηtry
της πρότασηςreturn
. Αυτό μπορεί να προκαλέσει σύγχυση και επομένως αποθαρρύνεται. Από την έκδοση 3.14, ο μεταγλωττιστής εκπέμπει έναSyntaxWarning
για αυτό (δείτε PEP 765).
Για παράδειγμα:
>>> def bool_return():
... try:
... return True
... finally:
... return False
...
>>> bool_return()
False
Ένα πιο περίπλοκο παράδειγμα:
>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print("division by zero!")
... else:
... print("result is", result)
... finally:
... print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
divide("2", "1")
~~~~~~^^^^^^^^^^
File "<stdin>", line 3, in divide
result = x / y
~~^~~
TypeError: unsupported operand type(s) for /: 'str' and 'str'
Όπως μπορείτε να δείτε, η πρόταση finally
εκτελείται σε οποιαδήποτε περίπτωση. Το TypeError
που δημιουργείται με τη διαίρεση δύο συμβολοσειρών δεν χειρίζεται από την πρόταση except
και επομένως γίνεται ξανά raise μετά την εκτέλεση του όρου finally
.
Στις εφαρμογές του πραγματικού κόσμου, η πρόταση finally
είναι χρήσιμη για την απελευθέρωση εξωτερικών πόρων (όπως αρχεία ή συνδέσεις δικτύου), ανεξάρτητα από το εάν η χρήση του πόρου ήταν επιτυχής.
8.8. Προκαθορισμένες ενέργειες καθαρισμού¶
Μερικά αντικείμενα ορίζουν τις τυπικές ενέργειες καθαρισμού που πρέπει να αναλαμβάνονται όταν το αντικείμενο δεν χρειάζεται πλέον, ανεξάρτητα από το εάν η λειτουργία που χρησιμοποιεί το αντικείμενο πέτυχε ή απέτυχε. Κοιτάξτε το ακόλουθο αντικείμενο, το οποίο προσπαθεί να ανοίξει ένα αρχείο και να εκτυπώσει τα περιεχόμενα του στην οθόνη.
for line in open("myfile.txt"):
print(line, end="")
Το πρόβλημα με αυτόν τον κώδικα είναι ότι αφήνει το αρχείο ανοιχτό για απροσδιόριστο χρονικό διάστημα μετά την ολοκλήρωση της εκτέλεσης αυτού του τμήματος του κώδικα. Αυτό δεν είναι πρόβλημα σε απλά σενάρια, αλλά μπορεί να είναι πρόβλημα για μεγαλύτερες εφαρμογές. Η δήλωση with
επιτρέπει σε αντικείμενα όπως αρχεία να χρησιμοποιούνται με τρόπο που διασφαλίζει ότι καθαρίζονται πάντα άμεσα και σωστά.
with open("myfile.txt") as f:
for line in f:
print(line, end="")
Μετά την εκτέλεση της πρότασης, το αρχείο f είναι πάντα κλειστό, ακόμα και αν παρουσιάστηκε πρόβλημα κατά την επεξεργασία των γραμμών. Τα αντικείμενα που, όπως τα αρχεία παρέχουν προκαθορισμένες ενέργειες καθαρισμού θα το υποδεικνύουν στην τεκμηρίωση τους.
8.10. Εμπλουτίζοντας τις Εξαιρέσεις με Σημειώσεις¶
Όταν δημιουργείται μια εξαίρεση προκειμένου να γίνει raise, συνήθως αρχικοποιείται με πληροφορίες που περιγράφουν το σφάλμα που έχει προκύψει. Υπάρχουν περιπτώσεις όπου είναι χρήσιμο να προστεθούν πληροφορίες μετά την σύλληψη της εξαίρεσης. Για το σκοπό αυτό, οι εξαιρέσεις έχουνε μια μέθοδο add_note(note)
που δέχεται μια συμβολοσειρά και την προσθέτει στη λίστα σημειώσεων της εξαίρεσης. Η standard απόδοση παρακολούθησης περιλαμβάνει όλες τις σημειώσεις, με τη σειρά που προστέθηκα, μετά την εξαίρεση.
>>> try:
... raise TypeError('bad type')
... except Exception as e:
... e.add_note('Add some information')
... e.add_note('Add some more information')
... raise
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
raise TypeError('bad type')
TypeError: bad type
Add some information
Add some more information
>>>
Για παράδειγμα, όταν συλλέγουμε εξαιρέσεις σε μια ομάδα εξαιρέσεων, μπορεί να θέλουμε να προσθέσουμε πληροφορίες περιβάλλοντος για τα μεμονωμένα σφάλματα. Στην συνέχεια κάθε εξαίρεση στην ομάδα έχει μια σημείωση που υποδεικνύει πότε έχει συμβεί αυτό το σφάλμα.
>>> def f():
... raise OSError('operation failed')
...
>>> excs = []
>>> for i in range(3):
... try:
... f()
... except Exception as e:
... e.add_note(f'Happened in Iteration {i+1}')
... excs.append(e)
...
>>> raise ExceptionGroup('We have some problems', excs)
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| raise ExceptionGroup('We have some problems', excs)
| ExceptionGroup: We have some problems (3 sub-exceptions)
+-+---------------- 1 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise OSError('operation failed')
| OSError: operation failed
| Happened in Iteration 1
+---------------- 2 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise OSError('operation failed')
| OSError: operation failed
| Happened in Iteration 2
+---------------- 3 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 3, in <module>
| f()
| ~^^
| File "<stdin>", line 2, in f
| raise OSError('operation failed')
| OSError: operation failed
| Happened in Iteration 3
+------------------------------------
>>>