# 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 Πρωτεύοντα 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:                     "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="

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

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

Μια επαυξημένη εντολή ανάθεσης όπως `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`, ανατρέξτε στην ενότητα Εκφράσεις απόδοσης.

## 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

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

Άλλαξε στην έκδοση 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. define a name or names in the current namespace for the scope where the `import` statement occurs, just as an assignment statement would (including `global` and `nonlocal` semantics).

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

Οι λεπτομέρειες του πρώτου βήματος, η εύρεση και η φόρτωση των 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. otherwise, a reference to that value is stored in the current namespace, using the name in the `as` clause if it is present, otherwise using the attribute name

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

    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 Μη-ASCII χαρακτήρες στα ονόματα 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`. Η προδιαγραφή για τις σχετικές εισαγωγές περιέχεται στην ενότητα Σχετικές εισαγωγές σε πακέτα.

Η συνάρτηση `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.

#### 7.11.1.1. Compatibility via `__lazy_modules__`

As an alternative to using the `lazy` keyword, a module can opt into lazy loading for specific imports by defining a module-level `__lazy_modules__` variable. When present, it must be a container of fully qualified module name strings. Any regular (non-`lazy`) `import` statement at module scope whose target appears in `__lazy_modules__` is treated as a lazy import, exactly as if the `lazy` keyword had been used.

This provides a way to enable lazy loading for specific dependencies without changing individual `import` statements. This is useful when supporting Python versions older than 3.15 while using lazy imports in 3.15+:

    __lazy_modules__ = ["json", "pathlib"]

    import json     # loaded lazily (name is in __lazy_modules__)
    import os       # loaded eagerly (name not in __lazy_modules__)

    import pathlib  # loaded lazily

Relative imports are resolved to their absolute name before the lookup, so `__lazy_modules__` must always contain fully qualified module names.

For `from`-style imports, the relevant name is the module following `from`, not the names of its members:

    # In mypackage/mymodule.py
    __lazy_modules__ = ["mypackage", "mypackage.sub.utils"]

    from . import helper         # loaded lazily: . resolves to mypackage
    from .sub.utils import func  # loaded lazily: .sub.utils resolves to mypackage.sub.utils
    import json                  # loaded eagerly (not in __lazy_modules__)

Imports inside functions, class bodies, or `try`/`except`/`finally` blocks are always eager, regardless of `__lazy_modules__`.

Setting `-X lazy_imports=none` (or the `PYTHON_LAZY_IMPORTS` environment variable to `none`) overrides `__lazy_modules__` and forces all imports to be eager.

Added in version 3.15.

### 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 προσθέτοντας μια λιστα παραμέτρων τύπου μετά το όνομα. Ανατρέξτε στα Ψευδώνυμα γενικού τύπου για περισσότερα.

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

Added in version 3.12.

Δείτε επίσης

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

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