7. Απλές εντολές

Μια απλή εντολή περιλαμβάνεται σε μία μόνο λογική γραμμή. Πολλές απλές εντολές μπορεί να εμφανιστούν σε μία μόνο γραμμή χωρισμένες με ελληνικό ερωτηματικό. Η σύνταξη για απλές εντολές είναι:

simple_stmt: expression_stmt
             | assert_stmt
             | assignment_stmt
             | augmented_assignment_stmt
             | annotated_assignment_stmt
             | pass_stmt
             | del_stmt
             | return_stmt
             | yield_stmt
             | raise_stmt
             | break_stmt
             | continue_stmt
             | import_stmt
             | future_stmt
             | global_stmt
             | nonlocal_stmt
             | type_stmt

7.1. Εντολές έκφρασης

Οι εντολές έκφρασης χρησιμοποιούνται (κυρίως διαδραστικά) για τον υπολογισμό και την εγγραφή μιας τιμής, ή (συνήθως) για την κλήση μιας διαδικασίας (μια συνάρτηση που δεν επιστρέφει ουσιαστικό αποτέλεσμα· στην Python, οι διαδικασίες επιστρέφουν την τιμή None). Άλλες χρήσεις εντολών έκφρασης επιτρέπονται και είναι περιστασιακά χρήσιμες. Η σύνταξη μιας εντολή έκφρασης είναι:

expression_stmt: starred_expression

Μια εντολή έκφρασης αξιολογεί τη λίστα εκφράσεων (που μπορεί να είναι μία μόνο έκφραση).

Σε διαδραστική λειτουργία, εάν η τιμή δεν είναι None, μετατρέπεται σε συμβολοσειρά χρησιμοποιώντας την ενσωματωμένη συνάρτηση repr() και η προκύπτουσα συμβολοσειρά γράφεται στην τυπική έξοδο σε μια γραμμή από μόνη της (εκτός εάν το αποτέλεσμα είναι None, έτσι ώστε οι κλήσεις διαδικασίας να μην προκαλούν καμία έξοδο.)

7.2. Εντολές ανάθεσης

Οι εντολές ανάθεσης χρησιμοποιούνται για την (επανα)δέσμευση ονομάτων σε τιμές και για την τροποποίηση χαρακτηριστικών ή στοιχείων μεταβλητών αντικειμένων:

assignment_stmt: (target_list "=")+ (starred_expression | yield_expression)
target_list:     target ("," target)* [","]
target:          identifier
                 | "(" [target_list] ")"
                 | "[" [target_list] "]"
                 | attributeref
                 | subscription
                 | "*" target

(See section Primaries for the syntax definitions for attributeref and subscription.)

Μια εντολή ανάθεσης αξιολογεί τη λίστα εκφράσεων (θυμηθείτε ότι αυτή μπορεί να είναι μια μεμονωμένη έκφραση ή μια λίστα διαχωρισμένη με κόμματα, με την τελευταία να αποδίδει μια πλειάδα) και αναθέτει το μεμονωμένο αντικείμενο που προκύπτει σε καθεμία από τις λίστες προορισμού, από τα αριστερά προς τα δεξιά.

Assignment is defined recursively depending on the form of the target (list). When a target is part of a mutable object (an attribute reference or subscription), the mutable object must ultimately perform the assignment and decide about its validity, and may raise an exception if the assignment is unacceptable. The rules observed by various types and the exceptions raised are given with the definition of the object types (see section Η τυπική ιεραρχία τύπου).

Η ανάθεση ενός αντικειμένου σε μια λίστα προορισμού, προαιρετικά περικλεισμένη σε παρενθέσεις ή αγκύλες, ορίζεται αναδρομικά ως εξής.

• Εάν η λίστα προορισμού είναι ένας μεμονωμένος στόχος χωρίς τελικό κόμμα, προαιρετικά σε παρενθέσεις, το αντικείμενο ανατίθεται σε αυτόν τον στόχο.

• Διαφορετικά:

  • Εάν η λίστα προορισμού περιέχει έναν στόχο με πρόθεμα έναν αστερίσκο, που ονομάζεται «στόχος με αστερίσκο»: Το αντικείμενο πρέπει να είναι ένα iterable με τουλάχιστον τόσα στοιχεία όσα και οι στόχοι στη λίστα προορισμού, μείον ένα. Τα πρώτα στοιχεία του iterable ανατίθενται, από αριστερά προς τα δεξιά, στους στόχους πριν από τον στόχο με αστερίσκο. Τα τελικά στοιχεία του iterable ανατίθενται στους στόχους μετά τον στόχο με αστερίσκο. Μια λίστα με τα υπολειπόμενα στοιχεία του iterable ανατίθεται στη συνέχεια στον στόχο με αστερίσκο (η λίστα μπορεί να είναι κενή).

  • Διαφορετικά: Το αντικείμενο πρέπει να είναι ένα iterable με τον ίδιο αριθμό στοιχείων με τους στόχους στη λίστα προορισμού και τα στοιχεία ανατίθενται, από αριστερά προς τα δεξιά, στους αντίστοιχους στόχους.

Η ανάθεση ενός αντικειμένου σε έναν μεμονωμένο στόχο ορίζεται αναδρομικά ως εξής.

• Εάν ο στόχος είναι ένα αναγνωριστικό (όνομα):

  • Εάν το όνομα δεν εμφανίζεται σε μια εντολή global ή nonlocal στο τρέχον μπλοκ κώδικα: το όνομα δεσμεύεται στο αντικείμενο στον τρέχον τοπικό namespace.

  • Διαφορετικά: το όνομα δεσμεύεται στο αντικείμενο στο καθολικό namespace ή στο εξωτερικό namespace που καθορίζεται από το nonlocal, αντίστοιχα.

  Το όνομα επαναδεσμεύεται εάν ήταν ήδη δεσμευμένο. Αυτό μπορεί να προκαλέσει ο μετρητής αναφοράς για το αντικείμενο, που είχε προηγουμένως δεσμευτεί στο όνομα, να φτάσει στο μηδέν, προκαλώντας την απελευθέρωση του αντικειμένου και την κλήση του καταστροφέα του (εάν έχει).

• Εάν ο στόχος είναι μια αναφορά χαρακτηριστικού: Η κύρια έκφραση στην αναφορά αξιολογείται. Θα πρέπει να αποδώσει ένα αντικείμενο με εκχωρήσιμα χαρακτηριστικά· εάν αυτό δεν συμβαίνει, προκαλείται TypeError. Στη συνέχεια, ζητείται από αυτό το αντικείμενο να αναθέσει το εκχωρημένο αντικείμενο στο δεδομένο χαρακτηριστικό· εάν δεν μπορεί να εκτελέσει την ανάθεση, προκαλεί μια εξαίρεση (συνήθως αλλά όχι απαραίτητα AttributeError).

  Σημείωση: Εάν το αντικείμενο είναι ένα στιγμιότυπο κλάσης και η αναφορά χαρακτηριστικού εμφανίζεται και στις δύο πλευρές του τελεστή ανάθεσης, η έκφραση στη δεξιά πλευρά, a.x μπορεί να έχει πρόσβαση είτε σε ένα χαρακτηριστικό στιγμιοτύπου είτε (εάν δεν υπάρχει χαρακτηριστικό στιγμιοτύπου) σε ένα χαρακτηριστικό κλάσης. Ο στόχος της αριστερής πλευράς a.x ορίζεται πάντα ως χαρακτηριστικό στιγμιοτύπου, δημιουργώντας το εάν είναι απαραίτητο. Έτσι, οι δύο εμφανίσεις του a.x δεν αναφέρονται απαραίτητα στο ίδιο χαρακτηριστικό: εάν η έκφραση στη δεξιά πλευρά αναφέρεται σε ένα χαρακτηριστικό κλάσης, η αριστερή πλευρά δημιουργεί ένα νέο χαρακτηριστικό στιγμιοτύπου ως στόχο της ανάθεσης:

  class Cls:
      x = 3             # class variable
  inst = Cls()
  inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
  

  Αυτή η περιγραφή δεν ισχύει απαραίτητα για τα χαρακτηριστικά περιγραφέων, όπως οι ιδιότητες που δημιουργήθηκαν με το property().

• If the target is a subscription: The primary expression in the reference is evaluated. Next, the subscript expression is evaluated. Then, the primary’s __setitem__() method is called with two arguments: the subscript and the assigned object.

  Typically, __setitem__() is defined on mutable sequence objects (such as lists) and mapping objects (such as dictionaries), and behaves as follows.

  Εάν το πρωτεύον είναι ένα μεταβλητό αντικείμενο ακολουθίας (όπως μια λίστα), ο δείκτης πρέπει να αποδώσει έναν ακέραιο αριθμό. Εάν είναι αρνητικός, προστίθεται σε αυτόν το μήκος της ακολουθίας. Η προκύπτουσα τιμή πρέπει να είναι ένας μη αρνητικός ακέραιος μικρότερος από το μήκος της ακολουθίας και ζητείται από την ακολουθία να αναθέσει το εκχωρημένο αντικείμενο στο στοιχείο της με αυτόν τον δείκτη. Εάν ο δείκτης είναι εκτός εμβέλειας, γίνεται raise η IndexError (η ανάθεση σε μια ακολουθία με δείκτη δεν μπορεί να προσθέσει νέα στοιχεία σε μια λίστα).

  Εάν το πρωτεύον είναι ένα αντικείμενο αντιστοίχισης (όπως ένα λεξικό), ο δείκτης πρέπει να έχει έναν τύπο συμβατό με τον τύπο κλειδιού της αντιστοίχισης και στη συνέχεια ζητείται από την αντιστοίχιση να δημιουργήσει ένα ζεύγος κλειδιού/τιμής που αντιστοιχίζει τον δείκτη στο εκχωρημένο αντικείμενο. Αυτό μπορεί είτε να αντικαταστήσει ένα υπάρχον ζεύγος κλειδιού/τιμής με την ίδια τιμή κλειδιού, είτε να εισαγάγει ένα νέο ζεύγος κλειδιού/τιμής (εάν δεν υπήρχε κλειδί με την ίδια τιμή).

  If the target is a slicing: The primary expression should evaluate to a mutable sequence object (such as a list). The assigned object should be iterable. The slicing’s lower and upper bounds should be integers; if they are None (or not present), the defaults are zero and the sequence’s length. If either bound is negative, the sequence’s length is added to it. The resulting bounds are clipped to lie between zero and the sequence’s length, inclusive. Finally, the sequence object is asked to replace the slice with the items of the assigned sequence. The length of the slice may be different from the length of the assigned sequence, thus changing the length of the target sequence, if the target sequence allows it.

Αν και ο ορισμός της ανάθεσης υπονοεί ότι οι επικαλύψεις μεταξύ της αριστερής και της δεξιάς πλευράς είναι «ταυτόχρονες» (για παράδειγμα, το a, b = b, a εναλλάσσει δύο μεταβλητές), οι επικαλύψεις μέσα στη συλλογή των μεταβλητών στις οποίες γίνεται ανάθεση συμβαίνουν από αριστερά προς τα δεξιά, προκαλώντας μερικές φορές σύγχυση. Για παράδειγμα, το ακόλουθο πρόγραμμα εκτυπώνει [0, 2]:

x = [0, 1]
i = 0
i, x[i] = 1, 2 # το i ενημερώνεται, και στη συνέχεια ενημερώνεται το x[i]
print(x)

Δείτε επίσης

PEP 3132 - Εκτεταμένη αποσυμπίεση επαναλαμβανόμενων

Η προδιαγραφή για τη δυνατότητα *target.

7.2.1. Επαυξημένες εντολές ανάθεσης

Η επαυξημένη ανάθεση είναι ο συνδυασμός, σε μία μόνο εντολή, μιας δυαδικής λειτουργίας και μιας εντολής ανάθεσης:

augmented_assignment_stmt: augtarget augop (expression_list | yield_expression)
augtarget:                 identifier | attributeref | subscription
augop:                     "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                           | ">>=" | "<<=" | "&=" | "^=" | "|="

(Ανατρέξτε στην ενότητα Primaries για τους ορισμούς σύνταξης των τριών τελευταίων συμβόλων.)

Μια επαυξημένη ανάθεση αξιολογεί τον στόχο (ο οποίος, σε αντίθεση με τις κανονικές εντολές ανάθεσης, δεν μπορεί να είναι αποσυμπίεση) και τη λίστα εκφράσεων, εκτελεί τη δυαδική λειτουργία που είναι συγκεκριμένη για τον τύπο ανάθεσης στους δύο τελεστές και αναθέτει το αποτέλεσμα στον αρχικό στόχο. Ο στόχος αξιολογείται μόνο μία φορά.

Μια επαυξημένη εντολή ανάθεσης όπως x += 1 μπορεί να ξαναγραφτεί ως x = x + 1 για να επιτευχθεί ένα παρόμοιο, αλλά όχι ακριβώς ίσο αποτέλεσμα. Στην επαυξημένη έκδοση, το x αξιολογείται μόνο μία φορά. Επίσης, όταν είναι δυνατό, η πραγματική λειτουργία εκτελείται επί τόπου, πράγμα που σημαίνει ότι αντί να δημιουργηθεί ένα νέο αντικείμενο και να ανατεθεί αυτό στον στόχο, το παλιό αντικείμενο τροποποιείται αντ” αυτού.

Σε αντίθεση με τις κανονικές αναθέσεις, οι επαυξημένες αναθέσεις αξιολογούν την αριστερή πλευρά πριν αξιολογήσουν τη δεξιά πλευρά. Για παράδειγμα, το a[i] += f(x) πρώτα αναζητά το a[i], στη συνέχεια αξιολογεί το f(x) και εκτελεί την πρόσθεση, και τέλος, γράφει το αποτέλεσμα πίσω στο a[i].

Με εξαίρεση την ανάθεση σε πλειάδες και πολλαπλούς στόχους σε μία μόνο εντολή, η ανάθεση που γίνεται από τις επαυξημένες εντολές ανάθεσης αντιμετωπίζεται με τον ίδιο τρόπο όπως οι κανονικές αναθέσεις. Ομοίως, με εξαίρεση την πιθανή συμπεριφορά επί τόπου, η δυαδική λειτουργία που εκτελείται από την επαυξημένη ανάθεση είναι η ίδια με τις κανονικές δυαδικές λειτουργίες.

Για στόχους που είναι αναφορές χαρακτηριστικών, ισχύει η ίδια caveat σχετικά με τα χαρακτηριστικά κλάσης και εμφάνισης όπως και για τις κανονικές αναθέσεις.

7.2.2. Εντολές ανάθεσης με σχολιασμό

Η ανάθεση Σχολιασμός είναι ο συνδυασμός, σε μία μόνο εντολή, ενός σχολιασμού μεταβλητής ή χαρακτηριστικού και μιας προαιρετικής εντολής ανάθεσης:

annotated_assignment_stmt: augtarget ":" expression
                           ["=" (starred_expression | yield_expression)]

Η διαφορά από την κανονική Εντολές ανάθεσης είναι ότι επιτρέπεται μόνο ένας στόχος.

Ο στόχος ανάθεσης θεωρείται «απλός» εάν αποτελείται από ένα μόνο όνομα που δεν περικλείεται σε παρενθέσεις. Για απλούς στόχους ανάθεσης, εάν βρίσκονται σε εμβέλεια κλάσης ή module, οι σχολιασμοί συγκεντρώνονται σε ένα εύρος σχολιασμού που αξιολογείται με καθυστέρηση. Οι σχολιασμοί μπορούν να αξιολογηθούν χρησιμοποιώντας το χαρακτηριστικό __annotations__ μιας κλάσης ή module ή χρησιμοποιώντας τις διευκολύνσεις στο module annotationlib.

Εάν ο στόχος ανάθεσης δεν είναι απλός (ένα χαρακτηριστικό, ένας κόμβος δείκτη ή ένα όνομα σε παρένθεση), ο σχολιασμός δεν αξιολογείται ποτέ.

Εάν ένα όνομα σχολιαστεί σε ένα εύρος συνάρτησης, τότε αυτό το όνομα είναι τοπικό γι’ αυτό το εύρος. Οι σχολιασμοί δεν αξιολογούνται και δεν αποθηκεύονται ποτέ σε εύρη συναρτήσεων.

Εάν υπάρχει η δεξιά πλευρά, μια σχολιασμένη ανάθεση εκτελεί την πραγματική ανάθεση σαν να μην υπήρχε σχολιασμός. Εάν η δεξιά πλευρά δεν υπάρχει για έναν στόχο έκφρασης, τότε ο διερμηνέας αξιολογεί τον στόχο εκτός από την τελευταία κλήση __setitem__() ή __setattr__().

Δείτε επίσης

PEP 526 - Σύνταξη για σχολιασμούς μεταβλητών

Η πρόταση που πρόσθεσε σύνταξη για τον σχολιασμό των τύπων των μεταβλητών (συμπεριλαμβανομένων των μεταβλητών κλάσης και των μεταβλητών εμφάνισης), αντί να τις εκφράζει μέσω σχολίων.

PEP 484 - Υποδείξεις τύπων

Η πρόταση που πρόσθεσε το module typing για να παρέχει μια τυπική σύνταξη για σχολιασμούς τύπων που μπορούν να χρησιμοποιηθούν σε εργαλεία στατικής ανάλυσης και IDE.

Άλλαξε στην έκδοση 3.8: Πλέον, οι σχολιασμένες αναθέσεις επιτρέπουν τις ίδιες εκφράσεις στη δεξιά πλευρά με τις κανονικές αναθέσεις. Προηγουμένως, ορισμένες εκφράσεις (όπως οι εκφράσεις πλειάδας χωρίς παρενθέσεις) προκαλούσαν σφάλμα σύνταξης.

Άλλαξε στην έκδοση 3.14: Οι σχολιασμοί αξιολογούνται πλέον νωχελικά σε ένα ξεχωριστό εύρος σχολιασμού. Εάν ο στόχος της ανάθεσης δεν είναι απλός, οι σχολιασμοί δεν αξιολογούνται ποτέ.

7.3. Η εντολή assert

Οι εντολές assert είναι ένας βολικός τρόπος για την εισαγωγή ισχυρισμών εντοπισμού σφαλμάτων σε ένα πρόγραμμα:

assert_stmt: "assert" expression ["," expression]

Η απλή μορφή, assert expression, είναι ισοδύναμη με

if __debug__:
    if not expression: raise AssertionError

Η εκτεταμένη μορφή, assert expression1, expression2, είναι ισοδύναμη με

if __debug__:
    if not expression1: raise AssertionError(expression2)

Αυτές οι ισοδυναμίες υποθέτουν ότι οι __debug__ και AssertionError αναφέρονται στις ενσωματωμένες μεταβλητές με αυτά τα ονόματα. Στην τρέχουσα υλοποίηση, η ενσωματωμένη μεταβλητή __debug__ είναι True υπό κανονικές συνθήκες, False όταν ζητείται βελτιστοποίηση (επιλογή γραμμής εντολών -O). Ο τρέχων γεννήτορας κώδικα δεν εκπέμπει κώδικα για μια εντολή assert όταν ζητείται βελτιστοποίηση κατά τη μεταγλώττιση. Σημειώστε ότι δεν είναι απαραίτητο να συμπεριληφθεί ο πηγαίος κώδικας για την έκφραση που απέτυχε στο μήνυμα σφάλματος· θα εμφανιστεί ως μέρος της ανίχνευσης στοίβας.

Οι αναθέσεις στο __debug__ είναι παράνομες. Η τιμή για την ενσωματωμένη μεταβλητή καθορίζεται κατά την έναρξη του διερμηνέα.

7.4. Η έκφραση pass

pass_stmt: "pass"

Η εντολή pass είναι μια κενή λειτουργία — όταν εκτελείται, δεν συμβαίνει τίποτα. Είναι χρήσιμη ως ένας placeholder όταν απαιτείται μια εντολή συντακτικά, αλλά δεν χρειάζεται να εκτελεστεί κώδικας, για παράδειγμα:

def f(arg): pass    # μια συνάρτηση που δεν κάνει τίποτα (ακόμα)

class C: pass       # μια κλάση χωρίς μεθόδους (ακόμα)

7.5. Η εντολή del

del_stmt: "del" target_list

Η διαγραφή ορίζεται αναδρομικά με παρόμοιο τρόπο με τον τρόπο που ορίζεται η ανάθεση. Αντί να το εξηγήσουμε λεπτομερώς, εδώ είναι μερικές συμβουλές.

Η διαγραφή μιας λίστας προορισμού διαγράφει αναδρομικά κάθε στόχο, από τα αριστερά προς τα δεξιά.

Η διαγραφή ενός ονόματος καταργεί τη δέσμευση αυτού του ονόματος από το local ή το global namespace, ανάλογα με το αν το όνομα εμφανίζεται σε μια εντολή global στο ίδιο κομμάτι κώδικα. Η προσπάθεια διαγραφής ενός μη δεσμευμένου ονόματος κάνει raise μια εξαίρεση NameError.

Deletion of attribute references and subscriptions is passed to the primary object involved; deletion of a slicing is in general equivalent to assignment of an empty slice of the right type (but even this is determined by the sliced object).

Άλλαξε στην έκδοση 3.2: Προηγουμένως, ήταν παράνομο να διαγραφεί ένα όνομα από το τοπικό namespace εάν εμφανίζεται ως ελεύθερη μεταβλητή σε ένα εμφωλευμένο μπλοκ.

7.6. Η εντολή return

return_stmt: "return" [expression_list]

Η εντολή return μπορεί να εμφανιστεί μόνο συντακτικά ενσωματωμένη σε έναν ορισμό συνάρτησης, όχι μέσα σε έναν εμφωλευμένο ορισμό κλάσης.

Εάν υπάρχει μια λίστα εκφράσεων, αξιολογείται, αλλιώς αντικαθίσταται με το None.

Η εντολή return εξέρχεται από την τρέχουσα κλήση συνάρτησης με τη λίστα εκφράσεων (ή None) ως τιμή επιστροφής.

Όταν η εντολή return μεταβιβάζει τον έλεγχο από μια εντολή try με μια ρήτρα finally, αυτή η ρήτρα finally εκτελείται πριν από την πραγματική έξοδο από τη συνάρτηση.

Σε μια συνάρτηση generator, η εντολή return υποδεικνύει ότι ο generator έχει ολοκληρωθεί και θα προκαλέσει την εξαίρεση StopIteration. Η επιστρεφόμενη τιμή (εάν υπάρχει) χρησιμοποιείται ως όρισμα για την κατασκευή της StopIteration και γίνεται το χαρακτηριστικό StopIteration.value.

Σε μια ασύγχρονη συνάρτηση generator, μια κενή εντολή return υποδεικνύει ότι ο ασύγχρονος generator έχει ολοκληρωθεί και θα κάνει raise την εξαίρεση StopAsyncIteration. Μια μη κενή εντολή return είναι συντακτικό σφάλμα σε μια ασύγχρονη συνάρτηση generator.

7.7. Η εντολή yield

yield_stmt: yield_expression

Μια εντολή yield είναι σημασιολογικά ισοδύναμη με μια yield expression. Η εντολή yield μπορεί να χρησιμοποιηθεί για την παράλειψη των παρενθέσεων που διαφορετικά θα απαιτούνταν στην ισοδύναμη εντολή έκφρασης απόδοσης. Για παράδειγμα, οι εντολές απόδοσης

yield <expr>
yield from <expr>

είναι ισοδύναμες με τις εντολές έκφρασης απόδοσης

(yield <expr>)
(yield from <expr>)

Οι εκφράσεις και οι εντολές απόδοσης χρησιμοποιούνται μόνο κατά τον ορισμό μιας συνάρτησης generator και χρησιμοποιούνται μόνο στο σώμα της συνάρτησης generator. Η χρήση της yield σε έναν ορισμό συνάρτησης είναι αρκετή για να προκαλέσει αυτόν τον ορισμό να δημιουργήσει μια συνάρτηση generator αντί για μια κανονική συνάρτηση.

Για πλήρεις λεπτομέρειες της σημασιολογίας της yield, ανατρέξτε στην ενότητα Yield expressions.

7.8. Η εντολή raise

raise_stmt: "raise" [expression ["from" expression]]

Εάν δεν υπάρχουν εκφράσεις, η raise επαναφέρει την εξαίρεση που αντιμετωπίζεται εκείνη τη στιγμή, η οποία είναι επίσης γνωστή ως ενεργή εξαίρεση. Εάν δεν υπάρχει προς το παρόν ενεργή εξαίρεση, εμφανίζεται μια εξαίρεση RuntimeError που υποδεικνύει ότι πρόκειται για σφάλμα.

Διαφορετικά, η raise αξιολογεί την πρώτη έκφραση ως αντικείμενο στιγμιοτύπου. Πρέπει να είναι είτε υποκατηγορία είτε παράδειγμα της BaseException. Εάν είναι κλάση, το στιγμιότυπο της εξαίρεσης θα ληφθεί όταν χρειαστεί με τη δημιουργία της κλάσης χωρίς ορίσματα.

Ο τύπος της εξαίρεσης είναι η κλάση του στιγμιοτύπου της εξαίρεσης, η τιμή είναι το ίδιο το στιγμιότυπο.

Ένα αντικείμενο ανίχνευσης (traceback) δημιουργείται κανονικά αυτόματα όταν προκαλείται μια εξαίρεση και επισυνάπτεται σε αυτήν ως το χαρακτηριστικό __traceback__. Μπορείτε να δημιουργήσετε μια εξαίρεση και να ορίσετε τη δική σας ανίχνευση σε ένα βήμα χρησιμοποιώντας τη μέθοδο εξαίρεσης with_traceback() (η οποία επιστρέφει το ίδιο στιγμιότυπο εξαίρεσης, με το traceback του, ορισμένο στο όρισμά του), ως εξής:

raise Exception("foo occurred").with_traceback(tracebackobj)

Η ρήτρα from χρησιμοποιείται για την αλυσιδωτή εξαίρεση: εάν δοθεί, η δεύτερη έκφραση πρέπει να είναι μια άλλη κλάση εξαίρεσης ή στιγμιότυπο. Εάν η δεύτερη έκφραση είναι ένα παράδειγμα εξαίρεσης, θα επισυναφθεί στην εξαίρεση που δημιουργήθηκε ως χαρακτηριστικό __cause__ (το οποίο είναι εγγράψιμο). Εάν η έκφραση είναι μια κλάση εξαίρεσης, η κλάση θα δημιουργηθεί και το προκύπτον στιγμιότυπο εξαίρεσης θα επισυναφθεί στην εξαίρεση που δημιουργήθηκε ως χαρακτηριστικό __cause__. Εάν η εξαίρεση που δημιουργήθηκε δεν αντιμετωπιστεί, θα εκτυπωθούν και οι δύο εξαιρέσεις:

>>> try:
...     print(1 / 0)
... except Exception as exc:
...     raise RuntimeError("Something bad happened") from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    print(1 / 0)
          ~~^~~
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
    raise RuntimeError("Something bad happened") from exc
RuntimeError: Something bad happened

Ένας παρόμοιος μηχανισμός λειτουργεί σιωπηρά εάν προκύψει μια νέα εξαίρεση όταν μια εξαίρεση αντιμετωπίζεται ήδη. Μια εξαίρεση μπορεί να αντιμετωπιστεί όταν χρησιμοποιείται μια ρήτρα except ή finally, ή μια εντολή with. Η προηγούμενη εξαίρεση επισυνάπτεται στη συνέχεια ως το χαρακτηριστικό __context__ της νέας εξαίρεσης:

>>> try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened")
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
    print(1 / 0)
          ~~^~~
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
    raise RuntimeError("Something bad happened")
RuntimeError: Something bad happened

Η αλυσιδωτή εξαίρεση μπορεί να καταργηθεί ρητά, καθορίζοντας το None στη ρήτρα from:

>>> try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

Πρόσθετες πληροφορίες σχετικά με τις εξαιρέσεις μπορείτε να βρείτε στην ενότητα Εξαιρέσεις και πληροφορίες σχετικά με τον χειρισμό εξαιρέσεων στην ενότητα The try statement.

Άλλαξε στην έκδοση 3.3: Το None επιτρέπεται πλέον ως Y στο raise X from Y.

Προστέθηκε το χαρακτηριστικό __suppress_context__ για την κατάργηση της αυτόματης εμφάνισης του περιβάλλοντος της εξαίρεσης.

Άλλαξε στην έκδοση 3.11: Εάν η ανίχνευση της ενεργής εξαίρεσης τροποποιηθεί σε μια ρήτρα except, μια επακόλουθη εντολή raise επαναδημιουργεί την εξαίρεση με την τροποποιημένη ανίχνευση. Προηγουμένως, η εξαίρεση επαναδημιουργούνταν με την ανίχνευση που είχε όταν εντοπίστηκε.

7.9. Η εντολή break

break_stmt: "break"

Η εντολή break μπορεί να εμφανιστεί μόνο συντακτικά ενσωματωμένη σε έναν βρόχο for ή while, αλλά όχι ενσωματωμένη σε έναν ορισμό συνάρτησης ή κλάσης μέσα σε αυτόν τον βρόχο.

Τερματίζει τον πλησιέστερο περικλείοντα βρόχο, παρακάμπτοντας την προαιρετική ρήτρα else εάν ο βρόχος έχει μία.

Εάν ένας βρόχος for τερματιστεί από την εντολή break, ο στόχος ελέγχου του βρόχου διατηρεί την τρέχουσα τιμή του.

Όταν η εντολή break μεταβιβάζει τον έλεγχο από μια εντολή try με μια ρήτρα finally, αυτή η ρήτρα finally εκτελείται πριν από την πραγματική έξοδο από τον βρόχο.

7.10. Η εντολή continue

continue_stmt: "continue"

Η εντολή continue μπορεί να εμφανιστεί μόνο συντακτικά ενσωματωμένη σε έναν βρόχο for ή while, αλλά όχι ενσωματωμένη σε έναν ορισμό συνάρτησης ή κλάσης μέσα σε αυτόν τον βρόχο. Συνεχίζει με τον επόμενο κύκλο του πλησιέστερου περικλείοντος βρόχου.

Όταν η εντολή continue μεταβιβάζει τον έλεγχο από μια εντολή try με μια ρήτρα finally, αυτή η ρήτρα finally εκτελείται πριν από την πραγματική έναρξη του επόμενου κύκλου του βρόχου.

7.11. Η εντολή import

import_stmt:     ["lazy"] "import" module ["as" identifier] ("," module ["as" identifier])*
                 | ["lazy"] "from" relative_module "import" identifier ["as" identifier]
                 ("," identifier ["as" identifier])*
                 | ["lazy"] "from" relative_module "import" "(" identifier ["as" identifier]
                 ("," identifier ["as" identifier])* [","] ")"
                 | "from" relative_module "import" "*"
module:          (identifier ".")* identifier
relative_module: "."* module | "."+

Η βασική εντολή εισαγωγής (χωρίς ρήτρα from) εκτελείται σε δύο βήματα:

1. βρείτε ένα module, φορτώστε το και αρχικοποιήστε το εάν είναι απαραίτητο

2. ορίστε ένα ή περισσοτέρα ονόματα στο τοπικό namespace για το εύρος όπου εμφανίζεται η εντολή import.

Όταν η εντολή περιέχει πολλαπλές ρήτρες (διαχωρισμένες με κόμματα), τα δύο βήματα εκτελούνται ξεχωριστά για κάθε ρήτρα, σαν οι ρήτρες να είχαν διαχωριστεί σε μεμονωμένες εντολές εισαγωγής.

Οι λεπτομέρειες του πρώτου βήματος, η εύρεση και η φόρτωση των modules, περιγράφονται με περισσότερες λεπτομέρειες στην ενότητα για το σύστημα εισαγωγής, το οποίο περιγράφει επίσης τους διάφορους τύπους πακέτων και modules που μπορούν να εισαχθούν, καθώς και όλα τα άγκιστρα που μπορούν να χρησιμοποιηθούν για την προσαρμογή του συστήματος εισαγωγής. Σημειώστε ότι οι αποτυχίες σε αυτό το βήμα μπορεί να υποδεικνύουν είτε ότι το module δεν ήταν δυνατό να εντοπιστεί, ή ότι παρουσιάστηκε σφάλμα κατά την αρχικοποίηση του module, συμπεριλαμβανομένης της εκτέλεσης του κώδικά του.

Εάν το ζητούμενο module ανακτηθεί με επιτυχία, θα είναι διαθέσιμο στο τοπικό namespace με έναν από τους τρεις τρόπους:

• Εάν το όνομα του module ακολουθείται από as, τότε το όνομα που ακολουθεί το as δεσμεύεται απευθείας στο εισαγόμενο module.

• Εάν δεν έχει καθοριστεί άλλο όνομα και το module που εισάγεται είναι ένα module ανώτατου επιπέδου, το όνομα του module δεσμεύεται στο τοπικό namespace ως αναφορά στο εισαγόμενο module

• Εάν το module που εισάγεται δεν είναι ένα module ανώτατου επιπέδου, τότε το όνομα του πακέτου ανώτατου επιπέδου που περιέχει το module δεσμεύεται στο τοπικό namespace ως αναφορά στο πακέτο ανώτατου επιπέδου. Η πρόσβαση στο εισαγόμενο module πρέπει να γίνεται χρησιμοποιώντας το πλήρες ειδικευμένο όνομά του και όχι απευθείας

Η μορφή from χρησιμοποιεί μια ελαφρώς πιο σύνθετη διαδικασία:

1. βρείτε το module που καθορίζεται στη ρήτρα from, φορτώστε το και αρχικοποιήστε το εάν είναι απαραίτητο·

2. για καθένα από τα αναγνωριστικά που καθορίζονται στις ρήτρες import:

   1. ελέγξτε εάν το εισαγόμενο module έχει ένα χαρακτηριστικό με αυτό το όνομα

   2. εάν όχι, προσπαθήστε να εισαγάγετε ένα submodule με αυτό το όνομα και, στη συνέχεια, ελέγξτε ξανά το εισαγόμενο module για αυτό το χαρακτηριστικό

   3. εάν το χαρακτηριστικό δεν βρεθεί, γίνεται raise η ImportError.

   4. διαφορετικά, μια αναφορά σε αυτήν την τιμή αποθηκεύεται στο τοπικό namespace, χρησιμοποιώντας το όνομα στη ρήτρα as εάν υπάρχει, διαφορετικά χρησιμοποιώντας το όνομα του χαρακτηριστικού

Παραδείγματα:

import foo                 # foo imported and bound locally
import foo.bar.baz         # foo, foo.bar, and foo.bar.baz imported, foo bound locally
import foo.bar.baz as fbb  # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as fbb
from foo.bar import baz    # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as baz
from foo import attr       # foo imported and foo.attr bound as attr

Εάν η λίστα των αναγνωριστικών αντικατασταθεί από έναν αστερίσκο ('*'), όλα τα δημόσια ονόματα που ορίζονται στο module δεσμεύονται στο τοπικό namespace για το εύρος όπου εμφανίζεται η εντολή import.

The public names defined by a module are determined by checking the module’s namespace for a variable named __all__; if defined, it must be a sequence of strings which are names defined or imported by that module. Names containing non-ASCII characters must be in the normalization form NFKC; see Non-ASCII characters in names for details. The names given in __all__ are all considered public and are required to exist. If __all__ is not defined, the set of public names includes all names found in the module’s namespace which do not begin with an underscore character ('_'). __all__ should contain the entire public API. It is intended to avoid accidentally exporting items that are not part of the API (such as library modules which were imported and used within the module).

Η μορφή εισαγωγής με χαρακτήρα μπαλαντέρ — from module import * — επιτρέπεται μόνο σε επίπεδο module. Η προσπάθεια χρήσης της σε ορισμούς κλάσεων ή συναρτήσεων θα προκαλέσει SyntaxError.

Κατά τον καθορισμό του module προς εισαγωγή, δεν χρειάζεται να καθορίσετε το απόλυτο όνομα του module. Όταν ένα module ή ένα πακέτο περιέχεται μέσα σε ένα άλλο πακέτο, είναι δυνατή η σχετική εισαγωγή μέσα στο ίδιο πακέτο ανώτατου επιπέδου χωρίς να χρειάζεται να αναφερθεί το όνομα του πακέτου. Χρησιμοποιώντας leading dots στο καθορισμένο module ή πακέτο μετά το from, μπορείτε να καθορίσετε πόσο ψηλά θα διασχίσετε την τρέχουσα ιεραρχία πακέτων χωρίς να καθορίσετε ακριβή ονόματα. Ένα leading dot σημαίνει το τρέχον πακέτο όπου υπάρχει το module που πραγματοποιεί την εισαγωγή. Δύο leading dots σημαίνουν ένα επίπεδο πακέτου προς τα πάνω. Τρία leading dots είναι δύο επίπεδα προς τα πάνω, κ.λπ. Έτσι, εάν εκτελέσετε το from . import mod από ένα module στο πακέτο pkg, θα καταλήξετε να εισάγετε το pkg.mod. Εάν εκτελέσετε το from ..subpkg2 import mod από το pkg.subpkg1, θα εισαγάγετε το pkg.subpkg2.mod. Η προδιαγραφή για τις σχετικές εισαγωγές περιέχεται στην ενότητα Package Relative Imports.

Η συνάρτηση importlib.import_module() παρέχεται για την υποστήριξη εφαρμογών που καθορίζουν δυναμικά τα modules που θα φορτωθούν.

Κάνει raise ένα auditing event import με ορίσματα module, filename, sys.path, sys.meta_path, sys.path_hooks.

7.11.1. Lazy imports

The lazy keyword is a soft keyword that only has special meaning when it appears immediately before an import or from statement. When an import statement is preceded by the lazy keyword, the import becomes lazy: the module is not loaded immediately at the import statement. Instead, a lazy proxy object is created and bound to the name. The actual module is loaded on first use of that name.

Lazy imports are only permitted at module scope. Using lazy inside a function, class body, or try/except/finally block raises a SyntaxError. Star imports cannot be lazy (lazy from module import * is a syntax error), and future statements cannot be lazy.

When using lazy from ... import, each imported name is bound to a lazy proxy object. The first access to any of these names triggers loading of the entire module and resolves only that specific name to its actual value. Other names remain as lazy proxies until they are accessed.

Example:

lazy import json
import sys

print('json' in sys.modules)  # False - json module not yet loaded

# First use triggers loading
result = json.dumps({"hello": "world"})

print('json' in sys.modules)  # True - now loaded

If an error occurs during module loading (such as ImportError or SyntaxError), it is raised at the point where the lazy import is first used, not at the import statement itself.

See PEP 810 for the full specification of lazy imports.

Added in version 3.15.0a6 (unreleased).

7.11.2. Μελλοντικές δηλώσεις

Μια μελλοντική δήλωση είναι μια οδηγία προς τον μεταγλωττιστή ότι ένα συγκεκριμένο module πρέπει να μεταγλωττιστεί χρησιμοποιώντας σύνταξη ή σημασιολογία που θα είναι διαθέσιμη σε μια καθορισμένη μελλοντική έκδοση της Python όπου η δυνατότητα γίνεται πρότυπο.

Η μελλοντική δήλωση προορίζεται να διευκολύνει τη μετάβαση σε μελλοντικές εκδόσεις της Python που εισάγουν ασύμβατες αλλαγές στη γλώσσα. Επιτρέπει τη χρήση των νέων δυνατοτήτων ανά module πριν από την έκδοση στην οποία η δυνατότητα γίνεται πρότυπο.

future_stmt: "from" "__future__" "import" feature ["as" identifier]
             ("," feature ["as" identifier])*
             | "from" "__future__" "import" "(" feature ["as" identifier]
             ("," feature ["as" identifier])* [","] ")"
feature:     identifier

Μια μελλοντική δήλωση πρέπει να εμφανίζεται κοντά στην κορυφή του module. Οι μόνες γραμμές που μπορούν να εμφανιστούν πριν από μια μελλοντική δήλωση είναι:

• η συμβολοσειρά τεκμηρίωσης του module (εάν υπάρχει),

• σχόλια,

• κενές γραμμές, και

• άλλες μελλοντικές δηλώσεις.

Η μόνη δυνατότητα που απαιτεί τη χρήση της μελλοντικής δήλωσης είναι τα annotations (ανατρέξτε στο PEP 563).

Όλες οι ιστορικές δυνατότητες που ενεργοποιούνται από τη μελλοντική δήλωση εξακολουθούν να αναγνωρίζονται από την Python 3. Η λίστα περιλαμβάνει τα absolute_import, division, generators, generator_stop, unicode_literals, print_function, nested_scopes και with_statement. Είναι όλα περιττά επειδή είναι πάντα ενεργοποιημένα και διατηρούνται μόνο για λόγους συμβατότητας προς τα πίσω.

Μια μελλοντική δήλωση αναγνωρίζεται και αντιμετωπίζεται ειδικά κατά τη μεταγλώττιση: Οι αλλαγές στη σημασιολογία των βασικών δομών υλοποιούνται συχνά με τη δημιουργία διαφορετικού κώδικα. Μπορεί ακόμη και να συμβεί μια νέα δυνατότητα να εισάγει νέα ασύμβατη σύνταξη (όπως μια νέα δεσμευμένη λέξη), οπότε ο μεταγλωττιστής μπορεί να χρειαστεί να αναλύσει το module διαφορετικά. Τέτοιες αποφάσεις δεν μπορούν να αναβληθούν μέχρι το χρόνο εκτέλεσης.

Για κάθε δεδομένη έκδοση, ο μεταγλωττιστής γνωρίζει ποια ονόματα δυνατοτήτων έχουν οριστεί και προκαλεί σφάλμα μεταγλώττισης εάν μια μελλοντική δήλωση περιέχει μια δυνατότητα που δεν του είναι γνωστή.

Η άμεση σημασιολογία χρόνου εκτέλεσης είναι η ίδια όπως για κάθε εντολή εισαγωγής: υπάρχει ένα τυπικό module __future__, που περιγράφεται παρακάτω, και θα εισαχθεί με τον συνήθη τρόπο κατά την εκτέλεση της μελλοντικής δήλωσης.

Η ενδιαφέρουσα σημασιολογία χρόνου εκτέλεσης εξαρτάται από τη συγκεκριμένη δυνατότητα που ενεργοποιείται από τη μελλοντική δήλωση.

Σημειώστε ότι δεν υπάρχει τίποτα το ιδιαίτερο σχετικά με την εντολή:

import __future__ [as name]

Αυτή δεν είναι μια μελλοντική δήλωση· είναι μια συνηθισμένη εντολή εισαγωγής χωρίς ειδικούς περιορισμούς σημασιολογίας ή σύνταξης.

Ο κώδικας που μεταγλωττίζεται από κλήσεις στις ενσωματωμένες συναρτήσεις exec() και compile() που εμφανίζονται σε ένα module M που περιέχει μια μελλοντική δήλωση θα χρησιμοποιήσει, από προεπιλογή, τη νέα σύνταξη ή σημασιολογία που σχετίζεται με τη μελλοντική δήλωση. Αυτό μπορεί να ελεγχθεί από προαιρετικά ορίσματα στο compile() — ανατρέξτε στην τεκμηρίωση αυτής της συνάρτησης για λεπτομέρειες.

Μια μελλοντική δήλωση που πληκτρολογείται σε μια διαδραστική γραμμή εντολών του διερμηνέα θα τεθεί σε ισχύ για το υπόλοιπο της περιόδου λειτουργίας του διερμηνέα. Εάν ένας διερμηνέας εκκινηθεί με την επιλογή -i, του δοθεί ένα όνομα σεναρίου για εκτέλεση και το σενάριο περιλαμβάνει μια μελλοντική δήλωση, θα ισχύει στη διαδραστική συνεδρία που ξεκίνησε μετά την εκτέλεση του σεναρίου.

Δείτε επίσης

PEP 236 - Επιστροφή στο __future__

Η αρχική πρόταση για τον μηχανισμό __future__.

7.12. Η εντολή global

global_stmt: "global" identifier ("," identifier)*

Η εντολή global προκαλεί την ερμηνεία των αναγραφόμενων αναγνωριστικών ως καθολικών (globals). Θα ήταν αδύνατο να γίνει ανάθεση σε μια καθολική μεταβλητή χωρίς το global, αν και οι ελεύθερες μεταβλητές μπορεί να αναφέρονται σε καθολικές μεταβλητές χωρίς να δηλωθούν καθολικές.

Η εντολή global ισχύει για ολόκληρο το τρέχον πεδίο (module, σώμα συνάρτησης ή ορισμός κλάσης). Ένα SyntaxError προκαλείται εάν μια μεταβλητή χρησιμοποιηθεί ή ανατεθεί πριν από την καθολική της δήλωση στο πεδίο.

Σε επίπεδο module, όλες οι μεταβλητές είναι καθολικές (global), επομένως μια εντολή global δεν έχει κανένα αποτέλεσμα. Ωστόσο, οι μεταβλητές δεν πρέπει ακόμα να χρησιμοποιούνται ή να ανατίθενται πριν από τη δήλωσή τους με το global. Αυτή η απαίτηση δεν είναι τόσο ρητή στη διαδραστική γραμμή εντολών (REPL).

Σημείωση προγραμματιστή: Το global είναι μια οδηγία προς τον parser. Ισχύει μόνο για κώδικα που αναλύεται ταυτόχρονα με την εντολή global. Συγκεκριμένα, μια εντολή global που περιέχεται σε μια συμβολοσειρά ή αντικείμενο κώδικα που παρέχεται στην ενσωματωμένη συνάρτηση exec() δεν επηρεάζει το κομμάτι κώδικα που περιέχει την κλήση συνάρτησης και ο κώδικας που περιέχεται σε μια τέτοια συμβολοσειρά δεν επηρεάζεται από τις εντολές global στον κώδικα που περιέχει την κλήση συνάρτησης. Το ίδιο ισχύει για τις συναρτήσεις eval() και compile().

7.13. Η εντολή nonlocal

nonlocal_stmt: "nonlocal" identifier ("," identifier)*

Όταν ο ορισμός μιας συνάρτησης ή κλάσης είναι ενσωματωμένος (περικλείεται) στους ορισμούς άλλων συναρτήσεων, τα μη τοπικά του πεδία είναι τα τοπικά πεδία των περικλειόμενων συναρτήσεων. Η εντολή nonlocal προκαλεί τα αναγραφόμενα αναγνωριστικά να αναφέρονται σε ονόματα που είχαν προηγουμένως δεσμευτεί σε μη τοπικά πεδία. Επιτρέπει στον ενθυλακωμένο κώδικα να επαναδεσμεύσει τέτοια μη τοπικά αναγνωριστικά. Εάν ένα όνομα είναι δεσμευμένο σε περισσότερα από ένα μη τοπικά πεδία, χρησιμοποιείται η πλησιέστερη δέσμευση. Εάν ένα όνομα δεν είναι δεσμευμένο σε κανένα μη τοπικό πεδίο, ή εάν δεν υπάρχει μη τοπικό πεδίο, γίνεται raise το SyntaxError.

Η εντολή nonlocal ισχύει για ολόκληρο το πεδίο ενός σώματος συνάρτησης ή κλάσης. Ένα SyntaxError γίνεται raise εάν μια μεταβλητή χρησιμοποιηθεί ή ανατεθεί πριν από τη μη τοπική της δήλωση στο πεδίο.

Δείτε επίσης

PEP 3104 - Πρόσβαση σε ονόματα σε εξωτερικά πεδία

Η προδιαγραφή για την εντολή nonlocal.

Σημείωση προγραμματιστή: Το nonlocal είναι μια οδηγία προς τον parser και ισχύει μόνο για κώδικα που αναλύεται μαζί του. Ανατρέξτε στη σημείωση για την εντολή global.

7.14. Η εντολή type

type_stmt: 'type' identifier [type_params] "=" expression

Η εντολή type δηλώνει ένα ψευδώνυμο τύπου, το οποίο είναι ένα στιγμιότυπο του typing.TypeAliasType.

Για παράδειγμα, η ακόλουθη εντολή δημιουργεί ένα ψευδώνυμο τύπου:

type Point = tuple[float, float]

Αυτός ο κώδικας είναι περίπου ισοδύναμος με:

annotation-def VALUE_OF_Point():
    return tuple[float, float]
Point = typing.TypeAliasType("Point", VALUE_OF_Point())

Το annotation-def υποδεικνύει ένα πεδίο σχολιασμού, το οποίο συμπεριφέρεται κυρίως σαν μια συνάρτηση, αλλά με αρκετές μικρές διαφορές.

Η τιμή του ψευδώνυμου τύπου αξιολογείται στο πεδίο σχολιασμού. Δεν αξιολογείται κατά τη δημιουργία του ψευδώνυμου τύπου, αλλά μόνο όταν η τιμή προσπελαστεί μέσω του χαρακτηριστικού __value__ του ψευδώνυμου τύπου (ανατρέξτε στην Καθυστερημένη εκτίμηση). Αυτό επιτρέπει στο ψευδώνυμο τύπου να αναφέρεται σε ονόματα που δεν έχουν ακόμη οριστεί.

Τα ψευδώνυμα τύπων μπορούν να γίνουν generic προσθέτοντας μια λιστα παραμέτρων τύπου μετά το όνομα. Ανατρέξτε στα Generic type aliases για περισσότερα.

Το type είναι μια ήπια λέξη-κλειδί.

Added in version 3.12.

Δείτε επίσης

PEP 695 - Σύνταξη παραμέτρων τύπου

Εισήγαγε την εντολή type και τη σύνταξη για γενικές κλάσεις και συναρτήσεις.