# 2. Λεξική ανάλυση

Ένα πρόγραμμα Python διαβάζεται από έναν αναλυτή (parser). Η είσοδος του αναλυτή είναι μια ροή από tokens, που παράγεται από τον λεξικό αναλυτή (γνωστό και ως tokenizer). Αυτό το κεφάλαιο περιγράφει πώς ο λεξικός αναλυτής παράγει αυτά τα tokens.

Ο λεξικός αναλυτής καθορίζει την κωδικοποίηση του κειμένου του προγράμματος (UTF-8 από προεπιλογή) και αποκωδικοποιεί το κείμενο σε χαρακτήρες πηγής. Αν το κείμενο δεν μπορεί να αποκωδικοποιηθεί, γίνεται raise ένα `SyntaxError`.

Στη συνέχεια, ο λεξικός αναλυτής χρησιμοποιεί τους χαρακτήρες προέλευσης για να δημιουργήσει μια ροή από tokens. Ο τύπος ενός παραγόμενου token γενικά εξαρτάται από τον επόμενο χαρακτήρα πηγής που πρόκειται να επεξεργαστεί. Αντίστοιχα, άλλες ειδικές συμπεριφορές του αναλυτή εξαρτώνται από τον πρώτο χαρακτήρα πηγής που δεν έχει ακόμη επεξεργαστεί. Ο παρακάτω πίνακας δίνει μια σύντομη σύνοψη αυτών των χαρακτήρων πηγής, με συνδέσμους προς τις ενότητες που περιέχουν περισσότερες πληροφορίες.

Χαρακτήρας | Επόμενο token (ή άλλη σχετική τεκμηρίωση)
--- | ---

- κενό

- tab

- αλλαγή σελίδας (formfeed)

- Κενά διαστήματα

- CR, LF

- Νέα γραμμή

- Εσοχή

- ανάστροφη κάθετος (backslash) (`\`)

- Ρητή συνένωση γραμμών

- (Σημαντική επίσης στις ακολουθίες διαφυγής συμβολοσειρών)

- δίεση (`#`)

- Σχόλιο

- εισαγωγικό (`'`, `"`)

- Συμβολοσειρά

- γράμμα ASCII (`a`-`z`, `A`-`Z`)

- μη-ASCII χαρακτήρας

- Όνομα

- Λεκτικό συμβολοσειράς ή bytes με πρόθεμα

- κάτω παύλα (`_`)

- Όνομα

- (Μπορεί επίσης να αποτελεί μέρος αριθμητικών)

- αριθμός (`0`-`9`)

- Αριθμητικό

- τελεία (`.`)

- Αριθμητικό

- Τελεστής

- ερωτηματικό (`?`)

- σύμβολο δολαρίου (`$`)

- ανάποδο εισαγωγικό (`​`​`)

- χαρακτήρας ελέγχου

- Σφάλμα (εκτός λεκτικών συμβολοσειράς και σχολίων)

- άλλος εκτυπώσιμος χαρακτήρας

- Τελεστής ή delimiter

- τέλος αρχείου

- Δείκτης τέλους

## 2.1. Δομή γραμμών

Ένα πρόγραμμα Python χωρίζεται σε έναν αριθμό από λογικές γραμμές.

### 2.1.1. Λογικές γραμμές

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

### 2.1.2. Φυσικές γραμμές

Μια φυσική γραμμή είναι μια ακολουθία χαρακτήρων που τερματίζεται από μία από τις παρακάτω ακολουθίες τέλους γραμμής:

- τη μορφή Unix που χρησιμοποιεί ASCII LF (linefeed),

- τη μορφή Windows που χρησιμοποιεί την ASCII ακολουθία CR LF (return ακολουθούμενο από linefeed),

- τη μορφή “Classic Mac OS” που χρησιμοποιεί τον χαρακτήρα ASCII CR (return).

Ανεξάρτητα από την πλατφόρμα, καθεμία από αυτές τις ακολουθίες αντικαθίσταται από έναν μόνο χαρακτήρα ASCII LF (linefeed). (Αυτό γίνεται ακόμη και μέσα σε συμβολοσειρές.) Κάθε γραμμή μπορεί να χρησιμοποιεί οποιαδήποτε από τις ακολουθίες· δεν χρειάζεται να είναι συνεπείς μέσα στο ίδιο αρχείο.

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

Τυπικά:

    newline: <ASCII LF> | <ASCII CR> <ASCII LF> | <ASCII CR>

### 2.1.3. Σχόλια

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

### 2.1.4. Δηλώσεις κωδικοποίησης

Αν ένα σχόλιο στην πρώτη ή δεύτερη γραμμή ενός Python script ταιριάζει με την κανονική έκφραση (regular expression) `coding[=:]\s*([-\w.]+)`, τότε το σχόλιο επεξεργάζεται ως δήλωση κωδικοποίησης· η πρώτη ομάδα αυτής της έκφρασης ονομάζει την κωδικοποίηση του αρχείου πηγαίου κώδικα. Η δήλωση κωδικοποίησης πρέπει να εμφανίζεται μόνη της σε μια γραμμή. Αν βρίσκεται στη δεύτερη γραμμή, τότε η πρώτη γραμμή πρέπει να περιέχει μόνο σχόλιο. Οι προτεινόμενες μορφές δήλωσης κωδικοποίησης είναι

    # -*- coding: <encoding-name> -*-

η οποία αναγνωρίζεται επίσης από το GNU Emacs, και

    # vim:fileencoding=<encoding-name>

η οποία αναγνωρίζεται από το VIM του Bram Moolenaar.

Αν δεν βρεθεί δήλωση κωδικοποίησης, η προεπιλεγμένη κωδικοποίηση είναι UTF-8. Αν η έμμεση ή ρητή κωδικοποίηση ενός αρχείου είναι UTF-8, ένα αρχικό UTF-8 byte-order mark (`b'\xef\xbb\xbf'`) αγνοείται αντί να θεωρείται σφάλμα σύνταξης.

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

Όλη η λεξική ανάλυση, συμπεριλαμβανομένων λεκτικών συμβολοσειράς, σχολίων και αναγνωριστικών, γίνεται πάνω σε κείμενο Unicode που έχει αποκωδικοποιηθεί με την κωδικοποίηση πηγής. Οποιοδήποτε σημείο κώδικα Unicode, εκτός από τον χαρακτήρα ελέγχου NUL, μπορεί να εμφανιστεί σε πηγαίο κώδικα Python.

    source_character:  <any Unicode code point, except NUL>

### 2.1.5. Ρητή συνένωση γραμμών

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

    if 1900 < year < 2100 and 1 <= month <= 12 \
       and 1 <= day <= 31 and 0 <= hour < 24 \
       and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
            return 1

Μια γραμμή που τελειώνει με ανάστροφη κάθετο δεν μπορεί να περιέχει σχόλιο. Η ανάστροφη κάθετος δεν συνεχίζει ένα σχόλιο. Η ανάστροφη κάθετος δεν συνεχίζει ένα token, εκτός από λεκτικά συμβολοσειράς (δηλ. tokens διαφορετικά από λεκτικά συμβολοσειράς δεν μπορούν να «σπάσουν» σε περισσότερες φυσικές γραμμές με χρήση ανάστροφης καθέτου). Η ανάστροφη κάθετος είναι παράνομη οπουδήποτε αλλού σε μια γραμμή εκτός λεκτικού συμβολοσειράς.

### 2.1.6. Έμμεση συνένωση γραμμών

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

    month_names = ['Januari', 'Februari', 'Maart',      # These are the
                   'April',   'Mei',      'Juni',       # Dutch names
                   'Juli',    'Augustus', 'September',  # for the months
                   'Oktober', 'November', 'December']   # of the year

Οι έμμεσα συνεχόμενες γραμμές μπορούν να περιέχουν σχόλια. Η εσοχή των γραμμών συνέχισης δεν είναι σημαντική. Επιτρέπονται κενές γραμμές συνέχισης. Δεν υπάρχει token NEWLINE ανάμεσα σε έμμεσα συνεχόμενες γραμμές. Έμμεσα συνεχόμενες γραμμές μπορούν επίσης να εμφανιστούν μέσα σε συμβολοσειρές τριπλών εισαγωγικών (βλ. παρακάτω)· σε αυτή την περίπτωση δεν μπορούν να περιέχουν σχόλια.

### 2.1.7. Κενές γραμμές

Μια λογική γραμμή που περιέχει μόνο κενά, tabs, αλλαγές σελίδας και πιθανόν σχόλιο, αγνοείται (δηλ. δεν παράγεται token `NEWLINE`). Κατά τη διαδραστική εισαγωγή εντολών, ο χειρισμός μιας κενής γραμμής μπορεί να διαφέρει ανάλογα με την υλοποίηση του read-eval-print loop. Στον τυπικό διαδραστικό διερμηνέα, μια εντελώς κενή λογική γραμμή (δηλ. που δεν περιέχει ούτε κενούς χαρακτήρες ούτε σχόλιο) τερματίζει μια εντολή πολλαπλών γραμμών.

### 2.1.8. Εσοχή

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

Τα tabs αντικαθίστανται (από αριστερά προς τα δεξιά) από ένα έως οκτώ κενά έτσι ώστε το συνολικό πλήθος χαρακτήρων μέχρι και την αντικατάσταση να είναι πολλαπλάσιο του οκτώ (πρόκειται για τον ίδιο κανόνας που χρησιμοποιείται στο Unix). Το συνολικό πλήθος κενών πριν από τον πρώτο μη-κενό χαρακτήρα καθορίζει την εσοχή της γραμμής. Η εσοχή δεν μπορεί να «σπάσει» σε περισσότερες φυσικές γραμμές με χρήση ανάστροφων καθέτων· οι κενοί χαρακτήρες μέχρι την πρώτη ανάστροφη κάθετο καθορίζουν την εσοχή.

Η εσοχή απορρίπτεται ως ασυνεπής αν ένα αρχείο πηγαίου κώδικα αναμειγνύει tabs και κενά με τρόπο που κάνει το νόημα να εξαρτάται από το πόσα κενά αντιστοιχούν σε ένα tab· σε αυτή την περίπτωση γίνεται raise ένα `TabError`.

Σημείωση συμβατότητας μεταξύ πλατφορμών: λόγω της φύσης των επεξεργαστών κειμένου σε μη-UNIX πλατφόρμες, δεν είναι συνετό να χρησιμοποιείται μίξη κενών και tabs για την εσοχή μέσα στο ίδιο αρχείο πηγαίου κώδικα. Θα πρέπει επίσης να σημειωθεί ότι διαφορετικές πλατφόρμες ενδέχεται να περιορίζουν ρητά το μέγιστο επίπεδο εσοχής.

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

Τα επίπεδα εσοχής διαδοχικών γραμμών χρησιμοποιούνται για τη δημιουργία των tokens `INDENT` και `DEDENT`, χρησιμοποιώντας μια στοίβα, ως εξής.

Πριν διαβαστεί η πρώτη γραμμή του αρχείου, ένα μοναδικό μηδενικό ωθείται στη στοίβα· αυτό δεν θα αφαιρεθεί ποτέ. Οι αριθμοί που ωθούνται στη στοίβα θα είναι πάντα αυστηρά αυξανόμενοι από κάτω προς τα πάνω. Στην αρχή κάθε λογικής γραμμής, το επίπεδο εσοχής της γραμμής συγκρίνεται με την κορυφή της στοίβας. Αν είναι ίσο, δεν συμβαίνει τίποτα. Αν είναι μεγαλύτερο, ωθείται στη στοίβα και παράγεται ένα token `INDENT`. Αν είναι μικρότερο, πρέπει να είναι ένας από τους αριθμούς που υπάρχουν στη στοίβα· όλοι οι μεγαλύτεροι αριθμοί αφαιρούνται (pop) και για κάθε αριθμό που αφαιρείται παράγεται ένα token `DEDENT`. Στο τέλος του αρχείου, παράγεται ένα token `DEDENT` για κάθε αριθμό που απομένει στη στοίβα και είναι μεγαλύτερος από το μηδέν.

Ακολουθεί ένα παράδειγμα (αν και μπερδεμένο) κώδικα Python με σωστή εσοχή:

    def perm(l):
            # Compute the list of all permutations of l
        if len(l) <= 1:
                      return [l]
        r = []
        for i in range(len(l)):
                 s = l[:i] + l[i+1:]
                 p = perm(s)
                 for x in p:
                  r.append(l[i:i+1] + x)
        return r

Το παρακάτω παράδειγμα δείχνει διάφορα σφάλματα εσοχής:

     def perm(l):                       # error: first line indented
    for i in range(len(l)):             # error: not indented
        s = l[:i] + l[i+1:]
            p = perm(l[:i] + l[i+1:])   # error: unexpected indent
            for x in p:
                    r.append(l[i:i+1] + x)
                return r                # error: inconsistent dedent

(Στην πραγματικότητα, τα τρία πρώτα σφάλματα εντοπίζονται από τον parser· μόνο το τελευταίο σφάλμα εντοπίζεται από τον λεξικό αναλυτή — η εσοχή του `return r` δεν ταιριάζει με επίπεδο που αφαιρέθηκε από τη στοίβα.)

### 2.1.9. Κενοί χαρακτήρες μεταξύ των tokens

Except at the beginning of a logical line or in string literals, the whitespace characters space, tab and formfeed can be used interchangeably to separate tokens:

    whitespace:  ' ' | tab | formfeed

Whitespace is needed between two tokens only if their concatenation could otherwise be interpreted as a different token. For example, `ab` is one token, but `a b` is two tokens. However, `+a` and `+ a` both produce two tokens, `+` and `a`, as `+a` is not a valid token.

### 2.1.10. Δείκτης τέλους

Στο τέλος μη-διαδραστικής εισόδου, ο λεξικός αναλυτής παράγει ένα token `ENDMARKER`.

## 2.2. Άλλα tokens

Εκτός από τα `NEWLINE`, `INDENT` και `DEDENT`, υπάρχουν και οι εξής κατηγορίες tokens: αναγνωριστικά και λέξεις-κλειδιά (`NAME`), λεκτικά (όπως `NUMBER` και `STRING`) και άλλα σύμβολα (τελεστές και οριοθέτες, `OP`). Οι κενοί χαρακτήρες (εκτός από τους τερματιστές λογικής γραμμής που συζητήθηκαν νωρίτερα) δεν είναι tokens, αλλά χρησιμεύουν για τον διαχωρισμό των tokens. Όπου υπάρχει ασάφεια, ένα token αποτελείται από τη μεγαλύτερη δυνατή συμβολοσειρά που σχηματίζει έγκυρο token, όταν διαβάζεται από αριστερά προς τα δεξιά.

## 2.3. Ονόματα (αναγνωριστικά και λέξεις-κλειδιά)

Τα tokens `NAME` αναπαριστούν αναγνωριστικά, λέξεις-κλειδιά και ήπιες λέξεις-κλειδιά.

Τα ονόματα αποτελούνται από τους παρακάτω χαρακτήρες:

- κεφαλαία και πεζά γράμματα (`A-Z` και `a-z`),

- την κάτω παύλα (`_`),

- ψηφία (`0` έως `9`), που δεν μπορούν να εμφανιστούν ως πρώτος χαρακτήρας, και

- μη-ASCII χαρακτήρες. Έγκυρα ονόματα μπορούν να περιέχουν μόνο χαρακτήρες «γραμμάτων” και «ψηφίων”· δείτε Μη-ASCII χαρακτήρες στα ονόματα για λεπτομέρειες.

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

Τυπικά, τα ονόματα περιγράφονται από τους παρακάτω λεξικούς ορισμούς:

    NAME:          name_start name_continue*
    name_start:    "a"..."z" | "A"..."Z" | "_" | <non-ASCII character>
    name_continue: name_start | "0"..."9"
    identifier:    <NAME, except keywords>

Σημειώστε ότι δεν είναι έγκυρα όλα τα ονόματα που ταιριάζουν σε αυτή τη γραμματική· δείτε Μη-ASCII χαρακτήρες στα ονόματα για λεπτομέρειες.

### 2.3.1. Λέξεις-κλειδιά

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

    False      await      else       import     pass
    None       break      except     in         raise
    True       class      finally    is         return
    and        continue   for        lambda     try
    as         def        from       nonlocal   while
    assert     del        global     not        with
    async      elif       if         or         yield

### 2.3.2. Ήπιες λέξεις-κλειδιά

Added in version 3.10.

Κάποια ονόματα είναι δεσμευμένα μόνο σε συγκεκριμένα συμφραζόμενα. Αυτά είναι γνωστά ως ήπιες λέξεις-κλειδιά:

- `match`, `case` και `_`, όταν χρησιμοποιούνται στην εντολή `match`.

- `type`, όταν χρησιμοποιείται στην εντολή `type`.

- `lazy`, when used before an `import` statement.

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

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

Άλλαξε στην έκδοση 3.12: Το `type` είναι πλέον ήπια λέξη-κλειδί.

Άλλαξε στην έκδοση 3.15: `lazy` is now a soft keyword.

### 2.3.3. Δεσμευμένες κλάσεις αναγνωριστικών

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

`_*`

  Δεν εισάγεται με `from module import *`.

`_`

  Σε ένα μοτίβο `case` μέσα σε εντολή `match`, το `_` είναι ήπια λέξη-κλειδί που δηλώνει ένα μπαλαντέρ.

  Ανεξάρτητα από αυτό, ο διαδραστικός διερμηνέας κάνει διαθέσιμο το αποτέλεσμα της τελευταίας αξιολόγησης στη μεταβλητή `_`. (Αποθηκεύεται στο module `builtins`, δίπλα σε ενσωματωμένες συναρτήσεις όπως το `print`.)

  Αλλού, το `_` είναι ένα κανονικό αναγνωριστικό. Συχνά χρησιμοποιείται για να ονομάζει «ειδικά» αντικείμενα, αλλά δεν είναι ιδιαίτερο για την ίδια την Python.

  Σημείωση

  Το όνομα `_` χρησιμοποιείται συχνά σε συνδυασμό με διεθνοποίηση· ανατρέξτε στην τεκμηρίωση του module `gettext` για περισσότερες πληροφορίες σχετικά με αυτή τη σύμβαση.

  Χρησιμοποιείται επίσης συχνά για αχρησιμοποίητες μεταβλητές.

`__*__`

  Ονόματα ορισμένα από το σύστημα, ατύπως γνωστά ως ονόματα «dunder». Αυτά τα ονόματα ορίζονται από τον διερμηνέα και την υλοποίησή του (συμπεριλαμβανομένης της τυπικής βιβλιοθήκης). Τα τρέχοντα ονόματα συστήματος συζητούνται στην ενότητα Ειδικά ονόματα μεθόδων και αλλού. Πιθανότατα θα οριστούν περισσότερα σε μελλοντικές εκδόσεις της Python. Κάθε χρήση ονομάτων `__*__`, σε οποιοδήποτε πλαίσιο, που δεν ακολουθεί ρητά τεκμηριωμένη χρήση, είναι πιθανό να «σπάσει» χωρίς προειδοποίηση.

`__*`

  Ιδιωτικά ονόματα σε κλάση. Τα ονόματα αυτής της κατηγορίας, όταν χρησιμοποιούνται μέσα στο πλαίσιο ενός ορισμού κλάσης, ξαναγράφονται σε «παραμορφωμένη» (mangled) μορφή ώστε να αποφεύγονται συγκρούσεις ονομάτων μεταξύ «ιδιωτικών» γνωρισμάτων βασικών και παραγόμενων κλάσεων. Δείτε την ενότητα Αναγνωριστικά (Ονόματα).

### 2.3.4. Μη-ASCII χαρακτήρες στα ονόματα

Ονόματα που περιέχουν μη-ASCII χαρακτήρες χρειάζονται πρόσθετη κανονικοποίηση και επικύρωση πέρα από τους κανόνες και τη γραμματική που εξηγούνται παραπάνω. Για παράδειγμα, τα `ř_1`, `蛇` ή `साँप` είναι έγκυρα ονόματα, αλλά τα `r〰2`, `€` ή `🐍` δεν είναι.

Αυτή η ενότητα εξηγεί τους ακριβείς κανόνες.

Όλα τα ονόματα μετατρέπονται στη normalization form NFKC κατά την ανάλυση. Αυτό σημαίνει ότι, για παράδειγμα, ορισμένες τυπογραφικές παραλλαγές χαρακτήρων μετατρέπονται στη «βασική» τους μορφή. Για παράδειγμα, το `ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ` κανονικοποιείται σε `finalization`, οπότε η Python τα αντιμετωπίζει ως το ίδιο όνομα:

    >>> ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ = 3
    >>> finalization
    3

Σημείωση

Η κανονικοποίηση γίνεται μόνο στο λεξικό επίπεδο. Συναρτήσεις χρόνου εκτέλεσης που δέχονται ονόματα ως strings γενικά δεν κανονικοποιούν τα ορίσματά τους. Για παράδειγμα, η μεταβλητή που ορίστηκε παραπάνω είναι προσβάσιμη κατά την εκτέλεση στο λεξικό `globals()` ως `globals()["finalization"]` αλλά όχι ως `globals()["ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ"]`.

Όπως ακριβώς τα ονόματα που αποτελούνται μόνο από ASCII πρέπει να περιέχουν μόνο γράμματα, ψηφία και κάτω παύλα και δεν μπορούν να ξεκινούν με ψηφίο, έτσι και ένα έγκυρο όνομα πρέπει να ξεκινά με χαρακτήρα από το σύνολο``xid_start`` τύπου γραμμάτων, και οι υπόλοιποι χαρακτήρες πρέπει να ανήκουν στο σύνολο `xid_continue` τύπου γραμμάτων και ψηφίων.

These sets are based on the XID_Start and XID_Continue sets as defined by the Unicode standard annex UAX-31. Python’s `xid_start` additionally includes the underscore (`_`). Note that Python does not necessarily conform to UAX-31.

Μια μη-κανονιστική λίστα χαρακτήρων των συνόλων XID_Start και XID_Continue όπως ορίζονται από το Unicode είναι διαθέσιμη στο αρχείο DerivedCoreProperties.txt της Unicode Character Database. Για αναφορά, οι κανόνες κατασκευής για τα σύνολα `xid_*` δίνονται παρακάτω.

Το σύνολο `id_start` ορίζεται ως η ένωση των:

- Κατηγορία Unicode `<Lu>` - κεφαλαία γράμματα (περιλαμβάνει `A` έως `Z`)

- Κατηγορία Unicode `<Ll>` - πεζά γράμματα (περιλαμβάνει `a` έως `z`)

- Κατηγορία Unicode `<Lt>` - γράμματα τύπου titlecase

- Κατηγορία Unicode `<Lm>` - τροποποιητικά γράμματα

- Κατηγορία Unicode `<Lo>` - άλλα γράμματα

- Κατηγορία Unicode `<Nl>` - αριθμοί-γράμματα

- {`"_"`} - η κάτω παύλα

- `<Other_ID_Start>` - ένα ρητό σύνολο χαρακτήρων στο PropList.txt για να υποστηρίζεται η συμβατότητα προς τα πίσω

Το σύνολο `xid_start` κατόπιν «κλείνει» αυτό το σύνολο υπό κανονικοποίηση NFKC, αφαιρώντας όλους τους χαρακτήρες των οποίων η κανονικοποίηση δεν είναι της μορφής `id_start id_continue*`.

Το σύνολο `id_continue` ορίζεται ως η ένωση των:

- `id_start` (βλ. παραπάνω)

- Κατηγορία Unicode `<Nd>` - δεκαδικοί αριθμοί (περιλαμβάνει `0` έως `9`)

- Κατηγορία Unicode `<Pc>` - σημεία στίξης σύνδεσης

- Κατηγορία Unicode `<Mn>` - nonspacing marks

- Κατηγορία Unicode `<Mc>` - συνδυαστικά σημάδια με απόσταση

- `<Other_ID_Continue>` - ένα ακόμη ρητό σύνολο χαρακτήρων στο PropList.txt για να υποστηρίζεται η συμβατότητα προς τα πίσω

Και πάλι, το `xid_continue` «κλείνει» αυτό το σύνολο υπό κανονικοποίηση NFKC.

Οι κατηγορίες Unicode χρησιμοποιούν την έκδοση της Unicode Character Database όπως περιλαμβάνεται στο module `unicodedata`.

Δείτε επίσης

- PEP 3131 – Υποστήριξη μη-ASCII αναγνωριστικών

- PEP 672 – Ζητήματα ασφάλειας σχετικά με το Unicode στην Python

## 2.4. Λεκτικά

Τα λεκτικά είναι σημειογραφίες για σταθερές τιμές ορισμένων ενσωματωμένων τύπων.

Όσον αφορά τη λεξική ανάλυση, η Python έχει λεκτικά συμβολοσειράς, bytes και αριθμητικά.

Άλλα «λεκτικά» δηλώνονται λεξικά μέσω λέξεων-κλειδιών (`None`, `True`, `False`) και του ειδικού token έλλειψης (`...`).

## 2.5. Λεκτικά συμβολοσειράς και Bytes

Τα λεκτικά συμβολοσειράς είναι κείμενο μέσα σε μονά εισαγωγικά (`'`) ή διπλά εισαγωγικά (`"`). Για παράδειγμα:

    "spam"
    'eggs'

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

    'Say "Hello", please.'
    "Don't do that!"

Πέρα από αυτόν τον περιορισμό, η επιλογή εισαγωγικού (`'` ή `"`) δεν επηρεάζει το πώς αναλύεται το λεκτικό.

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

    >>> print("Say \"Hello\" to everyone!")
    Say "Hello" to everyone!

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

### 2.5.1. Συμβολοσειρές τριπλού εισαγωγικού

Οι συμβολοσειρές μπορούν επίσης να περικλείονται σε αντίστοιχες ομάδες τριών μονών ή τριών διπλών εισαγωγικών. Αυτές συνήθως αναφέρονται ως triple-quoted strings:

    """This is a triple-quoted string."""

Σε λεκτικά τριπλών εισαγωγικών, επιτρέπονται (και διατηρούνται) εισαγωγικά χωρίς διαφυγή, με εξαίρεση ότι τρία εισαγωγικά χωρίς διαφυγή στη σειρά τερματίζουν το λεκτικό, αν είναι του ίδιου είδους (`'` ή `"`) με αυτό που χρησιμοποιήθηκε στην αρχή:

    """This string has "quotes" inside."""

Επιτρέπονται επίσης (και διατηρούνται) νέες γραμμές χωρίς διαφυγή:

    '''This triple-quoted string
    continues on the next line.'''

### 2.5.2. Προθέματα συμβολοσειράς

Τα λεκτικά συμβολοσειράς μπορούν να έχουν ένα προαιρετικό prefix που επηρεάζει το πώς αναλύεται το περιεχόμενο του λεκτικού, για παράδειγμα:

    b"data"
    f'{result=}'

Τα επιτρεπόμενα προθέματα είναι:

- `b`: Λεκτικό bytes

- `r`: Ακατέργαστη συμβολοσειρά (raw string)

- `f`: Λεκτικό μορφοποιημένης συμβολοσειράς («f-string»)

- `t`: Λεκτικό συμβολοσειράς προτύπου («t-string»)

- `u`: Καμία επίδραση (επιτρέπεται για συμβατότητα προς τα πίσω)

Δείτε τις αντίστοιχες ενότητες για λεπτομέρειες σχετικά με κάθε τύπο.

Τα προθέματα δεν κάνουν διάκριση κεφαλαίων/πεζών (για παράδειγμα, το “`B`” λειτουργεί όπως το “`b`”). Το πρόθεμα “`r`” μπορεί να συνδυαστεί με “`f`”, “`t`” ή “`b`”, οπότε και τα “`fr`”, “`rf`”, “`tr`”, “`rt`”, “`br`” και “`rb`” είναι επίσης έγκυρα προθέματα.

Added in version 3.3: Το πρόθεμα `'rb'` για raw bytes λεκτικά έχει προστεθεί ως συνώνυμο του `'br'`.

Η υποστήριξη για το παλιό unicode λεκτικό (`u'value'`) επανεισήχθη για να απλοποιηθεί η συντήρηση κωδικών βάσεων που υποστηρίζουν ταυτόχρονα Python 2.x και 3.x. Δείτε το PEP 414 για περισσότερες πληροφορίες.

### 2.5.3. Τυπική γραμματική

Τα λεκτικά συμβολοσειράς, εκτός από τα «f-strings» και «t-strings», περιγράφονται από τους παρακάτω λεξικούς ορισμούς.

Αυτοί οι ορισμοί χρησιμοποιούν αρνητικά lookaheads (`!`) για να υποδείξουν ότι ένα τελικό εισαγωγικό τερματίζει το λεκτικό.

    STRING:          [stringprefix] (stringcontent)
    stringprefix:    <("r" | "u" | "b" | "br" | "rb"), case-insensitive>
    stringcontent:
       | "'''" ( !"'''" longstringitem)* "'''"
       | '"""' ( !'"""' longstringitem)* '"""'
       | "'" ( !"'" stringitem)* "'"
       | '"' ( !'"' stringitem)* '"'
    stringitem:      stringchar | stringescapeseq
    stringchar:      <any source_character, except backslash and newline>
    longstringitem:  stringitem | newline
    stringescapeseq: "\" <any source_character>

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

### 2.5.4. Ακολουθίες διαφυγής

Εκτός αν υπάρχει πρόθεμα “`r`” ή “`R`”, οι ακολουθίες διαφυγής σε λεκτικά συμβολοσειράς και bytes ερμηνεύονται με κανόνες παρόμοιους με αυτούς της Standard C. Οι αναγνωριζόμενες ακολουθίες διαφυγής είναι:

Ακολουθία διαφυγής | Σημασία
--- | ---
`\`<newline> | Αγνοημένο τέλος γραμμής
`\\` | Ανάστροφη κάθετος
`\'` | Μονό εισαγωγικό
`\"` | Διπλό εισαγωγικό
`\a` | ASCII Bell (BEL)
`\b` | ASCII Backspace (BS)
`\f` | ASCII Formfeed (FF)
`\n` | ASCII Linefeed (LF)
`\r` | ASCII Carriage Return (CR)
`\t` | ASCII Horizontal Tab (TAB)
`\v` | ASCII Vertical Tab (VT)
`\ooo` | Οκταδικός χαρακτήρας
`\xhh` | Δεκαεξαδικός χαρακτήρας
`\N{name}` | Ονοματισμένος χαρακτήρας Unicode
`\uxxxx` | Δεκαεξαδικός χαρακτήρας Unicode
`\Uxxxxxxxx` | Δεκαεξαδικός χαρακτήρας Unicode

#### 2.5.4.1. Αγνοημένο τέλος γραμμής

Μπορεί να προστεθεί ανάστροφη κάθετος στο τέλος μιας γραμμής για να αγνοηθεί η νέα γραμμή:

    >>> 'This string will not include \
    ... backslashes or newline characters.'
    'This string will not include backslashes or newline characters.'

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

#### 2.5.4.2. Χαρακτήρες με διαφυγή

Για να συμπεριληφθεί μια ανάστροφη κάθετος σε λεκτικό συμβολοσειράς Python που δεν είναι raw, πρέπει να διπλασιαστεί. Η ακολουθία διαφυγής `\\` δηλώνει έναν μοναδικό χαρακτήρα ανάστροφης καθέτου:

    >>> print('C:\\Program Files')
    C:\Program Files

Αντίστοιχα, οι ακολουθίες `\'` και `\"` δηλώνουν τον χαρακτήρα μονών και διπλών εισαγωγικών, αντίστοιχα:

    >>> print('\' and \"')
    ' and "

#### 2.5.4.3. Οκταδικός χαρακτήρας

Η ακολουθία `\ooo` δηλώνει έναν χαρακτήρα με οκταδική (βάση 8) τιμή ooo:

    >>> '\120'
    'P'

Γίνονται δεκτά έως τρία οκταδικά ψηφία (0 έως 7).

Σε λεκτικό bytes, χαρακτήρας σημαίνει ένα byte με τη δεδομένη τιμή. Σε λεκτικό συμβολοσειράς, σημαίνει χαρακτήρας Unicode με τη δεδομένη τιμή.

Άλλαξε στην έκδοση 3.11: Οκταδικές διαφυγές με τιμή μεγαλύτερη από `0o377` (255) παράγουν ένα `DeprecationWarning`.

Άλλαξε στην έκδοση 3.12: Οκταδικές διαφυγές με τιμή μεγαλύτερη από `0o377` (255) παράγουν ένα `SyntaxWarning`. Σε μελλοντική έκδοση της Python θα κάνουν raise `SyntaxError`.

#### 2.5.4.4. Δεκαεξαδικός χαρακτήρας

Η ακολουθία `\xhh` δηλώνει έναν χαρακτήρα με δεκαεξαδική (βάση 16) τιμή hh:

    >>> '\x50'
    'P'

Σε αντίθεση με την Standard C, απαιτούνται ακριβώς δύο δεκαεξαδικά ψηφία.

Σε λεκτικό bytes, χαρακτήρας σημαίνει ένα byte με τη δεδομένη τιμή. Σε λεκτικό συμβολοσειράς, σημαίνει χαρακτήρας Unicode με τη δεδομένη τιμή.

#### 2.5.4.5. Ονοματισμένος χαρακτήρας Unicode

Η ακολουθία `\N{name}` δηλώνει έναν χαρακτήρα Unicode με το δοσμένο όνομα:

    >>> '\N{LATIN CAPITAL LETTER P}'
    'P'
    >>> '\N{SNAKE}'
    '🐍'

Αυτή η ακολουθία δεν μπορεί να εμφανιστεί σε λεκτικά bytes.

Άλλαξε στην έκδοση 3.3: Support for name aliases has been added.

#### 2.5.4.6. Δεκαεξαδικοί χαρακτήρες Unicode

Οι ακολουθίες `\uxxxx` και `\Uxxxxxxxx` δηλώνουν τον χαρακτήρα Unicode με τη δεδομένη δεκαεξαδική (βάση 16) τιμή. Απαιτούνται ακριβώς τέσσερα ψηφία για το `\u` και ακριβώς οκτώ ψηφία για το `\U`. Η δεύτερη μπορεί να κωδικοποιήσει οποιονδήποτε χαρακτήρα Unicode.

    >>> '\u1234'
    'ሴ'
    >>> '\U0001f40d'
    '🐍'

Αυτές οι ακολουθίες δεν μπορούν να εμφανιστούν σε λεκτικά bytes.

#### 2.5.4.7. Μη αναγνωρισμένες ακολουθίες διαφυγής

Σε αντίθεση με την Standard C, όλες οι μη αναγνωρισμένες ακολουθίες διαφυγής αφήνονται αμετάβλητες στη συμβολοσειρά, δηλαδή η ανάστροφη κάθετος παραμένει στο αποτέλεσμα:

    >>> print('\q')
    \q
    >>> list('\q')
    ['\\', 'q']

Σημειώστε ότι για λεκτικά bytes, οι ακολουθίες διαφυγής που αναγνωρίζονται μόνο σε λεκτικά συμβολοσειράς (`\N...`, `\u...`, `\U...`) εμπίπτουν στην κατηγορία των μη αναγνωρισμένων διαφυγών.

Άλλαξε στην έκδοση 3.6: Οι μη αναγνωρισμένες ακολουθίες διαφυγής παράγουν ένα `DeprecationWarning`.

Άλλαξε στην έκδοση 3.12: Οι μη αναγνωρισμένες ακολουθίες διαφυγής παράγουν ένα `SyntaxWarning`. Σε μελλοντική έκδοση της Python θα κάνουν raise `SyntaxError`.

### 2.5.5. Λεκτικά bytes

Τα Bytes literals έχουν πάντα πρόθεμα “`b`” ή “`B`”· παράγουν ένα αντικείμενο του τύπου `bytes` αντί του `str`. Μπορούν να περιέχουν μόνο χαρακτήρες ASCII· bytes με αριθμητική τιμή 128 ή μεγαλύτερη πρέπει να εκφράζονται με ακολουθίες διαφυγής (συνήθως Δεκαεξαδικός χαρακτήρας ή Οκταδικός χαρακτήρας):

    >>> b'\x89PNG\r\n\x1a\n'
    b'\x89PNG\r\n\x1a\n'
    >>> list(b'\x89PNG\r\n\x1a\n')
    [137, 80, 78, 71, 13, 10, 26, 10]

Αντίστοιχα, ένα μηδενικό byte πρέπει να εκφράζεται με ακολουθία διαφυγής (συνήθως `\0` ή `\x00`).

### 2.5.6. Λεκτικά raw συμβολοσειράς

Τόσο τα λεκτικά συμβολοσειράς όσο και τα λεκτικά bytes μπορούν προαιρετικά να έχουν πρόθεμα το γράμμα “`r`” ή “`R`”· τέτοιες κατασκευές ονομάζονται raw string literals και raw bytes literals αντίστοιχα και αντιμετωπίζουν τις ανάστροφες καθέτους ως χαρακτήρες. Ως αποτέλεσμα, στα λεκτικά raw συμβολοσειράς, οι ακολουθίες διαφυγής δεν αντιμετωπίζονται ειδικά:

    >>> r'\d{4}-\d{2}-\d{2}'
    '\\d{4}-\\d{2}-\\d{2}'

Ακόμη και σε ένα raw λεκτικό, τα εισαγωγικά μπορούν να «ξεφύγουν» (escape) με ανάστροφη κάθετο, αλλά η ανάστροφη κάθετος παραμένει στο αποτέλεσμα· για παράδειγμα, το `r"\""` είναι έγκυρο λεκτικό συμβολοσειράς που αποτελείται από δύο χαρακτήρες: μια ανάστροφη κάθετο και ένα διπλό εισαγωγικό· το `r"\"` δεν είναι έγκυρο λεκτικό συμβολοσειράς (ακόμη και μια raw συμβολοσειρά δεν μπορεί να τελειώνει με περιττό αριθμό ανάστροφων καθέτων). Συγκεκριμένα, ένα raw λεκτικό δεν μπορεί να τελειώνει με μία μόνο ανάστροφη κάθετο (αφού η ανάστροφη κάθετος θα διέφευγε τον επόμενο χαρακτήρα εισαγωγικού). Σημειώστε επίσης ότι μια μοναδική ανάστροφη κάθετος ακολουθούμενη από νέα γραμμή ερμηνεύονται ως μέρος του λεκτικού, όχι ως συνέχιση γραμμής.

### 2.5.7. f-strings

Added in version 3.6.

Άλλαξε στην έκδοση 3.7: The `await` and `async for` can be used in expressions within f-strings.

Άλλαξε στην έκδοση 3.8: Added the debug specifier (`=`)

Άλλαξε στην έκδοση 3.12: Many restrictions on expressions within f-strings have been removed. Notably, nested strings, comments, and backslashes are now permitted.

A formatted string literal or f-string is a string literal that is prefixed with “`f`” or “`F`”. Unlike other string literals, f-strings do not have a constant value. They may contain replacement fields delimited by curly braces `{}`. Replacement fields contain expressions which are evaluated at run time. For example:

    >>> who = 'nobody'
    >>> nationality = 'Spanish'
    >>> f'{who.title()} expects the {nationality} Inquisition!'
    'Nobody expects the Spanish Inquisition!'

Any doubled curly braces (`{{` or `}}`) outside replacement fields are replaced with the corresponding single curly brace:

    >>> print(f'{{...}}')
    {...}

Other characters outside replacement fields are treated like in ordinary string literals. This means that escape sequences are decoded (except when a literal is also marked as a raw string), and newlines are possible in triple-quoted f-strings:

    >>> name = 'Galahad'
    >>> favorite_color = 'blue'
    >>> print(f'{name}:\t{favorite_color}')
    Galahad:       blue
    >>> print(rf"C:\Users\{name}")
    C:\Users\Galahad
    >>> print(f'''Three shall be the number of the counting
    ... and the number of the counting shall be three.''')
    Three shall be the number of the counting
    and the number of the counting shall be three.

Expressions in formatted string literals are treated like regular Python expressions. Each expression is evaluated in the context where the formatted string literal appears, in order from left to right. An empty expression is not allowed, and both `lambda` and assignment expressions `:=` must be surrounded by explicit parentheses:

    >>> f'{(half := 1/2)}, {half * 42}'
    '0.5, 21.0'

Επιτρέπεται να επαναχρησιμοποιείται ο τύπος εισαγωγικών του εξωτερικού f-string μέσα σε ένα πεδίο αντικατάστασης:

    >>> a = dict(x=2)
    >>> f"abc {a["x"]} def"
    'abc 2 def'

Επιτρέπονται επίσης ανάστροφες καθέτοι μέσα σε πεδία αντικατάστασης και αξιολογούνται με τον ίδιο τρόπο όπως σε οποιοδήποτε άλλο πλαίσιο:

    >>> a = ["a", "b", "c"]
    >>> print(f"List a contains:\n{"\n".join(a)}")
    List a contains:
    a
    b
    c

It is possible to nest f-strings:

    >>> name = 'world'
    >>> f'Repeated:{f' hello {name}' * 3}'
    'Repeated: hello world hello world hello world'

Portable Python programs should not use more than 5 levels of nesting.

Λεπτομέρεια υλοποίησης CPython: CPython does not limit nesting of f-strings.

Replacement expressions can contain newlines in both single-quoted and triple-quoted f-strings and they can contain comments. Everything that comes after a `#` inside a replacement field is a comment (even closing braces and quotes). This means that replacement fields with comments must be closed in a different line:

    >>> a = 2
    >>> f"abc{a  # This comment  }"  continues until the end of the line
    ...       + 3}"
    'abc5'

After the expression, replacement fields may optionally contain:

- a debug specifier – an equal sign (`=`), optionally surrounded by whitespace on one or both sides;

- a conversion specifier – `!s`, `!r` or `!a`; and/or

- a format specifier prefixed with a colon (`:`).

See the Standard Library section on f-strings for details on how these fields are evaluated.

As that section explains, format specifiers are passed as the second argument to the `format()` function to format a replacement field value. For example, they can be used to specify a field width and padding characters using the Format Specification Mini-Language:

    >>> number = 14.3
    >>> f'{number:20.7f}'
    '          14.3000000'

Top-level format specifiers may include nested replacement fields:

    >>> field_size = 20
    >>> precision = 7
    >>> f'{number:{field_size}.{precision}f}'
    '          14.3000000'

These nested fields may include their own conversion fields and format specifiers:

    >>> number = 3
    >>> f'{number:{field_size}}'
    '                   3'
    >>> f'{number:{field_size:05}}'
    '00000000000000000003'

However, these nested fields may not include more deeply nested replacement fields.

Formatted string literals cannot be used as docstrings, even if they do not include expressions:

    >>> def foo():
    ...     f"Not a docstring"
    ...
    >>> print(foo.__doc__)
    None

Δείτε επίσης

- PEP 498 – Literal String Interpolation

- PEP 701 – Syntactic formalization of f-strings

- `str.format()`, which uses a related format string mechanism.

### 2.5.8. t-strings

Added in version 3.14.

A template string literal or t-string is a string literal that is prefixed with “`t`” or “`T`”. These strings follow the same syntax rules as formatted string literals. For differences in evaluation rules, see the Standard Library section on t-strings

### 2.5.9. Formal grammar for f-strings

F-strings are handled partly by the lexical analyzer, which produces the tokens `FSTRING_START`, `FSTRING_MIDDLE` and `FSTRING_END`, and partly by the parser, which handles expressions in the replacement field. The exact way the work is split is a CPython implementation detail.

Correspondingly, the f-string grammar is a mix of lexical and syntactic definitions.

Whitespace is significant in these situations:

- There may be no whitespace in `FSTRING_START` (between the prefix and quote).

- Whitespace in `FSTRING_MIDDLE` is part of the literal string contents.

- In `fstring_replacement_field`, if `f_debug_specifier` is present, all whitespace after the opening brace until the `f_debug_specifier`, as well as whitespace immediately following `f_debug_specifier`, is retained as part of the expression.

  Λεπτομέρεια υλοποίησης CPython: The expression is not handled in the tokenization phase; it is retrieved from the source code using locations of the `{` token and the token after `=`.

The `FSTRING_MIDDLE` definition uses negative lookaheads (`!`) to indicate special characters (backslash, newline, `{`, `}`) and sequences (`f_quote`).

    fstring:    FSTRING_START fstring_middle* FSTRING_END

    FSTRING_START:      fstringprefix ("'" | '"' | "'''" | '"""')
    FSTRING_END:        f_quote
    fstringprefix:      <("f" | "fr" | "rf"), case-insensitive>
    f_debug_specifier:  '='
    f_quote:            <the quote character(s) used in FSTRING_START>

    fstring_middle:
       | fstring_replacement_field
       | FSTRING_MIDDLE
    FSTRING_MIDDLE:
       | (!"\" !newline !'{' !'}' !f_quote) source_character
       | stringescapeseq
       | "{{"
       | "}}"
       | <newline, in triple-quoted f-strings only>
    fstring_replacement_field:
       | '{' f_expression [f_debug_specifier] [fstring_conversion]
             [fstring_full_format_spec] '}'
    fstring_conversion:
       | "!" ("s" | "r" | "a")
    fstring_full_format_spec:
       | ':' fstring_format_spec*
    fstring_format_spec:
       | FSTRING_MIDDLE
       | fstring_replacement_field
    f_expression:
       | ','.(conditional_expression | "*" or_expr)+ [","]
       | yield_expression

Σημείωση

In the above grammar snippet, the `f_quote` and `FSTRING_MIDDLE` rules are context-sensitive – they depend on the contents of `FSTRING_START` of the nearest enclosing `fstring`.

Constructing a more traditional formal grammar from this template is left as an exercise for the reader.

The grammar for t-strings is identical to the one for f-strings, with t instead of f at the beginning of rule and token names and in the prefix.

    tstring:    TSTRING_START tstring_middle* TSTRING_END

    <rest of the t-string grammar is omitted; see above>

## 2.6. Αριθμητικά λεκτικά

Τα tokens `NUMBER` αναπαριστούν αριθμητικά λεκτικά, τα οποία είναι τριών τύπων: ακέραιοι, αριθμοί κινητής υποδιαστολής και φανταστικοί αριθμοί.

    NUMBER: integer | floatnumber | imagnumber

Η αριθμητική τιμή ενός αριθμητικού λεκτικού είναι η ίδια σαν να περνιόταν ως string στον αντίστοιχο constructor των `int`, `float` ή `complex`. Σημειώστε ότι δεν είναι όλες οι έγκυρες είσοδοι για αυτούς τους constructors και έγκυρα λεκτικά.

Τα αριθμητικά λεκτικά δεν περιλαμβάνουν πρόσημο· μια έκφραση όπως `-1` είναι στην πραγματικότητα μια έκφραση που αποτελείται από τον μοναδιαίο τελεστή “`-`” και το λεκτικό `1`.

### 2.6.1. Λεκτικά ακεραίων

Τα λεκτικά ακεραίων δηλώνουν ακέραιους αριθμούς. Για παράδειγμα:

    7
    3
    2147483647

Δεν υπάρχει όριο στο μήκος των ακεραίων πέρα από αυτό που μπορεί να αποθηκευτεί στη διαθέσιμη μνήμη:

    7922816251426433759354395033679228162514264337593543950336

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

    100_000_000_000
    100000000000
    1_00_00_00_00_000

Οι κάτω παύλες μπορούν να εμφανίζονται μόνο ανάμεσα σε ψηφία. Για παράδειγμα, τα `_123`, `321_` και `123__321` δεν είναι έγκυρα λεκτικά.

Οι ακέραιοι μπορούν να δηλωθούν ως δυαδικοί (βάση του 2), οκταδικοί (βάση του 8) ή δεκαεξαδικοί (βάση του 16) χρησιμοποιώντας τα προθέματα `0b`, `0o` και `0x`, αντίστοιχα. Τα δεκαεξαδικά ψηφία 10 έως 15 αναπαριστώνται από τα γράμματα `A`-`F`, χωρίς διάκριση κεφαλαίων/πεζών. Για παράδειγμα:

    0b100110111
    0b_1110_0101
    0o177
    0o377
    0xdeadbeef
    0xDead_Beef

Μια κάτω παύλα μπορεί να ακολουθεί τον προσδιοριστή βάσης. Για παράδειγμα, το `0x_1f` είναι έγκυρο λεκτικό, αλλά τα `0_x1f` και `0x__1f` δεν είναι.

Δεν επιτρέπονται μηδενικά στην αρχή σε μη-μηδενικό δεκαδικό αριθμό. Για παράδειγμα, το `0123` δεν είναι έγκυρο λεκτικό. Αυτό γίνεται για να αποσαφηνίζεται η διάκριση με οκταδικά λεκτικά τύπου C, τα οποία η Python χρησιμοποιούσε πριν την έκδοση 3.0.

Τυπικά, τα λεκτικά ακεραίων περιγράφονται από τους παρακάτω λεξικούς ορισμούς:

    integer:      decinteger | bininteger | octinteger | hexinteger | zerointeger
    decinteger:   nonzerodigit (["_"] digit)*
    bininteger:   "0" ("b" | "B") (["_"] bindigit)+
    octinteger:   "0" ("o" | "O") (["_"] octdigit)+
    hexinteger:   "0" ("x" | "X") (["_"] hexdigit)+
    zerointeger:  "0"+ (["_"] "0")*
    nonzerodigit: "1"..."9"
    digit:        "0"..."9"
    bindigit:     "0" | "1"
    octdigit:     "0"..."7"
    hexdigit:     digit | "a"..."f" | "A"..."F"

Άλλαξε στην έκδοση 3.6: Οι κάτω παύλες επιτρέπονται πλέον στα λεκτικά για σκοπούς ομαδοποίησης.

### 2.6.2. Λεκτικά κινητής υποδιαστολής

Τα λεκτικά κινητής υποδιαστολής (float), όπως `3.14` ή `1.5`, δηλώνουν προσεγγίσεις πραγματικών αριθμών.

Αποτελούνται από ακέραιο και κλασματικό μέρος, το καθένα από δεκαδικά ψηφία. Τα μέρη χωρίζονται από τελεία, `.`:

    2.71828
    4.0

Σε αντίθεση με τα λεκτικά ακεραίων, επιτρέπονται μηδενικά στην αρχή. Για παράδειγμα, το `077.010` είναι νόμιμο και δηλώνει τον ίδιο αριθμό με το `77.01`.

Όπως και στα λεκτικά ακεραίων, μονές κάτω παύλες μπορούν να εμφανίζονται ανάμεσα σε ψηφία για καλύτερη αναγνωσιμότητα:

    96_485.332_123
    3.14_15_93

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

    10.  # (ισοδύναμο με το 10.0)
    .001  # (ισοδύναμο με το 0.001)

Προαιρετικά, το ακέραιο και το κλασματικό μέρος μπορεί να ακολουθούνται από έναν εκθέτη: το γράμμα `e` ή `E`, ακολουθούμενο από προαιρετικό πρόσημο, `+` ή `-`, και έναν αριθμό στην ίδια μορφή με το ακέραιο και το κλασματικό μέρος. Το `e` ή `E` σημαίνει «επί δέκα υψωμένο στη δύναμη»:

    1.0e3  # (αντιπροσωπεύει το 1.0×10³, ή το 1000.0)
    1.166e-5  # (αντιπροσωπεύει το 1.166×10⁻⁵, ή το 0.00001166)
    6.02214076e+23  # (αντιπροσωπεύει το 6.02214076×10²³, ή το 602214076000000000000000.)

Σε floats που έχουν μόνο ακέραιο μέρος και εκθέτη, η υποδιαστολή μπορεί να παραλειφθεί:

    1e3  # (ισοδύναμο με το 1.e3 και το 1.0e3)
    0e0  # (ισοδύναμο με το 0.)

Τυπικά, τα λεκτικά κινητής υποδιαστολής περιγράφονται από τους παρακάτω λεξικούς ορισμούς:

    floatnumber:
       | digitpart "." [digitpart] [exponent]
       | "." digitpart [exponent]
       | digitpart exponent
    digitpart: digit (["_"] digit)*
    exponent:  ("e" | "E") ["+" | "-"] digitpart

Άλλαξε στην έκδοση 3.6: Οι κάτω παύλες επιτρέπονται πλέον στα λεκτικά για σκοπούς ομαδοποίησης.

### 2.6.3. Λεκτικά φανταστικών

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

Για παράδειγμα, στα μαθηματικά, ο μιγαδικός αριθμός 3+4.2i γράφεται ως ο πραγματικός αριθμός 3 συν ο φανταστικός αριθμός 4.2i. Η Python χρησιμοποιεί παρόμοια σύνταξη, με τη διαφορά ότι η φανταστική μονάδα γράφεται ως `j` αντί για i:

    3+4.2j

Αυτή είναι μια έκφραση που αποτελείται από το λεκτικό ακεραίου `3`, τον τελεστή “`+`” και το λεκτικό φανταστικού `4.2j`. Εφόσον αυτά είναι τρία ξεχωριστά tokens, επιτρέπονται κενοί χαρακτήρες ανάμεσά τους:

    3 + 4.2j

Δεν επιτρέπονται κενοί χαρακτήρες μέσα σε κάθε token. Συγκεκριμένα, το επίθημα `j` δεν μπορεί να διαχωριστεί από τον αριθμό που προηγείται.

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

    4.2j
    3.14j
    10.j
    .001j
    1e100j
    3.14e-10j
    3.14_15_93j

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

    10j
    0j
    1000000000000000000000000j   # ισοδύναμο με το 1e+24j

Το επίθημα `j` δεν κάνει διάκριση κεφαλαίων/πεζών. Αυτό σημαίνει ότι μπορείτε να χρησιμοποιήσετε `J` αντί αυτού:

    3.14J   # ισοδύναμο με το 3.14j

Τυπικά, τα λεκτικά φανταστικών περιγράφονται από τον παρακάτω λεξικό ορισμό:

    imagnumber: (floatnumber | digitpart) ("j" | "J")

## 2.7. Τελεστές και οριοθέτες

Η παρακάτω γραμματική ορίζει tokens operator και delimiter, δηλαδή τον γενικό τύπο token `OP`. Μια λίστα αυτών των tokens και των ονομάτων τους είναι επίσης διαθέσιμη στην τεκμηρίωση του module `token`.

    OP:
       | assignment_operator
       | bitwise_operator
       | comparison_operator
       | enclosing_delimiter
       | other_delimiter
       | arithmetic_operator
       | "..."
       | other_op

    assignment_operator:   "+=" | "-=" | "*=" | "**=" | "/="  | "//=" | "%=" |
                           "&=" | "|=" | "^=" | "<<=" | ">>=" | "@="  | ":="
    bitwise_operator:      "&"  | "|"  | "^"  | "~"   | "<<"  | ">>"
    comparison_operator:   "<=" | ">=" | "<"  | ">"   | "=="  | "!="
    enclosing_delimiter:   "("  | ")"  | "["  | "]"   | "{"   | "}"
    other_delimiter:       ","  | ":"  | "!"  | ";"   | "="   | "->"
    arithmetic_operator:   "+"  | "-"  | "**" | "*"   | "//"  | "/"   | "%"
    other_op:              "."  | "@"

Σημείωση

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

Κάποια tokens μπορούν να λειτουργούν είτε ως τελεστές είτε ως οριοθέτες, ανάλογα με τη χρήση. Για παράδειγμα, το `*` είναι και τελεστής πολλαπλασιασμού και οριοθέτης που χρησιμοποιείται για unpacking ακολουθιών, και το `@` είναι και πολλαπλασιασμός πινάκων και οριοθέτης που εισάγει decorators.

Για ορισμένα tokens, η διάκριση δεν είναι ξεκάθαρη. Για παράδειγμα, κάποιοι θεωρούν τα `.`, `(` και `)` ως οριοθέτες, ενώ άλλοι τα βλέπουν ως τον τελεστή `getattr()` και τον/τους τελεστή/τελεστές κλήσης συνάρτησης.

Κάποιοι τελεστές της Python, όπως `and`, `or` και `not in`, χρησιμοποιούν tokens λέξεων-κλειδιών αντί για «σύμβολα» (operator tokens).

A sequence of three consecutive periods (`...`) has a special meaning as an `Ellipsis` literal.