This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# 3. Μοντέλο Δεδομένων

## 3.1. Αντικείμενα, τιμές και τύποι

Το Objects είναι μια αφαιρετική αναπαράσταση της Python για τα δεδομένα. Όλα τα δεδομένα σε ένα Python πρόγραμμα αναπαριστώνται από αντικείμενα ή από συσχετίσεις μεταξύ αντικειμένων. (Κατά μία έννοια, και σύμφωνα με το μοντέλο του Von Neumann για έναν «υπολογιστή αποθηκευμένου προγράμματος», ο κώδικας αντιπροσωπεύεται επίσης από αντικείμενα.)

Every object has an identity, a type and a value. An object’s identity never changes once it has been created; you may think of it as the object’s address in memory. The “`is`” operator compares the identity of two objects; the `id()` function returns an integer representing its identity.

CPython implementation detail: Για την CPython, το `id(x)` είναι η διεύθυνση μνήμης όπου είναι αποθηκευμένο το `x`.

Ο τύπος ενός αντικειμένου καθορίζει τις λειτουργίες που υποστηρίζει το αντικείμενο (π.χ., «έχει μήκος;») και ορίζει επίσης τις πιθανές τιμές για αντικείμενα αυτού του τύπου. Η συνάρτηση `type()` επιστρέφει τον τύπο ενός αντικειμένου (που είναι το ίδιο το αντικείμενο). Όπως και η ταυτότητά, το type ενός αντικειμένου είναι επίσης αμετάβλητο. 1

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

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

CPython implementation detail: Η CPython χρησιμοποιεί επί του παρόντος ένα σχήμα μέτρησης αναφορών με (προαιρετικό) καθυστερημένο εντοπισμό κυκλικά συνδεδεμένων σκουπιδιών, το οποίο συλλέγει τα περισσότερα αντικείμενα μόλις γίνουν απρόσιτα, αλλά δεν είναι εγγυημένο ότι συλλέγει σκουπίδια που κάνουν κυκλικές αναφορές. Δείτε την τεκμηρίωση του module `gc` για πληροφορίες σχετικά με τον έλεγχο της συλλογής κυκλικών σκουπιδιών. Άλλες υλοποιήσεις ενεργούν διαφορετικά και η CPython μπορεί να αλλάξει. Μην εξαρτάστε από την άμεση οριστικοποίηση των αντικειμένων όταν γίνονται απρόσιτα (έτσι θα πρέπει πάντα να κλείνετε ρητά τα αρχεία).

Note that the use of the implementation’s tracing or debugging facilities may keep objects alive that would normally be collectable. Also note that catching an exception with a “`try`…`except`” statement may keep objects alive.

Some objects contain references to «external» resources such as open files or windows. It is understood that these resources are freed when the object is garbage-collected, but since garbage collection is not guaranteed to happen, such objects also provide an explicit way to release the external resource, usually a `close()` method. Programs are strongly recommended to explicitly close such objects. The “`try`…`finally`” statement and the “`with`” statement provide convenient ways to do this.

Μερικά αντικείμενα περιέχουν αναφορές σε άλλα αντικείμενα· αυτά ονομάζονται containers. Παραδείγματα containers είναι πλειάδες, λίστες και λεξικά. Οι αναφορές αποτελούν μέρος της τιμής ενός container. Στις περισσότερες περιπτώσεις, όταν μιλάμε για την αξία ενός container, υπονοούμε τις τιμές, όχι τις ταυτότητες των αντικειμένων που περιέχονται. Ωστόσο, όταν μιλάμε για τη μεταβλητότητα ενός δοχείου υπονοούνται μόνο οι ταυτότητες των αμέσως περιεχομένων αντικειμένων. Έτσι, εάν ένα αμετάβλητο container (όπως μια πλειάδα) περιέχει μια αναφορά σε ένα μεταβλητό αντικείμενο, η τιμή του αλλάζει εάν αυτό το μεταβλητό αντικείμενο αλλάξει.

Types affect almost all aspects of object behavior. Even the importance of object identity is affected in some sense: for immutable types, operations that compute new values may actually return a reference to any existing object with the same type and value, while for mutable objects this is not allowed. E.g., after `a = 1; b = 1`, `a` and `b` may or may not refer to the same object with the value one, depending on the implementation, but after `c = []; d = []`, `c` and `d` are guaranteed to refer to two different, unique, newly created empty lists. (Note that `c = d = []` assigns the same object to both `c` and `d`.)

## 3.2. Η τυπική ιεραρχία τύπου

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

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

None

  Αυτό ο τύπος έχει μια ενιαία τιμή. Υπάρχει ένα μεμονωμένο αντικείμενο με αυτήν την τιμή. Η πρόσβαση σε αυτό το αντικείμενο γίνεται μέσω του ενσωματωμένου ονόματος `None`. Χρησιμοποιείται για να υποδηλώσει την απουσία τιμής σε πολλές περιπτώσεις, π.χ. επιστρέφεται από συναρτήσεις που δεν επιστρέφουν ρητά τίποτα. Η τιμή αλήθειας του είναι ψευδής.

NotImplemented

  This type has a single value. There is a single object with this value. This object is accessed through the built-in name `NotImplemented`. Numeric methods and rich comparison methods should return this value if they do not implement the operation for the operands provided. (The interpreter will then try the reflected operation, or some other fallback, depending on the operator.) It should not be evaluated in a boolean context.

  Δείτε το Implementing the arithmetic operations για περισσότερες λεπτομέρειες.

  Άλλαξε στην έκδοση 3.9: Evaluating `NotImplemented` in a boolean context is deprecated. While it currently evaluates as true, it will emit a `DeprecationWarning`. It will raise a `TypeError` in a future version of Python.

Ellipsis

  Αυτός ο τύπος έχει μια ενιαία τιμή. Υπάρχει ένα μεμονωμένο αντικείμενο με αυτή την τιμή. Η πρόσβαση σε αυτό το αντικείμενο γίνεται μέσω του literal `...` ή του ενσωματωμένου ονόματος `Ellipsis`. Η τιμή αλήθειας του είναι αληθής.

`numbers.Number`

  Αυτά δημιουργούνται από αριθμητικά literals και επιστρέφονται ως αποτελέσματα από αριθμητικούς τελεστές και αριθμητικές ενσωματωμένες συναρτήσεις. Τα αριθμητικά αντικείμενα είναι αμετάβλητα∙ μόλις δημιουργηθούν, η τιμή τους δεν αλλάζει ποτέ. Οι αριθμοί Python φυσικά σχετίζονται στενά με τους μαθηματικούς αριθμούς, αλλά υπόκεινται στους περιορισμούς της αριθμητικής αναπαράστασης στους υπολογιστές.

  Οι αναπαραστάσεις συμβολοσειρών των αριθμητικών κλάσεων, που υπολογίζονται από την `__repr__()` και από τη `__str__()`, έχουν τις ακόλουθες ιδιότητες:

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

  - Η αναπαράσταση είναι στη βάση του 10, όταν αυτό είναι εφικτό.

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

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

  - Ένα πρόσημο εμφανίζεται μόνο όταν ο αριθμός είναι αρνητικός.

  Python distinguishes between integers, floating point numbers, and complex numbers:

  `numbers.Integral`

    Αυτά αντιπροσωπεύουν στοιχεία από το μαθηματικό σύνολο ακεραίων (θετικών και αρνητικών).

    Υπάρχουν δύο τύποι ακεραίων:

    Ακέραιοι (`int`)

      Αυτές αντιπροσωπεύουν αριθμούς σε απεριόριστο εύρος, υπόκεινται μόνο στη διαθέσιμη (εικονική) μνήμη. Για τους σκοπούς των λειτουργιών μετατόπισης και κάλυψης, θεωρείται μια δυαδική αναπαράσταση και οι αρνητικοί αριθμοί αντιπροσωπεύονται σε μια παραλλαγή του συμπληρώματος του 2 που δίνει την ψευδαίσθηση μιας άπειρης συμβολοσειράς bits από bits προσήμου που εκτείνονται προς τα αριστερά.

    Booleans (`bool`)

      Αυτά αντιπροσωπεύουν τις τιμές αλήθειας False και True. Τα δύο αντικείμενα που αντιπροσωπεύουν τις τιμές `False` και `True` είναι τα μόνα Boolean αντικείμενα. Ο Boolean τύπος είναι ένας υποτύπος του ακεραίου τύπου και οι Boolean τιμές συμπεριφέρονται όπως οι τιμές 0 και 1, αντίστοιχα, σχεδόν σε όλα τα περιβάλλοντα, οι εξαιρέσεις που μετατρέπονται σε string είναι `"False"` ή `"True"` επιστρέφονται, αντίστοιχα.

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

  `numbers.Real` (`float`)

    These represent machine-level double precision floating point numbers. You are at the mercy of the underlying machine architecture (and C or Java implementation) for the accepted range and handling of overflow. Python does not support single-precision floating point numbers; the savings in processor and memory usage that are usually the reason for using these are dwarfed by the overhead of using objects in Python, so there is no reason to complicate the language with two kinds of floating point numbers.

  `numbers.Complex` (`complex`)

    These represent complex numbers as a pair of machine-level double precision floating point numbers. The same caveats apply as for floating point numbers. The real and imaginary parts of a complex number `z` can be retrieved through the read-only attributes `z.real` and `z.imag`.

Ακολουθίες

  These represent finite ordered sets indexed by non-negative numbers. The built-in function `len()` returns the number of items of a sequence. When the length of a sequence is n, the index set contains the numbers 0, 1, …, n-1. Item i of sequence a is selected by `a[i]`.

  Sequences also support slicing: `a[i:j]` selects all items with index k such that i `<=` k `<` j. When used as an expression, a slice is a sequence of the same type. This implies that the index set is renumbered so that it starts at 0.

  Ορισμένες ακολουθίες υποστηρίζουν επίσης την «εκτεταμένη τμηματοποίηση» με μια τρίτη παράμετρο «βήμα»: το `a[i:j:k]` επιλέγει όλα τα στοιχεία του a με ευρετήριο x όπου `x = i + n*k`, n `>=` `0` και i `<=` x `<` j.

  Οι ακολουθίες διακρίνονται ανάλογα με τη μεταβλητότητά τους:

  Αμετάβλητες ακολουθίες

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

    Οι ακόλουθοι τύποι είναι αμετάβλητες ακολουθίες:

    Συμβολοσειρές

      A string is a sequence of values that represent Unicode code points. All the code points in the range `U+0000 - U+10FFFF` can be represented in a string. Python doesn’t have a `char` type; instead, every code point in the string is represented as a string object with length `1`. The built-in function `ord()` converts a code point from its string form to an integer in the range `0 - 10FFFF`; `chr()` converts an integer in the range `0 - 10FFFF` to the corresponding length `1` string object. `str.encode()` can be used to convert a `str` to `bytes` using the given text encoding, and `bytes.decode()` can be used to achieve the opposite.

    Πλειάδες (Tuples)

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

    Bytes

      A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 <= x < 256. Bytes literals (like `b'abc'`) and the built-in `bytes()` constructor can be used to create bytes objects. Also, bytes objects can be decoded to strings via the `decode()` method.

  Μεταβλητές ακολουθίες

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

    Υπάρχει επί του παρόντος δύο εγγενείς τύποι μεταβλητών ακολουθιών:

    Λίστες

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

    Πίνακες Byte

      Ένα αντικείμενο bytearray είναι ένα ευμετάβλητος πίνακας. Δημιουργούνται από τον ενσωματωμένο κατασκευαστή `bytearray()`. Εκτός από το ότι είναι μεταβλητοί (και επομένως μη κατακερματισμένοι), οι πίνακες byte κατά τα άλλα παρέχουν την ίδια διεπαφή και λειτουργικότητα με τα αμετάβλητα αντικείμενα `bytes`.

    The extension module `array` provides an additional example of a mutable sequence type, as does the `collections` module.

Σύνολο τύπων

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

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

  Υπάρχουν επί του παρόντος δύο εγγενείς τύποι συνόλων:

  Σύνολα

    Αυτά αντιπροσωπεύουν ένα μεταβλητό σύνολο. Δημιουργούνται από τον ενσωματωμένο κατασκευαστή `set()` και μπορούν να τροποποιηθούν στη συνέχεια με διάφορες μεθόδους, όπως `add()`.

  Frozen σύνολα

    Αυτά αντιπροσωπεύουν ένα αμετάβλητο σύνολο. Δημιουργούνται από τον ενσωματωμένο κατασκευαστή `frozenset()`. Καθώς ένα παγωμένο σύνολο είναι αμετάβλητο και το hashable, μπορεί να χρησιμοποιηθεί ξανά ως στοιχείο ενός άλλου συνόλου ή ως κλειδί λεξικού.

Αντιστοιχίσεις

  Αυτά αντιπροσωπεύουν πεπερασμένα σύνολα αντικειμένων που ευρετηριάζονται από αυθαίρετα σύνολα ευρετηρίου. Ο συμβολικός συμβολισμός `a[k]` επιλέγει το στοιχείο που ευρετηριάζεται με `k` από την αντιστοίχιση `a` · αυτό μπορεί να χρησιμοποιηθεί σε εκφράσεις και ως στόχος αναθέσεων ή δηλώσεων `del`. Η ενσωματωμένη συνάρτηση `len()` επιστρέφει τον αριθμό των στοιχείων σε μια αντιστοίχιση.

  Υπάρχει επί του παρόντος ένας ενιαίος εγγενής τύπος αντιστοίχισης:

  Λεξικά

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

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

    Dictionaries are mutable; they can be created by the `{...}` notation (see section Dictionary displays).

    Τα modules επέκτασης `dbm.ndbm` και `dbm.gnu` παρέχουν πρόσθετα παραδείγματα τύπων αντιστοίχισης, όπως και το module `collections`.

    Άλλαξε στην έκδοση 3.7: Τα λεξικά δεν διατήρησαν τη σειρά εισαγωγής σε εκδόσεις της Python πριν από την 3.6. Στη CPython 3.6, η σειρά εισαγωγής διατηρήθηκε, αλλά θεωρήθηκε ως λεπτομέρεια υλοποίησης εκείνη τη στιγμή και όχι ως εγγύηση γλώσσας.

Τύποι με δυνατότητα κλήσης

  Αυτοί είναι οι τύποι στους οποίους μπορεί να εφαρμοστεί η λειτουργία κλήσης συνάρτησης (βλ. ενότητα Calls) :

  Συναρτήσεις που καθορίζονται από το χρήστη

    Ένα αντικείμενο συνάρτησης που ορίζεται από τον χρήστη δημιουργείται από έναν ορισμό συνάρτησης (βλ. ενότητα Function definitions). Θα πρέπει να καλείται με μια λίστα ορισμών που περιέχει τον ίδιο αριθμό στοιχείων με την επίσημη λίστα παραμέτρων της συνάρτησης.

    Special attributes:

    Χαρακτηριστικό | Έννοια |
    --- | --- | ---
    `__doc__` | The function’s documentation string, or `None` if unavailable; not inherited by subclasses. | Writable
    `__name__` | The function’s name. | Writable
    `__qualname__` | The function’s qualified name. Νέο στην έκδοση 3.3. | Writable
    `__module__` | Το όνομα του module στην οποία ορίστηκε η συνάρτηση ή `None` εάν δεν είναι διαθέσιμη. | Writable
    `__defaults__` | A tuple containing default argument values for those arguments that have defaults, or `None` if no arguments have a default value. | Writable
    `__code__` | The code object representing the compiled function body. | Writable
    `__globals__` | A reference to the dictionary that holds the function’s global variables — the global namespace of the module in which the function was defined. | Read-only
    `__dict__` | The namespace supporting arbitrary function attributes. | Writable
    `__closure__` | `None` or a tuple of cells that contain bindings for the function’s free variables. See below for information on the `cell_contents` attribute. | Read-only
    `__annotations__` | A dict containing annotations of parameters. The keys of the dict are the parameter names, and `'return'` for the return annotation, if provided. | Writable
    `__kwdefaults__` | A dict containing defaults for keyword-only parameters. | Writable

    Most of the attributes labelled «Writable» check the type of the assigned value.

    Function objects also support getting and setting arbitrary attributes, which can be used, for example, to attach metadata to functions. Regular attribute dot-notation is used to get and set such attributes. Note that the current implementation only supports function attributes on user-defined functions. Function attributes on built-in functions may be supported in the future.

    Ένα αντικείμενο κελιού έχει το χαρακτηριστικό `cell_contents`. Αυτό μπορεί να χρησιμοποιηθεί για να ληφθεί η τιμή του κελιού, καθώς και να οριστεί η τιμή.

    Additional information about a function’s definition can be retrieved from its code object; see the description of internal types below. The `cell` type can be accessed in the `types` module.

  Μέθοδοι Στιγμιοτύπου

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

    Special read-only attributes: `__self__` is the class instance object, `__func__` is the function object; `__doc__` is the method’s documentation (same as `__func__.__doc__`); `__name__` is the method name (same as `__func__.__name__`); `__module__` is the name of the module the method was defined in, or `None` if unavailable.

    Methods also support accessing (but not setting) the arbitrary function attributes on the underlying function object.

    User-defined method objects may be created when getting an attribute of a class (perhaps via an instance of that class), if that attribute is a user-defined function object or a class method object.

    When an instance method object is created by retrieving a user-defined function object from a class via one of its instances, its `__self__` attribute is the instance, and the method object is said to be bound. The new method’s `__func__` attribute is the original function object.

    When an instance method object is created by retrieving a class method object from a class or instance, its `__self__` attribute is the class itself, and its `__func__` attribute is the function object underlying the class method.

    When an instance method object is called, the underlying function (`__func__`) is called, inserting the class instance (`__self__`) in front of the argument list. For instance, when `C` is a class which contains a definition for a function `f()`, and `x` is an instance of `C`, calling `x.f(1)` is equivalent to calling `C.f(x, 1)`.

    When an instance method object is derived from a class method object, the «class instance» stored in `__self__` will actually be the class itself, so that calling either `x.f(1)` or `C.f(1)` is equivalent to calling `f(C,1)` where `f` is the underlying function.

    Note that the transformation from function object to instance method object happens each time the attribute is retrieved from the instance. In some cases, a fruitful optimization is to assign the attribute to a local variable and call that local variable. Also notice that this transformation only happens for user-defined functions; other callable objects (and all non-callable objects) are retrieved without transformation. It is also important to note that user-defined functions which are attributes of a class instance are not converted to bound methods; this only happens when the function is an attribute of the class.

  Generator Συναρτήσεις

    A function or method which uses the `yield` statement (see section The yield statement) is called a generator function. Such a function, when called, always returns an iterator object which can be used to execute the body of the function: calling the iterator’s `iterator.__next__()` method will cause the function to execute until it provides a value using the `yield` statement. When the function executes a `return` statement or falls off the end, a `StopIteration` exception is raised and the iterator will have reached the end of the set of values to be returned.

  Coroutine συναρτήσεις

    Μια συνάρτηση ή μέθοδος που ορίζεται χρησιμοποιώντας `async def` ονομάζεται μια coroutine function. Μια τέτοια συνάρτηση, όταν καλείται, επιστρέφει ένα αντικείμενο coroutine. Μπορεί να περιέχει εκφράσεις `await`, καθώς και `async with` και `async for`. Δείτε επίσης την ενότητα Coroutine Αντικείμενα.

  Asynchronous generator συναρτήσεις

    A function or method which is defined using `async def` and which uses the `yield` statement is called a asynchronous generator function. Such a function, when called, returns an asynchronous iterator object which can be used in an `async for` statement to execute the body of the function.

    Η κλήση της μεθόδου `aiterator.__anext__` του ασύγχρονου iterator θα επιστρέψει ένα awaitable το οποίο όταν αναμένεται θα εκτελεστεί έως ότου δώσει μια τιμή χρησιμοποιώντας την έκφραση `yield`. Όταν η συνάρτηση εκτελεί μια κενή εντολή `return` ή πέφτει στο τέλος, γίνεται raise μια εξαίρεση `StopAsyncIteration` και ο ασύγχρονος iterator θα έχει φτάσει στο τέλος του συνόλου τιμών που θα αποδοθούν.

  Ενσωματωμένες συναρτήσεις

    A built-in function object is a wrapper around a C function. Examples of built-in functions are `len()` and `math.sin()` (`math` is a standard built-in module). The number and type of the arguments are determined by the C function. Special read-only attributes: `__doc__` is the function’s documentation string, or `None` if unavailable; `__name__` is the function’s name; `__self__` is set to `None` (but see the next item); `__module__` is the name of the module the function was defined in or `None` if unavailable.

  Ενσωματωμένες μεθόδους

    This is really a different disguise of a built-in function, this time containing an object passed to the C function as an implicit extra argument. An example of a built-in method is `alist.append()`, assuming alist is a list object. In this case, the special read-only attribute `__self__` is set to the object denoted by alist.

  Κλάσεις

    Classes are callable. These objects normally act as factories for new instances of themselves, but variations are possible for class types that override `__new__()`. The arguments of the call are passed to `__new__()` and, in the typical case, to `__init__()` to initialize the new instance.

  Στιγμιότυπα Κλάσης

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

Modules

  Modules are a basic organizational unit of Python code, and are created by the import system as invoked either by the `import` statement, or by calling functions such as `importlib.import_module()` and built-in `__import__()`. A module object has a namespace implemented by a dictionary object (this is the dictionary referenced by the `__globals__` attribute of functions defined in the module). Attribute references are translated to lookups in this dictionary, e.g., `m.x` is equivalent to `m.__dict__["x"]`. A module object does not contain the code object used to initialize the module (since it isn’t needed once the initialization is done).

  Η εκχώρηση χαρακτηριστικών ενημερώνει το λεξικό χώρου ονομάτων του module, π.χ., `m.x = 1` ισοδυναμεί με `m.__dict__["x"] = 1`.

  Predefined (writable) attributes: `__name__` is the module’s name; `__doc__` is the module’s documentation string, or `None` if unavailable; `__annotations__` (optional) is a dictionary containing variable annotations collected during module body execution; `__file__` is the pathname of the file from which the module was loaded, if it was loaded from a file. The `__file__` attribute may be missing for certain types of modules, such as C modules that are statically linked into the interpreter; for extension modules loaded dynamically from a shared library, it is the pathname of the shared library file.

  Special read-only attribute: `__dict__` is the module’s namespace as a dictionary object.

  CPython implementation detail: Λόγω του τρόπου με τον οποίο η CPython διαγράφει τα λεξικά των modules το λεξικό του module θα διαγραφεί όταν το module πέσει εκτός πεδίου εφαρμογής, ακόμα κι αν το λεξικό εξακολουθεί να έχει ζωντανές αναφορές. Για να αποφύγετε αυτό, αντιγράψτε το λεξικό ή κρατήστε το module ενώ χρησιμοποιείται απευθείας το λεξικό της.

Προσαρμοσμένες κλάσεις

  Custom class types are typically created by class definitions (see section Class definitions). A class has a namespace implemented by a dictionary object. Class attribute references are translated to lookups in this dictionary, e.g., `C.x` is translated to `C.__dict__["x"]` (although there are a number of hooks which allow for other means of locating attributes). When the attribute name is not found there, the attribute search continues in the base classes. This search of the base classes uses the C3 method resolution order which behaves correctly even in the presence of “diamond” inheritance structures where there are multiple inheritance paths leading back to a common ancestor. Additional details on the C3 MRO used by Python can be found in the documentation accompanying the 2.3 release at https://www.python.org/download/releases/2.3/mro/.

  When a class attribute reference (for class `C`, say) would yield a class method object, it is transformed into an instance method object whose `__self__` attribute is `C`. When it would yield a static method object, it is transformed into the object wrapped by the static method object. See section Υλοποίηση Περιγραφέων for another way in which attributes retrieved from a class may differ from those actually contained in its `__dict__`.

  Οι αναθέσεις χαρακτηριστικών κλάσης ενημερώνουν το λεξικό της κλάσης, ποτέ το λεξικό μιας βασικής κλάσης.

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

  Special attributes: `__name__` is the class name; `__module__` is the module name in which the class was defined; `__dict__` is the dictionary containing the class’s namespace; `__bases__` is a tuple containing the base classes, in the order of their occurrence in the base class list; `__doc__` is the class’s documentation string, or `None` if undefined; `__annotations__` (optional) is a dictionary containing variable annotations collected during class body execution.

Στιγμιότυπα κλάσης

  A class instance is created by calling a class object (see above). A class instance has a namespace implemented as a dictionary which is the first place in which attribute references are searched. When an attribute is not found there, and the instance’s class has an attribute by that name, the search continues with the class attributes. If a class attribute is found that is a user-defined function object, it is transformed into an instance method object whose `__self__` attribute is the instance. Static method and class method objects are also transformed; see above under «Classes». See section Υλοποίηση Περιγραφέων for another way in which attributes of a class retrieved via its instances may differ from the objects actually stored in the class’s `__dict__`. If no class attribute is found, and the object’s class has a `__getattr__()` method, that is called to satisfy the lookup.

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

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

  Special attributes: `__dict__` is the attribute dictionary; `__class__` is the instance’s class.

Αντικείμενα εισόδου/εξόδου (γνωστά και ως αντικείμενα αρχείου)

  Ένα αντικείμενο file object αντιπροσωπεύει ένα ανοιχτό αρχείο. Διάφορες συντομεύσεις είναι διαθέσιμες για τη δημιουργία αντικειμένων αρχείου: η ενσωματωμένη συνάρτηση `open()`, και επίσης `os.popen()`, `os.fdopen()`, και τη μέθοδο `makefile()` των αντικειμένων socket (και ίσως από άλλες συναρτήσεις ή μεθόδους που παρέχονται από modules επέκτασης).

  Τα αντικείμενα `sys.stdin`, `sys.stdout` και `sys.stderr` αρχικοποιούνται για να αρχειοθετούν αντικείμενα που αντιστοιχούν στις τυπικές ροές εισόδου, εξόδου και σφαλμάτων του διερμηνέα· είναι όλα ανοιχτά σε λειτουργία κειμένου και επομένως ακολουθούν τη διεπαφή που ορίζεται από την αφηρημένη κλάση `io.TextIOBase`.

Εσωτερικοί τύποι

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

  Αντικείμενα κώδικα

    Τα αντικείμενα κώδικα αντιπροσωπεύουν byte-compiled εκτελέσιμο κώδικα Python, ή bytecode. Η διαφορά μεταξύ ενός αντικειμένου κώδικα και ενός αντικειμένου συνάρτησης είναι ότι το αντικείμενο συνάρτησης περιέχει μια ρητή αναφορά στα καθολικά της συνάρτησης (το module στο οποίο ορίστηκε), ενώ ένα αντικείμενο κώδικα δεν περιέχει πλαίσιο· επίσης, οι προεπιλεγμένες τιμές ορίσματος αποθηκεύονται στο αντικείμενο συνάρτησης, όχι στο αντικείμενο κώδικα (επειδή αντιπροσωπεύουν τιμές που υπολογίζονται κατά τον χρόνο εκτέλεσης). Σε αντίθεση με τα αντικείμενα συνάρτησης, τα αντικείμενα κώδικα είναι αμετάβλητα και δεν περιέχουν αναφορές (άμεσα ή έμμεσα) σε μεταβλητά αντικείμενα.

    Special read-only attributes: `co_name` gives the function name; `co_argcount` is the total number of positional arguments (including positional-only arguments and arguments with default values); `co_posonlyargcount` is the number of positional-only arguments (including arguments with default values); `co_kwonlyargcount` is the number of keyword-only arguments (including arguments with default values); `co_nlocals` is the number of local variables used by the function (including arguments); `co_varnames` is a tuple containing the names of the local variables (starting with the argument names); `co_cellvars` is a tuple containing the names of local variables that are referenced by nested functions; `co_freevars` is a tuple containing the names of free variables; `co_code` is a string representing the sequence of bytecode instructions; `co_consts` is a tuple containing the literals used by the bytecode; `co_names` is a tuple containing the names used by the bytecode; `co_filename` is the filename from which the code was compiled; `co_firstlineno` is the first line number of the function; `co_lnotab` is a string encoding the mapping from bytecode offsets to line numbers (for details see the source code of the interpreter); `co_stacksize` is the required stack size; `co_flags` is an integer encoding a number of flags for the interpreter.

    The following flag bits are defined for `co_flags`: bit `0x04` is set if the function uses the `*arguments` syntax to accept an arbitrary number of positional arguments; bit `0x08` is set if the function uses the `**keywords` syntax to accept arbitrary keyword arguments; bit `0x20` is set if the function is a generator.

    Future feature declarations (`from __future__ import division`) also use bits in `co_flags` to indicate whether a code object was compiled with a particular feature enabled: bit `0x2000` is set if the function was compiled with future division enabled; bits `0x10` and `0x1000` were used in earlier versions of Python.

    Other bits in `co_flags` are reserved for internal use.

    If a code object represents a function, the first item in `co_consts` is the documentation string of the function, or `None` if undefined.

  Πλαίσιο αντικειμένων

    Frame objects represent execution frames. They may occur in traceback objects (see below), and are also passed to registered trace functions.

    Special read-only attributes: `f_back` is to the previous stack frame (towards the caller), or `None` if this is the bottom stack frame; `f_code` is the code object being executed in this frame; `f_locals` is the dictionary used to look up local variables; `f_globals` is used for global variables; `f_builtins` is used for built-in (intrinsic) names; `f_lasti` gives the precise instruction (this is an index into the bytecode string of the code object).

    Accessing `f_code` raises an auditing event `object.__getattr__` with arguments `obj` and `"f_code"`.

    Special writable attributes: `f_trace`, if not `None`, is a function called for various events during code execution (this is used by the debugger). Normally an event is triggered for each new source line - this can be disabled by setting `f_trace_lines` to `False`.

    Implementations may allow per-opcode events to be requested by setting `f_trace_opcodes` to `True`. Note that this may lead to undefined interpreter behaviour if exceptions raised by the trace function escape to the function being traced.

    `f_lineno` is the current line number of the frame — writing to this from within a trace function jumps to the given line (only for the bottom-most frame). A debugger can implement a Jump command (aka Set Next Statement) by writing to f_lineno.

    Τα αντικείμενα πλαισίου υποστηρίζουν μια μέθοδο:

    `frame.``clear`()

      This method clears all references to local variables held by the frame. Also, if the frame belonged to a generator, the generator is finalized. This helps break reference cycles involving frame objects (for example when catching an exception and storing its traceback for later use).

      Το `RuntimeError` γίνεται raise εάν το πλαίσιο εκτελείται αυτή την στιγμή.

      Νέο στην έκδοση 3.4.

  Αντικείμενα ανίχνευσης

    Traceback objects represent a stack trace of an exception. A traceback object is implicitly created when an exception occurs, and may also be explicitly created by calling `types.TracebackType`.

    For implicitly created tracebacks, when the search for an exception handler unwinds the execution stack, at each unwound level a traceback object is inserted in front of the current traceback. When an exception handler is entered, the stack trace is made available to the program. (See section The try statement.) It is accessible as the third item of the tuple returned by `sys.exc_info()`, and as the `__traceback__` attribute of the caught exception.

    When the program contains no suitable handler, the stack trace is written (nicely formatted) to the standard error stream; if the interpreter is interactive, it is also made available to the user as `sys.last_traceback`.

    For explicitly created tracebacks, it is up to the creator of the traceback to determine how the `tb_next` attributes should be linked to form a full stack trace.

    Special read-only attributes: `tb_frame` points to the execution frame of the current level; `tb_lineno` gives the line number where the exception occurred; `tb_lasti` indicates the precise instruction. The line number and last instruction in the traceback may differ from the line number of its frame object if the exception occurred in a `try` statement with no matching except clause or with a finally clause.

    Accessing `tb_frame` raises an auditing event `object.__getattr__` with arguments `obj` and `"tb_frame"`.

    Special writable attribute: `tb_next` is the next level in the stack trace (towards the frame where the exception occurred), or `None` if there is no next level.

    Άλλαξε στην έκδοση 3.7: Traceback objects can now be explicitly instantiated from Python code, and the `tb_next` attribute of existing instances can be updated.

  Αντικείμενα τμηματοποίησης

    Τα αντικείμενα τμηματοποίησης χρησιμοποιούνται για να αναπαραστήσουν τμήματα για μεθόδους `__getitem__()`. Δημιουργούνται επίσης από την ενσωματωμένη συνάρτηση `slice()`.

    Ειδικά χαρακτηριστικά μόνο για ανάγνωση: το `start` είναι το κάτω όριο∙ το `stop` είναι το άνω όριο∙ και το `step` είναι το βήμα∙ κάθε ένα είναι `None` αν παραλειφθεί. Τα χαρακτηριστικά μπορούν να έχουν οποιονδήποτε τύπο.

    Τα αντικείμενα slice υποστηρίζουν μια μέθοδο:

    `slice.``indices`(self, length)

      Αυτή η μέθοδος παίρνει ένα μόνο ακέραιο όρισμα length και υπολογίζει πληροφορίες σχετικά το slice που θα περιέγραφε το αντικείμενο slice εάν εφαρμοστεί σε μια ακολουθία στοιχείων length. Επιστρέφει μια πλειάδα τριών ακεραίων αριθμών∙ αντίστοιχα αυτοί είναι δείκτες start και stop και το step ή το μήκος του βήματος του τμήματος. Οι δείκτες που λείπουν ή είναι εκτός ορίων αντιμετωπίζονται με τρόπο που συνάδει με τα κανονικά slices.

  Αντικείμενα στατικών μεθόδων

    Static method objects provide a way of defeating the transformation of function objects to method objects described above. A static method object is a wrapper around any other object, usually a user-defined method object. When a static method object is retrieved from a class or a class instance, the object actually returned is the wrapped object, which is not subject to any further transformation. Static method objects are not themselves callable, although the objects they wrap usually are. Static method objects are created by the built-in `staticmethod()` constructor.

  Αντικείμενα μεθόδων κλάσεων

    A class method object, like a static method object, is a wrapper around another object that alters the way in which that object is retrieved from classes and class instances. The behaviour of class method objects upon such retrieval is described above, under «User-defined methods». Class method objects are created by the built-in `classmethod()` constructor.

## 3.3. Ειδικά ονόματα μεθόδων

Μια κλάση μπορεί να εφαρμόσει ορισμένες πράξεις που καλούνται από ειδική σύνταξη (όπως αριθμητικές πράξεις ή εγγραφή και κοπή) ορίζονται μεθόδους με ειδικά ονόματα. Αυτή είναι η προσέγγιση της Python για το operator overloading, επιτρέποντας στις κλάσεις να ορίσουν τη δική τους συμπεριφορά σε σχέση με τους τελεστές γλώσσας. Για παράδειγμα, εάν μια κλάση ορίζει μια μέθοδο με το όνομα `__getitem__()`, και το `x` είναι ένα στιγμιότυπο αυτής της κλάσης, τότε το `x[i]` είναι περίπου ισοδύναμο με το `type(x).__getitem__(x, i)`. Εκτός από τις περιπτώσεις που αναφέρονται, οι προσπάθειες εκτέλεσης μιας λειτουργίας δημιουργούν εξαίρεση όταν δεν ορίζεται κατάλληλη μέθοδος (συνήθως `AttributeError` ή `TypeError`).

Ο ορισμός μιας ειδική μεθόδου σε `None` σημαίνει ότι η αντίστοιχη λειτουργία δεν είναι διαθέσιμη. Για παράδειγμα, εάν μια κλάση ορίσει την `__iter__()` σε `None` η κλάση δεν είναι iterable, επομένως η κλήση `iter()` στα στιγμιότυπα της θα κάνει raise μια `TypeError` (χωρίς να επιστρέψουμε στο `__getitem__()`). 2

Κατά την υλοποίηση μιας κλάσης που προσομοιώνει οποιονδήποτε ενσωματωμένο τύπο, είναι σημαντικό η εξομοίωση να υλοποιείται μόνο στο βαθμό που έχει νόημα για το αντικείμενο που μοντελοποιείται. Για παράδειγμα, ορισμένες ακολουθίες μπορεί να λειτουργούν καλά με την ανάκτηση μεμονωμένων στοιχείων, αλλά η εξαγωγή ενός τμήματος μπορεί να μην έχει νόημα. (Ένα παράδειγμα αυτού είναι η διεπαφή `NodeList` στο Μοντέλο Αντικειμένου Εγγράφου του W3C.)

### 3.3.1. Βασική προσαρμογή

`object.``__new__`(cls[, ...])

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

  Typical implementations create a new instance of the class by invoking the superclass’s `__new__()` method using `super().__new__(cls[, ...])` with appropriate arguments and then modifying the newly-created instance as necessary before returning it.

  Εάν το `__new__()` καλείται κατά την κατασκευή αντικειμένου και επιστρέφει ένα στιγμιότυπο του cls, τότε η μέθοδος `__init__()` του νέου στιγμιοτύπου θα κληθεί όπως `__init__(self[, ...])`, όπου το self είναι το νέο στιγμιότυπο και τα υπόλοιπα ορίσματα είναι τα ίδια με αυτά που διαβιβάστηκαν στον κατασκευαστή του αντικειμένου.

  Εάν το `__new__()` δεν επιστρέφει ένα στιγμιότυπο του cls, τότε η μέθοδος `__init__()` του νέου στιγμιοτύπου δεν θα κληθεί.

  Το `__new__()` προορίζεται κυρίως για να επιτρέψει σε υποκλάσεις αμετάβλητων τύπων (όπως int, str, ή tuple) να προσαρμόσουν τη δημιουργία στιγμιοτύπων. Επίσης συνήθως παρακάμπτεται σε προσαρμοσμένες μετακλάσεις προκειμένου να προσαρμόσουν τη δημιουργία κλάσεων.

`object.``__init__`(self[, ...])

  Καλείται μετά τη δημιουργία του στιγμιοτύπου (από `__new__()`), αλλά πριν επιστραφεί εκεί που καλέστηκε. Τα ορίσματα είναι αυτά που μεταβιβάζονται στην έκφραση του κατασκευαστή κλάσης. Εάν μια κλάση βάσης έχει μια μέθοδο `__init__()`, η μέθοδος `__init__()` της παραγόμενης κλάσης, εάν υπάρχει πρέπει να την καλέσει ρητά για να διασφαλιστεί η σωστή προετοιμασία του τμήματος της βασικής κλάσης του στιγμιοτύπου∙ για παράδειγμα: `super().__init__([args...])`.

  Επειδή τα `__new__()` και `__init__()` συνεργάζονται για την κατασκευή αντικειμένων (`__new__()` για να το δημιουργήσετε, και `__init__()` για να το προσαρμόσετε), δεν επιτρέπεται να επιστραφεί καμία τιμή μη-`None` από το `__init__()` ∙ αν το κάνετε αυτό, θα εμφανιστεί ένα `TypeError` κατά το χρόνο εκτέλεσης.

`object.``__del__`(self)

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

  Είναι δυνατό (αν και δεν συνίσταται!) η μέθοδος `__del__()` να αναβάλει την καταστροφή του στιγμιότυπου δημιουργώντας μια νέα αναφορά σε αυτό. Αυτό ονομάζεται αντικείμενο ανάσταση (resurrection). Εξαρτάται από την υλοποίηση εάν το `__del__()` καλείται δεύτερη φορά όταν ένα αναστημένο αντικείμενο πρόκειται να καταστραφεί εξαρτάται από την υλοποίηση∙ η τρέχουσα υλοποίηση του CPython την καλεί μόνο μία φορά.

  It is not guaranteed that `__del__()` methods are called for objects that still exist when the interpreter exits.

  Σημείωση

  Το `del x` δεν καλεί απευθείας το `x.__del__()` — το πρώτο μειώνει το πλήθος αναφοράς για το `x` κατά ένα και το δεύτερο καλείται μόνο όταν το πλήθος αναφοράς του `x` φτάσει στο μηδέν.

  CPython implementation detail: It is possible for a reference cycle to prevent the reference count of an object from going to zero. In this case, the cycle will be later detected and deleted by the cyclic garbage collector. A common cause of reference cycles is when an exception has been caught in a local variable. The frame’s locals then reference the exception, which references its own traceback, which references the locals of all frames caught in the traceback.

  Δείτε επίσης

  Τεκμηρίωση για το module `gc`.

  Προειδοποίηση

  Λόγω των επισφαλών συνθηκών υπό τις οποίες καλούνται οι μέθοδοι `__del__()`, οι εξαιρέσεις που προκύπτουν κατά την εκτέλεση τους αγνοούνται και αντ” αυτού εκτυπώνεται μια προειδοποίηση στο `sys.stderr`. Ειδικότερα:

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

  - Η `__del__()` μπορεί να εκτελεστεί κατά τη διάρκεια του τερματισμού λειτουργίας του διερμηνέα. Κατά συνέπεια, οι καθολικές μεταβλητές στις οποίες χρειάζεται πρόσβαση (συμπεριλαμβανομένων άλλως modules) μπορεί να έχουν ήδη διαγραφεί ή να έχουν οριστεί σε `None`. Η Python εγγυάται ότι τα καθολικά των οποίων το όνομα αρχίζει με μία μόνο υπογράμμιση διαγράφονται από το module τους πριν διαγραφούν άλλα καθολικά∙ εάν δεν υπάρχουν άλλες αναφορές σε τέτοια καθολικά, αυτό μπορεί να βοηθήσει στη διασφάλιση ότι τα εισαγόμενα modules εξακολουθούν να είναι διαθέσιμες τη στιγμή που καλείται η μέθοδος `__del__()`.

`object.``__repr__`(self)

  Καλείται από την ενσωματωμένη συνάρτηση `repr()` για τον υπολογισμό της «official» αναπαράστασης συμβολοσειράς ενός αντικειμένου. Εάν είναι δυνατόν, αυτό θα πρέπει να μοιάζει με μια έγκυρη έκφραση Python που θα μπορούσε να χρησιμοποιηθεί για την αναδημιουργία ενός αντικειμένου με την ίδια τιμή (δεδομένου ενός κατάλληλου περιβάλλοντος). Εάν αυτό δεν είναι δυνατό, θα πρέπει να επιστραφεί μια συμβολοσειρά της μορφής `<...κάποια χρήσιμη περιγραφή...>`. Η τιμή επιστροφής πρέπει να είναι αντικείμενο συμβολοσειράς. Εάν μια κλάση ορίζει `__repr__()` αλλά όχι `__str__()`, τότε η `__repr__()` χρησιμοποιείται επίσης όταν απαιτείται μια «ανεπίσημη» αναπαράσταση συμβολοσειράς στιγμιοτύπων αυτής της κλάσης.

  This is typically used for debugging, so it is important that the representation is information-rich and unambiguous.

`object.``__str__`(self)

  Called by `str(object)` and the built-in functions `format()` and `print()` to compute the «informal» or nicely printable string representation of an object. The return value must be a string object.

  Αυτή η μέθοδος διαφέρει από τη `object.__repr__()` στο ότι δεν υπάρχει καμία προσδοκία ότι η `__str__()` θα επιστρέψει μια έγκυρη έκφραση Python: μπορεί να χρησιμοποιηθεί μια πιο βολική ή συνοπτική αναπαράσταση.

  Η προεπιλεγμένη υλοποίηση που ορίζεται από τον ενσωματωμένο τύπο `object` καλεί την `object.__repr__()`.

`object.``__bytes__`(self)

  Called by bytes to compute a byte-string representation of an object. This should return a `bytes` object.

`object.``__format__`(self, format_spec)

  Καλείται από την ενσωματωμένη συνάρτηση `format()` και κατ” επέκταση, αξιολόγηση των formatted string literals και της μεθόδου `str.format()`, για την παραγωγή μιας «μορφοποιημένης» συμβολοσειράς αναπαράστασης ενός αντικειμένου. Το όρισμα format_spec είναι μια συμβολοσειρά που περιέχει μια περιγραφή των επιλογών μορφοποίησης που επιθυμείτε. Η ερμηνεία του ορίσματος format_spec εξαρτάται από τον τύπο που υλοποιεί τη `__format__()`, ωστόσο οι περισσότερες κλάσεις είτε θα αναθέσουν τη μορφοποίηση σε έναν από τους ενσωματωμένους τύπους είτε θα χρησιμοποιήσουν παρόμοια σύνταξη επιλογής μορφοποίησης.

  Δείτε το Format Specification Mini-Language για μια περιγραφή της τυπικής σύνταξης μορφοποίησης.

  Η τιμή επιστροφής πρέπει να είναι αντικείμενο συμβολοσειράς.

  Άλλαξε στην έκδοση 3.4: Η ίδια μέθοδος __format__ του `object` κάνει raise μια `TypeError` εάν περάσει οποιαδήποτε μη κενή συμβολοσειρά.

  Άλλαξε στην έκδοση 3.7: Το `object.__format__(x, '')` είναι πλέον ισοδύναμο με το `str(x)` αντί για το `format(str(x), '')`.

`object.``__lt__`(self, other)
`object.``__le__`(self, other)
`object.``__eq__`(self, other)
`object.``__ne__`(self, other)
`object.``__gt__`(self, other)
`object.``__ge__`(self, other)

  Αυτές είναι οι λεγόμενες μέθοδοι «πλούσιας σύγκρισης (rich comparison)». Η αντιστοιχία μεταξύ των συμβόλων των τελεστών και των ονομάτων των μεθόδων έχει ως εξής: `x<y` καλεί `x.__lt__(y)`, `x<=y` καλεί `x.__le__(y)`, `x==y` καλεί `x.__eq__(y)`, `x!=y` καλεί `x.__ne__(y)`, `x>y` καλεί `x.__gt__(y)`, και `x>=y` καλεί `x.__ge__(y)`.

  A rich comparison method may return the singleton `NotImplemented` if it does not implement the operation for a given pair of arguments. By convention, `False` and `True` are returned for a successful comparison. However, these methods can return any value, so if the comparison operator is used in a Boolean context (e.g., in the condition of an `if` statement), Python will call `bool()` on the value to determine if the result is true or false.

  By default, `object` implements `__eq__()` by using `is`, returning `NotImplemented` in the case of a false comparison: `True if x is y else NotImplemented`. For `__ne__()`, by default it delegates to `__eq__()` and inverts the result unless it is `NotImplemented`. There are no other implied relationships among the comparison operators or default implementations; for example, the truth of `(x<y or x==y)` does not imply `x<=y`. To automatically generate ordering operations from a single root operation, see `functools.total_ordering()`.

  Δείτε την παράγραφο σχετικά με το `__hash__()` για μερικές σημαντικές σημειώσεις σχετικά με τη δημιουργία αντικειμένων hashable τα οποία υποστηρίζουν προσαρμοσμένες λειτουργίες σύγκρισης και μπορούν να χρησιμοποιηθούν ως κλειδιά λεξικού.

  There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, `__lt__()` and `__gt__()` are each other’s reflection, `__le__()` and `__ge__()` are each other’s reflection, and `__eq__()` and `__ne__()` are their own reflection. If the operands are of different types, and right operand’s type is a direct or indirect subclass of the left operand’s type, the reflected method of the right operand has priority, otherwise the left operand’s method has priority. Virtual subclassing is not considered.

`object.``__hash__`(self)

  Καλείται από την ενσωματωμένη συνάρτηση `hash()` και για λειτουργίες σε μέλη κατακερματισμένων συλλόγων, συμπεριλαμβανομένων των `set`, `frozenset`, and `dict`. Η μέθοδος `__hash__()` θα πρέπει να επιστρέφει έναν ακέραιο αριθμό. Η μόνη απαιτούμενη ιδιότητα είναι ότι τα αντικείμενα που συγκρίνονται ίσα έχουν την ίδια τιμή κατακερματισμού. Συνίσταται να αναμειγνύεται τις τιμές κατακερματισμού των στοιχείων του αντικειμένου που παίζουν επίσης ρόλο στη σύγκριση αντικειμένων, συσκευάζοντας τα σε μια πλειάδα και κατακερματίζοντας την πλειάδα. Παράδειγμα:

      def __hash__(self):
          return hash((self.name, self.nick, self.color))

  Σημείωση

  Η `hash()` περικόπτει την τιμή που επιστρέφεται από την προσαρμοσμένη μέθοδο `__hash__()` ενός αντικειμένου στο μέγεθος `Py_ssize_t`. Αυτό είναι συνήθως 8 byte σε εκδόσεις 64-bit και 4 byte σε εκδόσεις 32-bit. Εάν η `__hash__()` ενός αντικειμένου πρέπει να διαλειτουργήσει σε εκδόσεις διαφορικών μεγεθών bit, φροντίστε να ελέγξετε το πλάτος σε όλες τις υποστηριζόμενες εκδόσεις. Ένας εύκολος τρόπος για να το κάνετε αυτό είναι με την `python -c "import sys; print(sys.hash_info.width)"`.

  If a class does not define an `__eq__()` method it should not define a `__hash__()` operation either; if it defines `__eq__()` but not `__hash__()`, its instances will not be usable as items in hashable collections. If a class defines mutable objects and implements an `__eq__()` method, it should not implement `__hash__()`, since the implementation of hashable collections requires that a key’s hash value is immutable (if the object’s hash value changes, it will be in the wrong hash bucket).

  User-defined classes have `__eq__()` and `__hash__()` methods by default; with them, all objects compare unequal (except with themselves) and `x.__hash__()` returns an appropriate value such that `x == y` implies both that `x is y` and `hash(x) == hash(y)`.

  Μια κλάση που παρακάμπτει τη `__eq__()` και δεν ορίζει τη `__hash__()` θα έχει τη `__hash__()` της έμμεσα ορισμένο σε `None`. Όταν η μέθοδος `__hash__()` μιας κλάσης είναι `None`, τα στιγμιότυπα της κλάσης θα κάνουν raise μια κατάλληλη `TypeError` όταν ένα πρόγραμμα επιχειρήσει να ανακτήσει την τιμή κατακερματισμού τους και θα αναγνωρίσουν επίσης σωστά ως μη κατακερματιζόμενες κατά τον έλεγχο του `isinstance(obj, collections.abc.Hashable)`.

  Εάν μια κλάση που παρακάμπτει την `__eq__()` χρειάζεται να διατηρήσει την υλοποίηση της `__hash__()` από μια γονική κλάση, ο διερμηνέας πρέπει να ενημερωθεί ρητά για αυτό ορίζονται την `__hash__ = <ParentClass>.__hash__`.

  Εάν μια κλάση που δεν παρακάμπτει τη `__eq__()` επιθυμεί να καταστείλει την υποστήριξη κατακερματισμού, θα πρέπει να συμπεριλάβει το `__hash__ = None` στον ορισμός της κλάσης. Μια κλάση που ορίζει τη δικιά της `__hash__()` που κάνει raise μια `TypeError` θα αναγνωριστεί εσφαλμένα ως μια κλάση που μπορεί να κατακερματιστεί από μια κλήση `isinstance(obj, collections.abc.Hashable)`.

  Σημείωση

  Από προεπιλογή, οι τιμές `__hash__()` των αντικειμένων str και bytes είναι «salted» με μια απρόβλεπτη τυχαία τιμή. Παρόλο που παραμένουν σταθερές μέσα σε μια μεμονωμένη διεργασία Python, δεν είναι προβλέψιμες μεταξύ επαναλαμβανόμενων κλήσεων της Python.

  This is intended to provide protection against a denial-of-service caused by carefully-chosen inputs that exploit the worst case performance of a dict insertion, O(n2) complexity. See http://www.ocert.org/advisories/ocert-2011-003.html for details.

  Η αλλαγή των τιμών κατακερματισμού επηρεάζει τη σειρά επανάληψης των συνόλων. Η Python δεν έχει δώσει ποτέ εγγυήσεις σχετικά με αυτήν τη σειρά (και συνήθως ποικίλει μεταξύ εκδόσεων 32-bit και 64-bit).

  Δείτε επίσης `PYTHONHASHSEED`.

  Άλλαξε στην έκδοση 3.3: Η τυχαιοποίηση κατακερματισμού είναι ενεργοποιημένη από προεπιλογή.

`object.``__bool__`(self)

  Called to implement truth value testing and the built-in operation `bool()`; should return `False` or `True`. When this method is not defined, `__len__()` is called, if it is defined, and the object is considered true if its result is nonzero. If a class defines neither `__len__()` nor `__bool__()`, all its instances are considered true.

### 3.3.2. Προσαρμογή πρόσβασης χαρακτηριστικών

Οι ακόλουθες μέθοδοι μπορούν αν οριστούν για την προσαρμογή της έννοιας της πρόσβασης χαρακτηριστικών (χρήση, ανάθεση ή διαγραφή του `x.name`) για στιγμιότυπα κλάσης.

`object.``__getattr__`(self, name)

  Called when the default attribute access fails with an `AttributeError` (either `__getattribute__()` raises an `AttributeError` because name is not an instance attribute or an attribute in the class tree for `self`; or `__get__()` of a name property raises `AttributeError`). This method should either return the (computed) attribute value or raise an `AttributeError` exception.

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

`object.``__getattribute__`(self, name)

  Καλείται χωρίς προϋποθέσεις για την υλοποίηση της πρόσβασης σε χαρακτηριστικά για στιγμιότυπα κλάσης. Αν η κλάση ορίζει επίσης τη μέθοδο `__getattr__()`, αυτή δεν θα κληθεί εκτός αν η `__getattribute__()` την καλέσει ρητά ή κάνει raise μια εξαίρεση `AttributeError`. Αυτή η μέθοδος πρέπει να επιστρέφει την (υπολογισμένη) τιμή του χαρακτηριστικού ή να κάνει raise μια εξαίρεση `AttributeError`. Για να αποφευχθεί η ατέρμονη αναδρομή μέσα σε αυτή τη μέθοδο, η υλοποίηση της πρέπει πάντα να καλεί τη μέθοδο της βασικής κλάσης με το ίδιο όνομα για να έχει πρόσβαση σε οποιαδήποτε ιδιότητα χρειάζεται, για παράδειγμα `object.__getattribute__(self, name)`.

  Σημείωση

  This method may still be bypassed when looking up special methods as the result of implicit invocation via language syntax or built-in functions. See Αναζήτηση ειδικής μεθόδου.

  Για συγκεκριμένες προσβάσεις ευαίσθητων χαρακτηριστικών, δημιουργεί ένα auditing event `object.__getattr__` με ορίσματα `obj` και `name`.

`object.``__setattr__`(self, name, value)

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

  Εάν η `__setattr__()` θέλει να εκχωρήσει σε ένα χαρακτηριστικό στιγμιοτύπου, θα πρέπει να καλέσει τη μέθοδο της βασικής κλάσης με το ίδιο όνομα, για παράδειγμα, `object.__setattr__(self, name, value)`.

  Για ορισμένες εκχωρήσεις ευαίσθητων χαρακτηριστικών, γίνεται raise μια auditing event `object.__setattr__` με ορίσματα `obj`, `name`, `value`.

`object.``__delattr__`(self, name)

  Όπως η `__setattr__()` αλλά για διαγραφή χαρακτηριστικών αντί για ανάθεση. Αυτό θα πρέπει να εφαρμοστεί μόνο εάν το `del obj.name` έχει νόημα για το αντικείμενο.

  Για ορισμένες διαγραφές ευαίσθητων χαρακτηριστικών, κάνει raise ένα auditing event `object.__delattr__` με ορίσματα `obj` και `name`.

`object.``__dir__`(self)

  Called when `dir()` is called on the object. A sequence must be returned. `dir()` converts the returned sequence to a list and sorts it.

#### 3.3.2.1. Προσαρμογή πρόσβασης χαρακτηριστικών module

Οι ειδικές ονομασίες `__getattr__` και `__dir__` μπορούν επίσης να χρησιμοποιηθούν για την προσαρμογή της πρόσβασης στα χαρακτηριστικά του module. Η συνάρτηση `__getattr__` στο επίπεδο του module πρέπει να δέχεται ένα όρισμα, το οποίο είναι το όνομα ενός χαρακτηριστικού, και να επιστρέφει την υπολογισμένη τιμή ή να κάνει raise μια εξαίρεση `AttributeError`. Εάν ένα χαρακτηριστικό δεν βρεθεί σε ένα αντικείμενο module μέσω της κανονικής αναζήτησης, δηλαδή με τη μέθοδο `object.__getattribute__()`, τότε η μέθοδος `__getattr__` αναζητείται στο λεξικό `__dict__` του module πριν γίνει raise η εξαίρεση `AttributeError`. Αν βρεθεί, καλείται με το όνομα της ιδιότητας και το αποτέλεσμα επιστρέφεται.

The `__dir__` function should accept no arguments, and return a sequence of strings that represents the names accessible on module. If present, this function overrides the standard `dir()` search on a module.

Για μια πιο λεπτομερή προσαρμογή της συμπεριφοράς του module (ρύθμιση χαρακτηριστικών, ιδιοτήτων κλπ.), μπορεί κανείς να ορίσει το χαρακτηριστικό `__class__` ενός αντικειμένου module σε μια υποκλάση `types.ModuleType`. Για παράδειγμα:

    import sys
    from types import ModuleType

    class VerboseModule(ModuleType):
        def __repr__(self):
            return f'Verbose {self.__name__}'

        def __setattr__(self, attr, value):
            print(f'Setting {attr}...')
            super().__setattr__(attr, value)

    sys.modules[__name__].__class__ = VerboseModule

Σημείωση

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

Άλλαξε στην έκδοση 3.5: Το χαρακτηριστικό `__class__` του module είναι πλέον εγγράψιμο.

Νέο στην έκδοση 3.7: Τα χαρακτηριστικά `__getattr__` και `__dir__` του module.

Δείτε επίσης

PEP 562 - Module __getattr__ και __dir__

  Περιγράφει τις συναρτήσεις `__getattr__` και `__dir__` σε modules.

#### 3.3.2.2. Υλοποίηση Περιγραφέων

The following methods only apply when an instance of the class containing the method (a so-called descriptor class) appears in an owner class (the descriptor must be in either the owner’s class dictionary or in the class dictionary for one of its parents). In the examples below, «the attribute» refers to the attribute whose name is the key of the property in the owner class” `__dict__`.

`object.``__get__`(self, instance, owner=None)

  Καλείται για να ληφθεί η ιδιότητα της ιδιοκτήτρια κλάσης (πρόσβαση σε χαρακτηριστικό κλάσης) ή ενός στιγμιοτύπου αυτή της κλάση (πρόσβαση σε χαρακτηριστικό στιγμιοτύπου). Η προαιρετική παράμετρος owner είναι η ιδιοκτήτρια κλάση, ενώ η instance είναι το στιγμιότυπο μέσω της οποίας έγινε πρόσβαση στο χαρακτηριστικό, ή `None` όταν η πρόσβαση στο χαρακτηριστικό έγινε μέσω της owner.

  Αυτή η μέθοδος πρέπει να επιστρέφει την υπολογισμένη τιμή του χαρακτηριστικού ή να κάνει raise μια `AttributeError` εξαίρεση.

  Το PEP 252 ορίζει ότι η μέθοδος `__get__()` μπορεί να καλείται με ένα ή δύο ορίσματα. Οι ενσωματωμένοι περιγραφείς της Python υποστηρίζουν αυτή την προδιαγραφή∙ ωστόσο, είναι πιθανό κάποια εργαλεία τρίτων να έχουν περιγραφείς που απαιτούν και τα δύο ορίσματα. Η ενσωματωμένη υλοποίηση της Python για τη μέθοδο `__getattribute__()` περνάει πάντα και τα δύο ορίσματα, είτε είναι απαραίτητα είτε όχι.

`object.``__set__`(self, instance, value)

  Καλείται για να οριστεί το χαρακτηριστικό σε ένα στιγμιότυπο instance της ιδιοκτήτρια κλάσης σε μια νέα τιμή, value.

  Σημείωση, η προσθήκη της `__set__()` ή `__delete__()` αλλάζει το είδος του περιγραφέα σε έναν «περιγραφέα δεδομένων». Δείτε το Κλήση Descriptors για περισσότερες λεπτομέρειες.

`object.``__delete__`(self, instance)

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

`object.``__set_name__`(self, owner, name)

  Called at the time the owning class owner is created. The descriptor has been assigned to name.

  Σημείωση

  `__set_name__()` is only called implicitly as part of the `type` constructor, so it will need to be called explicitly with the appropriate parameters when a descriptor is added to a class after initial creation:

      class A:
         pass
      descr = custom_descriptor()
      A.attr = descr
      descr.__set_name__(A, 'attr')

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

  Νέο στην έκδοση 3.6.

The attribute `__objclass__` is interpreted by the `inspect` module as specifying the class where this object was defined (setting this appropriately can assist in runtime introspection of dynamic class attributes). For callables, it may indicate that an instance of the given type (or a subclass) is expected or required as the first positional argument (for example, CPython sets this attribute for unbound methods that are implemented in C).

#### 3.3.2.3. Κλήση Descriptors

Γενικά, ένας descriptor είναι ένα χαρακτηριστικό αντικειμένου με «συμπεριφορά δέσμευσης», δηλαδή μια ιδιότητα της οποίας η πρόσβαση έχει παρακαμφθεί μέσω μεθόδων του πρωτοκόλλου περιγραφέα `__get__()`, `__set__()`, και `__delete__()`. Αν οποιαδήποτε από αυτές τις μεθόδους έχει οριστεί για ένα αντικείμενο, τότε το αντικείμενο αυτό θεωρείται descriptor.

Η προεπιλεγμένη συμπεριφορά για την πρόσβαση χαρακτηριστικών είναι η ανάκτηση, ο ορισμός, ή η διαγραφή του χαρακτηριστικού από το λεξικό ενός αντικειμένου. Για παράδειγμα, το `a.x` έχει μια αλυσίδα αναζήτησης που ξεκινά με `a.__dict__['x']`, στη συνέχεια με `type(a).__dict__['x']` και συνεχίζει στις βασικές κατηγορίες του `type(a)` εξαιρουμένων των μετακλάσεων.

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

Το σημείο εκκίνηση για την επίκληση του περιγραφέα είναι ένα δεσμευτικό, `a.x`. Ο τρόπος συναρμολόγησης των ορισμάτων εξαρτάται από το `a`:

Απευθείας Κλήση

  Η απλούστερη και λιγότερο συνηθισμένη κλήση είναι όταν ο κωδικός χρήστη καλεί απευθείας μια μέθοδο περιγραφής: `x.__get__(a)`.

Δέσμευση Στιγμιοτύπου

  Εάν δεσμεύεται σε ένα στιγμιότυπο αντικειμένου, το `a.x` μετατρέπεται στην κλήση: `type(a).__dict__['x'].__get__(a, type(a))`.

Δέσμευση Κλάσης

  Εάν δεσμεύεται σε μια κλάση, το `A.x` μετατρέπεται στην κλήση: `A.__dict__['x'].__get__(None, A)`.

Υπερ-Δέσμευση

  If `a` is an instance of `super`, then the binding `super(B, obj).m()` searches `obj.__class__.__mro__` for the base class `A` immediately following `B` and then invokes the descriptor with the call: `A.__dict__['m'].__get__(obj, obj.__class__)`.

For instance bindings, the precedence of descriptor invocation depends on which descriptor methods are defined. A descriptor can define any combination of `__get__()`, `__set__()` and `__delete__()`. If it does not define `__get__()`, then accessing the attribute will return the descriptor object itself unless there is a value in the object’s instance dictionary. If the descriptor defines `__set__()` and/or `__delete__()`, it is a data descriptor; if it defines neither, it is a non-data descriptor. Normally, data descriptors define both `__get__()` and `__set__()`, while non-data descriptors have just the `__get__()` method. Data descriptors with `__get__()` and `__set__()` (and/or `__delete__()`) defined always override a redefinition in an instance dictionary. In contrast, non-data descriptors can be overridden by instances.

Οι μέθοδοι Python (συμπεριλαμβανομένων εκείνων που είναι διακοσμημένες με `@staticmethod` και `@classmethod`) υλοποιούνται ως περιγραφέα χωρίς δεδομένα. Αντίστοιχα, τα στιγμιότυπα μπορούν να επαναπροσδιορίσουν και να παρακάμψουν μεθόδους. Αυτό επιτρέπει σε μεμονωμένα στιγμιότυπα να αποκτήσουν συμπεριφορές που διαφέρουν από άλλα στιγμιότυπα της ίδιας κλάσης.

Η συνάρτηση `property()` υλοποιείται ως περιγραφέας δεδομένων. Συνεπώς, οι περιπτώσεις δεν μπορούν να παρακάμψουν τη συμπεριφορά μιας ιδιότητας.

#### 3.3.2.4. __slots__

Το __slots__ μας επιτρέπει να δηλώνουμε ρητά τα μέλη δεδομένων (όπως ιδιότητες) και να αρνηθούμε τη δημιουργία των `__dict__` και __weakref__ (εκτός εάν δηλώνεται ρητά στο __slots__ ή είναι διαθέσιμο σε έναν γονέα.)

Ο χώρος που εξοικονομείται χρησιμοποιώντας `__dict__` μπορεί να είναι σημαντικός. Η ταχύτητα αναζήτησης χαρακτηριστικών μπορεί επίσης να βελτιωθεί σημαντικά.

`object.``__slots__`

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

##### 3.3.2.4.1. Notes on using __slots__

- Όταν γίνεται κληρονομιά από μια κλάση χωρίς __slots__, το χαρακτηριστικό `__dict__` και __weakref__ των στιγμιοτύπων θα είναι πάντα προσβάσιμο.

- Χωρίς μια μεταβλητή `__dict__`, τα στιγμιότυπα δεν μπορούν να αντιστοιχιστούν σε νέες μεταβλητές που δεν αναφέρονται στον ορισμό __slots__. Οι προσπάθειες αντιστοίχισης σε ένα όνομα μεταβλητής εκτός λίστας κάνουν raise τη `AttributeError`. Εάν είναι επιθυμητή η δυναμική αντιστοίχιση νέων μεταβλητών, τότε προσθέστε το `'__dict__'` στην ακολουθία συμβολοσειρών στη δήλωση __slots__.

- Χωρίς μια μεταβλητή __weakref__ για κάθε στιγμιότυπο, οι κλάσεις που ορίζουν __slots__ δεν υποστηρίζουν `weak references` στα στιγμιότυπα τους. Εάν απαιτείται αδύναμη υποστήριξη για αδύναμες αναφορές, τότε προσθέστε το `'__weakref__'` στην ακολουθία των συμβολοσειρών στη δήλωση των __slots__.

- Τα __slots__ υλοποιούνται σε επίπεδα κλάσης με τη δημιουργία descriptors για κάθε όνομα μεταβλητής. Ως ένα αποτέλεσμα, οι ιδιότητες της κλάσης δεν μπορούν να χρησιμοποιηθούν για να ορίσουν προεπιλεγμένες τιμές για μεταβλητές στιγμιοτύπων που έχουν δηλωθεί μέσω __slots__ ∙ διαφορετικά, το χαρακτηριστικό της κλάσης θα αντικαθιστούσε την ανάθεση του descriptor.

- The action of a __slots__ declaration is not limited to the class where it is defined. __slots__ declared in parents are available in child classes. However, child subclasses will get a `__dict__` and __weakref__ unless they also define __slots__ (which should only contain names of any additional slots).

- Αν μια κλάση ορίσει ένα slot που έχει ήδη οριστεί σε μια γονική κλάση, τότε η μεταβλητή στιγμιοτύπου που ορίζεται από το slot της γονικής κλάσης γίνεται μη προσβάσιμη (εκτός αν ανακτηθεί απευθείας ο descriptor της από τη γονική κλάση). Αυτό καθιστά το νόημα του προγράμματος ασαφές. Στο μέλλον, μπορεί να προστεθεί έλεγχος που να αποτρέπει κάτι τέτοιο.

- Nonempty __slots__ does not work for classes derived from «variable-length» built-in types such as `int`, `bytes` and `tuple`.

- Οποιαδήποτε μη συμβολοσειρά iterable μπορεί να εκχωρηθεί σε __slots__.

- Αν χρησιμοποιηθεί μια `dictionary` για την ανάθεση των __slots__, τα κλειδιά του λεξικού θα χρησιμοποιηθούν ως ονόματα των slots. Οι τιμές του λεξικού μπορούν να χρησιμοποιηθούν για να παρέχουν τεκμηρίωση (docstrings) για κάθε ιδιότητα ξεχωριστά, η οποία θα αναγνωρίζεται από τη συνάρτηση `inspect.getdoc()` και θα εμφανίζεται στην έξοδο της `help()`.

- `__class__` assignment works only if both classes have the same __slots__.

- Το Multiple inheritance με πολλαπλές γονικές κλάσεις που χρησιμοποιούν __slots__ μπορεί να χρησιμοποιηθεί, αλλά επιτρέπεται μόνο ένας γονέας να έχει ορίσει ιδιότητες μέσω των slots (οι υπόλοιπες γονικές κλάσεις πρέπει να έχουν κενή διάταξη slots) - παραβιάσεις αυτού κάνουν raise `TypeError`.

- Εάν χρησιμοποιείται ένας iterator για __slots__ τότε δημιουργείται ένας descriptor για κάθε μία από τις τιμές του iterator. Ωστόσο, το χαρακτηριστικό __slots__ θα είναι ένας κενός iterator.

### 3.3.3. Προσαρμογή δημιουργίας κλάσης

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

classmethod `object.``__init_subclass__`(cls)

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

  Keyword arguments which are given to a new class are passed to the parent’s class `__init_subclass__`. For compatibility with other classes using `__init_subclass__`, one should take out the needed keyword arguments and pass the others over to the base class, as in:

      class Philosopher:
          def __init_subclass__(cls, /, default_name, **kwargs):
              super().__init_subclass__(**kwargs)
              cls.default_name = default_name

      class AustralianPhilosopher(Philosopher, default_name="Bruce"):
          pass

  Η προεπιλεγμένη υλοποίηση `object.__init_subclass__` δεν κάνει τίποτα, αλλά δημιουργεί ένα σφάλμα εάν καλείται με οποιαδήποτε ορίσματα.

  Σημείωση

  Η υπόδειξη μετακλάσης `metaclass` καταναλώνεται από τα υπόλοιπα μηχανήματα τύπου και δεν μεταβιβάζεται ποτέ στις υλοποιήσεις `__init_subclass__`. Η πραγματική μετακλάση (και όχι η ρητή υπόδειξη) μπορεί να προσπελαστεί ως `type(cls)`.

  Νέο στην έκδοση 3.6.

#### 3.3.3.1. Μετα-κλάσεις

Από προεπιλογή, οι κλάσεις κατασκευάζονται χρησιμοποιώντας `type()`. Το σώμα κλάσης εκτελείται σε νέο χώρο ονομάτων και το όνομα της κλάσης συνδέεται τοπικά με το αποτέλεσμα του `type(name, bases, namespace)`.

Η διαδικασία δημιουργία κλάσης μπορεί να προσαρμοστεί μεταβιβάζοντας το όρισμα λέξης-κλειδιού `metaclass` στη γραμμή ορισμού κλάσης ή κληρονομώντας από μια υπάρχουσα κλάση που περιλάμβανε ένα τέτοιο όρισμα. Στο παρακάτω παράδειγμα, τόσο το `MyClass` και `MySubclass` είναι περιπτώσεις του `Meta`:

    class Meta(type):
        pass

    class MyClass(metaclass=Meta):
        pass

    class MySubclass(MyClass):
        pass

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

Όταν εκτελείται ένας ορισμός κλάσης, εμφανίζονται τα ακόλουθα βήματα:

- Οι εγγραφές MRO επιλύονται∙

- καθορίζεται η κατάλληλη μετακλάση∙

- προετοιμάζεται ο χώρος ονομάτων της κλάσης∙

- εκτελείται το σώμα της κλάσης∙

- δημιουργείται το αντικείμενο της κλάσης.

#### 3.3.3.2. Επίλυση εγγραφών MRO

If a base that appears in class definition is not an instance of `type`, then an `__mro_entries__` method is searched on it. If found, it is called with the original bases tuple. This method must return a tuple of classes that will be used instead of this base. The tuple may be empty, in such case the original base is ignored.

Δείτε επίσης

PEP 560 - Core support for typing module and generic types

#### 3.3.3.3. Προσδιορισμός της κατάλληλης μετακλάσης

Η κατάλληλη μετακλάση για έναν ορισμό κλάσης καθορίζεται ως εξής:

- εάν δεν δίνονται βάσεις και καμία ρητή μετακλάση, τότε χρησιμοποιείται η `type()` ∙

- εάν δοθεί μια ρητή μετακλάση και δεν είναι ένα στιγμιότυπο της `type()`, τότε χρησιμοποιείται απευθείας ως μετακλάση∙

- εάν ένα στιγμιότυπο της `type()` δίνεται ως ρητή μετακλάση ή ορίζονται βάσεις, τότε χρησιμοποιείται η πιο παραγόμενη μετακλάση.

Η πιο παραγόμενη μετακλάση επιλέγεται από τη ρητά καθορισμένη μετακλάση (εάν υπάρχει) και τις μετακλάσεις (δηλαδή `type(cls)`) όλων των καθορισμένων βασικών κλάσεων. Η πιο παραγόμενη μετακλάση είναι αυτή που είναι υπο-τύπος όλων αυτών των υποψήφιων μετακλάσεων. Εάν καμία από τις υποψήφιες μετακλάσεις δεν πληροί αυτό το κριτήριο, τότε ο ορισμός της κλάσης θα αποτύχει με `TypeError`.

#### 3.3.3.4. Προετοιμασία του χώρου ονομάτων της κλάσης

Μόλις εντοπιστεί η κατάλληλη μετακλάση, τότε προετοιμάζεται ο χώρος ονομάτων της κλάσης. Εάν η μετακλάση έχει ένα χαρακτηριστικό `__prepare__`, ονομάζεται `namespace = metaclass.__prepare__(name, bases, **kwds)` (όπου τα πρόσθετα ορίσματα λέξης-κλειδιού, εάν υπάρχουν, προέρχονται από τον ορισμό της κλάσης). Η μέθοδος `__prepare__` θα πρέπει να υλοποιηθεί ως μέθοδος `classmethod`. Ο χώρος ονομάτων που επιστρέφεται από το `__prepare__` μεταβιβάζεται στο `__new__`, αλλά όταν δημιουργείται το τελικό αντικείμενο κλάσης, ο χώρος ονομάτων αντιγράφεται σε ένα νέο `dict`.

Εάν η μετακλάση δεν έχει χαρακτηριστικό `__prepare__`, τότε ο χώρος ονομάτων κλάσης αρχικοποιείται ως κενή ταξινομημένη αντιστοίχιση.

Δείτε επίσης

PEP 3115 - Μετακλάσεις στην Python 3000

  Παρουσιάστηκε το άγκιστρο χώρου ονομάτων `__prepare__`

#### 3.3.3.5. Εκτέλεση του σώματος της κλάσης

Το σώμα της κλάσης εκτελείται (περίπου) ως `exec(body, globals(), namespace)`. Η βασική διαφορά από μια κανονική κλήση στην `exec()` είναι ότι το λεξικό πεδίο εφαρμογής επιτρέπει στο σώμα της κλάσης (συμπεριλαμβανομένων οποιωνδήποτε μεθόδων) να παραπέμπει σε ονόματα από το τρέχον και το εξωτερικό πεδίο εφαρμογής όταν ο ορισμός κλάσης εμφανίζεται μέσα σε μια συνάρτηση.

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

#### 3.3.3.6. Δημιουργία αντικειμένου κλάσης

Μόλις ο χώρος ονομάτων της κλάσης έχει συμπληρωθεί εκτελώντας το σώμα της κλάσης, το αντικείμενο της κλάσης δημιουργείται καλώντας `metaclass(name, bases, namespace, **kwds)` (οι πρόσθετε λέξεις-κλειδιά που μεταβιβάζονται εδώ είναι οι ίδιες με αυτές που διαβιβάζονται στο `__prepare__`).

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

CPython implementation detail: Στη CPython 3.6 και μεταγενέστερα, το κελί `__class__` μεταβιβάζεται στην μετακλάση ως μια καταχώρηση `__classcell__` στον χώρο ονομάτων της κλάσης. Εάν υπάρχει, αυτό πρέπει να διαδοθεί μέχρι την κλήση `type.__new__`, προκειμένου η κλάση να έχει ως αποτέλεσμα να αρχικοποιηθεί σωστά ώστε να γίνει σωστά. Αν δεν το κάνετε αυτό θα έχει ως αποτέλεσμα μια `RuntimeError` στην Python 3.8.

When using the default metaclass `type`, or any metaclass that ultimately calls `type.__new__`, the following additional customisation steps are invoked after creating the class object:

- first, `type.__new__` collects all of the descriptors in the class namespace that define a `__set_name__()` method;

- second, all of these `__set_name__` methods are called with the class being defined and the assigned name of that particular descriptor;

- finally, the `__init_subclass__()` hook is called on the immediate parent of the new class in its method resolution order.

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

When a new class is created by `type.__new__`, the object provided as the namespace parameter is copied to a new ordered mapping and the original object is discarded. The new copy is wrapped in a read-only proxy, which becomes the `__dict__` attribute of the class object.

Δείτε επίσης

PEP 3135 - Νέο super

  Περιγράφει την σιωπηρή αναφορά κλεισίματος `__class__`

#### 3.3.3.7. Χρήσεις για μετακλάσεις

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

### 3.3.4. Προσαρμογή ελέγχων παρουσίας και υποκλάσης

Οι ακόλουθες μέθοδοι χρησιμοποιούνται για την παράκαμψη της προεπιλεγμένης συμπεριφοράς των ενσωματωμένων συναρτήσεων `isinstance()` και `issubclass()`.

Συγκεκριμένα, η μετακλάση `abc.ABCMeta` υλοποιεί αυτές τις μεθόδους προκειμένου να επιτρέψει την προσθήκη Αφηρημένων Βασικών Κλάσεων (ABCs) ως «εικονικές βασικές κλάσεις» σε οποιαδήποτε κλάση ή τύπο (συμπεριλαμβανομένων των ενσωματωμένων τύπων), συμπεριλαμβανομένων άλλων ABCs.

`class.``__instancecheck__`(self, instance)

  Επιστρέφετε true εάν το instance θα πρέπει να θεωρείται ένα (άμεσο ή έμμεσο) στιγμιότυπο της class. Εάν ορίζεται, καλείται να υλοποιήσει `isinstance(instance, class)`.

`class.``__subclasscheck__`(self, subclass)

  Επιστρέφετε true εάν η subclass πρέπει να θεωρείται μια (άμεση ή έμμεση) υποκλάση της class. Εάν ορίζεται, καλείται να υλοποιήσει `issubclass(subclass, class)`.

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

Δείτε επίσης

PEP 3119 - Εισάγοντας τις Αφηρημένες Βασικές Κλάσεις

  Includes the specification for customizing `isinstance()` and `issubclass()` behavior through `__instancecheck__()` and `__subclasscheck__()`, with motivation for this functionality in the context of adding Abstract Base Classes (see the `abc` module) to the language.

### 3.3.5. Εξομοίωση γενικών τύπων

Όταν χρησιμοποιείτε το type annotations, είναι συχνά χρήσιμο να παραμετροποιήσετε έναν generic type χρησιμοποιώντας τον συμβολισμό σε αγκύλες της Python. Για παράδειγμα, το annotation `list[int]` μπορεί να χρησιμοποιηθεί για να υποδηλώσει μια `list` στην οποία όλα τα στοιχεία της κλάσης είναι τύπου `int`.

Δείτε επίσης

PEP 484 - Τύπος Hints

  Εισάγοντας το πλαίσιο της Python για τύπους annotations

Generic Alias Types

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

Generics, user-defined generics και `typing.Generic`

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

Μια κλάση γενικά μπορεί να παραμετροποιηθεί μόνο εάν ορίζει την ειδική μέθοδο κλάσης `__class_getitem__()`.

classmethod `object.``__class_getitem__`(cls, key)

  Επιστρέφετε ένα αντικείμενο που αντιπροσωπεύει την εξειδίκευση μιας γενικής κλάσης κατά ορίσματα τύπου που βρίσκονται στο key.

  Όταν ορίζεται σε μια κλάση, το `__class_getitem__()` είναι αυτόματα μέθοδος κλάσης. Ως εκ τούτου, δεν χρειάζεται να γίνει decorated με `@classmethod` όταν ορίζεται.

#### 3.3.5.1. Ο σκοπός του __class_getitem__

Ο σκοπός της `__class_getitem__()` είναι να επιτρέψει την παραμετροποίηση χρόνου εκτέλεσης των γενικών κλάσεων τυπικής βιβλιοθήκης προκειμένου να εφαρμοστούν πιο εύκολα type hints σε αυτές τις κλάσεις.

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

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

#### 3.3.5.2. __class_getitem__ έναντι __getitem__

Συνήθως, η subscription ενός αντικειμένου που χρησιμοποιεί αγκύλες θα καλεί τη μέθοδο του στιγμιοτύπου `__getitem__()` που ορίζεται στην κλάση του αντικειμένου. Ωστόσο, εάν το αντικείμενο που εγγράφεται είναι το ίδιο μια κλάση, η μέθοδος της κλάσης `__class_getitem__()` μπορεί να κληθεί αντί να γίνει. Το `__class_getitem__()` θα πρέπει να επιστρέψει ένα αντικείμενο GenericAlias, εάν έχει οριστεί σωστά.

Παρουσιάζεται με το expression `obj[x]`, ο διερμηνέας Python ακολουθεί κάτι σαν την ακόλουθη διαδικασία για να αποφασίσει εάν θα πρέπει να κληθεί `__getitem__()` ή `__class_getitem__()`:

    from inspect import isclass

    def subscribe(obj, x):
        """Return the result of the expression `obj[x]`"""

        class_of_obj = type(obj)

        # If the class of obj defines __getitem__,
        # call class_of_obj.__getitem__(obj, x)
        if hasattr(class_of_obj, '__getitem__'):
            return class_of_obj.__getitem__(obj, x)

        # Else, if obj is a class and defines __class_getitem__,
        # call obj.__class_getitem__(x)
        elif isclass(obj) and hasattr(obj, '__class_getitem__'):
            return obj.__class_getitem__(x)

        # Else, raise an exception
        else:
            raise TypeError(
                f"'{class_of_obj.__name__}' object is not subscriptable"
            )

Στην Python, όλες οι κλάσεις είναι οι ίδιες παρουσίες άλλων κλάσεων. Η κλάση μιας κλάσης είναι γνωστή ως metaclass αυτής της κλάσης, και οι περισσότερες κλάσεις έχουν ως μετακλάση την κλάση `type`. Η `type` δεν ορίζει το `__getitem__()`, πράγμα που σημαίνει ότι εκφράσεις όπως `list[int]`, `dict[str, float]` και `tuple[str, bytes]` έχουν ως αποτέλεσμα την κλήση της `__class_getitem__()`:

    >>> # list has class "type" as its metaclass, like most classes:
    >>> type(list)
    <class 'type'>
    >>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
    True
    >>> # "list[int]" calls "list.__class_getitem__(int)"
    >>> list[int]
    list[int]
    >>> # list.__class_getitem__ returns a GenericAlias object:
    >>> type(list[int])
    <class 'types.GenericAlias'>

Ωστόσο, εάν μια κλάση έχει μια προσαρμοσμένη μετακλάση που ορίζει `__getitem__()`, η εγγραφή στην κλάση μπορεί να οδηγήσει σε διαφορετική συμπεριφορά. Ένα παράδειγμα αυτού μπορεί να βρεθεί στο module `__getitem__()`:

    >>> from enum import Enum
    >>> class Menu(Enum):
    ...     """A breakfast menu"""
    ...     SPAM = 'spam'
    ...     BACON = 'bacon'
    ...
    >>> # Enum classes have a custom metaclass:
    >>> type(Menu)
    <class 'enum.EnumMeta'>
    >>> # EnumMeta defines __getitem__,
    >>> # so __class_getitem__ is not called,
    >>> # and the result is not a GenericAlias object:
    >>> Menu['SPAM']
    <Menu.SPAM: 'spam'>
    >>> type(Menu['SPAM'])
    <enum 'Menu'>

Δείτε επίσης

PEP 560 - Βασική υποστήριξη για module πληκτρολόγησης και γενικούς τύπους

  Παρουσίαση της `__class_getitem__()`, και περιγραφή του πότε ένα subscription έχει ως αποτέλεσμα την κλήση `__class_getitem__()` αντί για `__getitem__()`

### 3.3.6. Εξομοίωση αντικειμένων με δυνατότητα κλήσης

`object.``__call__`(self[, args...])

  Called when the instance is «called» as a function; if this method is defined, `x(arg1, arg2, ...)` roughly translates to `type(x).__call__(x, arg1, ...)`.

### 3.3.7. Εξομοίωση τύπων κοντέινερ

The following methods can be defined to implement container objects. Containers usually are sequences (such as `lists` or `tuples`) or mappings (like `dictionaries`), but can represent other containers as well. The first set of methods is used either to emulate a sequence or to emulate a mapping; the difference is that for a sequence, the allowable keys should be the integers k for which `0 <= k < N` where N is the length of the sequence, or `slice` objects, which define a range of items. It is also recommended that mappings provide the methods `keys()`, `values()`, `items()`, `get()`, `clear()`, `setdefault()`, `pop()`, `popitem()`, `copy()`, and `update()` behaving similar to those for Python’s standard `dictionary` objects. The `collections.abc` module provides a `MutableMapping` abstract base class to help create those methods from a base set of `__getitem__()`, `__setitem__()`, `__delitem__()`, and `keys()`. Mutable sequences should provide methods `append()`, `count()`, `index()`, `extend()`, `insert()`, `pop()`, `remove()`, `reverse()` and `sort()`, like Python standard `list` objects. Finally, sequence types should implement addition (meaning concatenation) and multiplication (meaning repetition) by defining the methods `__add__()`, `__radd__()`, `__iadd__()`, `__mul__()`, `__rmul__()` and `__imul__()` described below; they should not define other numerical operators. It is recommended that both mappings and sequences implement the `__contains__()` method to allow efficient use of the `in` operator; for mappings, `in` should search the mapping’s keys; for sequences, it should search through the values. It is further recommended that both mappings and sequences implement the `__iter__()` method to allow efficient iteration through the container; for mappings, `__iter__()` should iterate through the object’s keys; for sequences, it should iterate through the values.

`object.``__len__`(self)

  Called to implement the built-in function `len()`. Should return the length of the object, an integer `>=` 0. Also, an object that doesn’t define a `__bool__()` method and whose `__len__()` method returns zero is considered to be false in a Boolean context.

  CPython implementation detail: In CPython, the length is required to be at most `sys.maxsize`. If the length is larger than `sys.maxsize` some features (such as `len()`) may raise `OverflowError`. To prevent raising `OverflowError` by truth value testing, an object must define a `__bool__()` method.

`object.``__length_hint__`(self)

  Called to implement `operator.length_hint()`. Should return an estimated length for the object (which may be greater or less than the actual length). The length must be an integer `>=` 0. The return value may also be `NotImplemented`, which is treated the same as if the `__length_hint__` method didn’t exist at all. This method is purely an optimization and is never required for correctness.

  Νέο στην έκδοση 3.4.

Σημείωση

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

    a[1:2] = b

μεταφράζεται σε

    a[slice(1, 2, None)] = b

και ούτω καθεξής. Τα στοιχεία τμήματος που λείπουν συμπληρώνονται πάντα με `None`.

`object.``__getitem__`(self, key)

  Called to implement evaluation of `self[key]`. For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes (if the class wishes to emulate a sequence type) is up to the `__getitem__()` method. If key is of an inappropriate type, `TypeError` may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values), `IndexError` should be raised. For mapping types, if key is missing (not in the container), `KeyError` should be raised.

  Σημείωση

  Οι βρόχοι `for` αναμένουν ότι θα γίνει raise ένα `IndexError` για παράνομα ευρετήρια για να επιτρέπεται ο σωστός εντοπισμός του τέλους της ακολουθίας.

  Σημείωση

  Όταν το subscripting μια class, η μέθοδος ειδικής κλάσης `__class_getitem__()` μπορεί να κληθεί αντί για `__getitem__()`. Δείτε το __class_getitem__ έναντι __getitem__ για περισσότερες λεπτομέρειες.

`object.``__setitem__`(self, key, value)

  Καλείται για την υλοποίηση της ανάθεσης στο `self[key]`. Ίδια σημείωση με το `__getitem__()`. Αυτό θα πρέπει να εφαρμοστεί μόνο για αντιστοιχίσεις εάν τα αντικείμενα υποστηρίζουν αλλαγές στις τιμές για κλειδιά ή εάν μπορούν να προστεθούν νέα κλειδιά ή για ακολουθίες εάν μπορούν να αντικατασταθούν στοιχεία. Θα πρέπει να δημιουργηθούν οι ίδιες εξαιρέσεις για ακατάλληλες τιμές key όπως και για τη μέθοδο `__getitem__()`.

`object.``__delitem__`(self, key)

  Κλήθηκε για την υλοποίηση της διαγραφής του `self[key]`. Ίδια σημείωση με το `__getitem__()`. Αυτό θα πρέπει να εφαρμόζεται μόνο για αντιστοιχίσεις εάν τα αντικείμενα υποστηρίζουν την αφαίρεση πλήκτρων ή για ακολουθίες εάν μπορούν να αφαιρεθούν στοιχεία από την ακολουθία. Θα πρέπει να δημιουργηθούν οι ίδιες εξαιρέσεις για ακατάλληλες τιμές key όπως και για τη μέθοδο `__getitem__()`.

`object.``__missing__`(self, key)

  Κλήθηκε από `dict`.`__getitem__()` για την υλοποίηση του `self[key]` για υποκλάσεις dict όταν το κλειδί δεν υπάρχει στο λεξικό.

`object.``__iter__`(self)

  This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container. For mappings, it should iterate over the keys of the container.

  Iterator objects also need to implement this method; they are required to return themselves. For more information on iterator objects, see Τύποι Iterator.

`object.``__reversed__`(self)

  Καλείται (εάν υπάρχει) από την ενσωματωμένη `reversed()` για την υλοποίηση της αντίστροφης επανάληψης. Θα πρέπει να επιστρέψει ένα νέο iterator αντικείμενο που επαναλαμβάνεται πάνω από όλα τα αντικείμενα στο κοντέινερ με αντίστροφη σειρά.

  Εάν η μέθοδος `__reversed__()` δεν παρέχεται, η ενσωματωμένη `reversed()` θα χρησιμοποιήσει το πρωτόκολλο ακολουθίας (`__len__()` και `__getitem__()`). Τα αντικείμενα που υποστηρίζουν το πρωτόκολλο ακολουθίας θα πρέπει να παρέχουν μόνο τη `__reversed__()` εάν μπορούν να παρέχουν μια υλοποίηση που είναι πιο αποτελεσματική από αυτή που παρέχεται από τη `reversed()`.

Οι τελεστές τεστ ιδιότητας μέλους (`in` και `not in`) συνήθως υλοποιούνται ως επανάληψη μέσω ενός κοντέινερ. Ωστόσο, τα αντικείμενα κοντέινερ μπορούν να παρέχουν την ακόλουθη ειδική μέθοδο μια μια αποτελεσματική υλοποίηση, η οποία επίσης δεν απαιτεί το αντικείμενο να είναι επαναλαμβανόμενο.

`object.``__contains__`(self, item)

  Καλείται για την εφαρμογή τελεστών δοκιμής ιδιότητας μέλους. Θα πρέπει να επιστρέψει true εάν το item είναι στο self, false διαφορετικά. Για την αντιστοίχιση αντικειμένων, αυτό θα πρέπει να λαμβάνει υπόψη τα κλειδιά της αντιστοίχισης αντί για τις τιμές ή τα ζεύγη κλειδιών-στοιχείων.

  Για αντικείμενα που δεν ορίζουν `__contains__()`, το τεστ ιδιότητας δοκιμάζει πρώτα την επανάληψη μέσω `__iter__()`, και μετά το παλιό πρωτόκολλο επανάληψης ακολουθίας μέσω `__getitem__()`, δείτε this section in the language reference.

### 3.3.8. Εξομοίωση αριθμητικών τύπων

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

`object.``__add__`(self, other)
`object.``__sub__`(self, other)
`object.``__mul__`(self, other)
`object.``__matmul__`(self, other)
`object.``__truediv__`(self, other)
`object.``__floordiv__`(self, other)
`object.``__mod__`(self, other)
`object.``__divmod__`(self, other)
`object.``__pow__`(self, other[, modulo])
`object.``__lshift__`(self, other)
`object.``__rshift__`(self, other)
`object.``__and__`(self, other)
`object.``__xor__`(self, other)
`object.``__or__`(self, other)

  These methods are called to implement the binary arithmetic operations (`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`, `pow()`, `**`, `<<`, `>>`, `&`, `^`, `|`). For instance, to evaluate the expression `x + y`, where x is an instance of a class that has an `__add__()` method, `x.__add__(y)` is called. The `__divmod__()` method should be the equivalent to using `__floordiv__()` and `__mod__()`; it should not be related to `__truediv__()`. Note that `__pow__()` should be defined to accept an optional third argument if the ternary version of the built-in `pow()` function is to be supported.

  If one of those methods does not support the operation with the supplied arguments, it should return `NotImplemented`.

`object.``__radd__`(self, other)
`object.``__rsub__`(self, other)
`object.``__rmul__`(self, other)
`object.``__rmatmul__`(self, other)
`object.``__rtruediv__`(self, other)
`object.``__rfloordiv__`(self, other)
`object.``__rmod__`(self, other)
`object.``__rdivmod__`(self, other)
`object.``__rpow__`(self, other[, modulo])
`object.``__rlshift__`(self, other)
`object.``__rrshift__`(self, other)
`object.``__rand__`(self, other)
`object.``__rxor__`(self, other)
`object.``__ror__`(self, other)

  These methods are called to implement the binary arithmetic operations (`+`, `-`, `*`, `@`, `/`, `//`, `%`, `divmod()`, `pow()`, `**`, `<<`, `>>`, `&`, `^`, `|`) with reflected (swapped) operands. These functions are only called if the left operand does not support the corresponding operation 3 and the operands are of different types. 4 For instance, to evaluate the expression `x - y`, where y is an instance of a class that has an `__rsub__()` method, `y.__rsub__(x)` is called if `x.__sub__(y)` returns NotImplemented.

  Λάβετε υπόψη ότι το τριαδικό `pow()` δεν θα προσπαθήσει να καλέσει το `__rpow__()` (οι κανόνες εξαναγκασμού θα γίνουν πολύ περίπλοκοι).

  Σημείωση

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

`object.``__iadd__`(self, other)
`object.``__isub__`(self, other)
`object.``__imul__`(self, other)
`object.``__imatmul__`(self, other)
`object.``__itruediv__`(self, other)
`object.``__ifloordiv__`(self, other)
`object.``__imod__`(self, other)
`object.``__ipow__`(self, other[, modulo])
`object.``__ilshift__`(self, other)
`object.``__irshift__`(self, other)
`object.``__iand__`(self, other)
`object.``__ixor__`(self, other)
`object.``__ior__`(self, other)

  These methods are called to implement the augmented arithmetic assignments (`+=`, `-=`, `*=`, `@=`, `/=`, `//=`, `%=`, `**=`, `<<=`, `>>=`, `&=`, `^=`, `|=`). These methods should attempt to do the operation in-place (modifying self) and return the result (which could be, but does not have to be, self). If a specific method is not defined, the augmented assignment falls back to the normal methods. For instance, if x is an instance of a class with an `__iadd__()` method, `x += y` is equivalent to `x = x.__iadd__(y)` . Otherwise, `x.__add__(y)` and `y.__radd__(x)` are considered, as with the evaluation of `x + y`. In certain situations, augmented assignment can result in unexpected errors (see Γιατί το a_tuple[i] += [“item”] δημιουργεί μια εξαίρεση όταν λειτουργεί η προσθήκη;), but this behavior is in fact part of the data model.

  Σημείωση

  Due to a bug in the dispatching mechanism for `**=`, a class that defines `__ipow__()` but returns `NotImplemented` would fail to fall back to `x.__pow__(y)` and `y.__rpow__(x)`. This bug is fixed in Python 3.10.

`object.``__neg__`(self)
`object.``__pos__`(self)
`object.``__abs__`(self)
`object.``__invert__`(self)

  Καλείται για την υλοποίηση μονομερών αριθμητικών πράξεων (`-`, `+`, `abs()` και `~`).

`object.``__complex__`(self)
`object.``__int__`(self)
`object.``__float__`(self)

  Καλείται για την υλοποίηση των ενσωματωμένων συναρτήσεων `complex()`, `int()` και `float()`. Θα πρέπει να επιστρέψει μια τιμή του κατάλληλου τύπου.

`object.``__index__`(self)

  Καλείται για υλοποίηση `operator.index()`, και όποτε η Python χρειάζεται να μετατρέψει χωρίς απώλειες το αριθμητικό αντικείμενο σε ένα ακέραιο αντικείμενο (όπως στη λειτουργία τμηματοποίησης ή στις ενσωματωμένες συναρτήσεις `bin()`, `hex()` και `oct()`). Η παρουσία αυτής της μεθόδου υποδεικνύει ότι το αριθμητικό αντικείμενο είναι ακέραιου τύπου. Πρέπει να επιστρέψει έναν ακέραιο αριθμό.

  Εάν οι `__int__()`, `__float__()` και `__complex__()` δεν ορίζονται, τότε οι αντίστοιχες ενσωματωμένες συναρτήσεις `int()`, `float()` και `complex()` επιστρέφουν στο `__index__()`.

`object.``__round__`(self[, ndigits])
`object.``__trunc__`(self)
`object.``__floor__`(self)
`object.``__ceil__`(self)

  Καλείται για την υλοποίηση της ενσωματωμένης συνάρτησης `round()` και `math` συναρτήσεις `trunc()`, `floor()` και `ceil()`. Εκτός εάν το ndigits μεταβιβαστεί στο `__round__()` όλες αυτές οι μέθοδοι θα πρέπει να επιστρέψουν την τιμή του αντικειμένου που περικόπτεται σε μια `Integral` (συνήθως ένα `int`).

  Η ενσωματωμένη συνάρτηση `int()` επιστρέφει σε `__trunc__()` εάν δεν έχει οριστεί ούτε `__int__()` ούτε `__index__()`.

### 3.3.9. Με τους Διαχειριστές Περιβάλλοντος Δήλωσης

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

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

For more information on context managers, see Τύποι Διαχείρισης Περιεχομένου.

`object.``__enter__`(self)

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

`object.``__exit__`(self, exc_type, exc_value, traceback)

  Έξοδος από το περιβάλλον χρόνου εκτέλεσης που σχετίζεται με αυτό το αντικείμενο. Οι παράμετροι περιγράφουν την εξαίρεση που προκάλεσε την έξοδο από το περιβάλλον. Εάν το περιβάλλον είχε βγει χωρίς εξαίρεση, και τα τρία ορίσματα θα είναι `None`.

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

  Note that `__exit__()` methods should not reraise the passed-in exception; this is the caller’s responsibility.

Δείτε επίσης

PEP 343 - Η πρόταση «with»

  Οι προδιαγραφές, το υπόβαθρο και τα παραδείγματα για τη δήλωση Python `with`.

### 3.3.10. Αναζήτηση ειδικής μεθόδου

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

    >>> class C:
    ...     pass
    ...
    >>> c = C()
    >>> c.__len__ = lambda: 5
    >>> len(c)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: object of type 'C' has no len()

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

    >>> 1 .__hash__() == hash(1)
    True
    >>> int.__hash__() == hash(int)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: descriptor '__hash__' of 'int' object needs an argument

Η εσφαλμένη προσπάθειας επίκλησης μιας μη δεσμευμένης μεθόδου μιας κλάσης με αυτόν τον τρόπο αναφέρεται μερικές φορές ως “σύγχυση μετακλάσης”, και αποφεύγεται με παράκαμψη της παρουσίας κατά την αναζήτηση ειδικών μεθόδων:

    >>> type(1).__hash__(1) == hash(1)
    True
    >>> type(int).__hash__(int) == hash(int)
    True

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

    >>> class Meta(type):
    ...     def __getattribute__(*args):
    ...         print("Metaclass getattribute invoked")
    ...         return type.__getattribute__(*args)
    ...
    >>> class C(object, metaclass=Meta):
    ...     def __len__(self):
    ...         return 10
    ...     def __getattribute__(*args):
    ...         print("Class getattribute invoked")
    ...         return object.__getattribute__(*args)
    ...
    >>> c = C()
    >>> c.__len__()                 # Explicit lookup via instance
    Class getattribute invoked
    10
    >>> type(c).__len__(c)          # Explicit lookup via type
    Metaclass getattribute invoked
    10
    >>> len(c)                      # Implicit lookup
    10

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

## 3.4. Coroutines

### 3.4.1. Awaitable Αντικείμενα

Ένα αντικείμενο awaitable εφαρμόζει γενικά μια μέθοδο `__await__()`. Τα Coroutine objects που επιστρέφονται από τις `async def` συναρτήσεις είναι awaitable.

Σημείωση

The generator iterator objects returned from generators decorated with `types.coroutine()` or `asyncio.coroutine()` are also awaitable, but they do not implement `__await__()`.

`object.``__await__`(self)

  Must return an iterator. Should be used to implement awaitable objects. For instance, `asyncio.Future` implements this method to be compatible with the `await` expression.

Νέο στην έκδοση 3.5.

Δείτε επίσης

Το PEP 492 για πρόσθετες πληροφορίες σχετικά με τα awaitable αντικείμενα.

### 3.4.2. Coroutine Αντικείμενα

Τα Coroutine objects είναι awaitable αντικείμενα. Η εκτέλεση μιας coroutine μπορεί να ελεγχθεί καλώντας το `__await__()` και επαναλαμβάνοντας το αποτέλεσμα. Όταν η coroutine ολοκληρώσει την εκτέλεση και επιστρέψει ο iterator κάνει raise την `StopIteration`, και το χαρακτηριστικό `value` της εξαίρεσης διατηρεί την τιμή επιστροφής. Εάν η coroutine εγείρει μια εξαίρεση, αυτή διαδίδεται από τον iterator. Οι coroutines δεν πρέπει να κάνουν raise ανεξέλεγκτες εξαιρέσεις `StopIteration`.

Οι coroutines έχουν επίσης τις μεθόδου που αναφέρονται παρακάτω, οι οποίες είναι ανάλογες με αυτές των γεννητριών (βλ. Generator-iterator methods). Ωστόσο, σε αντίθεση με τις γεννήτριες, οι coroutines δεν υποστηρίζουν άμεσα την επανάληψη.

Άλλαξε στην έκδοση 3.5.2: Είναι ένα `RuntimeError` να περιμένει κανείς σε μια coroutine περισσότερες από μία φορές.

`coroutine.``send`(value)

  Starts or resumes execution of the coroutine. If value is `None`, this is equivalent to advancing the iterator returned by `__await__()`. If value is not `None`, this method delegates to the `send()` method of the iterator that caused the coroutine to suspend. The result (return value, `StopIteration`, or other exception) is the same as when iterating over the `__await__()` return value, described above.

`coroutine.``throw`(value)
`coroutine.``throw`(type[, value[, traceback]])

  Κάνει Raise την καθορισμένη εξαίρεση στην coroutine. Αυτή η μέθοδος εκχωρεί στη μέθοδο `throw()` του iterator που προκάλεσε την αναστολή της coroutine, εάν διαθέτει τέτοια μέθοδο. Διαφορετικά, η εξαίρεση γίνεται raise στο σημείο αναστολής. Το αποτέλεσμα (επιστρεφόμενη τιμή, `StopIteration`, ή άλλη εξαίρεση) είναι το ίδιο όπως όταν γίνεται επανάληψη πάνω από την τιμή επιστροφής `__await__()`, που περιγράφεται παραπάνω. Εάν η εξαίρεση δεν περιλαμβάνεται στην coroutine, διαδίδεται πίσω από εκεί που καλέστηκε.

`coroutine.``close`()

  Προκαλεί τον καθαρισμό και την έξοδο της coroutine. Εάν η coroutine τεθεί σε αναστολή, αυτή η μέθοδος εκχωρεί πρώτα στην μέθοδο `close()` του iterator που προκάλεσε την αναστολή της coroutine, εάν έχει τέτοια μέθοδο. Στη συνέχεια, σηκώνει το `GeneratorExit` στο σημείο αναστολής, με αποτέλεσμα η coroutine να καθαριστεί αμέσως. Τέλος, η coroutine επισημαίνεται ότι έχει τελειώσει την εκτέλεση, ακόμα κι αν δεν ξεκίνησε ποτέ.

  Τα αντικείμενα coroutine κλείνουν αυτόματα χρησιμοποιώντας την παραπάνω διαδικασία όταν πρόκειται να καταστραφούν.

### 3.4.3. Ασύγχρονοι Iterators

Ένας ασύγχρονος iterator μπορεί να καλέσει ασύγχρονο κώδικα με τη μέθοδο `__anext__`.

Οι ασύγχρονοι iterators μπορούν να χρησιμοποιηθούν σε μια δήλωση `async for`.

`object.``__aiter__`(self)

  Πρέπει να επιστρέψει ένα αντικείμενο ασύγχρονου iterator.

`object.``__anext__`(self)

  Πρέπει να επιστρέψει ένα αναμενόμενο που θα έχει ως αποτέλεσμα μια επόμενη τιμή iterator. Θα πρέπει να κάνει raise ένα σφάλμα `StopAsyncIteration` όταν τελειώσει η επανάληψη.

Παράδειγμα σύγχρονου iterator αντικειμένου:

    class Reader:
        async def readline(self):
            ...

        def __aiter__(self):
            return self

        async def __anext__(self):
            val = await self.readline()
            if val == b'':
                raise StopAsyncIteration
            return val

Νέο στην έκδοση 3.5.

Άλλαξε στην έκδοση 3.7: Πριν από την Python 3.7, η `__aiter__()` θα μπορούσε να επιστρέψει ένα αναμενόμενο που θα επιλύονται σε ένα asynchronous iterator.

Ξεκινώντας με την Python 3.7, η `__aiter__()` πρέπει να επιστρέψει ένα ασύγχρονο αντικείμενο iterator. Εάν επιστρέφει οτιδήποτε άλλο θα έχει ως αποτέλεσμα ένα σφάλμα `TypeError`.

### 3.4.4. Ασύγχρονοι Διαχειριστές Περιβάλλοντος

Ένας ασύγχρονος διαχειριστής περιβάλλοντος είναι ένα διαχειριστής περιβάλλοντος που μπορεί να αναστείλει την εκτέλεση στις μεθόδους `__aenter__` και `__aexit__`.

Οι ασύγχρονοι διαχειριστές περιβάλλοντος μπορούν να χρησιμοποιηθούν σε μια δήλωση `async with`.

`object.``__aenter__`(self)

  Semantically similar to `__enter__()`, the only difference being that it must return an awaitable.

`object.``__aexit__`(self, exc_type, exc_value, traceback)

  Semantically similar to `__exit__()`, the only difference being that it must return an awaitable.

Ένα παράδειγμα κλάσης ασύγχρονης διαχείρισης περιβάλλοντος:

    class AsyncContextManager:
        async def __aenter__(self):
            await log('entering context')

        async def __aexit__(self, exc_type, exc, tb):
            await log('exiting context')

Νέο στην έκδοση 3.5.

Υποσημειώσεις

1

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

2

  Οι μέθοδοι `__hash__()`, `__iter__()`, `__reversed__()`, και `__contains__()` έχουν ειδικό χειρισμό για αυτό∙ άλλοι θα εξακολουθήσουν να κάνουν raise ένα `TypeError`, αλλά μπορεί να το κάνει βασιζόμενος στη συμπεριφορά ότι το `None` δεν καλείται.

3

  «Does not support» here means that the class has no such method, or the method returns `NotImplemented`. Do not set the method to `None` if you want to force fallback to the right operand’s reflected method—that will instead have the opposite effect of explicitly blocking such fallback.

4

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