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


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

Το *Objects* είναι μια αφαιρετική αναπαράσταση της Python για τα
δεδομένα.  Όλα τα δεδομένα σε ένα Python πρόγραμμα αναπαριστώνται από
αντικείμενα ή από συσχετίσεις μεταξύ αντικειμένων. Ακόμη και ο κώδικας
αναπαρίσταται από αντικείμενα.

Κάθε αντικείμενο έχει μια ταυτότητα, έναν τύπο και μια τιμή.  Η
*ταυτότητα* ενός αντικειμένου δεν αλλάζει ποτέ αφού δημιουργηθεί∙
μπορείτε να το σκεφτείτε ως τη διεύθυνση του αντικειμένου στη μνήμη.
Ο τελεστής "is" συγκρίνει την ταυτότητα δύο αντικειμένων∙ η συνάρτηση
"id()" επιστρέφει έναν ακέραιο αριθμό που αντιπροσωπεύει την ταυτότητά
του.

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

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

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

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

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

Λάβετε υπόψη ότι η χρήση των υπηρεσιών ανίχνευσης ή εντοπισμού
σφαλμάτων της υλοποίησης μπορεί να διατηρήσει ζωντανά αντικείμενα που
κανονικά θα μπορούσαν να συλλεχθούν. Επίσης σημειώστε ότι η σύλληψη
μιας εξαίρεσης με μια δήλωση "try"..."except", μπορεί να κρατήσει
ζωντανά αντικείμενα.

Ορισμένα αντικείμενα περιέχουν αναφορές σε "εξωτερικούς" πόρους, όπως
ανοιχτά αρχεία ή παράθυρα.  Είναι κατανοητό ότι αυτοί οι πόροι
ελευθερώνονται όταν το αντικείμενο συλλέγεται από σκουπίδια, αλλά
επειδή η συλλογή απορριμμάτων δεν είναι εγγυημένη, τέτοια αντικείμενα
παρέχουν επίσης έναν σαφή τρόπο απελευθέρωσης του εξωτερικού πόρου,
συνήθως μια μέθοδο "close()". Συνιστώνται προγράμματα για τη ρητό
κλείσιμο τέτοιων αντικειμένων.  Η δήλωση "try"..."finally" και η
δήλωση "with" παρέχουν βολικούς τρόπους για να το κάνετε αυτό.

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

Οι τύποι επηρεάζουν σχεδόν όλες τις πτυχές της συμπεριφοράς των
αντικειμένων.  Ακόμη και η σημασία της ταυτότητας αντικειμένου
επηρεάζεται κατά κάποιο τρόπο: για αμετάβλητους τύπους, οι πράξεις που
υπολογίζουν νέες τιμές μπορούν στην πραγματικότητα να επιστρέψουν μια
αναφορά σε οποιοδήποτε υπάρχον αντικείμενο με τον ίδιο τύπο και τιμή,
ενώ για μεταβλητά αντικείμενα αυτό δεν επιτρέπεται. Π.χ., μετά από "a
= 1; b = 1", τα *a* και *b* μπορεί να αναφέρονται ή να μην αναφέρονται
στο ίδιο αντικείμενο με την τιμή ένα, ανάλογα με την υλοποίηση. Αυτό
συμβαίνει επειδή το "int" είναι ένας αμετάβλητος τύπος, επομένως η
αναφορά στο "1" μπορεί να επαναχρησιμοποιηθεί. Αυτή η συμπεριφορά
εξαρτάται από την υλοποίηση που χρησιμοποιείται, επομένως δεν πρέπει
να βασίζεστε σε αυτήν, αλλά είναι κάτι που πρέπει να γνωρίζετε όταν
χρησιμοποιείτε δοκιμές ταυτότητας αντικειμένων. Ωστόσο, μετά από "c =
[]; d = []", *c* και *d* είναι εγγυημένα ότι αναφέρονται σε δύο
διαφορετικές, μοναδικές, νεοδημιουργημένες κενές λίστες. (Σημειώστε
ότι το "e = f = []" αντιστοιχίζει το *ίδιο* αντικείμενο τόσο στο *e*
όσο και στο *f*.)


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

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

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


3.2.1. None
-----------

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


3.2.2. NotImplemented
---------------------

Αυτός ο τύπος έχει μια ενιαία τιμή.  Υπάρχει ένα μεμονωμένο
αντικείμενο με αυτήν την τιμή. Η πρόσβαση σε αυτό το αντικείμενο
γίνεται μέσω του ενσωματωμένου ονόματος "NotImplemented". Οι
αριθμητικές μέθοδοι και οι μέθοδοι εμπλουτισμένης σύγκρισης θα πρέπει
να επιστρέφουν αυτήν την τιμή εάν δεν εφαρμόζουν τη λειτουργία για
τους τελεστές που παρέχονται.  (Ο διερμηνέας θα δοκιμάσει την
ανακλώμενη λειτουργία ή κάποια άλλη εναλλακτική, ανάλογα με τον
τελεστή.)  Δεν πρέπει να αξιολογείται σε ένα boolean πλαίσιο.

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

Άλλαξε στην έκδοση 3.9: Η αξιολόγηση του "NotImplemented" σε ένα
boolean πλαίσιο έχει αποσυρθεί.

Άλλαξε στην έκδοση 3.14: Η αξιολόγηση του "NotImplemented" σε ένα
boolean πλαίσιο τώρα κάνει raise μια "TypeError". Προηγουμένως
αξιολογούνταν σε "True" και εξέπεμπε μια "DeprecationWarning" από την
Python 3.9.


3.2.3. Ellipsis
---------------

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


3.2.4. "numbers.Number"
-----------------------

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

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

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

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

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

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

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

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


3.2.4.1. "numbers.Integral"
~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

Σημείωση:

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

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

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

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


3.2.4.2. "numbers.Real" ("float")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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


3.2.4.3. "numbers.Complex" ("complex")
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Αυτοί αντιπροσωπεύουν μιγαδικούς αριθμούς ως ζεύγος αριθμών κινητής
υποδιαστολής διπλής ακρίβειας σε επίπεδο μηχανής.  Ισχύουν οι ίδιες
προειδοποιήσεις όπως και για τους αριθμούς κινητής υποδιαστολής. Τα
πραγματικά και τα φανταστικά μέρη ενός μιγαδικού αριθμού "z" μπορούν
να ανακτηθούν μέσω των χαρακτηριστικών "z.real" και "z.imag" μόνο για
ανάγνωση.


3.2.5. Ακολουθίες
-----------------

Αυτά αντιπροσωπεύουν πεπερασμένα διατεταγμένα σύνολα ευρετηριασμένα με
μη αρνητικούς αριθμούς. Η ενσωματωμένη συνάρτηση "len()" επιστρέφει
τον αριθμός των στοιχείων μιας ακολουθίας. Όταν το μήκος μια
ακολουθίας είναι *n*, το σύνολο δεικτών περιέχει τους αριθμούς 0, 1,
..., *n*-1.  Το στοιχείο *i* της ακολουθίας *a* επιλέγεται από το
"a[i]". Ορισμένες ακολουθίες, συμπεριλαμβανομένων των ενσωματωμένων
ακολουθιών, ερμηνεύουν αρνητικούς δείκτες προσθέτοντας το μήκος της
ακολουθίας. Για παράδειγμα, το "a[-2]" ισούται με "a[n-2]", το δεύτερο
έως το τελευταίο στοιχείο της ακολουθίας a με μήκος "n".

Οι ακολουθίες υποστηρίζουν επίσης την τμηματοποίηση: το "a[i:j]"
επιλέγει όλα τα στοιχεία με ευρετήριο *k* έτσι ώστε *i* "<=" *k* "<"
*j*. Όταν χρησιμοποιείται ως έκφραση, ένα τμήμα είναι μια ακολουθία
του ίδιου τύπου. Το παραπάνω σχόλιο σχετικά με τους αρνητικούς δείκτες
ισχύει και για αρνητικές θέσεις.

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

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


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

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

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

Συμβολοσειρές
   Μια συμβολοσειρά είναι μια ακολουθία τιμών που αντιπροσωπεύουν
   σημεία κώδικα Unicode. Όλα τα σημεία κώδικα στο εύρος "U+0000 -
   U+10FFFF" μπορούν να αναπαρασταθούν σε μια συμβολοσειρά.  Η Python
   δεν έχει τύπο char ∙ αντίθετα, κάθε σημείο κώδικα στη συμβολοσειρά
   αντιπροσωπεύεται ως αντικείμενο συμβολοσειράς με μήκος "1".  Η
   ενσωματωμένη συνάρτηση "ord()" μετατρέπει ένα σημείο κώδικα από τη
   μορφή συμβολοσειράς του σε έναν ακέραιο στο εύρος "0 - 10FFFF" ∙ η
   "chr()" μετατρέπει έναν ακέραιο στο εύρος "0 - 10FFFF" στο
   αντικείμενο συμβολοσειράς αντίστοιχου μήκους "1". Η "str.encode()"
   μπορεί να χρησιμοποιηθεί για τη μετατροπή μιας "str" σε "bytes"
   χρησιμοποιώντας τη δεδομένη κωδικοποίηση κειμένου και η
   "bytes.decode()" μπορεί να χρησιμοποιηθεί για να επιτευχθεί το
   αντίθετο.

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

Bytes
   Ένα αντικείμενο bytes είναι ένας αμετάβλητος πίνακας.  Τα στοιχεία
   είναι bytes των 8-bit, που αντιπροσωπεύονται από ακέραιους αριθμούς
   στο εύρος 0 <= x < 256.  Τα bytes literals (όπως "b'abc'") και ο
   ενσωματωμένος κατασκευαστής "bytes()" μπορεί να χρησιμοποιηθεί για
   τη δημιουργία αντικειμένων bytes.  Επίσης, τα αντικείμενα bytes
   μπορούν να αποκωδικοποιηθούν σε συμβολοσειρές μέσω της μεθόδου
   "decode()".


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

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

Σημείωση:

  Τα modules "collections" και "array" παρέχουν πρόσθετα παραδείγματα
  μεταβλητών τύπων ακολουθιών.

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

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

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


3.2.6. Σύνολο τύπων
-------------------

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

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

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

Σύνολα
   These represent a mutable set. They are created by the built-in
   "set()" constructor and can be modified afterwards by several
   methods, such as "add()".

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


3.2.7. Αντιστοιχίσεις
---------------------

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

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


3.2.7.1. Λεξικά
~~~~~~~~~~~~~~~

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

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

Τα λεξικά είναι μεταβλητά· μπορούν να δημιουργηθούν με τη σημείωση
"{...}" (βλ. ενότητα Dictionary displays).

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

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


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

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


3.2.8.1. Συναρτήσεις που ορίζονται από τον χρήστη
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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


3.2.8.1.1. Ειδικά χαρακτηριστικά μόνο για ανάγνωση
""""""""""""""""""""""""""""""""""""""""""""""""""

+----------------------------------------------------+----------------------------------------------------+
| Χαρακτηριστικό                                     | Έννοια                                             |
|====================================================|====================================================|
| function.__builtins__                              | A reference to the "dictionary" that holds the     |
|                                                    | function's builtins namespace.  Added in version   |
|                                                    | 3.10.                                              |
+----------------------------------------------------+----------------------------------------------------+
| function.__globals__                               | Μια αναφορά στη "dictionary" που περιέχει τις      |
|                                                    | global variables -- τον καθολικό χώρο ονομάτων του |
|                                                    | module στην οποία ορίστηκε η συνάρτηση.            |
+----------------------------------------------------+----------------------------------------------------+
| function.__closure__                               | Το "None" ή μια "tuple" από κελιά που περιέχουν    |
|                                                    | δεσμεύσεις για τα ονόματα που καθορίζονται στο     |
|                                                    | χαρακτηριστικό "co_freevars" του "code object" της |
|                                                    | συνάρτησης.  Ένα αντικείμενο κελιού έχει το        |
|                                                    | χαρακτηριστικό "cell_contents". Αυτό μπορεί να     |
|                                                    | χρησιμοποιηθεί για να ληφθεί η τιμή του κελιού,    |
|                                                    | καθώς και να οριστεί η τιμή.                       |
+----------------------------------------------------+----------------------------------------------------+


3.2.8.1.2. Ειδικά εγγράψιμα χαρακτηριστικά
""""""""""""""""""""""""""""""""""""""""""

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

+----------------------------------------------------+----------------------------------------------------+
| Χαρακτηριστικό                                     | Έννοια                                             |
|====================================================|====================================================|
| function.__doc__                                   | Η συμβολοσειρά τεκμηρίωσης της συνάρτηση ή "None"  |
|                                                    | εάν δεν είναι διαθέσιμη.                           |
+----------------------------------------------------+----------------------------------------------------+
| function.__name__                                  | Το όνομα της συνάρτησης. Δείτε επίσης "__name__    |
|                                                    | attributes".                                       |
+----------------------------------------------------+----------------------------------------------------+
| function.__qualname__                              | Η συνάρτηση είναι *qualified name*. Δείτε επίσης   |
|                                                    | "__qualname__ attributes".  Added in version 3.3.  |
+----------------------------------------------------+----------------------------------------------------+
| function.__module__                                | Το όνομα του module στην οποία ορίστηκε η          |
|                                                    | συνάρτηση ή "None" εάν δεν είναι διαθέσιμη.        |
+----------------------------------------------------+----------------------------------------------------+
| function.__defaults__                              | Ένα "tuple" που περιέχει προεπιλεγμένες τιμές      |
|                                                    | *parameter* για εκείνες τις παραμέτρους που έχουν  |
|                                                    | προεπιλογές ή "None" εάν καμία παράμετρος δεν έχει |
|                                                    | προεπιλεγμένη τιμή.                                |
+----------------------------------------------------+----------------------------------------------------+
| function.__code__                                  | Το αντικείμενο code object που αντιπροσωπεύει το   |
|                                                    | μεταγλωττισμένο σώμα συνάρτησης.                   |
+----------------------------------------------------+----------------------------------------------------+
| function.__dict__                                  | Ο χώρος ονομάτων που υποστηρίζει  αυθαίρετα        |
|                                                    | χαρακτηριστικά συνάρτησης. Δείτε επίσης "__dict__  |
|                                                    | attributes".                                       |
+----------------------------------------------------+----------------------------------------------------+
| function.__annotations__                           | Μια "dictionary" που περιέχει annotations για      |
|                                                    | *parameters*. Τα κλειδιά του λεξικού είναι τα      |
|                                                    | ονόματα των παραμέτρων και "'return'", για το      |
|                                                    | annotation επιστροφής, εάν παρέχεται. Δείτε        |
|                                                    | επίσης: "object.__annotations__".  Άλλαξε στην     |
|                                                    | έκδοση 3.14: Τα annotations πλέον lazily           |
|                                                    | evaluated. Βλ. **PEP 649**.                        |
+----------------------------------------------------+----------------------------------------------------+
| function.__annotate__                              | Η *annotate function* για αυτή τη συνάρτηση ή      |
|                                                    | "None" εάν η συνάρτηση δεν έχει annotations. Δείτε |
|                                                    | "object.__annotate__".  Added in version 3.14.     |
+----------------------------------------------------+----------------------------------------------------+
| function.__kwdefaults__                            | Μια "dictionary" που περιέχει προεπιλογές για      |
|                                                    | λέξεις-κλειδιά μόνο *parameters*.                  |
+----------------------------------------------------+----------------------------------------------------+
| function.__type_params__                           | Μια "tuple" που περιέχει τις παραμέτρους type      |
|                                                    | parameters μιας generic function.  Added in        |
|                                                    | version 3.12.                                      |
+----------------------------------------------------+----------------------------------------------------+

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

Η τρέχουσα υλοποίηση του CPython υποστηρίζει μόνο χαρακτηριστικά
συναρτήσεων σε συναρτήσεις που καθορίζονται από τον χρήστη. Τα
χαρακτηριστικά συναρτήσεων σε built-in functions ενδέχεται να
υποστηρίζονται στο μέλλον.

Μπορούν να ανακτηθούν πρόσθετες πληροφορίες σχετικά με τον ορισμό μιας
συνάρτησης από το αντικείμενο code object (προσβάσιμο μέσω του
χαρακτηριστικού "__code__").


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

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

Ειδικά χαρακτηριστικά μόνο για ανάγνωση:

+----------------------------------------------------+----------------------------------------------------+
| method.__self__                                    | Αναφέρεται στο αντικείμενο στιγμιοτύπου κλάσης στο |
|                                                    | οποίο βρίσκεται η μέθοδος bound                    |
+----------------------------------------------------+----------------------------------------------------+
| method.__func__                                    | Αναφέρεται στο αρχικό function object              |
+----------------------------------------------------+----------------------------------------------------+
| method.__doc__                                     | Η τεκμηρίωση της μεθόδου (ίδια με την              |
|                                                    | "method.__func__.__doc__"). Μια "string" εάν η     |
|                                                    | αρχική συνάρτηση είχε docstring, αλλιώς "None".    |
+----------------------------------------------------+----------------------------------------------------+
| method.__name__                                    | Το όνομα της μεθόδου (ίδιο με το                   |
|                                                    | "method.__func__.__name__")                        |
+----------------------------------------------------+----------------------------------------------------+
| method.__module__                                  | Το όνομα του module στην οποία ορίστηκε η μέθοδος, |
|                                                    | ή "None" εάν δεν είναι διαθέσιμη.                  |
+----------------------------------------------------+----------------------------------------------------+

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

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

Όταν δημιουργείται ένα αντικείμενο μεθόδου στιγμιοτύπου ανακτώντας ένα
αντικείμενο function object που ορίζεται από το χρήστη από μια κλάση,
το χαρακτηριστικό "__self__" είναι το στιγμιότυπο και το αντικείμενό
της μεθόδου λέγεται ότι είναι *δεσμευμένο*.  Το χαρακτηριστικό
"__func__" της νέας μεθόδου είναι το αρχικό αντικείμενο συνάρτησης.

Όταν ένα αντικείμενο μεθόδου παρουσίας δημιουργείται με ανάκτηση ενός
αντικειμένου "classmethod" από μια κλάση ή στιγμιότυπο, το
χαρακτηριστικό "__self__" είναι η ίδια κλάση και το χαρακτηριστικό
"__func__" είναι το αντικείμενο συνάρτησης που βρίσκεται κάτω από τη
μέθοδο κλάσης.

Όταν καλείται ένα αντικείμενο μεθόδου στιγμιοτύπου, καλείται η
υποκείμενη συνάρτηση ("__func__"), εισάγοντας το στιγμιότυπο κλάσης
("__self__") μπροστά από τη λίστα ορισμάτων.  Για παράδειγμα, όταν η
"C" είναι μια κλάση που περιέχει έναν ορισμό για μια συνάρτηση "f()",
και το "x" είναι ένα στιγμιότυπο της "C", η κλήση του "x.f(1)"
ισοδυναμεί με την κλήση του "C.f(x, 1)".

Όταν ένα αντικείμενο μεθόδου στιγμιοτύπου προέρχεται από ένα
αντικείμενο "classmethod", το "στιγμιότυπο κλάσης" που είναι
αποθηκευμένο στη "__self__" θα είναι στη πραγματικότητα η ίδια η
κλάση, έτσι ώστε η κλήση είτε του "x.f(1)" ή του "C.f(1)" ισοδυναμεί
με την κλήση του "f(C,1)" όπου το "f" είναι η υποκείμενη συνάρτηση.

Είναι σημαντικό να σημειωθεί ότι οι συναρτήσεις που ορίζονται από το
χρήστη και είναι χαρακτηριστικό ενός στιγμιοτύπου μιας κλάσης δεν
μετατρέπονται σε δεσμευμένες μεθόδους∙ Αυτό συμβαίνει *μόνο* όταν η
συνάρτηση είναι χαρακτηριστικό της κλάσης.


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

Μια συνάρτηση ή μέθοδος που χρησιμοποιεί τη δήλωση "yield" (βλ.
ενότητα The yield statement) ονομάζεται *generator function*.  Μια
τέτοια συνάρτηση, όταν καλείται, επιστρέφει πάντα ένα αντικείμενο
*iterator* που μπορεί να χρησιμοποιηθεί για την εκτέλεση του σώματος
της συνάρτησης: καλώντας τη μέθοδο "iterator.__next__()" του iterator
θα προκαλέσει την εκτέλεση της συνάρτησης έως ότου παρέχει μια τιμή
χρησιμοποιώντας τη δήλωση "yield".  Όταν η συνάρτηση εκτελεί μια
δήλωση "return" ή πέσει στο τέλος, γίνεται raise μια εξαίρεση
"StopIteration" και ο iterator θα έχει φτάσει στο τέλος του συνόλου
τιμών που θα επιστραφεί.


3.2.8.4. Coroutine συναρτήσεις
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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


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

Μια συνάρτηση ή μέθοδος που ορίζεται χρησιμοποιώντας "async def" και
που χρησιμοποιεί την πρόταση "yield" ονομάζεται *asynchronous
generator function*.  Μια τέτοια συνάρτηση, όταν καλείται, επιστρέφει
ένα αντικείμενο *asynchronous iterator* που μπορεί να χρησιμοποιηθεί
σε μια δήλωση "async for" για την εκτέλεση του σώματος της συνάρτησης.

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


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

Ένα αντικείμενο ενσωματωμένης συνάρτησης είναι ένας wrapper γύρω από
μια συνάρτηση C.  Παραδείγματα ενσωματωμένων συναρτήσεων είναι οι
"len()" και "math.sin()" ("math" είναι ένα ενσωματωμένο module). Ο
αριθμός και ο τύπος των ορισμάτων καθορίζονται από τη συνάρτηση C.
Ειδικά χαρακτηριστικά μόνο για ανάγνωση:

* Η "__doc__" είναι η συμβολοσειρά τεκμηρίωσης της συνάρτησης, ή
  "None" εάν δεν είναι διαθέσιμη . Δείτε "function.__doc__".

* Η "__name__" είναι το όνομα της συνάρτησης. Δείτε
  "function.__name__".

* Η "__self__" έχει οριστεί σε "None" (αλλά δείτε το επόμενο
  στοιχείο).

* Η "__module__" είναι το όνομα του module στην οποία ορίστηκε η
  συνάρτηση ή "None" εάν δεν είναι διαθέσιμη. Δείτε
  "function.__module__".


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

Αυτή είναι πραγματικά μια διαφορετική μεταμφίεση μιας ενσωματωμένης
συνάρτησης, αυτή τη φορά που περιέχει ένα αντικείμενο που
μεταβιβάστηκε στη συνάρτηση C ως ένα έμμεσο επιπλέον όρισμα. Ένα
παράδειγμα ενσωματωμένης μεθόδου είναι η "alist.append()", υποθέτοντας
ότι το *alist* είναι αντικείμενο λίστας. Σε αυτήν την περίπτωση, το
ειδικό χαρακτηριστικό μόνο για ανάγνωση "__self__" ορίζεται στο
αντικείμενο που συμβολίζεται με *alist*. (Το χαρακτηριστικό έχει την
ίδια σημασιολογία με το "other instance methods".)


3.2.8.8. Κλάσεις
~~~~~~~~~~~~~~~~

Οι κλάσεις μπορούν να κληθούν.  Αυτά τα αντικείμενα λειτουργούν
κανονικά ως εργοστάσια (factories) για νέα στιγμιότυπα του εαυτού
τους, αλλά είναι δυνατές παραλλαγές για τύπους κλάσεων που
παρακάμπτουν το "__new__()".  Τα ορίσματα της κλήσης μεταβιβάζονται
στην "__new__()" και, στην τυπική περίπτωση, στη "__init__()" για να
αρχικοποιηθεί το νέο στιγμιότυπο.


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

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


3.2.9. Modules
--------------

Τα modules είναι μια βασική οργανωτική μονάδα κώδικα Python, και
δημιουργούνται από το import system όπως καλείται είτε από τη δήλωση
"import" είτε με κλήση συναρτήσεων όπως "importlib.import_module()"
και το ενσωματωμένο "__import__()".  Ένα αντικείμενο module έχει έναν
χώρο ονομάτων που υλοποιείται από ένα αντικείμενο "dictionary" (αυτό
είναι το λεξικό που αναφέρεται από τη συνάρτηση "__globals__" των
συναρτήσεων που ορίζονται στο module).  Οι αναφορές χαρακτηριστικών
μεταφράζονται σε αναζητήσεις σε αυτό το λεξικό, π.χ., το "m.x"
ισοδυναμεί με "m.__dict__["x"]". Ένα αντικείμενο module δεν περιέχει
το αντικείμενο κώδικα που χρησιμοποιείται για την προετοιμασία του
module (καθώς δεν χρειάζεται μόλις ολοκληρωθεί η προετοιμασία).

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


3.2.9.1. Χαρακτηριστικά που σχετίζονται με εισαγωγή σε αντικείμενα modules
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Τα αντικείμενα modules έχουν τα ακόλουθα χαρακτηριστικά που
σχετίζονται με το import system. Όταν δημιουργείται ένα module με τη
χρήση του μηχανήματος που σχετίζεται με το σύστημα εισαγωγής, αυτά τα
χαρακτηριστικά συμπληρώνονται με βάση το *spec* του module, προτού το
*loader* εκτελέσει και φορτώσει το module.

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

Προσοχή:

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

     >>> import typing
     >>> typing.__name__, typing.__spec__.name
     ('typing', 'typing')
     >>> typing.__spec__.name = 'spelling'
     >>> typing.__name__, typing.__spec__.name
     ('typing', 'spelling')
     >>> typing.__name__ = 'keyboard_smashing'
     >>> typing.__name__, typing.__spec__.name
     ('keyboard_smashing', 'spelling')

module.__name__

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

   Αυτό το χαρακτηριστικό πρέπει να οριστεί στο πλήρως προσδιορισμένο
   όνομα του module. Αναμένεται να ταιριάζει με την τιμή
   "module.__spec__.name".

module.__spec__

   Μια εγγραφή της κατάστασης του module που σχετίζεται με το σύστημα
   εισαγωγής.

   Ορίστε την παράμετρο "module spec" που χρησιμοποιήθηκε κατά την
   εισαγωγή της ενότητας. Δείτε το Module specs για περισσότερες
   λεπτομέρειες.

   Added in version 3.4.

module.__package__

   Το *package* στο οποίο ανήκει μια ενότητα.

   Εάν το module είναι ανώτατου επιπέδου (δηλαδή, δεν αποτελεί μέρος
   κάποιου συγκεκριμένου πακέτου), τότε το χαρακτηριστικό θα πρέπει να
   οριστεί σε "''" (η κενή συμβολοσειρά). Διαφορετικά, θα πρέπει να
   οριστεί το όνομα του πακέτου της ενότητας (το οποίο μπορεί να είναι
   ίσο με "module.__name__" εάν η ίδια η ενότητα είναι πακέτο). Δείτε
   **PEP 366** για περισσότερες λεπτομέρειες.

   Αυτό το χαρακτηριστικό χρησιμοποιείται αντί για το "__name__" για
   την υπολογισμό σαφών σχετικών εισαγωγών για τα κύρια modules. Η
   προεπιλεγμένη τιμή είναι "None" για modules που δημιουργούνται
   δυναμικά χρησιμοποιώντας τον κατασκευαστή "types.ModuleType" ∙
   χρησιμοποιήστε το "importlib.util.module_from_spec()" για να
   βεβαιωθείτε ότι το χαρακτηριστικό έχει οριστεί σε "str".

   Συνίσταται ανεπιφύλακτα να χρησιμοποιείτε την εντολή
   "module.__spec__.parent" αντί για την εντολή "module.__package__".
   Η εντολή "__package__" χρησιμοποιείται πλέον μόνο ως εφεδρική
   εντολή εάν η εντολή "__spec__.parent" δεν έχει οριστεί και αυτή η
   εφεδρική διαδρομή έχει καταργηθεί.

   Άλλαξε στην έκδοση 3.4: Αυτό το χαρακτηριστικό έχει πλέον την
   προεπιλεγμένη τιμή "None" για modules που δημιουργούνται δυναμικά
   χρησιμοποιώντας τον κατασκευαστή "types.ModuleType". Προηγουμένως,
   το χαρακτηριστικό ήταν προαιρετικό.

   Άλλαξε στην έκδοση 3.6: Η τιμή του "__package__" αναμένεται να
   είναι η ίδια με την τιμή του "__spec__.parent". Το "__package__"
   χρησιμοποιείται πλέον μόνο ως εφεδρική τιμή κατά την ανάλυση
   εισαγωγής εάν δεν έχει οριστεί το "__spec__.parent".

   Άλλαξε στην έκδοση 3.10: Η "ImportWarning" γίνεται raised εάν η
   ανάλυση εισαγωγής επανέλθει σε "__package__" αντί για
   "__spec__.parent".

   Άλλαξε στην έκδοση 3.12: Γίνεται "DeprecationWarning" αντί για
   "ImportWarning" κατά την επιστροφή στο "__package__" κατά την
   επίλυση της εισαγωγής.

   Καταργήθηκε από την έκδοση 3.13, θα αφαιρεθεί στην έκδοση 3.15: Το
   "__package__" θα πάψει να ορίζεται ή να λαμβάνεται υπόψη από το
   σύστημα εισαγωγής ή την τυπική βιβλιοθήκη.

module.__loader__

   Το αντικείμενο *loader* που χρησιμοποίησε ο μηχανισμός εισαγωγής
   για τη φόρτωση του module.

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

   Το "__loader__" έχει προεπιλεγμένη τιμή "None" για modules που
   δημιουργούνται δυναμικά χρησιμοποιώντας τον κατασκευαστή
   "types.ModuleType" ∙ χρησιμοποιήστε τη
   "importlib.util.module_from_spec()" για να βεβαιωθείτε ότι το
   χαρακτηριστικό έχει οριστεί σε ένα αντικείμενο *loader*.

   Συνίσταται ανεπιφύλακτα να χρησιμοποιείτε την εντολή
   "module.__spec__.loader" αντί για την εντολή "module.__loader__".

   Άλλαξε στην έκδοση 3.4: Αυτό το χαρακτηριστικό έχει πλέον την
   προεπιλεγμένη τιμή "None" για modules που δημιουργούνται δυναμικά
   χρησιμοποιώντας τον κατασκευαστή "types.ModuleType". Προηγουμένως,
   το χαρακτηριστικό ήταν προαιρετικό.

   Καταργήθηκε από την έκδοση 3.12, θα αφαιρεθεί στην έκδοση 3.16: Ο
   ορισμός του "__loader__" σε ένα module χωρίς τον αντίστοιχο ορισμό
   του "__spec__.loader" θεωρείται παρωχημένος. Στην Python 3.16, το
   "__loader__" θα πάψει να ορίζεται η να λαμβάνεται υπόψη από το
   σύστημα εισαγωγής ή την τυπική βιβλιοθήκη.

module.__path__

   Μια (ενδεχομένως κενή) *sequence* από συμβολοσειρές που απαριθμεί
   τις τοποθεσίες όπου θα εντοπιστούν τα submodules του πακέτου.
   Modules που δεν είναι πακέτα δεν θα πρέπει να έχουν το
   χαρακτηριστικό "__path__". Δείτε το __path__ attributes on modules
   για περισσότερες λεπτομέρειες.

   Συνίσταται **ισχυρά** να χρησιμοποιείτε το
   "module.__spec__.submodule_search_locations" αντί για το
   "module.__path__".

module.__file__

module.__cached__

   Τα "__file__" και "__cached__" είναι και τα δύο προαιρετικά
   χαρακτηριστικά, τα οποία ενδέχεται να μην έχουν οριστεί. Όταν είναι
   διαθέσιμα, και τα δύο θα πρέπει να είναι αντικείμενα τύπου μιας
   "str".

   Το "__file__" υποδεικνύει το όνομα διαδρομής του αρχείου από το
   οποίο φορτώθηκε το module (εάν φορτώθηκε από ένα αρχείο) ή το όνομα
   διαδρομής της κοινόχρηστης βιβλιοθήκης στην περίπτωση επεκτάσεων
   που φορτώνονται δυναμικά από τέτοια βιβλιοθήκη. Ενδέχεται να
   απουσιάζει για ορισμένους τύπους modules, όπως modules C που έχουν
   συνδεθεί στατικά στον διερμηνέα, και το import system μπορεί να
   επιλέξει να μην το ορίσει εάν δεν έχει σημασιολογική αξία (π.χ. ένα
   module που φορτώνεται από μια βάση δεδομένων).

   Αν το "__file__" έχει οριστεί τότε το χαρακτηριστικό "__cached__"
   μπορεί επίσης να ρυθμιστεί, η οποία είναι η διαδρομή σε οποιαδήποτε
   καταρτισμένη έκδοση του κώδικα (για παράδειγμα, ένα byte-compiled
   αρχείο). Το αρχείο δεν χρειάζεται να υπάρχει για να ορίσετε αυτό το
   χαρακτηριστικό. Η διαδρομή μπορεί απλά να επισημάνει το πού *θα*
   υπήρχε το αρχείο που έχει καταρτιστεί (βλ. **PEP 3147**).

   Σημειώστε ότι το "__cached__" μπορεί να ρυθμιστεί ακόμη και αν το
   "__file__" δεν έχει οριστεί. Ωστόσο, αυτό το σενάριο είναι αρκετά
   άτυπο.  Τελικά, ο *loader* είναι αυτό που κάνει τη χρήση του spec
   module που παρέχεται από το *finder* (από το οποίο "__file__" και
   "__cached__" παρέχονται).  Έτσι, εάν ένας loader μπορεί να φορτωθεί
   από ένα προσωρινό module, αλλά διαφορετικά δεν φορτώνεται από ένα
   αρχείο, αυτό το άτυπο σενάριο μπορεί να είναι κατάλληλο.

   Συνίσταται **ισχυρά** να χρησιμοποιείτε το "module.__spec__.cached"
   αντί για το "module.__cached__".

   Καταργήθηκε από την έκδοση 3.13, θα αφαιρεθεί στην έκδοση 3.15: Ο
   ορισμός του "__cached__" σε ένα module χωρίς τον αντίστοιχο ορισμό
   του "__spec__.cached" θεωρείται παρωχημένος. Στην Python 3.15, το
   "__cached__" θα πάψει να ορίζεται η να λαμβάνεται υπόψη από το
   σύστημα εισαγωγής ή την τυπική βιβλιοθήκη.


3.2.9.2. Άλλα εγγράφως χαρακτηριστικά σε αντικείμενα μονάδων
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

module.__doc__

   Η συμβολοσειρά τεκμηρίωσης του module, ή "None" αν δεν είναι
   διαθέσιμη. Δείτε επίσης: "__doc__ attributes".

module.__annotations__

   Ένα λεξικό που περιέχει *variable annotations* που συλλέγονται κατά
   την εκτέλεση του σώματος του module.  Για τις βέλτιστες πρακτικές
   σχετικά με την εργασία με "__annotations__", δείτε το
   "annotationlib".

   Άλλαξε στην έκδοση 3.14: Τα annotations πλέον lazily evaluated. Βλ.
   **PEP 649**.

module.__annotate__

   Η *annotate function* για αυτό το module, ή "None" εάν το module
   δεν έχει annotations. Δείτε επίσης: "__annotate__" attributes.

   Added in version 3.14.


3.2.9.3. Λεξικά Modules
~~~~~~~~~~~~~~~~~~~~~~~

Τα αντικείμενα module έχουν επίσης την ακόλουθη ειδική ιδιότητα μόνο
για ανάγνωση:

module.__dict__

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

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


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

Οι τύποι προσαρμοσμένων κλάσεων δημιουργούνται συνήθως από ορισμούς
κλάσεων (βλ. ενότητα Class definitions).  Μια κλάση έχει έναν χώρο
ονομάτων που υλοποιείται από ένα αντικείμενο λεξικού. Οι αναφορές
χαρακτηριστικών κλάσης μεταφράζονται σε αναζητήσεις σε αυτό το λεξικό,
π.χ., το "C.x" μεταφράζεται σε "C.__dict__["x"]" (αν και άλλα μέσα για
τα οποία επιτρέπεται ο αριθμός των θέσεων υπάρχουν). Όταν το όνομα του
χαρακτηριστικού δεν βρίσκεται εκεί, η αναζήτηση χαρακτηριστικών
συνεχίζεται στις βασικές κλάσεις. Αυτή η αναζήτηση των βασικών κλάσεων
χρησιμοποιεί τη σειρά ανάλυσης της μεθόδου C3 η οποία συμπεριφέρεται
σωστά ακόμη και με την παρουσία δομών κληρονομικότητας «διαμάντι» όπου
υπάρχουν πολλαπλές διαδρομές κληρονομικότητας που οδηγούν πίσω σε έναν
κοινό πρόγονο. Πρόσθετε λεπτομέρειες για το C3 MRO που χρησιμοποιείται
από την Python μπορείτε να βρείτε στην διεύθυνση The Python 2.3 Method
Resolution Order.

Όταν μια αναφορά χαρακτηριστικού κλάσης (για την κλάση "C", ας πούμε)
θα έδινε ένα αντικείμενο μεθόδου κλάσης, μετατρέπεται σε ένα
αντικείμενο μεθόδου παρουσίας του οποίου το χαρακτηριστικό "__self__"
είναι "C". Όταν θα έδινε ένα αντικείμενο "staticmethod", μετατρέπεται
στο αντικείμενο που είναι wrapped από το αντικείμενο στατικής μεθόδου.
Δείτε την ενότητα Υλοποίηση Περιγραφέων για έναν άλλο τρόπο με το
οποίο τα χαρακτηριστικά που ανακτώνται από μια κλάση μπορεί να
διαφέρουν από αυτά που πραγματικά περιέχονται στο "__dict__" της.

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

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


3.2.10.1. Ειδικά χαρακτηριστικά
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+----------------------------------------------------+----------------------------------------------------+
| Χαρακτηριστικό                                     | Έννοια                                             |
|====================================================|====================================================|
| type.__name__                                      | Το όνομα της κλάσης, Δείτε επίσης: "__name__       |
|                                                    | attributes".                                       |
+----------------------------------------------------+----------------------------------------------------+
| type.__qualname__                                  | Το *qualified name* της κλάσης. Δείτε επίσης:      |
|                                                    | "__qualname__ attributes".                         |
+----------------------------------------------------+----------------------------------------------------+
| type.__module__                                    | Το όνομα του module στην οποία ορίστηκε η κλάση.   |
+----------------------------------------------------+----------------------------------------------------+
| type.__dict__                                      | Μια "mapping proxy" που παρέχει μια προβολή μόνο   |
|                                                    | για ανάγνωση του χώρου ονομάτων της κλάσης. Δείτε  |
|                                                    | επίσης: "__dict__ attributes".                     |
+----------------------------------------------------+----------------------------------------------------+
| type.__bases__                                     | Μια "tuple" που περιέχει τις βάσεις της κλάσης.    |
|                                                    | Στις περισσότερες περιπτώσεις, για μια κλάση που   |
|                                                    | ορίζεται ως "class X(A, B, C)", το "X.__bases__"   |
|                                                    | θα είναι ακριβώς ίσο με "(A, B, C)".               |
+----------------------------------------------------+----------------------------------------------------+
| type.__base__                                      | Η μοναδική βασική κλάση στην αλυσίδα               |
|                                                    | κληρονομικότητας που είναι υπεύθυνη για τη διάταξη |
|                                                    | μνήμης των στιγμιοτύπων. Αυτό το χαρακτηριστικό    |
|                                                    | αντιστοιχεί στο "tp_base" σε επίπεδο C.            |
+----------------------------------------------------+----------------------------------------------------+
| type.__doc__                                       | Η συμβολοσειρά τεκμηρίωσης της κλάσης ή "None" εάν |
|                                                    | δεν έχει οριστεί. Δεν κληρονομείται από            |
|                                                    | υποκλάσεις.                                        |
+----------------------------------------------------+----------------------------------------------------+
| type.__annotations__                               | Ένα λεξικό που περιέχει *variable annotations* που |
|                                                    | συλλέγονται κατά την εκτέλεση του σώματος της      |
|                                                    | κλάσης. Δείτε επίσης: "__annotations__             |
|                                                    | attributes".  Για βέλτιστες πρακτικές σχετικά με   |
|                                                    | την εργασία με "__annotations__", δείτε το         |
|                                                    | "annotationlib". Χρησιμοποιήστε την                |
|                                                    | "annotationlib.get_annotations()" αντί να έχετε    |
|                                                    | άμεση πρόσβαση σε αυτό το χαρακτηριστικό.          |
|                                                    | Προειδοποίηση:   Η πρόσβαση στο χαρακτηριστικό     |
|                                                    | "__annotations__" απευθείας σε ένα αντικείμενο     |
|                                                    | κλάσης ενδέχεται να επιστρέψει annotations για τη  |
|                                                    | λάθος κλάση, συγκεκριμένα σε ορισμένες περιπτώσεις |
|                                                    | όπου η κλάση, η βασική της κλάση ή μια μετακλάση   |
|                                                    | ορίζεται με το "from __future__ import             |
|                                                    | annotations". Δείτε το **749** για                 |
|                                                    | λεπτομέρειες.Αυτό το χαρακτηριστικό δεν υπάρχει σε |
|                                                    | ορισμένες ενσωματωμένες κλάσεις. Σε προσαρμοσμένες |
|                                                    | κλάσεις χωρίς "__annotations__", είναι ένα κενό    |
|                                                    | λεξικό.  Άλλαξε στην έκδοση 3.14: Τα annotations   |
|                                                    | πλέον lazily evaluated. Βλ. **PEP 649**.           |
+----------------------------------------------------+----------------------------------------------------+
| type.__annotate__()                                | Η *annotate function* για αυτή την κλάση, ή "None" |
|                                                    | εάν η κλάση δεν έχει annotations. Δείτε επίσης:    |
|                                                    | "__annotate__ attributes".  Added in version 3.14. |
+----------------------------------------------------+----------------------------------------------------+
| type.__type_params__                               | Μια "tuple" που περιέχει τις type parameters μιας  |
|                                                    | generic class.  Added in version 3.12.             |
+----------------------------------------------------+----------------------------------------------------+
| type.__static_attributes__                         | Ένα "tuple" που περιέχει ονόματα χαρακτηριστικών   |
|                                                    | αυτής της κλάσης τα οποία ανατίθενται μέσω του     |
|                                                    | "self.X" από οποιαδήποτε συνάρτηση στο σώμα της.   |
|                                                    | Added in version 3.13.                             |
+----------------------------------------------------+----------------------------------------------------+
| type.__firstlineno__                               | Ο αριθμός γραμμής της πρώτης γραμμής του ορισμού   |
|                                                    | της κλάσης, συμπεριλαμβανομένων των διακοσμητών. Ο |
|                                                    | ορισμός του χαρακτηριστικού "__module__" αφαιρεί   |
|                                                    | το "__firstlineno__" από το λεξικό του τύπου.      |
|                                                    | Added in version 3.13.                             |
+----------------------------------------------------+----------------------------------------------------+
| type.__mro__                                       | Η "tuple" των κλάσεων που λαμβάνονται υπόψη κατά   |
|                                                    | την αναζήτηση βασικών κλάσεων κατά την ανάλυση της |
|                                                    | μεθόδου.                                           |
+----------------------------------------------------+----------------------------------------------------+


3.2.10.2. Ειδικές μέθοδοι
~~~~~~~~~~~~~~~~~~~~~~~~~

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

type.mro()

   Αυτή η μέθοδος μπορεί να παρακαμφθεί από μια μετακλάση για να
   προσαρμόσετε τη σειρά ανάλυσης της μεθόδου για τις παρουσίες της.
   Καλείται κατά την έναρξη της κλάσης και το αποτέλεσμα της
   αποθηκεύεται στο "__mro__".

type.__subclasses__()

   Κάθε κλάση διατηρεί μια λίστα με ασθενείς αναφορές στις άμεσες
   υποκλάσεις της. Αυτή η μέθοδος επιστρέφει μια λίστα με όλες αυτές
   τις αναφορές που εξακολουθούν να είναι ενεργές. Η λίστα είναι με
   σειρά ορισμού. Παράδειγμα:

      >>> class A: pass
      >>> class B(A): pass
      >>> A.__subclasses__()
      [<class 'B'>]


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

Ένα στιγμιότυπο κλάσης δημιουργείται καλώντας ένα αντικείμενο κλάσης
(δείτε παραπάνω).  Ένα στιγμιότυπο κλάσης έχει έναν χώρο ονομάτων που
υλοποιείται ως λεξικό που είναι το πρώτο μέρος στο οποίο αναζητούνται
οι αναφορές χαρακτηριστικών. Όταν ένα χαρακτηριστικό δεν βρίσκεται
εκεί και η κλάση του στιγμιοτύπου έχει ένα χαρακτηριστικό με αυτό το
όνομα, η αναζήτηση συνεχίζεται με τα χαρακτηριστικά κλάσης.  Εάν
βρεθεί ένα χαρακτηριστικό κλάσης που είναι ένα αντικείμενο συνάρτησης
που ορίζεται από το χρήστη, μετατρέπεται σε ένα αντικείμενο μεθόδου
στιγμιοτύπου του οποίου το χαρακτηριστικό "__self__" είναι το
στιγμιότυπο.  Τα αντικείμενα στατικής μεθόδου και μεθόδου κλάσης
μετασχηματίζονται επίσης· δείτε παραπάνω στην ενότητα "Κλάσεις".
Δείτε την ενότητα Υλοποίηση Περιγραφέων για έναν άλλο τρόπο με τον
οποίο τα χαρακτηριστικά μιας κλάσης που ανακτώνται μέσω των
στιγμιοτύπων της μπορεί να διαφέρουν από τα αντικείμενα που είναι
πραγματικά αποθηκευμένα στο "__dict__" της κλάσης.  Εάν δεν βρεθεί
χαρακτηριστικό κλάσης και η κλάση του αντικειμένου έχει μια μέθοδο
"__getattr__()", αυτή καλείται να ικανοποιήσει την αναζήτηση.

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

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


3.2.11.1. Ειδικά χαρακτηριστικά
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

object.__class__

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

object.__dict__

   Ένα λεξικό ή άλλο αντικείμενο αντιστοίχισης που χρησιμοποιείται για
   την αποθήκευση των (εγγράψιμων) χαρακτηριστικών ενός αντικειμένου.
   Δεν έχουν όλα τα στιγμιότυπα ένα χαρακτηριστικό "__dict__" ∙ δείτε
   την ενότητα για τα __slots__ για περισσότερες λεπτομέρειες.


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

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

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


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

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


3.2.13.1. Αντικείμενα κώδικα
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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


3.2.13.1.1. Ειδικά χαρακτηριστικά μόνο για ανάγνωση
"""""""""""""""""""""""""""""""""""""""""""""""""""

+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_name                                 | Το όνομα της συνάρτησης                            |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_qualname                             | Το πλήρως αναγνωρισμένο όνομα συνάρτησης  Added in |
|                                                    | version 3.11.                                      |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_argcount                             | Ο συνολικός αριθμός των θέσεων *parameters*        |
|                                                    | (συμπεριλαμβανομένων των παραμέτρων μόνο θέσης και |
|                                                    | παραμέτρων με προεπιλεγμένες τιμές) που έχει η     |
|                                                    | συνάρτηση                                          |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_posonlyargcount                      | Ο αριθμός των *parameters* θέσεως                  |
|                                                    | (συμπεριλαμβανομένων ορισμάτων με προεπιλεγμένες   |
|                                                    | τιμές) που έχει η συνάρτηση                        |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_kwonlyargcount                       | Ο αριθμός των *parameters* λέξεων κλειδιών         |
|                                                    | (συμπεριλαμβανομένων ορισμάτων με προεπιλεγμένες   |
|                                                    | τιμές) που έχει η συνάρτηση                        |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_nlocals                              | Ο αριθμός των local variables που χρησιμοποιούνται |
|                                                    | από τη συνάρτηση (συμπεριλαμβανομένων των          |
|                                                    | παραμέτρων)                                        |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_varnames                             | Μια "tuple" που περιέχει τα  ονόματα των τοπικών   |
|                                                    | μεταβλητών στη συνάρτηση (ξεκινώντας με τα ονόματα |
|                                                    | των παραμέτρων)                                    |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_cellvars                             | Ένα "tuple" που περιέχει τα ονόματα των local      |
|                                                    | variables που αναφέρονται από τουλάχιστον ένα      |
|                                                    | *nested scope* μέσα στη συνάρτηση                  |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_freevars                             | Ένα "tuple" που περιέχει τα ονόματα των *free      |
|                                                    | (closure) variables* που αναφέρεται από ένα        |
|                                                    | *nested scope* σε ένα εξωτερικό πλαίσιο. Δείτε     |
|                                                    | επίσης το "function.__closure__".  Σημείωση: οι    |
|                                                    | αναφορές σε καθολικά και ενσωματωμένα ονόματα      |
|                                                    | *δεν* περιλαμβάνονται.                             |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_code                                 | Μια συμβολοσειρά που αντιπροσωπεύει την ακολουθία  |
|                                                    | εντολών *bytecode* στη συνάρτηση                   |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_consts                               | Μια "tuple" που περιέχει τα literals που           |
|                                                    | χρησιμοποιούνται από το *bytecode* στη συνάρτηση   |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_names                                | Μια "tuple" που περιέχει τα ονόματα που            |
|                                                    | χρησιμοποιούνται από τον *bytecode* στην συνάρτηση |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_filename                             | Το όνομα του αρχείου από το οποίο συντάχθηκε ο     |
|                                                    | κώδικας                                            |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_firstlineno                          | Ο αριθμός γραμμής της πρώτης γραμμής της           |
|                                                    | συνάρτησης                                         |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_lnotab                               | Μια συμβολοσειρά που κωδικοποιεί την αντιστοίχιση  |
|                                                    | από τον *bytecode* μετατοπίζεται σε αριθμούς       |
|                                                    | γραμμών. Για λεπτομέρειες, ανατρέξτε στον πηγαίο   |
|                                                    | κώδικα του διερμηνέα.  Αποσύρθηκε στην έκδοση      |
|                                                    | 3.12: Αυτό το χαρακτηριστικό των αντικειμένων      |
|                                                    | κώδικα έχει καταργηθεί, και μπορεί να αφαιρεθεί    |
|                                                    | στην Python 3.15.                                  |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_stacksize                            | Το απαιτούμενο μέγεθος στοίβας του αντικειμένου    |
|                                                    | κώδικα                                             |
+----------------------------------------------------+----------------------------------------------------+
| codeobject.co_flags                                | Μια "integer" που κωδικοποιεί έναν αριθμό flags    |
|                                                    | για τον διερμηνέα.                                 |
+----------------------------------------------------+----------------------------------------------------+

Τα ακόλουθα flag bits ορίζονται για "co_flags": το bit "0x04" ορίζεται
εάν η συνάρτηση χρησιμοποιεί τη σύνταξη "*arguments" για να αποδεχτεί
έναν αυθαίρετο αριθμό ορισμάτων θέσης· το bit "0x08" ορίζεται εάν η
συνάρτηση χρησιμοποιεί τη σύνταξη "**keywords" για να δέχεται
αυθαίρετα ορίσματα λέξεων-κλειδιών· το bit "0x20" ορίζεται εάν η
συνάρτηση είναι γεννήτρια. Δείτε το Code Objects Bit Flags για
λεπτομέρειες σχετικά με τη σημασιολογία κάθε σημαίας που μπορεί να
υπάρχει.

Οι δηλώσεις μελλοντικών δυνατοτήτων (για παράδειγμα, "from __future__
import division") χρησιμοποιούν επίσης bits στο "co_flags" για να
υποδείξουν εάν ένα αντικείμενο κώδικα έχει συνταχθεί με μια
συγκεκριμένη ενεργοποιημένη δυνατότητα. Δείτε το "compiler_flag".

Άλλα bits στο "co_flags" είναι δεσμευμένα για εσωτερική χρήση.

Εάν ένα αντικείμενο κώδικα αντιπροσωπεύει μια συνάρτηση και έχει μια
συμβολοσειρά τεκμηρίωσης, το bit "CO_HAS_DOCSTRING" ορίζεται στο
"co_flags" και το πρώτο στοιχείο στο "co_consts" είναι η συμβολοσειρά
τεκμηρίωσης της συνάρτησης.


3.2.13.1.2. Μέθοδοι σε αντικείμενα κώδικα
"""""""""""""""""""""""""""""""""""""""""

codeobject.co_positions()

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

   Ο iterator επιστρέφει "tuple"s που περιέχει το "(start_line,
   end_line, start_column, end_column)". Η πλειάδα *i-th* αντιστοιχεί
   στη θέση του πηγαίου κώδικα που μεταγλωττίστηκε στην εντολή *i-th*.
   Οι πληροφορίες στηλών είναι μετατοπίσεις utf-8 byte με ευρετήριο 0
   στη δεδομένη γραμμή πηγής.

   Αυτές οι πληροφορίες θέσης μπορεί να λείπουν. Μια μη εξαντλητική
   λίστα περιπτώσεων όπου αυτό μπορεί να συμβεί:

   * Εκτέλεση του διερμηνέα με "-X" "no_debug_ranges".

   * Φόρτωση ενός αρχείου pyc που έχει μεταγλωττιστεί κατά τη χρήση
     του "-X" "no_debug_ranges".

   * Τοποθετεί τις πλειάδες που αντιστοιχούν σε τεχνικές οδηγίες.

   * Αριθμοί γραμμών και στηλών που δεν μπορούν να αναπαρασταθούν λόγω
     περιορισμών για την υλοποίηση.

   Όταν συμβαίνει αυτό, ορισμένα η όλα τα πολλαπλά στοιχεία μπορεί να
   είναι "None".

   Added in version 3.11.

   Σημείωση:

     Αυτή η δυνατότητα απαιτεί αποθήκευση θέσεων στηλών σε αντικείμενα
     κώδικα που μπορεί να οδηγήσει σε μικρή αύξηση της χρήσης δίσκου
     των μεταγλωττισμένων αρχείων Python ή της χρήσης μνήμης
     διερμηνέα. Για να αποφύγετε την αποθήκευση των επιπλέον
     πληροφοριών ή/και να απενεργοποιήσετε την εκτύπωση των επιπλέον
     πληροφοριών παρακολούθησης, μπορεί να χρησιμοποιηθεί η σημαία
     (flag) γραμμής εντολών "-X" "no_debug_ranges" ή η μεταβλητή
     περιβάλλοντος "PYTHONNODEBUGRANGES".

codeobject.co_lines()

   Επιστρέφει έναν iterator που παράγει πληροφορίες σχετικά με
   διαδοχικά εύρη *bytecode*s. Κάθε στοιχείο που αποδίδεται είναι μια
   "(start, end, lineno)" "tuple":

   * Το "start" (ένα "int") αναπαριστά τη μετατόπιση
     (συμπεριλαμβανομένης) της έναρξης του εύρους *bytecode*

   * Το "end" (ένα "int") αναπαριστά τη μετατόπιση (αποκλειστική) του
     τέλους του εύρους *bytecode*

   * Το "lineno" είναι ένα "int" που αναπαριστά τον αριθμό γραμμής του
     εύρους *bytecode* ή "None" εάν τα bytecodes στη δεδομένη περιοχή
     δεν έχουν αριθμό γραμμής

   Τα στοιχεία που θα προκύψουν θα έχουν τις ακόλουθες ιδιότητες:

   * Το πρώτο εύρος που θα προκύψει θα έχει ένα "start" 0.

   * Τα εύρη "(start, end)" θα είναι μη φθίνουσες και διαδοχικές.
     Δηλαδή, για οποιοδήποτε ζεύγος "tuple"s, το "start" του δεύτερου
     θα είναι ίσο με το το "end" του πρώτου.

   * Κανένα εύρος δεν θα είναι προς τα πίσω: "end >= start" για όλες
     τις τριάδες.

   * Το τελευταίο "tuple" που θα αποφέρει θα έχει "end" ίσο με το
     μέγεθος του *bytecode*.

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

   Added in version 3.10.

   Δείτε επίσης:

     **PEP 626** - Ακριβείς αριθμοί γραμμών για εντοπισμό σφαλμάτων
     και άλλα εργαλεία.
        Το PEP που εισήγαγε τη μέθοδο "co_lines()".

codeobject.replace(**kwargs)

   Επιστρέφει ένα αντίγραφο του αντικειμένου κώδικα με νέες τιμές για
   τα καθορισμένα πεδία.

   Τα αντικείμενα κώδικα υποστηρίζονται επίσης από τη γενική συνάρτηση
   "copy.replace()".

   Added in version 3.8.


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

Τα αντικείμενα πλαισίου αναπαριστούν πλαίσια εκτέλεσης.  Μπορούν να
εμφανίζονται σε traceback objects, και επίσης μεταβιβάζονται σε
καταχωρημένες συναρτήσεις ανίχνευσης.


3.2.13.2.1. Ειδικά χαρακτηριστικά μόνο για ανάγνωση
"""""""""""""""""""""""""""""""""""""""""""""""""""

+----------------------------------------------------+----------------------------------------------------+
| frame.f_back                                       | Δείχνει το προηγούμενο πλαίσιο στοίβας (προς από   |
|                                                    | εκεί  που καλείται), ή "None" αν αυτό είναι το     |
|                                                    | πλαίσιο της κάτω στοίβας                           |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_code                                       | Το αντικείμενο code object εκτελείται σε αυτό το   |
|                                                    | πλαίσιο. Η πρόσβαση σε αυτό το χαρακτηριστικό      |
|                                                    | κάνει raise σε ένα συμβάν auditing event           |
|                                                    | "object.__getattr__" με ορίσματα "obj" και         |
|                                                    | ""f_code"".                                        |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_locals                                     | Η αντιστοίχιση που χρησιμοποιείται από το πλαίσιο  |
|                                                    | για την αναζήτηση local variables. Εάν το πλαίσιο  |
|                                                    | αναφέρεται σε ένα *optimized scope*, αυτό μπορεί   |
|                                                    | να επιστρέψει ένα αντικείμενο proxy write-through. |
|                                                    | Άλλαξε στην έκδοση 3.13: Επιστρέφει ένα proxy για  |
|                                                    | βελτιστοποιημένα πλαίσια.                          |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_globals                                    | Το λεξικό που χρησιμοποιείται από το πλαίσιο για   |
|                                                    | την αναζήτηση global variables                     |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_builtins                                   | Το λεξικό που χρησιμοποιείται από το πλαίσιο για   |
|                                                    | την αναζήτηση built- in (intrinsic) names          |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_lasti                                      | Η "ακριβής εντολή" του αντικειμένου πλαισίου (αυτό |
|                                                    | είναι ένα ευρετήριο στη συμβολοσειρά *bytecode*    |
|                                                    | του αντικειμένου code object)                      |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_generator                                  | Το αντικείμενο *generator* ή *coroutine* που       |
|                                                    | κατέχει αυτό το πλαίσιο, ή "None" εάν το πλαίσιο   |
|                                                    | είναι μια κανονική συνάρτηση.  Added in version    |
|                                                    | 3.14.                                              |
+----------------------------------------------------+----------------------------------------------------+


3.2.13.2.2. Ειδικά εγγράψιμα χαρακτηριστικά
"""""""""""""""""""""""""""""""""""""""""""

+----------------------------------------------------+----------------------------------------------------+
| frame.f_trace                                      | Εάν όχι "None", αυτή είναι μια συνάρτηση που       |
|                                                    | καλείται για διάφορα συμβάντα κατά την εκτέλεση    |
|                                                    | κώδικα (αυτό χρησιμοποιείται από προγράμματα       |
|                                                    | εντοπισμού σφαλμάτων). Κανονικά ένα συμβάν         |
|                                                    | ενεργοποιείται για κάθε νέα γραμμή πηγαίου κώδικα  |
|                                                    | (δείτε "f_trace_lines").                           |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_trace_lines                                | Ορίστε αυτό το χαρακτηριστικό σε "False" για να    |
|                                                    | απενεργοποιήσετε την ενεργοποίηση ενός συμβάντος   |
|                                                    | ανίχνευσης για κάθε γραμμή πηγαίου κώδικα.         |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_trace_opcodes                              | Ορίζει αυτό το χαρακτηριστικό σε "True" για να     |
|                                                    | επιτρέψετε να ζητηθούν συμβάντα ανά opcode.        |
|                                                    | Σημειώστε ότι αυτό μπορεί να οδηγήσει σε           |
|                                                    | απροσδιόριστη συμπεριφορά διερμηνέα εάν οι         |
|                                                    | εξαιρέσεις που προκύπτουν από τη συνάρτηση         |
|                                                    | ανίχνευσης διαφεύγουν στη συνάρτηση που            |
|                                                    | παρακολουθείται.                                   |
+----------------------------------------------------+----------------------------------------------------+
| frame.f_lineno                                     | Ο τρέχων αριθμός γραμμής του πλαισίου -- η εγγραφή |
|                                                    | σε αυτό μέσα από μια συνάρτηση ανίχνευσης          |
|                                                    | μεταβαίνει στη δεδομένη γραμμή (μόνο για το πιο    |
|                                                    | κάτω πλαίσιο).  Ένας εντοπισμός σφαλμάτων μπορεί   |
|                                                    | να εφαρμόσει μια εντολή Μετάβασης (γνωστή και ως   |
|                                                    | Ορισμός Επόμενης Δήλωσης) γράφοντας σε αυτό το     |
|                                                    | χαρακτηριστικό.                                    |
+----------------------------------------------------+----------------------------------------------------+


3.2.13.2.3. Μέθοδοι αντικειμένων πλαισίου
"""""""""""""""""""""""""""""""""""""""""

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

frame.clear()

   Αυτή η μέθοδος διαγράφει όλες τις αναφορές σε local variables που
   τηρούνται από το πλαίσιο.  Επίσης, εάν το πλαίσιο ανήκε σε ένα
   *generator*, η γεννήτρια έχει οριστικοποιηθεί.  Αυτό βοηθά στη
   διακοπή των κύκλων αναφοράς που περιλαμβάνουν αντικείμενα πλαισίου
   (για παράδειγμα, όταν γίνεται catch μια exception και αποθηκεύετε
   το traceback για μετέπειτα χρήση).

   Η "RuntimeError" γίνεται raise εάν το πλαίσιο εκτελείται ή
   αναστέλλεται.

   Added in version 3.4.

   Άλλαξε στην έκδοση 3.13: Η προσπάθεια εκκαθάρισης ενός ανασταλμένου
   πλαισίου κάνει raise "RuntimeError" (όπως πάντα συμβαίνει για τα
   εκτελούμενα πλαίσια).


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

Τα αντικείμενα ανίχνευσης αντιπροσωπεύουν το ίχνος στοίβας μιας
exception. Ένα αντικείμενο traceback δημιουργείται σιωπηρά όταν
εμφανίζεται μια εξαίρεση και μπορεί επίσης να δημιουργηθεί ρητά
καλώντας το "types.TracebackType".

Άλλαξε στην έκδοση 3.7: Τα αντικείμενα Traceback μπορούν τώρα να
δημιουργηθούν ρητά από τον κώδικα Python.

Για εμμέσως δημιουργημένα tracebacks, όταν η αναζήτηση για έναν
χειριστή εξαιρέσεων ξετυλίγει τη στοίβα εκτέλεσης, σε κάθε επίπεδο
ξετυλίγματος εισάγεται ένα αντικείμενο traceback μπροστά από το τρέχον
traceback.  Όταν εισάγεται ένα χειριστής εξαίρεσης, το ίχνος στοίβας
διατίθεται στο πρόγραμμα. (Δείτε την ενότητα The try statement.) Είναι
προσβάσιμο ως το τρίτο στοιχείο της πλειάδα που επιστρέφεται από το
"sys.exc_info()" και έχει ως το χαρακτηριστικό "__traceback__" της
εξαίρεσης που έχει εντοπιστεί.

Όταν το πρόγραμμα δεν περιέχει ον κατάλληλο χειριστή, το ίχνος στοίβας
γράφεται (όμορφα μορφοποιημένο) στην τυπική ροή σφαλμάτων· εάν ο
διερμηνέα είναι διαδραστικός, διατίθεται επίσης στον χρήστη ως
"sys.last_traceback".

Για ρητά δημιουργημένα tracebacks, εναπόκειται στον δημιουργό του
traceback να καθορίσει πως θα πρέπει να συνδεθούν, τα χαρακτηριστικά
"tb_next" για να σχηματίσουν ένα ίχνος πλήρους στοίβας.

Ειδικά χαρακτηριστικά μόνο για ανάγνωση:

+----------------------------------------------------+----------------------------------------------------+
| traceback.tb_frame                                 | Δείχνει την εκτέλεση frame του τρέχοντος επιπέδου. |
|                                                    | Η πρόσβαση σε αυτό το χαρακτηριστικό κάνει raise   |
|                                                    | ένα auditing event "object.__getattr__" με         |
|                                                    | ορίσματα "obj" και ""tb_frame"".                   |
+----------------------------------------------------+----------------------------------------------------+
| traceback.tb_lineno                                | Δίνει τον αριθμό γραμμής όπου προέκυψε η εξαίρεση  |
+----------------------------------------------------+----------------------------------------------------+
| traceback.tb_lasti                                 | Δηλώνει την "ακριβή οδηγία".                       |
+----------------------------------------------------+----------------------------------------------------+

Ο αριθμός γραμμής και η τελευταία εντολή στο traceback μπορεί να
διαφέρουν από τον αριθμό γραμμής του αντικειμένου frame object εάν η
εξαίρεση εμφανίστηκε σε μια πρόταση "try" χωρίς αντιστοίχιση εκτός από
τον όρο ή με έναν όρο "finally".

traceback.tb_next

   Το ειδικό εγγράψιμο χαρακτηριστικό "tb_next" είναι το επόμενο
   επίπεδο στο ίχνος στοίβας (προς το πλαίσιο όπου σημειώθηκε η
   εξαίρεση), ή "None" εάν δεν υπάρχει επόμενο επίπεδο.

   Άλλαξε στην έκδοση 3.7: Αυτό το χαρακτηριστικό είναι τώρα εγγράψιμο


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

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

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

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

slice.indices(self, length)

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


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

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


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

Ένα αντικείμενο μεθόδου κλάσης, όπως ένα αντικείμενο στατικής μεθόδου,
είναι ένα περιτύλιγμα γύρω από ένα άλλο αντικείμενο που αλλάζει τον
τρόπο με τον οποίο ανακτάται αυτό το αντικείμενο από κλάσεις και
στιγμιότυπα κλάσεων. Η συμπεριφορά των αντικειμένων της μεθόδου κλάσης
κατά την ανάκτηση αυτή περιγράφεται παραπάνω, στην ενότητα "instance
methods". Τα αντικείμενα της μεθόδου κλάσης δημιουργούνται από τον
ενσωματωμένο κατασκευαστή "classmethod()".


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*).

   Οι τυπικές υλοποιήσεις δημιουργούν ένα νέο στιγμιότυπο κλάσης
   επικαλώντας τη μέθοδο "__new__()" της υπερκλάσης χρησιμοποιώντας
   "super().__new__(cls[, ...])" με κατάλληλα ορίσματα και στη
   συνέχεια τροποποιώντας τη νεο-δημιουργηθείσα παρουσία όπως
   απαιτείται πριν την επιστρέψει.

   Εάν το "__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* την καλεί μόνο μία φορά.

   Δεν είναι εγγυημένο ότι οι μέθοδοι "__del__()" καλούνται για
   αντικείμενα που εξακολουθούν να υπάρχουν κατά την έξοδο του
   διερμηνέα. Η "weakref.finalize" παρέχει έναν απλό τρόπο για την
   καταχώριση μιας συνάρτησης καθαρισμού που θα καλείται όταν ένα
   αντικείμενο συλλέγεται από τα σκουπίδια.

   Σημείωση:

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

   Είναι δυνατό για έναν κύκλο αναφοράς να εμποδίσει το πλήθος
   αναφοράς ενός να μηδενιστεί.  Σε αυτήν την περίπτωσης, ο κύκλος θα
   εντοπιστεί αργότερα και θα διαγραφεί από τον *cyclic garbage
   collector*. Μια κοινή αιτία κύκλων αναφοράς είναι όταν μια εξαίρεση
   έχει εντοπιστεί σε μια τοπική μεταβλητή. Στη συνέχεια, τα τοπικά
   του πλαισίου αναφέρονται στην εξαίρεση, η οποία αναφέρεται στο δικό
   του traceback, το οποίο αναφέρεται στους τοπικούς αριθμούς όλων των
   καρέ που έχουν εντοπιστεί στο 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__()"
   χρησιμοποιείται επίσης όταν απαιτείται μια "ανεπίσημη" αναπαράσταση
   συμβολοσειράς στιγμιοτύπων αυτής της κλάσης.

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

object.__str__(self)

   Καλείται από "str(object)" και τις ενσωματωμένες συναρτήσεις
   "__format__()" και "print()" για τον υπολογισμό της "ανεπίσημης" ή
   ωραίας εκτύπωσης συμβολοσειράς ενός αντικειμένου. Η τιμή που
   επιστρέφεται πρέπει να είναι ένα αντικείμενο string.

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

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

object.__bytes__(self)

   Καλείται από bytes για να υπολογιστεί μια παράσταση συμβολοσειράς
   byte ενός αντικειμένου. Αυτό θα πρέπει να επιστρέψει ένα "bytes"
   αντικείμενο. Η ίδια κλάση "object" δεν παρέχει αυτήν τη μέθοδο.

object.__format__(self, format_spec)

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

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

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

   Η προεπιλεγμένη υλοποίηση από την κλάση "object" θα πρέπει να λάβει
   μια κενή συμβολοσειρά *format_spec*. Αναθέτει την εντολή σε
   "__str__()".

   Άλλαξε στην έκδοση 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)".

   Μια μέθοδος πλούσια σύγκρισης μπορεί να επιστρέψει το singleton
   "NotImplemented" εάν δεν υλοποιήσει τη λειτουργία για ένα δεδομένο
   ζεύγος ορισμάτων. Σύμφωνα με τη σύμβαση, επιστρέφονται οι τιμές
   "False" και "True" για μια επιτυχημένη σύγκριση. Ωστόσο, αυτές οι
   μέθοδοι μπορούν αν επιστρέψουν οποιαδήποτε τιμή, επομένως εάν ο
   τελεστής σύγκρισης χρησιμοποιείται σε ένα Boolean περιβάλλον (π.χ.,
   στη συνθήκη μιας πρότασης "if"), η Python θα καλέσει τη συνάρτηση
   "bool()" στην τιμή για να προσδιορίσει εάν το αποτέλεσμα είναι
   αληθές ή ψευδές.

   Από προεπιλογή, το "object" υλοποιεί την "__eq__()" χρησιμοποιώντας
   την "is", επιστρέφοντας "NotImplemented" σε περίπτωση ψευδούς
   σύγκρισης: "True if x is y else NotImplemented". Για την
   "__ne__()", από προεπιλογή αναθέτει σε "__eq__()" και αντιστρέφει
   το αποτέλεσμα εκτός αν είναι "NotImplemented". Δεν υπάρχουν άλλες
   σιωπηρές σχέσεις μεταξύ των τελεστών σύγκρισης ή των προεπιλεγμένων
   υλοποιήσεων∙ για παράδειγμα, το αληθές του "(x<y or x==y)" δεν
   συνεπάγεται "x<=y". Για να δημιουργήσετε αυτόματα λειτουργίες
   ταξινόμησης από μία μόνο ριζική λειτουργία, ανατρέξτε στο
   "functools.total_ordering()".

   Από προεπιλογή, η κλάση "object" παρέχει υλοποιήσεις συμβατές με
   Value comparisons: η ισότητα συγκρίνει σύμφωνα με την ταυτότητά του
   αντικειμένου και οι συγκρίσεις κατά σειρά κάνουν raise "TypeError".
   Κάθε προεπιλεγμένη μέθοδος μπορεί να δημιουργήσει αυτά τα
   αποτελέσματα απευθείας, αλλά μπορεί επίσης να επιστρέψει την τιμή
   "NotImplemented".

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

   Δεν υπάρχουν εκδόσεις αυτών των μεθόδων με εναλλασσόμενα ορίσματα
   (που χρησιμοποιούνται όταν το αριστερό όρισμα δεν υποστηρίζει τη
   λειτουργία, αλλά το δεξί όρισμα υποστηρίζει)∙ αντίθετα, οι
   "__lt__()" και "__gt__()" είναι η αντανάκλαση η μία της άλλης, οι
   "__le__()" και "__ge__()" είναι η αντανάκλαση η μία της άλλης, και
   οι "__eq__()" και "__ne__()" είναι η δική τους αντανάκλαση. Εάν οι
   τελεστέοι είναι διαφορετικών τύπων και ο τύπος του δεξιού τελεστέου
   είναι μια άμεση ή έμμεση υποκλάση του τύπου του αριστερού
   τελεστέου, η ανακλώμενη μέθοδος του δεξιού τελεστέου έχει
   προτεραιότητα, διαφορετικά η μέθοδος του αριστερού τελεστέου έχει
   προτεραιότητα. Η εικονική υποκλάση δεν λαμβάνεται υπόψη.

   Όταν καμία κατάλληλη μέθοδος δεν επιστρέφει καμία τιμή εκτός από
   την "NotImplemented", οι τελεστές "==" και "!=" θα επιστρέψουν στις
   τιμές "is" και "is not", αντίστοιχα.

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)"".

   Εάν μια κλάση δεν ορίζει μια μέθοδο "__eq__()", δεν θα πρέπει να
   ορίζει ούτε μια λειτουργία "__hash__()" ∙ εάν ορίζει τη "__eq__()"
   αλλά όχι τη "__hash__()", τα στιγμιότυπα της δεν θα είναι
   χρησιμοποιήσιμες ως στοιχεία σε συλλογές που μπορούν να
   κατακερματιστούν.  Εάν μια κλάση ορίζει αντικείμενα που μπορούν να
   μεταβληθούν και υλοποιεί μια μέθοδο "__eq__()", δεν θα πρέπει να
   υλοποιεί τη "__hash__()", καθώς η υλοποίηση των συλλογών *hashable*
   απαιτεί η τιμή hash ενός κλειδιού να είναι αμετάβλητη (εάν η τιμή
   hash του αντικειμένου αλλάξει, θα βρίσκεται σε λάθος κάδο hash).

   Οι κλάσεις που ορίζονται από τον χρήστη έχουν από προεπιλογή τις
   μεθόδους "__eq__()" και "__hash__()" από προεπιλογή (κληρονομούνται
   από την κλάση "object") ∙ με αυτές, όλα τα αντικείμενα συγκρίνονται
   άνισα (εκτός από τον εαυτό τους) και το "x.__hash__()" επιστρέφει
   μια κατάλληλη τιμή έτσι ώστε το "x == y" να υπονοεί ότι το "x is y"
   και "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.Αυτό έχει ως στόχο να παρέχει προστασία από άρνηση
     υπηρεσίας που προκαλείται από προσεκτικά επιλεγμένες εισόδους που
     εκμεταλλεύονται τη χειρότερη περίπτωση απόδοσης μιας εισαγωγής
     ψηφίου, πολυπλοκότητας *O*(*n*^2).  Δείτε
     http://ocert.org/advisories/ocert-2011-003.html για
     λεπτομέρειες.Η αλλαγή των τιμών κατακερματισμού επηρεάζει τη
     σειρά επανάληψης των συνόλων. Η Python δεν έχει δώσει ποτέ
     εγγυήσεις σχετικά με αυτήν τη σειρά (και συνήθως ποικίλει μεταξύ
     εκδόσεων 32-bit και 64-bit).Δείτε επίσης "PYTHONHASHSEED".

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

object.__bool__(self)

   Καλείται για την υλοποίηση ελέγχου τιμών αλήθειας και την
   ενσωματωμένη λειτουργία "bool()" ∙ θα πρέπει να επιστρέφει "False"
   ή "True".  Όταν αυτή η μέθοδος δεν έχει οριστεί, καλείται η
   "__len__()", εάν έχει οριστεί, και το αντικείμενο θεωρείται αληθές
   εάν το αποτέλεσμα του είναι μη μηδενικό.  Εάν μια κλάση δεν ορίζει
   ούτε "__len__()" ούτε "__bool__()", (κάτι που ισχύει για την ίδια
   την κλάση "object"), όλα τα στιγμιότυπα της θεωρούνται αληθείς.


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

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

object.__getattr__(self, name)

   Καλείται όταν η πρόσβαση προεπιλεγμένου χαρακτηριστικού αποτυγχάνει
   με μια "AttributeError" (είτε η "__getattribute__()" κάνει raise
   μια "AttributeError" επειδή το *name* δεν είναι χαρακτηριστικό
   στιγμιοτύπου ή χαρακτηριστικό στο δέντρο κλάσης για το "self" ∙ ή η
   "__get__()" μια ιδιότητας *name* κάνει raise μια "AttributeError").
   Αυτή η μέθοδος θα πρέπει είτε να επιστρέψει την (υπολογισμένη) τιμή
   του χαρακτηριστικού είτε να κάνει raise μια εξαίρεση
   "AttributeError". Η ίδια η κλάση "object" δεν παρέχει αυτήν τη
   μέθοδο.

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

object.__getattribute__(self, name)

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

   Σημείωση:

     Αυτή η μέθοδος μπορεί ακόμα να παρακαμφθεί κατά την αναζήτηση
     ειδικών μεθόδων ως αποτέλεσμα σιωπηρής επίκλησης μέσω σύνταξης
     γλώσσας ή built-in functions. Βλ. Αναζήτηση ειδικής μεθόδου.

   Για συγκεκριμένες προσβάσεις ευαίσθητων χαρακτηριστικών, δημιουργεί
   ένα 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)

   Καλείται όταν η "dir()" καλείται στο αντικείμενο. Πρέπει να
   επιστραφεί ένα iterable. Η "dir()" μετατρέπει το iterable που
   επιστρέφεται σε λίστα και τον ταξινομεί.


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

module.__getattr__()
module.__dir__()

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

Η συνάρτηση "__dir__" δεν πρέπει να δέχεται ορίσματα και να επιστρέφει
μια επαναλαμβανόμενη σειρά συμβολοσειρών που αντιπροσωπεύει τα ονόματα
που είναι προσβάσιμα στο module. Εάν υπάρχει, αυτή η συνάρτηση
παρακάμπτει την τυπική αναζήτηση "dir()" σε ένα module.

module.__class__

Για μια πιο λεπτομερή προσαρμογή της συμπεριφοράς του 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 είναι
πλέον εγγράψιμο.

Added in version 3.7: Τα χαρακτηριστικά "__getattr__" και "__dir__"
του module.

Δείτε επίσης:

  **PEP 562** - Module __getattr__ and __dir__
     Περιγράφει τις συναρτήσεις "__getattr__" και "__dir__" σε
     modules.


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

Οι παρακάτω μέθοδοι ισχύουν μόνο όταν ένα στιγμιότυπο της κλάσης που
περιέχει τη μέθοδο (μια λεγόμενη κλάση *περιγραφέα*) εμφανίζεται μια
*ιδιοκτήτρια* κλάση (ο περιγραφέας πρέπει να βρίσκεται είτε στο λεξικό
της κλάσης της ιδιοκτήτριας είτε στο λεξικό κλάσης κάποιου από τους
γονείς της).  Στα παρακάτω παραδείγματα, "το χαρακτηριστικό"
αναφέρεται στο χαρακτηριστικό του οποίου το όνομα είναι το κλειδί της
ιδιότητας στο "__dict__" της ιδιοκτήτριας κλάσης.  Η ίδια η κλάση
"object" δεν υλοποιεί κανένα από αυτά τα πρωτόκολλα.

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* της ιδιοκτήτρια κλάσης.

Τα στιγμιότυπα περιγραφέων μπορείς επίσης να έχουν διαθέσιμο το
χαρακτηριστικό "__objclass__":

object.__objclass__

   Το χαρακτηριστικό "__objclass__" ερμηνεύεται από το module
   "inspect" ως ένδειξη κλάσης στην οποία ορίστηκε το αντικείμενο (η
   κατάλληλη ρύθμιση αυτής μπορεί να βοηθήσει στην ανάκτηση
   πληροφοριών κατά την εκτέλεση για δυναμικά χαρακτηριστικά κλάσεων).
   Για αυτά που μπορούν να κληθούν, μπορεί να υποδεικνύει ότι ένα
   στιγμιότυπο του δεδομένου τύπου (ή μιας υποκλάσης του) αναμένεται ή
   απαιτείται ως το πρώτο όρισμα θέσεως (για παράδειγμα, η CPython
   θέτει αυτήν την ιδιότητα για μη δεσμευμένες μεθόδους που έχουν
   υλοποιηθεί σε 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)".

Υπερ-Δέσμευση
   Μια διακεκομμένη αναζήτηση όπως "super(A, a).x" αναζητά το
   "a.__class__.__mro__" για μια βασική κλάση "B" μετά το "A" και, στη
   συνέχεια, επιστρέφει το "B.__dict__['x'].__get__(a, A)".  Εάν δεν
   είναι περιγραφέας, το "x" επιστρέφεται αμετάβλητο.

Για δεσμεύσεις στιγμιοτύπου, η προτεραιότητα της κλήση του περιγραφέα
εξαρτάται από το ποιες μέθοδοι περιγραφέα έχουν οριστεί.  Ένα
περιγραφέας μπορεί να ορίσει οποιονδήποτε συνδυασμό των "__get__()",
"__set__()" και "__delete__()". Αν δεν ορίσει τη μέθοδο "__get__()",
τότε η πρόσβαση στην ιδιότητα θα επιστρέψει το ίδιο το αντικείμενο του
περιγραφέα, εκτός αν υπάρχει τιμή στο λεξικό στιγμιοτύπου του
αντικειμένου. Αν ο περιγραφέας ορίζει τη μέθοδο "__set__()" και/ή
"__delete__()", θεωρείται περιγραφέας δεδομένων∙ αν δεν ορίζει καμία
από τις δύο, είναι μη-περιγραφέας δεδομένων. Συνήθως, οι περιγραφείς
δεδομένων ορίζουν και τις δύο "__get__()" και "__set__()", ενώ οι
μη-περιγραφείς δεδομένων έχουν μόνο τη μέθοδο "__get__()". Οι
περιγραφείς δεδομένων που έχουν ορίσει "__get__()" και "__set__()"
(και/ή "__delete__()") υπερισχύουν πάντα από έναν επαναπροσδιορισμό
στο λεξικό στιγμιοτύπου. Αντίθετα, οι μη περιγραφείς δεδομένων μπορούν
να παρακαμφθούν από στιγμιότυπα.

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

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


3.3.2.4. __slots__
~~~~~~~~~~~~~~~~~~

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

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

object.__slots__

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

Σημειώσεις σχετικά με τη χρήση *__slots__*:

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

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

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

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

* Η ενέργεια μιας δήλωσης *__slots__* δεν περιορίζεται μόνο στην κλάση
  όπου ορίζεται. Τα *__slots__* που δηλώνονται σε γονικές κλάσεις
  είναι διαθέσιμα και στις θυγατρικές κλάσεις. Ωστόσο, οι θυγατρικές
  κλάσεις θα αποκτήσουν ένα "__dict__" και *__weakref__*, εκτός αν
  δηλώσουν και οι ίδιες *__slots__* (τα οποία θα πρέπει να περιέχουν
  μόνο τα *επιπλέον* ονόματα slots).

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

* Θα γίνει raise "TypeError" αν οριστούν μη κενά *__slots__* σε μια
  κλάση που προέρχεται από έναν ""variable-length" ενσωματωμένο τύπο",
  όπως οι "int", "bytes", και "tuple".

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

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

* Η ανάθεση στη "__class__" λειτουργεί μόνο αν και οι δύο κλάσεις
  έχουν τα ίδια *__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* είναι τότε η νέα υποκλάση. Εάν οριστεί ως μια κανονική
   μέθοδος στιγμιοτύπου, αυτή η μέθοδος μετατρέπεται σιωπηρά σε μέθοδο
   κλάσης.

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

      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)".

   Added in version 3.6.

Όταν δημιουργείται μια κλάση, η "type.__new__()" σαρώνει τις
μεταβλητές κλάσης και πραγματοποιεί επανάκληση σε εκείνες με ένα
"__set_name__()" hook.

object.__set_name__(self, owner, name)

   Καλείται αυτόματα τη στιγμή που δημιουργείται η ιδιοκτήτρια κλάση
   *owner*. Το αντικείμενο έχει εκχωρηθεί στο *name* σε αυτήν την
   κλάση:

      class A:
          x = C()  # Automatically calls: x.__set_name__(A, 'x')

   Εάν η μεταβλητή κλάσης εκχωρηθεί μετά τη δημιουργία της κλάσης, η
   "__set_name__()" δεν θα κληθεί αυτόματα. Εάν χρειάζεται, η
   "__set_name__()" μπορεί να κληθεί απευθείας:

      class A:
         pass

      c = C()
      A.x = c                  # The hook is not called
      c.__set_name__(A, 'x')   # Manually invoke the hook

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

   Added in version 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
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

object.__mro_entries__(self, bases)

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

Δείτε επίσης:

  "types.resolve_bases()"
     Επιλύστε δυναμικά βάσεις που δεν είναι στιγμιότυπα του "type".

  "types.get_original_bases()"
     Ανακτήσετε τις "αρχικές βάσεις" μιας κλάσης πριν από τις
     τροποποιήσεις από "__mro_entries__()".

  **PEP 560**
     Βασική υποστήριξη για modules τύπων και γενικούς τύπους.


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 3.6 και μεταγενέστερα, το κελί "__class__" μεταβιβάζεται
στην μετακλάση ως μια καταχώρηση "__classcell__" στον χώρο ονομάτων
της κλάσης. Εάν υπάρχει, αυτό πρέπει να διαδοθεί μέχρι την κλήση
"type.__new__", προκειμένου η κλάση να έχει ως αποτέλεσμα να
αρχικοποιηθεί σωστά ώστε να γίνει σωστά. Αν δεν το κάνετε αυτό θα έχει
ως αποτέλεσμα μια "RuntimeError" στην Python 3.8.

Κατά τη χρήση της προεπιλεγμένης μετακλάσης "type" ή οποιασδήποτε
μετακλάσης που τελικά καλεί "type.__new__", τα ακόλουθα πρόσθετα
βήματα προσαρμογής καλούνται μετά τη δημιουργία του αντικείμενου
κλάσης:

1. Η μέθοδος "type.__new__" συλλέγει όλα τα χαρακτηριστικά στον χώρο
   ονομάτων της κλάσης που ορίζουν μια μέθοδο "__set_name__()" ∙

2. Αυτές οι μέθοδοι "__set_name__" καλούνται με την κλάση που ορίζεται
   και το εκχωρημένο όνομα του συγκεκριμένου χαρακτηριστικού∙

3. Το άγκιστρο "__init_subclass__()" καλείται στον άμεσο γονέα της
   νέας κλάσης στη σειρά ανάλυσης της μεθόδου.

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

Όταν δημιουργείται μια νέα κλάση από "type.__new__", το αντικείμενο
που παρέχεται ως παράμετρος στο χώρο ονομάτων αντιγράφεται σε μια νέα
ταξινομημένη αντιστοίχιση και το αρχικό αντικείμενο απορρίπτεται. Το
νέο αντίγραφο τυλίγεται σε έναν διακομιστή μεσολάβησης μόνο για
ανάγνωση, ο οποίος γίνεται το χαρακτηριστικό "__dict__" του
αντικειμένου κλάσης.

Δείτε επίσης:

  **PEP 3135** - Νέο super
     Περιγράφει την σιωπηρή αναφορά κλεισίματος "__class__"


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

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


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

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

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

type.__instancecheck__(self, instance)

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

type.__subclasscheck__(self, subclass)

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

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

Δείτε επίσης:

  **PEP 3119** - Εισάγοντας τις Αφηρημένες Βασικές Κλάσεις
     Περιλαμβάνει την προδιαγραφή για την προσαρμογή της συμπεριφορά
     της "isinstance()" και της "issubclass()" μέσω των
     "__instancecheck__()" και "__subclasscheck__()", με κίνητρο για
     αυτήν τη λειτουργικότητα στο πλαίσιο της προσθήκης Αφηρημένης
     Βασικής Κλάσης (δείτε το module "abc") στη γλώσσα.


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 "enum":

   >>> 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...])

   Καλείται όταν το στιγμιότυπο "καλείται" ως συνάρτηση∙ εάν αυτή η
   μέθοδος οριστεί, το "x(arg1, arg2, ...)" μεταφράζεται χονδρικά σε
   "type(x).__call__(x, arg1, ...)". Η ίδια η κλάση "object" δεν
   παρέχει αυτήν τη μέθοδο.


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

Οι ακόλουθες μέθοδοι μπορούν να οριστούν για την υλοποίηση
αντικειμένων κοντέινερ. Καμία από αυτές δεν παρέχεται από την ίδια την
κλάση "object". Τα κοντέινερ είναι συνήθως *sequences* (όπως "lists" ή
"tuples") ή *mappings* (όπως *dictionaries*), αλλά τα λεξικά μπορούν
επίσης να αντιπροσωπεύουν άλλα κοντέινερ.  Το πρώτο σύνολο μεθόδων
χρησιμοποιείται είτε για την εξομοίωση μιας ακολουθίας είτε για την
εξομοίωση μιας αντιστοίχισης∙ η διαφορά είναι ότι για μια ακολουθία,
τα επιτρεπόμενα κλειδιά θα πρέπει να είναι οι ακέραιοι *k* για τους
οποίους "0 <= k < N" όπου *N* είναι το μήκος της ακολουθίας, ή
αντικείμενα "slice", τα οποία ορίζουν ένα εύρος στοιχείων.  Συνίσταται
επίσης οι αντιστοιχίσεις να παρέχουν τις μεθόδους "keys()",
"values()", "items()", "get()", "clear()", "setdefault()", "pop()",
"popitem()", "copy()", και "update()" όπου συμπεριφέρονται παρόμοια με
εκείνα για τα τυπικά αντικείμενα "dictionary" της Python.  Το module
"collections.abc" παρέχει μια "MutableMapping" *abstract base class*
για να βοηθήσει στη δημιουργία αυτών των μεθόδων από ένα βασικό σύνολο
"__getitem__()", "__setitem__()", "__delitem__()", και "keys()".

Οι μεταβλητές ακολουθίες θα πρέπει να παρέχουν μεθόδους "append()",
"clear()", "count()", "extend()", "index()", "insert()", "pop()",
"remove()", και "reverse()", όπως τα πρότυπα Python "list"
αντικείμενα. Τέλος, οι τύποι ακολουθιών θα πρέπει να υλοποιούν
πρόσθεση (που σημαίνει συνένωση) και πολλαπλασιασμό (δηλαδή επανάληψη)
ορίζοντας τις μεθόδους "__add__()", "__radd__()", "__iadd__()",
"__mul__()", "__rmul__()" και "__imul__()" που περιγράφονται παρακάτω∙
δεν θα πρέπει να ορίζουν άλλους αριθμητικούς τελεστές.

Αυτό συνίσταται τόσο οι αντιστοιχίσεις όσο και οι ακολουθίες να
εφαρμόζουν τη μέθοδο "__contains__()" για να επιτρέπεται η
αποτελεσματική χρήση του τελεστή "in" ∙ για αντιστοιχίσεις, το "in" θα
πρέπει να αναζητήσει τα κλειδιά της αντιστοίχισης∙ για ακολουθίες θα
πρέπει να αναζητήσει τις τιμές.  Συνίσταται περαιτέρω τόσο οι
αντιστοιχίσεις όσο και οι ακολουθίες να εφαρμόζουν τη μέθοδο
"__iter__()" για να επιτρέπεται η αποτελεσματική επανάληψη μέσω του
κοντέινερ∙ για αντιστοιχίσεις, η "__iter__()" θα πρέπει να
επαναλαμβάνεται μέσω των κλειδιών του αντικειμένου∙ για ακολουθίες, θα
πρέπει να επαναλαμβάνεται μέσω των τιμών.

object.__len__(self)

   Καλείται για την υλοποίηση της ενσωματωμένης συνάρτησης "len()".
   Θα πρέπει να επιστρέψει το μήκος του αντικειμένου, ένας ακέραιος
   αριθμός ">=" 0.  Επίσης, ένα αντικείμενο που δεν ορίζει μια μέθοδο
   "__bool__()" και του οποίου η μέθοδος "__len__()" επιστρέφει μηδέν,
   θεωρείται ψευδές σε ένα Boolean περιβάλλον.

   Στο CPython, το μήκος απαιτείται να είναι το πολύ "sys.maxsize".
   Εάν το μήκος είναι μεγαλύτερο από "sys.maxsize" ορισμένες
   δυνατότητες (όπως "len()") ενδέχεται να αυξήσουν το
   "OverflowError".  Για να αποφευχθεί να γίνει raise "OverflowError"
   από τον έλεγχο τιμής αλήθειας, ένα αντικείμενο πρέπει να ορίσει μια
   μέθοδο "__bool__()".

object.__length_hint__(self)

   Καλείται για υλοποίηση "operator.length_hint()". Θα πρέπει να
   επιστρέψει ένα εκτιμώμενο μήκος για το αντικείμενο (το οποίο μπορεί
   να είναι μεγαλύτερο ή μικρότερο από το πραγματικό μήκος). Το μήκος
   πρέπει να είναι ένας ακέραιος αριθμός ">=" 0. Η τιμή επιστροφής
   μπορεί επίσης να είναι "NotImplemented", η οποία αντιμετωπίζεται με
   τον ίδιο τρόπο σαν να μην υπήρχε καθόλου η μέθοδος
   "__length_hint__". Αυτή η μέθοδος είναι καθαρά βελτιστοποίηση και
   δεν απαιτείται ποτέ για ορθότητα.

   Added in version 3.4.

Σημείωση:

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

     a[1:2] = b

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

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

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

object.__getitem__(self, key)

   Καλείται για την υλοποίηση αξιολόγησης του "self[key]". Για τους
   τύπους *sequence*, τα αποδεκτά κλειδιά πρέπει να είναι ακέραιοι.
   Προαιρετικά, ενδέχεται να υποστηρίζουν επίσης αντικείμενα "slice".
   Η υποστήριξη αρνητικού ευρετηρίου είναι επίσης προαιρετική. Εάν το
   *key* είναι ακατάλληλου τύπου, μπορεί να γίνει raise το "TypeError"
   ∙ εάν το *key* είναι μια τιμή εκτός του συνόλου των ευρετηρίων για
   την ακολουθία (μετά από οποιαδήποτε ειδική ερμηνεία αρνητικών
   τιμών), το "IndexError" θα πρέπει να γίνει raise. Για τύπους
   *mapping*, εάν λείπει το *key*  (όχι στο κοντέινερ), το "KeyError"
   θα πρέπει να γίνει raise.

   Σημείωση:

     Οι βρόχοι "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)

   Αυτή η μέθοδος καλείται όταν απαιτείται ένας *iterator* για ένα
   κοντέινερ. Αυτή η μέθοδος θα πρέπει να επιστρέψει ένα νέο
   αντικείμενο 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)

   Αυτές οι μέθοδοι καλούνται να υλοποιήσουν τις δυαδικές αριθμητικές
   λειτουργίες ("+", "-", "*", "@", "/", "//", "%", "divmod()",
   "pow()", "**", "<<", ">>", "&", "^", "|"). Για παράδειγμα, για να
   αξιολογηθεί η έκφραση "x + y", όπου *x* είναι ένα στιγμιότυπο μιας
   κλάσης που έχει μια μέθοδο "__add__()", καλείται το
   "type(x).__add__(x, y)".  Η μέθοδος "__divmod__()" θα πρέπει να
   είναι ισοδύναμη με τη χρήση των "__floordiv__()" και "__mod__()";
   δεν θα πρέπει να σχετίζεται με τη "__truediv__()". Σημειώστε ότι η
   "__pow__()" θα πρέπει να ορίζεται ώστε να δέχεται ένα προαιρετικό
   τρίτο όρισμα εάν υποστηρίζεται η τριών ορισμάτων έκδοση της
   ενσωματωμένης συνάρτησης "pow()".

   Εάν μία από αυτές τις μεθόδους δεν υποστηρίζει τη λειτουργία με τα
   παρεχόμενα ορίσματα, θα πρέπει να επιστρέψει "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)

   Αυτές οι μέθοδοι καλούνται να υλοποιήσουν τις δυαδικές αριθμητικές
   λειτουργίες ("+", "-", "*", "@", "/", "//", "%", "divmod()",
   "pow()", "**", "<<", ">>", "&", "^", "|") με ανακλώμενους
   (ανταλλαγμένους) τελεστές.  Αυτές οι λειτουργίες καλούνται μόνο εάν
   οι τελεστές είναι διαφορετικών τύπων, όταν ο αριστερός τελεστής δεν
   υποστηρίζει την αντίστοιχη λειτουργία [3], ή η κλάση του δεξιού
   τελεστή προέρχεται από την κλάση του αριστερού τελεστή. [4] Για
   παράδειγμα, για να αξιολογηθεί η έκφραση "x - y", όπου *y* είναι
   ένα στιγμιότυπο μιας κλάσης που έχει μια μέθοδο "__rsub__()",
   καλείται το "type(y).__rsub__(y, x)" εάν το "type(x).__sub__(x, y)"
   επιστρέψει "NotImplemented" ή το "type(y)" είναι υποκλάση του
   "type(x)". [5]

   Σημειώστε ότι η "__rpow__()" θα πρέπει να ορίζεται ώστε να δέχεται
   ένα προαιρετικό τρίτο όρισμα εάν υποστηρίζεται η τριών ορισμάτων
   έκδοση της ενσωματωμένης συνάρτησης "pow()".

   Άλλαξε στην έκδοση 3.14: Η τριών ορισμάτων "pow()" τώρα προσπαθεί
   να καλέσει τη "__rpow__()" εάν είναι απαραίτητο. Παλαιότερα
   καλούνταν μόνο στη δύο ορισμάτων "pow()" και στον δυαδικό τελεστή
   δύναμης.

   Σημείωση:

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

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)

   Αυτές οι μέθοδοι καλούνται να υλοποιήσουν τις επαυξημένες
   αριθμητικές εκχωρήσεις ("+=", "-=", "*=", "@=", "/=", "//=", "%=",
   "**=", "<<=", ">>=", "&=", "^=", "|="). Αυτές οι μέθοδοι θα πρέπει
   να προσπαθήσουν να κάνουν τη λειτουργία επιτόπου (τροποποίηση
   *self*) και να επιστρέψουν το αποτέλεσμα (το οποίο θα μπορούσε,
   αλλά δεν χρειάζεται να είναι, *self*). Εάν δεν έχει οριστεί μια
   συγκεκριμένη μέθοδος ή εάν αυτή η μέθοδος επιστρέψει
   "NotImplemented", η επαυξημένη ανάθεση επανέρχεται στις κανονικές
   μεθόδους. Για παράδειγμα, εάν το *x* είναι ένα στιγμιότυπο μιας
   κλάσης με μια μέθοδο "__iadd__()", το "x += y" ισοδυναμεί "x =
   x.__iadd__(y)" . Εάν το "__iadd__()" δεν υπάρχει, ή εάν το
   "x.__iadd__(y)" επιστρέφει "NotImplemented", τα "x.__add__(y)" και
   "y.__radd__(x)" θεωρούνται, όπως και με την αξιολόγηση του. Σε
   ορισμένες περιπτώσεις, η επαυξημένη ανάθεση μπορεί να οδηγήσει σε
   απροσδόκητα σφάλματα (δείτε Γιατί το a_tuple[i] += ['item']
   δημιουργεί μια εξαίρεση όταν λειτουργεί η προσθήκη;), αλλά αυτή η
   συμπεριφορά είναι στην πραγματικότητα μέρος του μοντέλου δεδομένων.

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").

   Άλλαξε στην έκδοση 3.14: Η "int()" δεν αναθέτει πλέον στη μέθοδο
   "__trunc__()".


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

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

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

Για περισσότερες πληροφορίες σχετικά με τους διαχειριστές
περιβάλλοντος, ανατρέξτε στο Τύποι Διαχείρισης Περιεχομένου. Η ίδια η
κλάση "object" δεν παρέχει τις μεθόδους διαχειριστή περιβάλλοντος.

object.__enter__(self)

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

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

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

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

   Λάβετε υπόψη ότι οι μέθοδοι "__exit__()" δεν θα πρέπει να
   επαναφέρουν την εξαίρεση που μεταβιβάστηκε∙ αυτή είναι ευθύνη του
   καλούντος.

Δείτε επίσης:

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


3.3.10. Προσαρμογή ορισμάτων θέσης στην αντιστοίχιση προτύπων κλάσης
--------------------------------------------------------------------

Όταν χρησιμοποιείται ένα όνομα κλάσης σε ένα μοτίβο, τα ορίσματα θέσης
στο μοτίβο δεν επιτρέπονται από προεπιλογή, δηλαδή "case MyClass(x,
y)" δεν είναι συνήθως έγκυρη χωρίς ειδική υποστήριξη στο "MyClass".
Για να μπορέσει να χρησιμοποιήσει αυτό το είδος μοτίβου, η κλάση
πρέπει να ορίσει ένα χαρακτηριστικό *__match_args__*.

object.__match_args__

   Σε αυτήν την μεταβλητή κλάσης μπορεί να εκχωρηθεί μια πλειάδα
   συμβολοσειρών. Όταν αυτή η κλάση χρησιμοποιείται σε ένα μοτίβο
   κλάσης με ορίσματα θέσης, κάθε όρισμα θέσης θα μετατραπεί σε όρισμα
   λέξης-κλειδιού, χρησιμοποιώντας την αντίστοιχη τιμή στο
   *__match_args__* ως λέξη-κλειδί. Η απουσία αυτού του
   χαρακτηριστικού ισοδυναμεί με τη ρύθμιση του σε "()".

Για παράδειγμα, εάν το "MyClass.__match_args__" είναι "("left",
"center", "right")" αυτό σημαίνει ότι το "case MyClass(x, y)"
ισοδυναμεί με "case MyClass(left=x, center=y)". Σημειώστε ότι ο
αριθμός των ορισμάτων στο μοτίβο πρέπει να είναι μικρότερος ή ίσος με
τον αριθμό των στοιχείων στο *__match_args__* ∙ αν είναι μεγαλύτερο, η
προσπάθεια αντιστοίχισης μοτίβου θα κάνει raise μια "TypeError".

Added in version 3.10.

Δείτε επίσης:

  **PEP 634** - Αντιστοίχιση δομικών προτύπων
     Η προδιαγραφή για τη δήλωση Python "match".


3.3.11. Εξομοίωση τύπων buffer
------------------------------

Το πρωτόκολλο buffer protocol παρέχει έναν τρόπο για τα αντικείμενα
της Python να εκθέτουν αποτελεσματική πρόσβαση σε έναν πίνακα μνήμης
χαμηλού επιπέδου. Αυτό το πρωτόκολλο υλοποιείται από ενσωματωμένους
τύπους όπως "bytes" και "memoryview", και οι βιβλιοθήκες τρίτων
μπορούν να ορίσουν πρόσθετους τύπους buffer.

Ενώ οι τύπου buffer συνήθως υλοποιούνται σε C, είναι επίσης δυνατή η
υλοποίηση του πρωτοκόλλου στην Python.

object.__buffer__(self, flags)

   Καλείται όταν ζητείται buffer από τον *self* (για παράδειγμα, από
   τον κατασκευαστή "memoryview"). Το όρισμα *flags* είναι ένας
   ακέραιος αριθμός που αντιπροσωπεύει το είδος της προσωρινής μνήμης
   που ζητήθηκε, επηρεάζοντας για παράδειγμα εάν η προσωρινή μνήμη που
   επιστρέφεται είναι μόνο για ανάγνωση ή για εγγράψιμο. Η
   "inspect.BufferFlags" παρέχει έναν βολικό τρόπο ερμηνείας των
   flags. Η μέθοδος πρέπει να επιστρέψει ένα αντικείμενο "memoryview".

object.__release_buffer__(self, buffer)

   Καλείται όταν δεν χρειάζεται πλέον μια προσωρινή μνήμη. Το όρισμα
   *buffer* είναι ένα αντικείμενο "memoryview" που επιστράφηκε
   προηγουμένως από την "__buffer__()". Η μέθοδος πρέπει να
   απελευθερώσει τυχόν πόρους που σχετίζονται με το buffer. Αυτή η
   μέθοδος θα πρέπει να επιστρέψει "None". Τα αντικείμενα buffer που
   δεν χρειάζονται εκκαθάριση δεν απαιτούνται για την εφαρμογή αυτής
   της μεθόδου.

Added in version 3.12.

Δείτε επίσης:

  **PEP 688** - Κάνοντας το πρωτόκολλο buffer προσβάσιμο στην Python
     Παρουσιάζει τις μεθόδους Python "__buffer__" και
     "__release_buffer__".

  "collections.abc.Buffer"
     ABC για τύπους buffer.


3.3.12. Annotations
-------------------

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

object.__annotations__

   Αυτό το χαρακτηριστικό περιέχει τα annotations για ένα αντικείμενο.
   Είναι lazily evaluated, οπότε η πρόσβαση στο χαρακτηριστικό μπορεί
   να εκτελέσει αυθαίρετο κώδικα και να κάνει raise εξαιρέσεις. Εάν η
   αξιολόγηση είναι επιτυχής, το χαρακτηριστικό ορίζεται σε ένα λεξικό
   που αντιστοιχεί από ονόματα μεταβλητών σε annotations.

   Άλλαξε στην έκδοση 3.14: Τα annotations αξιολογούνται πλέον
   τεμπέλικα.

object.__annotate__(format)

   Ένα *annotate function*. Επιστρέφει ένα νέο αντικείμενο λεξικού που
   αντιστοιχεί ονόματα χαρακτηριστικών/παραμέτρων στις τιμές των
   annotations τους.

   Λαμβάνει μια παράμετρο μορφής που καθορίζει τη μορφή στην οποία θα
   πρέπει να παρέχονται οι τιμές των annotations. Πρέπει να είναι
   μέλος της "annotationlib.Format" enum, ή ένας ακέραιος αριθμός με
   τιμή που αντιστοιχεί σε μέλος της enum.

   Εάν μια annotate συνάρτηση δεν υποστηρίζει την ζητούμενη μορφή,
   πρέπει να κάνει raise "NotImplementedError". Οι annotate
   συναρτήσεις πρέπει πάντα να υποστηρίζουν τη μορφή "VALUE" ∙ δεν
   πρέπει να κάνουν raise "NotImplementedError()" όταν καλούνται με
   αυτή τη μορφή.

   Όταν καλείται με τη μορφή "VALUE", μια annotate συνάρτηση μπορεί να
   κάνει raise "NameError" ∙ δεν πρέπει να κάνει raise "NameError"
   όταν καλείται ζητώντας οποιαδήποτε άλλη μορφή.

   Εάν ένα αντικείμενο δεν έχει κανένα annotation, το "__annotate__"
   θα πρέπει κατά προτίμηση να ορίζεται σε "None" (δεν μπορεί να
   διαγραφεί), αντί να ορίζεται σε μια συνάρτηση που επιστρέφει ένα
   κενό dict.

   Added in version 3.14.

Δείτε επίσης:

  **PEP 649** --- Τεμπέλικη αξιολόγηση annotation χρησιμοποιώντας
  descriptors
     Παρουσιάζει την τεμπέλικη αξιολόγηση των annotations και τη
     συνάρτηση "__annotate__".


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

Για προσαρμοσμένες κλάσεις, οι σιωπηρές επικλήσεις ειδικών μεθόδων
είναι εγγυημένο ότι θα λειτουργούν σωστά μόνο εάν ορίζονται στον τύπο
ενός αντικειμένου και όχι στο λεξικό στιγμιοτύπου του αντικειμένου.
Αυτή η συμπεριφορά είναι ο λόγος για τον οποίο ο ακόλουθος κώδικας
κάνει 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.

Σημείωση:

  Τα αντικείμενα *generator iterator* που επιστράφηκαν από γεννήτριες
  διακοσμημένες με "types.coroutine()" είναι επίσης awaitable, αλλά
  δεν εφαρμόζουν το "__await__()".

object.__await__(self)

   Πρέπει να επιστρέψει ένα *iterator*.  Θα πρέπει να χρησιμοποιείται
   για την υλοποίηση *awaitable* αντικειμένων.  Για παράδειγμα, η
   "asyncio.Future" υλοποιεί αυτήν την μέθοδο ώστε να είναι συμβατή με
   την έκφραση "await". Η ίδια η κλάση "object" δεν είναι αναμονή και
   δεν παρέχει αυτήν τη μέθοδο.

   Σημείωση:

     Η γλώσσα δεν θέτει  κανέναν περιορισμό στον τύπο ή την τιμή των
     αντικειμένων που παράγονται από τον iterator που επιστρέφεται από
     το "__await__", καθώς αυτό αφορά συγκεκριμένα την υλοποίηση του
     πλαισίου ασύγχρονης εκτέλεσης (π.χ. "asyncio") που θα
     διαχειρίζεται το *awaitable* αντικείμενο.

Added in version 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)

   Ξεκινά ή συνεχίζει την εκτέλεση της coroutine.  Εάν η *τιμή* είναι
   "None", αυτό ισοδυναμεί με την προώθηση του iterator που
   επιστρέφεται "__await__()".  Εάν η *τιμή* δεν είναι "None", αυτή η
   μέθοδος εκχωρεί στη μέθοδο "send()" του iterator που προκάλεσε την
   αναστολή της coroutine.  Το αποτέλεσμα (επιστρεφόμενη τιμή,
   "StopIteration", ή άλλη εξαίρεση) είναι το ίδιο όπως όταν γίνεται
   επανάληψη πάνω από την τιμή επιστροφής "__await__()" , που
   περιγράφεται παραπάνω.

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

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

   Άλλαξε στην έκδοση 3.12: Η δεύτερη υπογραφή (type[, value[,
   traceback]])  έχει καταργηθεί και μπορεί να αφαιρεθεί σε μια
   μελλοντική έκδοση της Python.

coroutine.close()

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

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


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

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

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

Η ίδια η κλάση "object" δεν παρέχει αυτές τις μεθόδους.

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

Added in version 3.5.

Άλλαξε στην έκδοση 3.7: Πριν από την Python 3.7, η "__aiter__()" θα
μπορούσε να επιστρέψει ένα *αναμενόμενο* που θα επιλύονται σε ένα
*asynchronous iterator*.Ξεκινώντας με την Python 3.7, η "__aiter__()"
πρέπει να επιστρέψει ένα ασύγχρονο αντικείμενο iterator.  Εάν
επιστρέφει οτιδήποτε άλλο θα έχει ως αποτέλεσμα ένα σφάλμα
"TypeError".


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

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

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

Η ίδια η κλάση "object" δεν παρέχει αυτές τις μεθόδους.

object.__aenter__(self)

   Σημασιολογικά παρόμοια με "__enter__()", η μόνη διαφορά είναι ότι
   πρέπει να επιστρέψει ένα *awaitable*.

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

   Σημασιολογικά παρόμοια με "__exit__()", η μόνη διαφορά είναι ότι
   πρέπει να επιστρέψει ένα *awaitable*.

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

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

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

Added in version 3.5.

-[ Υποσημειώσεις ]-

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

[2] Οι μέθοδοι "__hash__()", "__iter__()", "__reversed__()",
    "__contains__()", "__class_getitem__()" και "__fspath__()" έχουν
    ειδικό χειρισμό για αυτό. Άλλες θα εξακολουθούν να κάνουν raise
    ένα "TypeError", αλλά μπορεί να το κάνουν με την αξιοποίηση της
    συμπεριφοράς ότι το "None" δεν είναι καλούμενο.

[3] Το "Δεν υποστηρίζει" εδώ σημαίνει ότι η κλάση δεν έχει τέτοια
    μέθοδο ή η μέθοδος επιστρέφει "NotImplemented".  Μην ορίσετε τη
    μέθοδο σε "None" εάν θέλετε να αναγκάσετε την επιστροφή στη μέθοδο
    ανακλώμενης του δεξιού τελεστή-αυτό θα έχει το αντίθετο αποτέλεσμα
    του ρητού *μπλοκαρίσματος* αυτού του εναλλακτικού.

[4] Για τελεστές του ίδιου τύπου, θεωρείται ότι εάν η μη ανακλώμενη
    μέθοδος (όπως "__add__()") αποτύχει τότε η λειτουργία δεν
    υποστηρίζεται, γι' αυτό δεν καλείται η ανακλώμενη μέθοδος.

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