Τύποι Built-in
**************

Οι παρακάτω κατηγορίες περιγράφουν τους standard τύπους που είναι
ενσωματωμένοι (built) μέσα στον interpreter.

Οι κύριοι ενσωματωμένοι (built) τύποι είναι αριθμοί, ακολουθίες,
αντιστοιχίσεις (mappings), κλάσεις, instances και exceptions.

Ορισμένες collection κλάσεις είναι μεταβλητές (mutable). Οι μέθοδοι
που προσθέτουν, αφαιρούν ή αναδιατάσσουν τα μέλη τους και δεν
επιστρέφουν ένα συγκεκριμένο αντικείμενο, ποτέ δεν επιστρέφουν το ίδιο
collection instance αλλά "None".

Ορισμένες λειτουργίες υποστηρίζονται από διάφορους τύπους
αντικειμένων· ειδικότερα, σχεδόν όλα τα αντικείμενα μπορούν να
συγκριθούν ως προς την ισότητα, να ελεγχθούν για την έγκυρη τιμή και
να μετατραπούν σε συμβολοσειρά (string) (με τη συνάρτηση "repr()" ή
την ελαφρώς διαφορετική συνάρτηση "str()"). Η τελευταία συνάρτηση
χρησιμοποιείται έμμεσα όταν ένα αντικείμενο γράφεται από τη συνάρτηση
"print()".


Έλεγχος Έγκυρης Τιμής
=====================

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

By default, an object is considered true unless its class defines
either a "__bool__()" method that returns "False" or a "__len__()"
method that returns zero, when called with the object. [1] If one of
the methods raises an exception when called, the exception is
propagated and the object does not have a truth value (for example,
"NotImplemented"). Here are most of the built-in objects considered
false:

* σταθερές που έχουν οριστεί ως false: "None" και "False"

* μηδέν οποιουδήποτε αριθμητικού τύπου: "0", "0,0", "0j",
  "Decimanl(0)", "Fraction(0, 1)"

* κενές ακολουθίες και collections: "''", "()", "[]", "{}", "set()",
  "range(0)"

Οι πράξεις και οι ενσωματωμένες (built-in) συναρτήσεις που έχουν
αποτέλεσμα Boolean πάντα επιστρέφουν "0" ή "False" για false και "1" ή
"True" για true, εκτός εάν δηλώνεται διαφορετικά. (Σημαντική εξαίρεση:
οι λογικές (Boolean) πράξεις "or" και "and" επιστρέφουν πάντα έναν από
τους τελεστές τους.)


Λογικές (Boolean) Πράξεις ---  "and", "or", "not"
=================================================

Αυτές είναι οι λογικές (Boolean) πράξεις, ταξινομημένες βάσει
προτεραιότητας:

+---------------+-----------------------------------+---------+
| Πράξη         | Αποτέλεσμα                        | Σημειώ  |
|               |                                   | σεις    |
|===============|===================================|=========|
| "x or y"      | αν το *x* είναι true, τότε *x*,   | (1)     |
|               | αλλιώς *y*                        |         |
+---------------+-----------------------------------+---------+
| "x and y"     | αν το *x* είναι false, τότε *x*,  | (2)     |
|               | αλλιώς *y*                        |         |
+---------------+-----------------------------------+---------+
| "not x"       | if *x* είναι false, τότε "True",  | (3)     |
|               | αλλιώς "False"                    |         |
+---------------+-----------------------------------+---------+

Σημειώσεις:

1. Αυτός είναι ένας τελεστής μικρού κυκλώματος, επομένως αξιολογεί
   μόνο το δεύτερο όρισμα αν το πρώτο είναι false.

2. Αυτός είναι ένας τελεστής μικρού κυκλώματος, επομένως αξιολογεί
   μόνο το δεύτερο όρισμα αν το πρώτο είναι true.

3. To "not" έχει χαμηλότερη προτεραιότητα από τους μη λογικούς (non-
   Boolean) τελεστές, οπότε το "not a == b" μεταφράζεται σαν "not
   (a==b)", και το "a == not b" είναι συντακτικό σφάλμα.


Συγκρίσεις
==========

Υπάρχουν οκτώ πράξεις σύγκρισης στην Python. Όλες έχουν την ίδια
προτεραιότητα (η οποία είναι υψηλότερη από αυτή των λογικών (Boolean)
πράξεων). Οι συγκρίσεις μπορεί να αλυσοδεθούν αυθαίρετα· για
παράδειγμα, το "x < y <= z" ισοδυναμεί με "x < y και y <= z", εκτός
από το ότι το *y* αξιολογείται μόνο μία φορά (αλλά και στις δύο
περιπτώσεις το *z* δεν αξιολογείται καθόλου όταν το "x < y" είναι
false).

Αυτός ο πίνακας συνοψίζει τις πράξεις σύγκρισης:

+--------------+---------------------------+
| Πράξη        | Έννοια                    |
|==============|===========================|
| "<"          | αυστηρά μικρότερο από     |
+--------------+---------------------------+
| "<="         | μικρότερο από ή ίσο       |
+--------------+---------------------------+
| ">"          | αυστηρά μεγαλύτερο από    |
+--------------+---------------------------+
| ">="         | μεγαλύτερο από ή ίσο      |
+--------------+---------------------------+
| "=="         | ίσο                       |
+--------------+---------------------------+
| "!="         | διάφορο                   |
+--------------+---------------------------+
| "is"         | ταυτότητα αντικειμένου    |
+--------------+---------------------------+
| "is not"     | αρνητική ταυτότητα        |
|              | αντικειμένου              |
+--------------+---------------------------+

Unless stated otherwise, objects of different types never compare
equal. The "==" operator is always defined but for some object types
(for example, class objects) is equivalent to "is". The "<", "<=", ">"
and ">=" operators are only defined where they make sense; for
example, they raise a "TypeError" exception when one of the arguments
is a complex number.

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

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

Η συμπεριφορά των τελεστών "is" και "is not" δεν μπορεί να είναι
προσαρμοσμένη· επίσης, μπορούν να εφαρμοστούν σε οποιαδήποτε δύο
αντικείμενα και ποτέ να μην δημιουργήσουν μία εξαίρεση.

Δύο ακόμη πράξεις με την ίδια συντακτική προτεραιότητα, "in" και "not
in", υποστηρίζονται από τύπους που είναι *iterable* ή υλοποιούν τη
μέθοδο "__contains__()".


Αριμθητικοί Τύποι --- "int", "float", "complex"
===============================================

Υπάρχουν τρεις διαφορετικοί αριθμητικοί τύποι: *integers*, *floating
point numbers* και *complex numbers*. Επιπλέον, τα Booleans είναι
υπό-τύπος ακεραίων (integers). Οι ακέραιοι αριθμοί έχουν απεριόριστη
ακρίβεια. Οι Αριθμοί κινητής υποδιαστολής (floating point numbers)
συνήθως υλοποιούνται χρησιμοποιώντας το double στη C· πληροφορίες
σχετικά με την ακρίβεια και την εσωτερική αναπαράσταση αριθμών κινητής
υποδιαστολής για το μηχάνημα στο οποίο εκτελείται το πρόγραμμά σας
είναι διαθέσιμο στο "sys.float_info". Οι μιγαδικοί αριθμοί (complex
numbers) έχουν ένα πραγματικό και φανταστικό μέρος, κάθε ένα από τα
οποία ένας αριθμός κινητής υποδιαστολής. Για να εξαγάγετε αυτά τα μέρη
από έναν μιγαδικό αριθμό *z*, χρησιμοποιήστε "z.real" και "z.imag". (Η
standard βιβλιοθήκη περιλαμβάνει τους πρόσθετους αριθμητικούς τύπους
"fractions.Fraction", για ορθολογικούς, και "decimal.Decimal", για
αριθμούς κινητής υποδιαστολής με ακρίβεια που ορίζει ο χρήστης.)

Οι αριθμοί δημιουργούνται με αριθμητικά γράμματα ή ως αποτέλεσμα
ενσωματωμένων (built-in) συναρτήσεων και τελεστών. Ακέραιοι αριθμοί
(συμπεριλαμβανομένων του εξαδικού, του οκταδικού και των δυαδικοί
αριθμών) αποδίδουν ακέραιους αριθμούς. Αριθμητικά που περιέχουν
δεκαδικό  ή εκθέτη παράγουν αριθμούς κινητής υποδιαστολής. Η
προσάρτηση του "'j'" ή του "'J'" σε ένα αριθμητικό παράγει έναν
φανταστικό αριθμό (έναν μιγαδικό αριθμό με μηδενικό πραγματικό μέρος)
το οποίο μπορείτε να προσθέσετε σε έναν ακέραιο ή κινητής υποδιαστολής
για να πάρετε έναν μιγαδικό αριθμό με πραγματικό και φανταστικό μέρος.

Μπορούν να χρησιμοποιηθούν οι κατασκευαστές "int()", "float()" και
"complex()" για να παράγουν αριθμούς συγκεκριμένου τύπου.

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

   x + complex(u, v) = complex(x + u, v)
   x * complex(u, v) = complex(x * u, x * v)

Μια σύγκριση μεταξύ αριθμών διαφορετικών τύπων συμπεριφέρεται σαν να
συγκρίνονται οι ακριβείς τιμές αυτών των αριθμών. [2]

Όλοι οι αριθμητικοί τύποι (εκτός των μιγαδικών) υποστηρίζουν τις
ακόλουθες πράξεις (για προτεραιότητες των πράξεων, βλέπε Operator
precedence):

+-----------------------+-----------------------------------+-----------+----------------------+
| Πράξη                 | Αποτέλεσμα                        | Σημειώσε  | Ολόκληρη τεκμηρίωση  |
|                       |                                   | ις        |                      |
|=======================|===================================|===========|======================|
| "x + y"               | άθροισμα του *x* και *y*          |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x - y"               | διαφορά του *x* και *y*           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x * y"               | γινόμενο των *x* και *y*          |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x / y"               | πηλίκο των *x* και *y*            |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x // y"              | ακέραιο μέρος του πηλίκου των *x* | (1)(2)    |                      |
|                       | και *y*                           |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x % y"               | υπόλοιπο του "x / y"              | (2)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "-x"                  | *x* αρνητικό                      |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "+x"                  | *x* αμετάβλητο                    |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "abs(x)"              | απόλυτη τιμή ή μέγεθος του *x*    |           | "abs()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "int(x)"              | μετατροπή του *x* σε ακέραιο      | (3)(6)    | "int()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "float(x)"            | μετατροπή του *x* σε κινητής      | (4)(6)    | "float()"            |
|                       | υποδιαστολής                      |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "complex(re, im)"     | ένας μιγαδικός αριθμός με         | (6)       | "complex()"          |
|                       | πραγματικό μέρος *re*, φανταστικό |           |                      |
|                       | μέρος *im*. Το *im* μετατρέπεται  |           |                      |
|                       | αυτόματα σε μηδέν.                |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "c.conjugate()"       | συζυγές του μιγαδικού αριθμού *c* |           |                      |
+-----------------------+-----------------------------------+-----------+----------------------+
| "divmod(x, y)"        | το ζευγάρι "(x // y, x % y)"      | (2)       | "divmod()"           |
+-----------------------+-----------------------------------+-----------+----------------------+
| "pow(x, y)"           | *x* σε δύναμη του *y*             | (5)       | "pow()"              |
+-----------------------+-----------------------------------+-----------+----------------------+
| "x ** y"              | *x* σε δύναμη του *y*             | (5)       |                      |
+-----------------------+-----------------------------------+-----------+----------------------+

Σημειώσεις:

1. Αναφέρεται επίσης ως διαίρεση ακέραιου αριθμού. Για τελεστές τύπου
   "int", το αποτέλεσμα έχει τύπο "int". Για τελεστές τύπου "float",
   το αποτέλεσμα έχει τύπο "float". Γενικά, το αποτέλεσμα είναι ένας
   ολόκληρος ακέραιος αριθμός, αν και ο τύπος του αποτελέσματος δεν
   είναι απαραίτητα "int". Το αποτέλεσμα είναι πάντα στρογγυλεμένο
   προς το μείον άπειρο: "1//2" είναι "0", "(-1)//2" είναι "-1",
   "1//(-2)" είναι "-1", και "(-1)//(-2)" είναι "0".

2. Όχι για μιγαδικούς αριθμούς. Αντίθετα μετατρέψτε σε float
   χρησιμοποιώντας "abs()" εάν είναι εφαρμόσιμο.

3. Η μετατροπή από "float" σε "int" περικόπτει, απορρίπτοντας το
   κλασματικό μέρος. Δείτε τις συναρτήσεις "math.floor()" και
   "math.ceil()" για εναλλακτικές μετατροπές.

4. το float δέχεται επίσης τις συμβολοσειρές (strings) "nan" και "inf"
   με ένα προαιρετικό πρόθεμα "+" ή "-" για το Not a Number (NaN - Όχι
   αριθμός) και θετικό ή αρνητικό άπειρο.

5. Η Python ορίζει το "pow(0, 0)" και το "0 ** 0" ως "1", όπως
   συνηθίζεται για τις γλώσσες προγραμματισμού.

6. Τα αριθμητικά κυριολεκτικά (numeric literals) που γίνονται δεκτά
   περιλαμβάνουν τα ψηφία "0" έως "9" ή οποιοδήποτε ισοδύναμο Unicode
   (σημεία κώδικα με την ιδιότητα "Nd").

   Δείτε το Thε Unicode Standard για μια πλήρη λίστα σημείων κώδικα με
   το "Nd" property.

Όλοι οι τύποι "numbers.Real" ("int" και "float") επίσης περιλαμβάνουν
τις ακόλουθες λειτουργίες:

+----------------------+-----------------------------------------------+
| Πράξη                | Αποτέλεσμα                                    |
|======================|===============================================|
| "math.trunc(x)"      | *x* μετατρέπεται σε "Integral"                |
+----------------------+-----------------------------------------------+
| "round(x[, n])"      | *x* στρογγυλοποιημένο σε *n* ψηφία,           |
|                      | στρογγυλοποιώντας το μισό σε ζυγό. Εάν το *n* |
|                      | παραλειφθεί, το default του είναι το 0.       |
+----------------------+-----------------------------------------------+
| "math.floor(x)"      | το μεγαλύτερο "Integral" <= *x*               |
+----------------------+-----------------------------------------------+
| "math.ceil(x)"       | το μικρότερο "Integral" >= *x*                |
+----------------------+-----------------------------------------------+

Για περαιτέρω αριθμητικές πράξεις δείτε τα modules "math" και "cmath".


Bitwise Πράξεις σε Ακέραιους Τύπους
-----------------------------------

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

Οι προτεραιότητες των δυαδικών πράξεων bitwise είναι όλες χαμηλότερες
από τις αριθμητικές πράξεις και υψηλότερες από τις συγκρίσεις· η
μοναδιαία πράξη "~" έχει την ίδια προτεραιότητα με τις άλλες
μοναδιαίες αριθμητικές πράξεις ("+" και "-").

Αυτός ο πίνακας παραθέτει όλες τις bitwise πράξεις ταξινομημένες σε
αύξουσα σειρά:

+--------------+----------------------------------+------------+
| Πράξη        | Αποτέλεσμα                       | Σημειώσεις |
|==============|==================================|============|
| "x | y"      | bitwise *or* των *x* και *y*     | (4)        |
+--------------+----------------------------------+------------+
| "x ^ y"      | bitwise *exclusive or* των *x*   | (4)        |
|              | και *y*                          |            |
+--------------+----------------------------------+------------+
| "x & y"      | bitwise *and* των *x* και *y*    | (4)        |
+--------------+----------------------------------+------------+
| "x << n"     | *x* ολισθημένο (shifted)         | (1)(2)     |
|              | αριστερά κατά *n* bits           |            |
+--------------+----------------------------------+------------+
| "x >> n"     | *x* ολισθημένο (shifted) δεξιά   | (1)(3)     |
|              | κατά *n* bits                    |            |
+--------------+----------------------------------+------------+
| "~x"         | τα bits του *x* αντιστραμμένα    |            |
+--------------+----------------------------------+------------+

Σημειώσεις:

1. Οι μετρήσεις αρνητικών ολισθήσεων (negative shift) είναι άκυρες και
   κάνουν raise "ValueError".

2. Μια αριστερή ολίσθηση (shift) κατά *n* bits ισοδυναμεί με
   πολλαπλασιασμό με "pow(2, n)".

3. Μια δεξιά ολίσθηση (shift) κατά *n* bits ισοδυναμεί με διαίρεση
   πατώματος με "pow(2, n)".

4. Η εκτέλεση αυτών των υπολογισμών με τουλάχιστον ένα επιπλέον bit
   επέκτασης πρόσημου σε μια αναπαράσταση ενός πεπερασμένου
   συμπληρώματος ως προς δύο (ένα ωφέλιμο bit-width "1 +
   max(x.bit_length(), y.bit_length())" ή περισσότερο) είναι αρκετό
   για να πάρει το ίδιο αποτέλεσμα σαν να υπήρχε ένας άπειρος αριθμός
   bits πρόσημου.


Περαιτέρω Μέθοδοι των Ακέραιων Τύπων
------------------------------------

Ο τύπος int υλοποιεί την "numbers.Integral" *abstract base class*.
Επιπλέον, παρέχει μερικές ακόμη μεθόδους:

int.bit_length()

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

      >>> n = -37
      >>> bin(n)
      '-0b100101'
      >>> n.bit_length()
      6

   Πιο συγκεκριμένα, εάν το "x" είναι μη μηδενικό, τότε το
   "x.bit_length()" είναι μοναδικός θετικός αριθμός "k" έτσι ώστε
   "2**(k-1) <= abs(x) < 2**k". Ισοδύναμα, όταν το "abs(x)" είναι
   αρκετά μικρό για να έχει ένα σωστά στρογγυλοποιημένο λογάριθμο,
   τότε "k = 1 + int(log(abs(x), 2))". Εάν το "x" είναι μηδέν, τότε το
   "x.bit_length()" επιστρέφει "0".

   Ισοδύναμο με:

      def bit_length(self):
          s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
          s = s.lstrip('-0b') # remove leading zeros and minus sign
          return len(s)       # len('100101') --> 6

   Added in version 3.1.

int.bit_count()

   Επιστρέφει τον αριθμό των μονάδων στην δυαδική αναπαράσταση της
   απόλυτης τιμής του ακεραίου. Αυτό είναι επίσης γνωστό ως το μέτρημα
   πληθυσμού (population count). Παράδειγμα:

      >>> n = 19
      >>> bin(n)
      '0b10011'
      >>> n.bit_count()
      3
      >>> (-n).bit_count()
      3

   Ισοδύναμο με:

      def bit_count(self):
          return bin(self).count("1")

   Added in version 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)

   Επιστρέφει ένα πίνακα από bytes που αναπαριστούν έναν ακέραιο.

   >>> (1024).to_bytes(2, byteorder='big')
   b'\x04\x00'
   >>> (1024).to_bytes(10, byteorder='big')
   b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
   >>> (-1024).to_bytes(10, byteorder='big', signed=True)
   b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
   >>> x = 1000
   >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
   b'\xe8\x03'

   Ο ακέραιος αναπαρίσταται χρησιμοποιώντας *length* bytes και η
   προεπιλεγμένη του τιμή (default) είναι 1.  Ένα "OverflowError"
   γίνεται raise αν ο ακέραιος αριθμός δεν δύναται να αναπαρασταθεί με
   τον αριθμό bytes που δόθηκε.

   Το όρισμα *byteorder* καθορίζει τη σειρά των byte που
   χρησιμοποιούνται για την αναπαράσταση του ακέραιου αριθμού, και
   έχουν προεπιλεγμένη τιμή (default) ""big"". Εάν το *byteorder*
   είναι ""big"", το πιο σημαντικό byte βρίσκεται στην αρχή του πίνακα
   των bytes. Εάν το *byteorder* είναι ""little"", το πιο σημαντικό
   byte βρίσκεται στο τέλος του πίνακα των bytes.

   Το όρισμα *signed* καθορίζει εάν το συμπλήρωμα ως προς δύο
   χρησιμοποιείται για να αντιπροσωπεύσει τον ακέραιο. Εάν το *signed*
   είναι "False" και έχει δοθεί ένας αρνητικός ακέραιος, γίνεται raise
   ένα "OverflowError". Η προεπιλεγμένη τιμή (default) για το *signed*
   είναι "False".

   Οι προεπιλεγμένες τιμές (defaults) μπορούν να χρησιμοποιηθούν για
   να μετατρέψουν βολικά έναν ακέραιο σε ένα μόνο byte αντικείμενο:

      >>> (65).to_bytes()
      b'A'

   Ωστόσο, όταν χρησιμοποιείτε προεπιλεγμένα ορίσματα, μην
   προσπαθήσετε να μετατρέψετε μια τιμή μεγαλύτερη από 255 ή
   διαφορετικά θα λάβετε ένα "OverflowError".

   Ισοδύναμο με:

      def to_bytes(n, length=1, byteorder='big', signed=False):
          if byteorder == 'little':
              order = range(length)
          elif byteorder == 'big':
              order = reversed(range(length))
          else:
              raise ValueError("byteorder must be either 'little' or 'big'")

          return bytes((n >> i*8) & 0xff for i in order)

   Added in version 3.2.

   Άλλαξε στην έκδοση 3.11: Προστιθέμενες προεπιλεγμένες τιμές
   (defaults) ορίσματος για "length" και "byteorder".

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)

   Επιστρέφει έναν ακέραιο που αναπαρίσταται από τον δοσμένο πίνακα
   των bytes.

   >>> int.from_bytes(b'\x00\x10', byteorder='big')
   16
   >>> int.from_bytes(b'\x00\x10', byteorder='little')
   4096
   >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
   -1024
   >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
   64512
   >>> int.from_bytes([255, 0, 0], byteorder='big')
   16711680

   Το όρισμα *bytes* πρέπει είτε να είναι ένα *bytes-like object* είτε
   ένα iterable που παράγει bytes.

   Το όρισμα *byteorder* καθορίζει τη σειρά byte που χρησιμοποιείται
   για την αναπαράσταση του ακέραιου αριθμού, και η προεπιλεγμένη τιμή
   (default) είναι ""big"". Εάν το *byteorder* είναι ""big"", το το
   πιο σημαντικό byte βρίσκεται στην αρχή του πίνακα των bytes. Εάν το
   *byteorder* είναι ""little"", το πιο σημαντικό byte βρίσκεται στο
   τέλος του πίνακα των bytes. Για να ζητήσετε την εγγενή σειρά των
   bytes του host συστήματος, χρησιμοποιήστε το "sys.byteorder" ως
   τιμή της σειράς byte.

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

   Ισοδύναμο με:

      def from_bytes(bytes, byteorder='big', signed=False):
          if byteorder == 'little':
              little_ordered = list(bytes)
          elif byteorder == 'big':
              little_ordered = list(reversed(bytes))
          else:
              raise ValueError("byteorder must be either 'little' or 'big'")

          n = sum(b << i*8 for i, b in enumerate(little_ordered))
          if signed and little_ordered and (little_ordered[-1] & 0x80):
              n -= 1 << 8*len(little_ordered)

          return n

   Added in version 3.2.

   Άλλαξε στην έκδοση 3.11: Προστιθέμενη προεπιλεγμένη τιμή (default)
   ορίσματος για το "byteorder".

int.as_integer_ratio()

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

   Added in version 3.8.

int.is_integer()

   Επιστρέφει "True". Υπάρχει για συμβατότητα τύπου duck με
   "float.is_integer()".

   Added in version 3.12.


Περαιτέρω Μέθοδοι για Float
---------------------------

Ο τύπος float (κινητής υποδιαστολής) υλοποιεί την "numbers.Real"
*abstract base class*. Ο float έχει επίσης τις ακόλουθες πρόσθετες
μεθόδους.

classmethod float.from_number(x)

   Μέθοδος κλάσης για την επιστροφή ενός αριθμού κινητής υποδιαστολής
   που κατασκευάζεται από έναν αριθμό *x*.

   Εάν το όρισμα είναι ακέραιος ή αριθμός κινητής υποδιαστολής,
   επιστρέφεται ένας αριθμός κινητής υποδιαστολής με την ίδια τιμή
   (εντός της ακρίβειας κινητής υποδιαστολής της Python). Εάν το
   όρισμα βρίσκεται εκτός του εύρους ενός Python float, θα κάνει raise
   μια "OverflowError".

   Για ένα γενικό αντικείμενο Python "x", "float.from_number(x)"
   ανατίθεται στο "x.__float__()". Εάν η "__float__()" δεν έχει
   οριστεί, τότε επιστρέφει στη "__index__()".

   Added in version 3.14.

float.as_integer_ratio()

   Επιστρέφει ένα ζεύγος ακεραίων των οποίων η αναλογία είναι ακριβώς
   ίση με το αρχικό float. Ο λόγος είναι στο χαμηλότερο επίπεδο και
   έχει θετικό παρονομαστή. Κάνει raise "OverflowError" στα άπειρα και
   ένα "ValueError" για NaNs.

float.is_integer()

   Επιστρέφει "True" εάν το float instance είναι πεπερασμένο με
   ακέραια τιμή και "False" διαφορετικά:

      >>> (-2.0).is_integer()
      True
      >>> (3.2).is_integer()
      False

Δύο μέθοδοι υποστηρίζουν τη μετατροπή από και προς δεκαεξαδικές
συμβολοσειρές (strings). Αφού τα floats της Python αποθηκεύονται
εσωτερικά ως δυαδικοί αριθμοί, η μετατροπή ενός float προς ή από μια
*δεκαδική* συμβολοσειρά συνήθως περιλαμβάνει ένα μικρό σφάλμα
στρογγυλοποίησης. Αντιθέτως, οι δεκαεξαδικές συμβολοσειρές επιτρέπουν
ακριβή αναπαράσταση και συγκεκριμενοποίηση των αριθμών κινητής
υποδιαστολής. Αυτό μπορεί να είναι χρήσιμο κατά το debugging και στην
αριθμητική.

float.hex()

   Επιστρέφει μια αναπαράσταση ενός αριθμού κινητής υποδιαστολής ως
   δεκαεξαδική συμβολοσειρά (string).  Για πεπερασμένους αριθμούς
   κινητής υποδιαστολής, αυτή η αναπαράσταση θα περιλαμβάνει πάντα ένα
   προπορευόμενο "0x" και ένα τελευταίο "p" και εκθέτη.

classmethod float.fromhex(s)

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

Σημειώστε ότι το "float.hex()" είναι ένα instance method, ενώ το
"float.fromhex()" είναι μια μέθοδος κλάσης.

Μια δεκαεξαδική συμβολοσειρά (string) έχει τη μορφή:

   [sign] ['0x'] integer ['.' fraction] ['p' exponent]

όπου το προαιρετικό "sign" μπορεί να είναι είτε "+" ή "-", "integer"
και "fraction" είναι συμβολοσειρές (strings) δεκαεξαδικών ψηφίων και ο
"exponent" (εκθέτης) είναι ένας δεκαδικός ακέραιος με προαιρετικό
πρόσημο. Τα πεζά ή κεφαλαία δεν είναι σημαντικά και πρέπει να υπάρχει
τουλάχιστον ένα δεκαεξαδικό ψηφίο είτε στον ακέραιο είτε στο κλάσμα.
Αυτή η σύνταξη είναι παρόμοια με τη σύνταξη που καθορίζεται στην
ενότητα 6.4.4.2 του προτύπου C99, καθώς και στη σύνταξη που
χρησιμοποιείται στην Java 1.5 και μετά. Ιδιαίτερα, η έξοδος του
"float.hex()" μπορεί να χρησιμοποιηθεί ως δεκαεξαδικό Κυριολεκτική
κινητής υποδιαστολής σε κώδικα C ή Java, και παράχθηκαν δεκαεξαδικές
συμβολοσειρές με τον χαρακτήρα μορφής "%a" της C ή το
*Double.toHexString* της Java είναι αποδεκτά από το "float.fromhex()".

Σημειώστε ότι ο εκθέτης είναι γραμμένος με δεκαδικό και όχι
δεκαεξαδικό και ότι δίνει τη δύναμη του 2 με την οποία
πολλαπλασιάζεται ο συντελεστής. Για παράδειγμα, η δεκαεξαδική
συμβολοσειρά (string) "0x3.a7p10" αντιπροσωπεύει τον αριθμό κινητής
υποδιαστολής "(3 + 10./16 + 7./16**2) * 2,0**10", ή "3740,0":

   >>> float.fromhex('0x3.a7p10')
   3740.0

Η εφαρμογή της αντίστροφης μετατροπής σε "3740.0" δίνει μία
διαφορετική δεκαεξαδική συμβολοσειρά (string) που αντιπροσωπεύει τον
ίδιο αριθμό:

   >>> float.hex(3740.0)
   '0x1.d380000000000p+11'


Περαιτέρω Μέθοδοι για Μιγαδικούς
--------------------------------

Ο τύπος "complex" υλοποιεί την "numbers.Complex" *abstract base
class*. Η "complex" έχει επίσης τις ακόλουθες πρόσθετε μεθόδους.

classmethod complex.from_number(x)

   Μέθοδος κλάσης για τη μετατροπή ενός αριθμούς σε ένα μιγαδικό
   αριθμός.

   Για ένα γενικό αντικείμενο Python "x", "complex.from_number(x)"
   ανατίθεται στο "x.__complex__()". Εάν η "__complex__()" δεν έχει
   οριστεί, τότε επιστρέφει "__float__()". Εάν η "__float__()" δεν
   έχει οριστεί, τότε επιστρέφει στη "__index__()".

   Added in version 3.14.


Κατακερματισμός των αριθμητικών τύπων
-------------------------------------

Για αριθμούς "x" και "y", πιθανώς διαφορετικών τύπων, είναι
προαπαιτούμενο ότι "hash(x) == hash(y)" όποτε "x == y" (δείτε την
τεκμηρίωση για την μέθοδο "__hash__()" για περισσότερες λεπτομέρειες).
Για την ευκολότερη εφαρμογή και αποτελεσματικότητα σε ένα εύρος
αριθμητικών τύπων (συμπεριλαμβανομένων των "int", "float",
"decimal.Decimal" και "fractions.Fraction") o κατακερματισμός της
Python για αριθμητικούς τύπους βασίζεται σε μία μόνο μαθηματική
συνάρτηση που ορίζεται για οποιονδήποτε ρητό αριθμό, και ως εκ τούτου
ισχύει για όλα τα instances "int" και "fractions.Fraction" και όλα
πεπερασμένα instances "float" και "decimal.Decimal". Ουσιαστικά, αυτή
η συνάρτηση δίνεται από το modulo μείωσης "P" για ένα σταθερό πρώτο
"P". Η τιμή του "P" διατίθεται στην Python ως χαρακτηριστικό "modulus"
του "sys.hash_info".

Αυτή τη στιγμή, ο πρώτος που χρησιμοποιείται είναι "P = 2**31 - 1" σε
μηχανήματα με μήκους 32-bit C και "P = 2**61 - 1" σε μηχανήματα με
μήκους 64-bit C.

Εδώ οι κανόνες λεπτομερώς:

* Αν το "x = m / n" είναι ένας μη αρνητικός ρητός αριθμός και το "n"
  δεν διαιρείται από "P", ορίστε το "hash(x)" ως "m * invmod(n, P) %
  P", όπου το "invmod(n, P)" μας δίνει το αντίστροφο του modulo "n"
  "P".

* Αν το "x = m / n" είναι ένας μη αρνητικός ρητός αριθμός και το "n"
  διαιρείται με το "P" (αλλά το "m" όχι) τότε το "n" δεν έχει
  αντίστροφο modulo "P" και ο κανόνας παραπάνω δεν ισχύει. Σε αυτήν
  την περίπτωση ορίστε το "hash(x)" ως σταθερή τιμή
  "sys.hash_info.inf".

* Αν "x = m / n" είναι ένας αρνητικός ρητός αριθμός τότε το "hash(x)"
  ορίζεται ως "-hash(-x)".  Αν το hash που προκύπτει είναι "-1",
  αντικαθίσταται με "-2".

* Οι συγκεκριμένες τιμές των "sys.hash_info.inf" και
  "-sys.hash_info.inf" χρησιμοποιούνται ως τιμές κατακερματισμού για
  το θετικό άπειρο ή το αρνητικό άπειρο (αντίστοιχα).

* Για έναν "complex" αριθμό "z", οι τιμές κατακερματισμού των
  πραγματικών και φανταστικών μερών συνδυάζονται με τον υπολογισμό
  "hash(z.real) + sys.hash_info.imag * hash(z.imag)", μειωμένο modulo
  "2**sys.hash_info.width" έτσι ώστε να βρίσκεται στο
  "range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width -
  1))".  Και πάλι, αν το αποτέλεσμα είναι "-1", αντικαθίσταται με
  "-2".

Για να αποσαφηνίσουμε τους παραπάνω κανόνες, εδώ είναι ένα παράδειγμα
κώδικα της Python, ισοδύναμο με το built-in hash, για τον υπολογισμό
του hash ενός ρητού αριθμού, "float", ή "complex":

   import sys, math

   def hash_fraction(m, n):
       """Compute the hash of a rational number m / n.

       Assumes m and n are integers, with n positive.
       Equivalent to hash(fractions.Fraction(m, n)).

       """
       P = sys.hash_info.modulus
       # Remove common factors of P.  (Unnecessary if m and n already coprime.)
       while m % P == n % P == 0:
           m, n = m // P, n // P

       if n % P == 0:
           hash_value = sys.hash_info.inf
       else:
           # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
           # pow(n, P-2, P) gives the inverse of n modulo P.
           hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
       if m < 0:
           hash_value = -hash_value
       if hash_value == -1:
           hash_value = -2
       return hash_value

   def hash_float(x):
       """Compute the hash of a float x."""

       if math.isnan(x):
           return object.__hash__(x)
       elif math.isinf(x):
           return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
       else:
           return hash_fraction(*x.as_integer_ratio())

   def hash_complex(z):
       """Compute the hash of a complex number z."""

       hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
       # do a signed reduction modulo 2**sys.hash_info.width
       M = 2**(sys.hash_info.width - 1)
       hash_value = (hash_value & (M - 1)) - (hash_value & M)
       if hash_value == -1:
           hash_value = -2
       return hash_value


Τύπος Boolean - "bool"
======================

Οι λογικές τιμές (Booleans) αντιπροσωπεύουν τιμές αλήθειας. Ο τύπος
"bool" έχει ακριβώς δύο σταθερές τιμές: "True" και "False".

Η ενσωματωμένη συνάρτηση "bool()" μετατρέπει οποιαδήποτε τιμή σε
λογική (boolean), αν η τιμή μπορεί να ερμηνευτεί ως τιμή αλήθειας
(βλέπε παραπάνω ενότητα Έλεγχος Έγκυρης Τιμής).

Για λογικές πράξεις, χρησιμοποιήστε τους τελεστές boolean "and", "or"
και "not". Κατά την εφαρμογή των bitwise τελεστών "&", "|", "^" σε δύο
booleans, επιστρέφουν ένα bool ισοδύναμο με τις λογικές πράξεις "and",
"or", "xor". Ωστόσο, οι λογικοί τελεστές "and", "or" και "!=" θα
πρέπει να προτιμώνται έναντι των "&", "|" και "^".

Αποσύρθηκε στην έκδοση 3.12: Η χρήση του bitwise inversion τελεστή "~"
είναι ξεπερασμένη και κάνει raise ένα σφάλμα στην Python 3.16.

Η "bool" είναι υποκλάση της "int" (βλέπε Αριμθητικοί Τύποι --- int,
float, complex). Σε πολλά αριθμητικά περιβάλλοντα, τα "False" και
"True" συμπεριφέρονται όπως οι ακέραιοι αριθμοί 0 και 1, αντίστοιχα.
Ωστόσο, δεν συνιστάται να βασίζεστε σε αυτό· πιο αναλυτικά κάντε
μετατροπή χρησιμοποιώντας τη "int()" αντ' αυτού.


Τύποι Iterator
==============

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

Μια μέθοδος πρέπει να οριστεί για τα container αντικείμενα ώστε να
παρέχει *iterable* υποστήριξη:

container.__iter__()

   Επιστρέφει ένα αντικείμενο *iterator*.  Το αντικείμενο απαιτείται
   να υποστηρίζει το πρωτόκολλο επαναλήψεων που περιγράφεται παρακάτω.
   Εάν ένας container υποστηρίζει διαφορετικούς τύπους της επανάληψης,
   μπορούν να παρασχεθούν πρόσθετες μέθοδοι για να ζητηθούν
   συγκεκριμένοι iterators για αυτούς τους τύπους επανάληψης.  (Ένα
   παράδειγμα αντικειμένου που υποστηρίζει πολλαπλές μορφές επανάληψης
   θα ήταν μια δενδρική δομή που υποστηρίζει και αμφότερες τις
   breadth-first και depth-first μορφές).  Αυτή η μέθοδος αντιστοιχεί
   στη μέθοδο "tp_iter" της δομής τύπου για αντικείμενα Python στο API
   της Python/C.

Τα ίδια τα αντικείμενα επαναλήψεων απαιτείται να υποστηρίζουν τις
ακόλουθες δύο μεθόδους, οι οποίες από κοινού αποτελούν το *iterator
protocol*:

iterator.__iter__()

   Επιστρέφει το ίδιο το αντικείμενο *iterator*.  Αυτό απαιτείται ώστε
   να επιτραπεί η χρησιμοποίηση τόσο των containers, όσο και των
   iterators με τα statements "for" και "in".  Αυτή η μέθοδος
   αντιστοιχεί στη δομή "tp_iter" των αντικειμένων της Python στο
   Python/C API.

iterator.__next__()

   Επιστρέφει το επόμενο στοιχείο από τον *iterator*.  Εάν δεν
   υπάρχουν άλλα στοιχεία, κάνει raise την εξαίρεση "StopIteration".
   Αυτή η μέθοδος αντιστοιχεί στην δομή "tp_iternext" των αντικειμένων
   της Python στο API της Python/C.

Η Python ορίζει διάφορα αντικείμενα iterator για την υποστήριξη της
επανάληψης πάνω σε γενικούς και συγκεκριμένους τύπους ακολουθιών
(sequences), λεξικά (dictionaries) και άλλες πιο εξειδικευμένες
μορφές.  Οι συγκεκριμένοι τύποι δεν είναι σημαντικοί πέρα από την
υλοποίησή του iterator πρωτοκόλλου.

Μόλις η μέθοδος "__next__()" ενός iterator κάνει raise ένα
"StopIteration", πρέπει να συνεχίσει να το κάνει σε επόμενες κλήσεις.
Υλοποιήσεις που δεν υπακούν σε αυτή την ιδιότητα θεωρούνται
εσφαλμένες.


Τύποι Generator
---------------

Οι *generator*s της Python παρέχουν έναν βολικό τρόπο για να
υλοποιήσετε το iterator πρωτόκολλο.  Εάν η μέθοδος "__iter__()" ενός
container αντικειμένου είναι υλοποιημένη ως generator, θα επιστρέψει
αυτόματα ένα αντικείμενο iterator (τεχνικά, ένα αντικείμενο generator)
που παρέχει τις "__iter__()" και "__next__()" μεθόδους. Περισσότερες
πληροφορίες σχετικά με τους generators μπορείτε να βρείτε στην the
documentation for the yield expression.


Τύποι Ακολουθίας (Sequence) --- "list", "tuple", "range"
========================================================

Υπάρχουν τρεις βασικοί τύποι ακολουθιών: lists (λίστες), tuples
(πλειάδες) και range objects (αντικείμενα εύρους). Πρόσθετοι τύποι
ακολουθίας προσαρμοσμένοι για την επεξεργασία binary data και text
strings περιγράφονται σε ειδικές ενότητες.


Κοινές Λειτουργίες Ακολουθιών (Sequences)
-----------------------------------------

Οι λειτουργίες του παρακάτω πίνακα υποστηρίζονται από τους
περισσότερους τύπους ακολουθιών, τόσο μεταβλητών (mutable) όσο και
αμετάβλητων (immutable). Η "collections.abc.Sequence" ABC παρέχεται
για να διευκολύνει τη σωστή υλοποίηση αυτών των πράξεων σε
προσαρμοσμένους τύπους ακολουθίας.

Αυτός ο πίνακας απαριθμεί τις λειτουργίες ακολουθίας ταξινομημένες
κατά αύξουσα προτεραιότητα.  Στον πίνακα, τα *s* και *t* είναι
ακολουθίες του ίδιου τύπου, τα *n*, *i*, *j* και *k* είναι ακέραιοι
αριθμοί και το *x* είναι ένα αυθαίρετο αντικείμενο που πληροί
οποιονδήποτε τύπο και περιορισμούς τιμής που επιβάλλονται από το *s*.

Οι πράξεις "in" και "not in" έχουν τις ίδιες προτεραιότητες με τις
πράξεις σύγκρισης. Οι πράξεις "+" (συνένωση) και "*" (επανάληψη) έχουν
την ίδια προτεραιότητα με τις αντίστοιχες αριθμητικές πράξεις. [3]

+----------------------------+----------------------------------+------------+
| Πράξη                      | Αποτέλεσμα                       | Σημειώσεις |
|============================|==================================|============|
| "x in s"                   | "True" αν ένα στοιχείο του *s*   | (1)        |
|                            | είναι ίσο με το *x*, αλλιώς      |            |
|                            | "False"                          |            |
+----------------------------+----------------------------------+------------+
| "x not in s"               | "False" αν ένα στοιχείο του *s*  | (1)        |
|                            | είναι ίσο με το *x*, αλλιώς      |            |
|                            | "True"                           |            |
+----------------------------+----------------------------------+------------+
| "s + t"                    | η συνένωση του *s* και *t*       | (6)(7)     |
+----------------------------+----------------------------------+------------+
| "s * n" ή "n * s"          | ίσο με την πρόσθεση του *s* στον | (2)(7)     |
|                            | εαυτό του *n* φορές              |            |
+----------------------------+----------------------------------+------------+
| "s[i]"                     | *i*ο στοιχείο του *s*, αρχή το 0 | (3)(8)     |
+----------------------------+----------------------------------+------------+
| "s[i:j]"                   | slice (υποσύνολο) του *s* από το | (3)(4)     |
|                            | *i* μέχρι το *j*                 |            |
+----------------------------+----------------------------------+------------+
| "s[i:j:k]"                 | slice (υποσύνολο) του *s* από το | (3)(5)     |
|                            | *i* μέχρι το *j* με βήμα *k*     |            |
+----------------------------+----------------------------------+------------+
| "len(s)"                   | μήκος του *s*                    |            |
+----------------------------+----------------------------------+------------+
| "min(s)"                   | μικρότερο αντικείμενο του *s*    |            |
+----------------------------+----------------------------------+------------+
| "max(s)"                   | μεγαλύτερο αντικείμενο του *s*   |            |
+----------------------------+----------------------------------+------------+

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

Εμπρόσθιοι και αντίστροφοι iterators πάνω σε μεταβλητές ακολουθίες
έχουν πρόσβαση σε τιμές χρησιμοποιώντας ένα δείκτη.  Αυτός ο δείκτης
θα συνεχίσει να βαδίζει προς τα εμπρός (ή προς τα πίσω) ακόμα και αν η
υποκείμενη ακολουθία μεταλλάσσεται.  Ο iterator τερματίζει μόνο όταν
ένα "IndexError" ή ένα "StopIteration" γίνει raise (ή όταν ο δείκτης
πέσει κάτω από το μηδέν).

Σημειώσεις:

1. Ενώ οι πράξεις "in" και "not in" χρησιμοποιούνται γενικά μόνο για
   απλό έλεγχο containment (αν στοιχείο περιέχεται σε μια δομή),
   ορισμένες εξειδικευμένες ακολουθίες (όπως όπως οι "str", "bytes"
   και "bytearray") τις χρησιμοποιούν επίσης για subsequence testing
   (έλεγχο υποακολουθίας):

      >>> "gg" in "eggs"
      True

2. Τιμές του *n* μικρότερες από το "0" αντιμετωπίζονται ως "0" (που
   δίνει μια κενή ακολουθία του ίδιου τύπου με *s*).  Σημειώστε ότι τα
   στοιχεία της ακολουθίας *s* δεν αντιγράφονται· αναφέρονται πολλές
   φορές.  Αυτό συχνά στοιχειώνει τα άτομα που ξεκινούν με Python-
   σκεφτείτε:

      >>> lists = [[]] * 3
      >>> lists
      [[], [], []]
      >>> lists[0].append(3)
      >>> lists
      [[3], [3], [3]]

   Αυτό που συνέβη είναι ότι το "[[]]" είναι μια λίστα ενός στοιχείου
   που περιέχει μία κενή λίστα, οπότε και τα τρία στοιχεία της "[[]] *
   3" είναι αναφορές σε αυτή τη μία κενή λίστα.  Η τροποποίηση
   οποιουδήποτε από τα στοιχεία της "lists" τροποποιεί αυτή τη
   μοναδική λίστα. Μπορείτε να δημιουργήσετε μια λίστα από
   διαφορετικές λίστες με αυτόν τον τρόπο:

      >>> lists = [[] for i in range(3)]
      >>> lists[0].append(3)
      >>> lists[1].append(5)
      >>> lists[2].append(7)
      >>> lists
      [[3], [5], [7]]

   Περαιτέρω επεξήγηση είναι διαθέσιμη στο λήμμα FAQ Πως φτιάχνω μια
   πολυδιάστατη λίστα;.

3. Εάν το *i* ή το *j* είναι αρνητικό, ο δείκτης είναι σχετικός με το
   τέλος της ακολουθίας *s*: το "len(s) + i" ή το "len(s) + j"
   αντικαθίσταται.  Σημειώστε όμως ότι το "-0" εξακολουθεί να είναι
   "0".

4. The slice of *s* from *i* to *j* is defined as the sequence of
   items with index *k* such that "i <= k < j".

   * If *i* is omitted or "None", use "0".

   * If *j* is omitted or "None", use "len(s)".

   * If *i* or *j* is less than "-len(s)", use "0".

   * If *i* or *j* is greater than "len(s)", use "len(s)".

   * If *i* is greater than or equal to *j*, the slice is empty.

5. Το υποσύνολο (slice) του *s* από *i* έως *j* με βήμα *k* ορίζεται
   ως η ακολουθία των στοιχείων με δείκτη "x = i + n*k" τέτοια ώστε "0
   <= n < (j-i)/k".  Με άλλα λόγια, οι δείκτες είναι "i", "i+k",
   "i+2*k", "i+3*k" και ούτω καθεξής, σταματώντας όταν φτάσουμε στο
   *j* (αλλά ποτέ δεν περιλαμβάνει το *j*).  Όταν το *k* είναι θετικό,
   τα *i* και *j* μειώνονται σε "len(s)" αν είναι μεγαλύτερα. Όταν το
   *k* είναι αρνητικό, τα *i* και *j* μειώνονται σε "len(s) - 1" αν
   είναι μεγαλύτερα.  Εάν τα *i* ή *j* παραλείπονται ή είναι "None",
   γίνονται τιμές "end" (το τέλος εξαρτάται από το πρόσημο του *k*).
   Σημειώστε ότι το *k* δεν μπορεί να είναι μηδέν. Εάν το *k* είναι
   "None", αντιμετωπίζεται όπως το "1".

6. Η συνένωση αμετάβλητων ακολουθιών (immutable sequences) οδηγεί
   πάντα σε ένα νέο αντικείμενο.  Αυτό σημαίνει ότι η δημιουργία μιας
   ακολουθίας με επαναλαμβανόμενη συνένωση θα έχει τετραγωνικό κόστος
   χρόνου εκτέλεσης (runtime cost) στο συνολικό μήκος της ακολουθίας.
   Για να πάρετε ένα γραμμικό κόστος χρόνου εκτέλεσης (runtime cost),
   πρέπει να μεταβείτε σε μία από τις παρακάτω εναλλακτικές λύσεις:

   * αν συνενώνεται αντικείμενα "str", μπορείτε να δημιουργήσετε μια
     λίστα και να χρησιμοποιήσετε την "str.join()" στο τέλος ή αλλιώς
     να γράψετε σε ένα "io.StringIO" instance και ανακτήσετε την τιμή
     της όταν ολοκληρωθεί

   * αν συνενώνεται αντικείμενα "bytes", μπορείτε να χρησιμοποιήσετε
     παρόμοια τη μέθοδο "bytes.join()" ή "io.BytesIO", ή μπορείτε να
     κάνετε in-place συνένωση (concatenation) με ένα "bytearray"
     αντικείμενο. Τα αντικείμενα "bytearray" είναι μεταβλητά και έχουν
     έναν αποτελεσματικό μηχανισμό συνολικής κατανομής
     (overallocation)

   * αν συνενώνεται αντικείμενα "tuple", επεκτείνετε μια "list" αντ'
     αυτού

   * για άλλους τύπους, ερευνήστε τη σχετική τεκμηρίωση των κλάσεων

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

8. Μια "IndexError" γίνεται raise εάν το *i* βρίσκεται εκτός του
   εύρους ακολουθίας.

-[ Μέθοδοι Ακολουθίας ]-

Οι τύποι ακολουθίας υποστηρίζουν επίσης τις ακόλουθες μεθόδους:

sequence.count(value, /)

   Επιστρέφει το συνολικό αριθμό των εμφανίσεων του *value* μέσα στην
   *sequence*.

sequence.index(value[, start[, stop])

   Επιστρέφει το δείκτη της πρώτης εμφάνισης του *value* μέσα στην
   *sequence*.

   Κάνει raise μια "ValueError" αν το *value* δεν μπορεί να βρεθεί
   μέσα στην *sequence*.

   Τα ορίσματα *start* ή *stop* επιτρέπουν αποδοτική αναζήτηση
   υποτμημάτων της ακολουθίας, ξεκινώντας από το *start* και
   τελειώνοντας στο *stop*. Αυτό είναι περίπου ισοδύναμο με το "start
   + sequence[start:stop].index(value)", μόνο που δεν αντιγράφονται
   δεδομένα.

   Προσοχή:

     Δεν υποστηρίζουν όλοι οι τύποι ακολουθιών τη χρήση των ορισμάτων
     *start* και *stop*.


Τύποι Αμετάβλητων Ακολουθιών (Sequences)
----------------------------------------

Η μόνη λειτουργία που υλοποιούν οι αμετάβλητοι γενικοί τύποι
ακολουθίας που δεν είναι υλοποιημένοι από μεταβλητούς τύπους
ακολουθίας, είναι η υποστήριξη της "hash()" built-in.

Αυτή η υποστήριξη επιτρέπει αμετάβλητες ακολουθίες, όπως οι
περιπτώσεις των "tuple", να χρησιμοποιούνται ως κλειδιά "dict" και να
αποθηκεύονται σε "set" και "frozenset" instances.

Η προσπάθεια κατακερματισμού μιας αμετάβλητης ακολουθίας που περιέχει
μη κατακερματιστέες (unhashable) τιμές θα οδηγήσει σε "TypeError".


Τύποι Μεταβλητών Ακολουθιών (Sequences)
---------------------------------------

Οι λειτουργίες του ακόλουθου πίνακα ορίζονται σε μεταβλητούς τύπους
ακολουθίας. Η "collections.abc.MutableSequence" ABC παρέχεται για να
κάνει ευκολότερη την σωστή υλοποίηση αυτών των λειτουργιών σε
προσαρμοσμένους τύπους ακολουθιών.

Στον πίνακα το *s* είναι ένα instance ενός μεταβλητού τύπου
ακολουθίας, το *t* είναι οποιοδήποτε iterable αντικείμενο και το *x*
είναι ένα αυθαίρετο αντικείμενο που πληροί οποιονδήποτε τύπο και
περιορισμούς τιμής που επιβάλλονται από το *s* (για παράδειγμα, το
"bytearray" δέχεται μόνο ακέραιους που πληρούν τον περιορισμό "0 <= x
<= 255").

+--------------------------------+----------------------------------+-----------------------+
| Πράξη                          | Αποτέλεσμα                       | Σημειώσεις            |
|================================|==================================|=======================|
| "s[i] = x"                     | το στοιχείο *i* του *s*          |                       |
|                                | αντικαθίσταται από το *x*        |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i]"                     | αφαιρεί το στοιχείο *i* από το   |                       |
|                                | *s*                              |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j] = t"                   | το υποσύνολο (slice) του *s* από |                       |
|                                | το *i* έως το *j* αντικαθίσταται |                       |
|                                | από τα περιεχόμενα του iterable  |                       |
|                                | *t*                              |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j]"                   | αφαιρεί τα στοιχεία της "s[i:j]" |                       |
|                                | από τη λίστα (παρόμοια όπως      |                       |
|                                | "s[i:j] = []")                   |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s[i:j:k] = t"                 | τα στοιχεία του "s[i:j:k]"       | (1)                   |
|                                | αντικαθίστανται από εκείνα του   |                       |
|                                | *t*                              |                       |
+--------------------------------+----------------------------------+-----------------------+
| "del s[i:j:k]"                 | αφαιρεί τα στοιχεία του          |                       |
|                                | "s[i:j:k]" από τη λίστα          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s += t"                       | επεκτείνει το *s* με τα          |                       |
|                                | περιεχόμενα του *t* (ως επί το   |                       |
|                                | πλείστον το ίδιο με το           |                       |
|                                | "s[len(s):len(s)] = t")          |                       |
+--------------------------------+----------------------------------+-----------------------+
| "s *= n"                       | ενημερώνει το *s* με το          | (2)                   |
|                                | περιεχόμενό του επαναλαμβανόμενο |                       |
|                                | *n* φορές                        |                       |
+--------------------------------+----------------------------------+-----------------------+

Σημειώσεις:

1. Αν το *k* δεν είναι ίσο με "1", το *t* πρέπει να έχει το ίδιο μήκος
   με το τμήμα που αντικαθιστά.

2. Η τιμή *n* είναι ένας ακέραιος αριθμός ή ένα αντικείμενο που
   υλοποιεί την "__index__()".  Οι μηδενικές και αρνητικές τιμές του
   *n* καθαρίζουν την ακολουθία.  Τα στοιχεία της ακολουθίας δεν
   αντιγράφονται· αναφέρονται πολλές φορές, όπως εξηγείται για το "s *
   n`" στο Κοινές Λειτουργίες Ακολουθιών (Sequences).

-[ Μέθοδοι Μεταβλητών Ακολουθιών (Sequences) ]-

Οι τύποι μεταβλητών ακολουθιών υποστηρίζουν επίσης τις ακόλουθες
μεθόδους:

sequence.append(value, /)

   Εισάγει το *value* στο τέλος της ακολουθίας Αυτό είναι ισοδύναμο με
   το να γράψουμε "seq[len(seq):len(seq)] = [value]".

sequence.clear()

   Added in version 3.3.

   Αφαιρεί όλα τα στοιχεία από την *sequence*. Αυτό είναι ισοδύναμο με
   το να γράψουμε "del sequence[:]".

sequence.copy()

   Added in version 3.3.

   Δημιουργεί ένα shallow αντίγραφο του *sequence*. Αυτό είναι
   ισοδύναμο με το να γράψουμε "sequence[:]".

   Συμβουλή:

     Η μέθοδος "copy()" δεν είναι μέρος της "MutableSequence" "ABC",
     αλλά οι περισσότερους συγκεκριμένοι μεταβλητοί τύποι ακολουθιών
     την παρέχουν.

sequence.extend(iterable, /)

   Επεκτείνει το *sequence* με τα περιεχόμενα του *iterable*. Για το
   μεγαλύτερο μέρος, αυτό είναι το ίδιο με το να γράψουμε
   "seq[len(seq):len(seq)] = iterable".

sequence.insert(index, value, /)

   Εισάγει το *value* στην *sequence* στη δοθείσα θέση *index*. Αυτό
   είναι ισοδύναμο με το να γράψουμε "sequence[index:index] =
   [value]".

sequence.pop(index=-1, /)

   Ανακτά το στοιχείο στη θέση *index* και το αφαιρεί επίσης από την
   *sequence*. Εξ ορισμού, το τελευταίο στοιχείο στην *sequence*
   αφαιρείται και επιστρέφεται.

sequence.remove(value, /)

   Αφαιρεί το πρώτο στοιχείο από την *sequence* όπου "sequence[i] ==
   value".

   Κάνει raise μια "ValueError" αν το *value* δεν μπορεί να βρεθεί
   μέσα στην *sequence*.

sequence.reverse()

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


Λίστες
------

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

class list(iterable=(), /)

   Οι λίστες μπορούν να κατασκευαστούν με διάφορους τρόπους:

   * Χρησιμοποιείστε ένα ζεύγος αγκυλών για να δηλώσετε την κενή
     λίστα: "[]"

   * Χρησιμοποιώντας αγκύλες, διαχωρίζοντας τα στοιχεία με κόμματα:
     "[a]", "[a, b, c]"

   * Χρήση ενός list comprehension: "[x for x in iterable]"

   * Χρήση του κατασκευαστή τύπου (type constructor): "list()" ή
     "list(iterable)"

   Ο κατασκευαστής (constructor) δημιουργεί μια λίστα της οποίας τα
   στοιχεία είναι τα ίδια και με την ίδια σειρά όπως τα στοιχεία του
   *iterable*.  Το *iterable* μπορεί να είναι είτε μια ακολουθία, είτε
   ένας container που υποστηρίζει την επανάληψη, ή ένα αντικείμενο
   iterator.  Εάν το *iterable* είναι ήδη μια λίστα, δημιουργείται ένα
   αντίγραφο και επιστρέφεται, παρόμοια με την "iterable[:]". Για
   παράδειγμα, η "list('abc')" επιστρέφει "['a', 'b', 'c']" και η
   "list( (1, 2, 3) )" επιστρέφει "[1, 2, 3]". Αν δεν δοθεί κανένα
   όρισμα, ο κατασκευαστής δημιουργεί μία νέα κενή λίστα, "[]".

   Πολλές άλλες λειτουργίες παράγουν επίσης λίστες,
   συμπεριλαμβανομένης της built-in "sorted()".

   Οι λίστες υλοποιούν όλες τις common και mutable λειτουργίες
   ακολουθίας. Οι λίστες παρέχουν επίσης την ακόλουθη πρόσθετη μέθοδο:

   sort(*, key=None, reverse=False)

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

      η "sort()" δέχεται δύο ορίσματα που μπορούν να περάσουν μόνο με
      τη λέξη-κλειδί (keyword-only arguments):

      το *key* καθορίζει μια συνάρτηση ενός ορίσματος που
      χρησιμοποιείται για την εξαγωγή ενός κλειδιού σύγκρισης
      (comparison key) από κάθε στοιχείο της λίστας (για παράδειγμα,
      "key=str.lower"). Το κλειδί που αντιστοιχεί σε κάθε στοιχείο της
      λίστας υπολογίζεται μία φορά και στη συνέχεια χρησιμοποιείται
      για ολόκληρη τη διαδικασία ταξινόμησης. Η προεπιλεγμένη τιμή
      (default) "None" σημαίνει ότι τα στοιχεία της λίστας
      ταξινομούνται απευθείας χωρίς να υπολογίζεται ξεχωριστή τιμή
      κλειδιού.

      Το utility "functools.cmp_to_key()" είναι διαθέσιμο για τη
      μετατροπή μια συνάρτηση *cmp* στυλ 2.x σε συνάρτηση *key*.

      η *reverse* είναι μια λογική (boolean) τιμή.  Αν τεθεί σε
      "True", τότε τα στοιχεία της λίστας ταξινομούνται σαν να ήταν
      αντίστροφη κάθε σύγκριση.

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

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

      Για παραδείγματα ταξινόμησης και ένα σύντομο tutorial, δείτε
      Sorting Techniques.

      Ενώ μια λίστα ταξινομείται, το αποτέλεσμα της προσπάθειας
      μετάλλαξης, ή ακόμα και η επιθεώρηση, της λίστας είναι
      απροσδιόριστη.  Η υλοποίηση της Python στη C κάνει την λίστα να
      εμφανίζεται κενή για όλη τη διάρκεια, και κάνει raise
      "ValueError" αν ανιχνεύσει ότι η λίστα έχει μεταλλαχθεί κατά τη
      διάρκεια μιας ταξινόμησης.

Thread safety: Reading a single element from a "list" is *atomic*:

   lst[i]   # list.__getitem__

The following methods traverse the list and use *atomic* reads of each
item to perform their function. That means that they may return
results affected by concurrent modifications:

   item in lst
   lst.index(item)
   lst.count(item)

All of the above methods/operations are also lock-free. They do not
block concurrent modifications. Other operations that hold a lock will
not block these from observing intermediate states.All other
operations from here on block using the per-object lock.Writing a
single item via "lst[i] = x" is safe to call from multiple threads and
will not corrupt the list.The following operations return new objects
and appear *atomic* to other threads:

   lst1 + lst2    # concatenates two lists into a new list
   x * lst        # repeats lst x times into a new list
   lst.copy()     # returns a shallow copy of the list

Methods that only operate on a single elements with no shifting
required are *atomic*:

   lst.append(x)  # append to the end of the list, no shifting required
   lst.pop()      # pop element from the end of the list, no shifting required

The "clear()" method is also *atomic*. Other threads cannot observe
elements being removed.The "sort()" method is not *atomic*. Other
threads cannot observe intermediate states during sorting, but the
list appears empty for the duration of the sort.The following
operations may allow lock-free operations to observe intermediate
states since they modify multiple elements in place:

   lst.insert(idx, item)  # shifts elements
   lst.pop(idx)           # idx not at the end of the list, shifts elements
   lst *= x               # copies elements in place

The "remove()" method may allow concurrent modifications since element
comparison may execute arbitrary Python code (via
"__eq__()")."extend()" is safe to call from multiple threads.
However, its guarantees depend on the iterable passed to it. If it is
a "list", a "tuple", a "set", a "frozenset", a "dict" or a dictionary
view object (but not their subclasses), the "extend" operation is safe
from concurrent modifications to the iterable. Otherwise, an iterator
is created which can be concurrently modified by another thread.  The
same applies to inplace concatenation of a list with other iterables
when using "lst += iterable".Similarly, assigning to a list slice with
"lst[i:j] = iterable" is safe to call from multiple threads, but
"iterable" is only locked when it is also a "list" (but not its
subclasses).Operations that involve multiple accesses, as well as
iteration, are never atomic. For example:

   # NOT atomic: read-modify-write
   lst[i] = lst[i] + 1

   # NOT atomic: check-then-act
   if lst:
       item = lst.pop()

   # NOT thread-safe: iteration while modifying
   for item in lst:
       process(item)  # another thread may modify lst

Consider external synchronization when sharing "list" instances across
threads.  See Python support for free threading for more information.


Πλειάδες (Tuples)
-----------------

Οι πλειάδες (tuples) είναι αμετάβλητες ακολουθίες, που συνήθως
χρησιμοποιούνται για την αποθήκευση συλλογών ετερογενών δεδομένων
(όπως οι 2-tuples που παράγονται από την built-in "enumerate()"). Τα
tuples χρησιμοποιούνται επίσης για περιπτώσεις όπου μια αμετάβλητη
ακολουθία ομοιογενών δεδομένων (όπως για παράδειγμα για να επιτρέπεται
η αποθήκευση σε ένα "set" ή σε ένα "dict" instance).

class tuple(iterable=(), /)

   Οι πλειάδες (tuples) μπορούν να κατασκευαστούν με διάφορους
   τρόπους:

   * Χρήση ενός ζεύγους παρενθέσεων για να δηλωθεί το κενό tuple
     (πλειάδα): "()"

   * Χρήση ενός κόμματος στο τέλος για ένα μοναδικό tuple (πλειάδα):
     "a," ή "(a,)"

   * Διαχωρισμός στοιχείων με κόμμα: "a, b, c" ή "(a, b, c)"

   * Χρήση του ενσωματωμένου "tuple()": "tuple()" ή "tuple(iterable)"

   Ο κατασκευαστής (constructor) δημιουργεί μια πλειάδα (tuple) του
   οποίου τα στοιχεία είναι τα ίδια και στην ίδια σειρά με τα στοιχεία
   του *iterable*.  Η *iterable* μπορεί να είναι είτε μια ακολουθία,
   είτε έναν container που υποστηρίζει την επανάληψη, ή ένα
   αντικείμενο iterator.  Εάν το *iterable* είναι ήδη ένα tuple,
   επιστρέφεται αμετάβλητο. Για παράδειγμα, το "tuple('abc')"
   επιστρέφει "('a', 'b', 'c')" και το "tuple( [1, 2, 3] )" επιστρέφει
   "(1, 2, 3)". Αν δεν δοθεί κανένα όρισμα, ο κατασκευαστής δημιουργεί
   μια ένα κενό tuple, "()".

   Σημειώστε ότι στην πραγματικότητα το κόμμα είναι αυτό που κάνει ένα
   tuple (πλειάδα), όχι οι παρενθέσεις. Οι παρενθέσεις είναι
   προαιρετικές, εκτός από την περίπτωση κενού tuple ή όταν
   χρειάζονται για την αποφυγή συντακτικής ασάφειας. Για παράδειγμα, η
   "f(a, b, c)" είναι μια κλήση συνάρτησης με τρία ορίσματα, ενώ η
   "f((a, b, c))" είναι μια συνάρτηση κλήση συνάρτησης με ένα 3-tuple
   ως μοναδικό όρισμα.

   Τα Tuples υλοποιούν όλες τις πράξεις ακολουθιών common.

Για ετερογενείς συλλογές δεδομένων όπου η πρόσβαση με βάση το όνομα
είναι σαφέστερη από την πρόσβαση με βάση το δείκτη, το
"collections.namedtuple()" μπορεί να είναι μια πιο κατάλληλη επιλογή
από ένα απλό αντικείμενο tuple (πλειάδα).


Εύρη (Ranges)
-------------

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

class range(stop, /)
class range(start, stop, step=1, /)

   Τα ορίσματα του  κατασκευαστή εύρους (range constructor) πρέπει να
   είναι ακέραιοι αριθμοί (είτε της built-in "int" ή οποιοδήποτε
   αντικείμενο που υλοποιεί την ειδική μέθοδο "__index__()"). Εάν το
   όρισμα *step* παραλείπεται, το προεπιλογή (default) είναι "1". Εάν
   το όρισμα *start* παραλείπεται, το προεπιλογή (default) είναι "0".
   Εάν το *step* είναι μηδέν, γίνεται raise ένα "ValueError".

   Για ένα θετικό *βήμα*, τα περιεχόμενα του range (εύρους) "r"
   καθορίζονται από τον τύπο "r[i] = start + step*i" όπου "i >= 0" και
   "r[i] < stop".

   Για ένα αρνητικό *βήμα*, τα περιεχόμενα του εύρους (range)
   εξακολουθούν να καθορίζονται από τον τύπο "r[i] = start + step*i",
   αλλά οι περιορισμοί είναι "i >= 0" και "r[i] > stop".

   Ένα αντικείμενο range θα είναι άδειο εάν το "r[0]" δεν πληροί τον
   περιορισμό τιμής. Τα ranges υποστηρίζουν αρνητικούς δείκτες, αλλά
   αυτοί ερμηνεύονται ως δείκτες από το τέλος της ακολουθίας που
   καθορίζεται από τους θετικούς δείκτες.

   Τα ranges που περιέχουν απόλυτες τιμές μεγαλύτερες από
   "sys.maxsize" είναι επιτρεπτά, αλλά ορισμένα χαρακτηριστικά (όπως
   "len()") μπορεί να κάνουν raise "OverflowError".

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

      >>> list(range(10))
      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      >>> list(range(1, 11))
      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      >>> list(range(0, 30, 5))
      [0, 5, 10, 15, 20, 25]
      >>> list(range(0, 10, 3))
      [0, 3, 6, 9]
      >>> list(range(0, -10, -1))
      [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
      >>> list(range(0))
      []
      >>> list(range(1, 0))
      []

   Τα ranges υλοποιούν όλες τις ακολουθίες common εκτός από τη
   συνένωση και την επανάληψη (λόγω του γεγονότος ότι τα range
   αντικείμενα μπορούν να αναπαριστούν μόνο ακολουθίες που ακολουθούν
   ένα αυστηρό μοτίβο και η επανάληψη και η συνένωση συνήθως
   παραβιάζουν αυτό το πρότυπο).

   start

      Η τιμή της παραμέτρου *start* (ή "0" αν η παράμετρος δεν
      παρέχεται)

   stop

      Η τιμή της παραμέτρου *stop*

   step

      Η τιμή της παραμέτρου *step* (ή "1" αν η παράμετρος δεν
      παρέχεται)

Το πλεονέκτημα του τύπου "range" έναντι ενός κανονικού τύπου "list" ή
"tuple" είναι ότι ένα αντικείμενο "range" θα παίρνει πάντα το ίδιο
(μικρό) ποσό μνήμης, ανεξάρτητα από το μέγεθος του range που
αντιπροσωπεύει (μιας και αποθηκεύει μόνο τις τιμές "start", "stop" και
"step", υπολογίζοντας τα μεμονωμένα στοιχεία και τις υποπεριοχές όπως
απαιτείται).

Τα αντικείμενα range υλοποιούν την "collections.abc.Sequence" ABC, και
παρέχουν χαρακτηριστικά όπως δοκιμές περιορισμού, αναζήτηση δείκτη
στοιχείου, τεμαχισμό και υποστήριξη αρνητικών δεικτών (βλ. Τύποι
Ακολουθίας (Sequence) --- list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Ο έλεγχος των αντικειμένων range για ισότητα με "==" και "!=" τα
συγκρίνει ως ακολουθίες.  Δηλαδή, δύο αντικείμενα range θεωρούνται ίσα
αν αντιπροσωπεύουν την ίδια ακολουθία τιμών.  (Σημειώστε ότι δύο
αντικείμενα range που συγκρίνονται ως ίσα μπορεί να έχουν διαφορετικά
"start", "stop" και "step" χαρακτηριστικά, για παράδειγμα "range(0) ==
range(2, 1, 3)" ή "range(0, 3, 2) == range(0, 4, 2)".)

Άλλαξε στην έκδοση 3.2: Υλοποιείστε την ακολουθία ABC. Υποστηρίξτε την
τμηματοποίηση και τους αρνητικούς δείκτες. Δοκιμάστε τα "int"
αντικείμενα για συμμετοχή σε σταθερό χρόνο αντί της επανάληψης σε όλα
τα αντικείμενα.

Άλλαξε στην έκδοση 3.3: Ορίστε τα '==' και '!=' για να συγκρίνετε
αντικείμενα range με βάση την ακολουθία των τιμών που ορίζουν (αντί να
συγκρίνουν με βάση την ταυτότητα του αντικειμένου).Προστέθηκαν τα
"start", "stop" και "step" attributes.

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

  * Η συνταγή linspace δείχνει πώς να υλοποιήσετε μια lazy έκδοση του
    range κατάλληλη για εφαρμογές κινητής υποδιαστολής.


Σύνοψη μεθόδων τύπου κειμένου και δυαδική ακολουθίας
====================================================

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

+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Κατηγορία                  | "str" methods                                                     | οι μέθοδοι "bytes" και "bytearray"                                          |
|============================|====================|==========|==========|========================|======================|===========|===========|==============================|
| Μορφοποίηση                | "str.format()"                                                    |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.format_map()"                                                |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | f-strings                                                         |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | printf-style String Formatting                                    | Μορφοποίηση Bytes τύπου printf                                              |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Αναζήτηση και              | "str.find()"       | "str.rfind()"                                | "bytes.find()"       | "bytes.rfind()"                                      |
| Αντικατάσταση              |                    |                                              |                      |                                                      |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.index()"      | "str.rindex()"                               | "bytes.index()"      | "bytes.rindex()"                                     |
|                            |                    |                                              |                      |                                                      |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.startswith()"                                                | "bytes.startswith()"                                                        |
|                            |                                                                   |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.endswith()"                                                  | "bytes.endswith()"                                                          |
|                            |                                                                   |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.count()"                                                     | "bytes.count()"                                                             |
|                            |                                                                   |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.replace()"                                                   | "bytes.replace()"                                                           |
|                            |                                                                   |                                                                             |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Διαχωρισμός και Ένωση      | "str.split()"                 | "str.rsplit()"                    | "bytes.split()"                  | "bytes.rsplit()"                         |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.splitlines()"                                                | "bytes.splitlines()"                                                        |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.partition()"                                                 | "bytes.partition()"                                                         |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.rpartition()"                                                | "bytes.rpartition()"                                                        |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.join()"                                                      | "bytes.join()"                                                              |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Ταξινόμηση Συμβολοσειρών   | "str.isalpha()"                                                   | "bytes.isalpha()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isdecimal()"                                                 |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isdigit()"                                                   | "bytes.isdigit()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isnumeric()"                                                 |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isalnum()"                                                   | "bytes.isalnum()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isidentifier()"                                              |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.islower()"                                                   | "bytes.islower()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isupper()"                                                   | "bytes.isupper()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.istitle()"                                                   | "bytes.istitle()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isspace()"                                                   | "bytes.isspace()"                                                           |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.isprintable()"                                               |                                                                             |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Χειρισμός υποθέσεων        | "str.lower()"                                                     | "bytes.lower()"                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.upper()"                                                     | "bytes.upper()"                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.casefold()"                                                  |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.capitalize()"                                                | "bytes.capitalize()"                                                        |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.title()"                                                     | "bytes.title()"                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.swapcase()"                                                  | "bytes.swapcase()"                                                          |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Συμπλήρωση και Αφαίρεση    | "str.ljust()"                 | "str.rjust()"                     | "bytes.ljust()"                  | "bytes.rjust()"                          |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.center()"                                                    | "bytes.center()"                                                            |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.expandtabs()"                                                | "bytes.expandtabs()"                                                        |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.strip()"                                                     | "bytes.strip()"                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.lstrip()"                           | "str.rstrip()"         | "bytes.lstrip()"                             | "bytes.rstrip()"             |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
| Μετάφραση και Κωδικοποίηση | "str.translate()"                                                 | "bytes.translate()"                                                         |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.maketrans()"                                                 | "bytes.maketrans()"                                                         |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            | "str.encode()"                                                    |                                                                             |
|                            +--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+
|                            |                                                                   | "bytes.decode()"                                                            |
+----------------------------+--------------------+----------+----------+------------------------+----------------------+-----------+-----------+------------------------------+


Τύπος Ακολουθίας (Sequence) Κειμένου --- "str"
==============================================

Τα δεδομένα κειμένου στην Python αντιμετωπίζονται με αντικείμενα "str"
ή *strings*. Τα αλφαριθμητικά (strings) είναι αμετάβλητες sequences
των Unicode points.  Τα αλφαριθμητικά γράφονται με διάφορους τρόπους:

* Απλά εισαγωγικά: "'allows embedded "double" quotes'"

* Διπλά εισαγωγικά: "'allows embedded "double" quotes'"

* Τριπλά εισαγωγικά: "'''Three single quotes'''", """"Three double
  quotes""""

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

Τα Αλφαριθμητικά (strings) που αποτελούν μέρος μιας ενιαίας έκφρασης
και έχουν μόνο κενά μεταξύ τους, θα μετατραπούν σιωπηρά σε ένα ενιαίο
αλφαριθμητικό literal. Δηλαδή, "("spam " "eggs") == "spam eggs"".

Δείτε τα String and Bytes literals για περισσότερες πληροφορίες
σχετικά με τις διάφορες μορφές των αλφαριθμητικών, συμπεριλαμβανομένων
των υποστηριζόμενων ακολουθιών escape sequences, και του "r" ("raw")
πρόθεμα που απενεργοποιεί την επεξεργασία των περισσότερων ακολουθιών
διαφυγής.

Τα αλφαριθμητικά (strings) μπορούν επίσης να δημιουργηθούν από άλλα
αντικείμενα χρησιμοποιώντας τον constructor "str".

Εφόσον δεν υπάρχει ξεχωριστός τύπος "character", το indexing μιας
συμβολοσειράς (string) παράγει συμβολοσειρές μήκους 1. Δηλαδή, για μια
μη κενή συμβολοσειρά *s*, "s[0] == s[0:1]".

Δεν υπάρχει επίσης μεταβλητός τύπος συμβολοσειράς (string), αλλά το
"str.join()" ή το "io.StringIO" μπορεί να χρησιμοποιηθεί για την
αποτελεσματική κατασκευή συμβολοσειρών από πολλαπλά μέρη.

Άλλαξε στην έκδοση 3.3: Για συμβατότητα προς τα πίσω (backwards
compatibility) με τη σειρά Python 2, το πρόθεμα "u" είναι επιτρεπτό
και πάλι σε αλφαριθμητικά. Δεν έχει καμία επίδραση στη σημασία των
αλφαριθμητικών και δεν μπορεί να συνδυαστεί με το πρόθεμα "r".

class str(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

   Επιστρέφει μια έκδοση string του *object*.  Αν το *object* δεν
   παρέχεται, επιστρέφει κενό αλφαριθμητικό.  Διαφορετικά, η
   συμπεριφορά της "str()" εξαρτάται από το αν δίνεται *encoding* ή
   *errors*, ως εξής.

   Αν δεν έχει δοθεί ούτε *encoding* ούτε *errors*, το "str(object)"
   επιστρέφει "type(object).__str__(object)", το οποίο είναι το
   "informal" ή ωραία εκτυπώσιμη αναπαράσταση συμβολοσειράς (string)
   του *object*.  Για αντικείμενα συμβολοσειράς, είναι η ίδια η
   συμβολοσειρά.  Εάν το *object* δεν έχει την "__str__()", τότε η
   "str()" επιστρέφει τη μέθοδο "repr(object)".

   Εάν δίνεται τουλάχιστον ένα από τα *encoding* ή *errors*, το
   *object* θα πρέπει να είναι ένα *bytes-like object* (π.χ. "bytes" ή
   "bytearray").  Σε αυτή την περίπτωση, αν το *object* είναι ένα
   αντικείμενο "bytes" (ή "bytearray"), τότε το "str(bytes, encoding,
   errors)" είναι ισοδύναμο με το "bytes.decode(encoding, errors)".
   Διαφορετικά, το αντικείμενο bytes που υποκρύπτει το αντικείμενο
   buffer λαμβάνεται πριν από την κλήση του "bytes.decode()".  Δείτε
   Τύποι δυαδικής ακολουθίας --- bytes, bytearray, memoryview και
   Buffer Protocol για πληροφορίες σχετικά με τα αντικείμενα buffer.

   Πέρασμα ενός αντικειμένου "bytes" στο "str()" χωρίς το *encoding* ή
   το *errors* ορίσματα εμπίπτει στην πρώτη περίπτωση επιστροφής της
   άτυπης αναπαράστασης συμβολοσειράς (string) (δείτε επίσης την
   επιλογή "-b" της γραμμής εντολών για Python).  Για παράδειγμα:

      >>> str(b'Zoot!')
      "b'Zoot!'"

   Για περισσότερες πληροφορίες σχετικά με την κλάση "str" και τις
   μεθόδους της, δείτε Τύπος Ακολουθίας (Sequence) Κειμένου --- str
   και την ενότητα Μέθοδοι Συμβολοσειράς (String) παρακάτω.  Για την
   παραγωγή μορφοποιημένων συμβολοσειρών (string), ανατρέξτε στις
   ενότητες f-strings και Format String Syntax.  Επιπλέον, δείτε την
   ενότητα Text Processing Services.


Μέθοδοι Συμβολοσειράς (String)
------------------------------

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

Οι συμβολοσειρές (string) υποστηρίζουν επίσης δύο στυλ μορφοποίησης
συμβολοσειρών, το ένα παρέχει ένα μεγάλο βαθμό ευελιξίας και
προσαρμογής (βλέπε "str.format()", Format String Syntax και Custom
String Formatting) και το άλλο βασίζεται στο στυλ μορφοποίησης
"printf" της C που χειρίζεται ένα στενότερο εύρος τύπων και είναι λίγο
πιο δύσκολο να χρησιμοποιηθεί σωστά, αλλά είναι συχνά ταχύτερο για τις
περιπτώσεις που μπορεί να χειριστεί (printf-style String Formatting).

Το τμήμα Text Processing Services της πρότυπης βιβλιοθήκης καλύπτει
έναν αριθμό από άλλες ενότητες που παρέχουν διάφορες βοηθητικές
υπηρεσίες που σχετίζονται με το κείμενο (συμπεριλαμβανομένης της
υποστήριξης των κανονικών εκφράσεων στην ενότητα "re").

str.capitalize()

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με τον πρώτο
   χαρακτήρα κεφαλαίο και τα υπόλοιπα με πεζά γράμματα.

   Άλλαξε στην έκδοση 3.8: Ο πρώτος χαρακτήρας τίθεται τώρα σε
   titlecase αντί για uppercase. Αυτό σημαίνει ότι χαρακτήρες όπως οι
   διγράφοι (digraphs) θα έχουν μόνο το πρώτο γράμμα τους με κεφαλαίο,
   αντί για όλους τους χαρακτήρες.

str.casefold()

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) σε casefolded
   μορφή. Οι casefolded συμβολοσειρές μπορούν να χρησιμοποιηθούν για
   caseless matching.

   Casefolding is similar to lowercasing but more aggressive because
   it is intended to remove all case distinctions in a string. For
   example, the German lowercase letter "'ß'" is equivalent to ""ss"".
   Since it is already lowercase, "lower()" would do nothing to "'ß'";
   "casefold()" converts it to ""ss"". For example:

      >>> 'straße'.lower()
      'straße'
      >>> 'straße'.casefold()
      'strasse'

   Ο αλγόριθμος casefolding περιγράφεται στην ενότητα 3.13 'Default
   Case Folding' του προτύπου Unicode.

   Added in version 3.3.

str.center(width, fillchar=' ', /)

   Επιστρέφει ένα κεντραρισμένο σε μια συμβολοσειρά (string) μήκους
   *width*. Το padding γίνεται με τη χρήση του καθορισμένου *fillchar*
   (το default είναι ένα κενό ASCII). Η αρχική συμβολοσειρά
   επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με το "len(s)".
   Για παράδειγμα:

      >>> 'Python'.center(10)
      '  Python  '
      >>> 'Python'.center(10, '-')
      '--Python--'
      >>> 'Python'.center(4)
      'Python'

str.count(sub[, start[, end]])

   Επιστρέφει τον αριθμό των μη επικαλυπτόμενων (non-overalpping)
   εμφανίσεων της υποομάδας *sub* στο εύρος [*start*, *end*].  Τα
   προαιρετικά ορίσματα *start* και *end* ερμηνεύονται όπως στο slice
   notation.

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

      >>> 'spam, spam, spam'.count('spam')
      3
      >>> 'spam, spam, spam'.count('spam', 5)
      2
      >>> 'spam, spam, spam'.count('spam', 5, 10)
      1
      >>> 'spam, spam, spam'.count('eggs')
      0
      >>> 'spam, spam, spam'.count('')
      17

str.encode(encoding='utf-8', errors='strict')

   Επιστρέφει την συμβολοσειρά (string) κωδικοποιημένη σε "bytes".

   το *encoding* έχει default σε "'utf-8'"- δείτε Standard Encodings
   για πιθανές τιμές.

   το *errors* ελέγχει τον τρόπο χειρισμού των σφαλμάτων
   κωδικοποίησης. Εάν είναι "'strict'" (το default), τότε γίνεται
   raise μια εξαίρεση "UnicodeError". Άλλες πιθανές τιμές είναι τα
   "'ignore'", "'replace'", "'xmlcharrefreplace'",
   "'backslashreplace'" και οποιοδήποτε άλλο όνομα που έχει
   καταχωρηθεί μέσω του "codecs.register_error()". Δείτε το Error
   Handlers για λεπτομέρειες.

   Για λόγους απόδοσης, η τιμή των *errors* δεν ελέγχεται ως προς την
   εγκυρότητα εκτός αν όντως προκύψει σφάλμα κωδικοποίησης, αν το
   Python Development Mode είναι ενεργοποιημένο ή αν ένα debug build
   χρησιμοποιείται. Για παράδειγμα:

      >>> encoded_str_to_bytes = 'Python'.encode()
      >>> type(encoded_str_to_bytes)
      <class 'bytes'>
      >>> encoded_str_to_bytes
      b'Python'

   Άλλαξε στην έκδοση 3.1: Επιπρόσθετη υποστήριξη για keyword
   ορίσματα.

   Άλλαξε στην έκδοση 3.9: Η τιμή του όρου *errors* ελέγχεται τώρα στο
   Python Development Mode και στο debug mode.

str.endswith(suffix[, start[, end]])

   Επιστρέφει "True" αν η συμβολοσειρά (string) τελειώνει με το
   καθορισμένο *suffix*, αλλιώς επιστρέφει "False".  Το *suffix*
   μπορεί επίσης να είναι ένα tuple (πλειάδα) από επιθέματα που πρέπει
   να αναζητηθούν.  Με το προαιρετικό *start*, το τεστ αρχίζει από
   αυτή τη θέση.  Με το προαιρετικό *end*, η σύγκριση σταματά σε αυτή
   τη θέση. Χρησιμοποιώντας *start* και *end* είναι ισοδύναμο με την
   "str[start:end].endswith(suffix)". Για παράδειγμα:

      >>> 'Python'.endswith('on')
      True
      >>> 'a tuple of suffixes'.endswith(('at', 'in'))
      False
      >>> 'a tuple of suffixes'.endswith(('at', 'es'))
      True
      >>> 'Python is amazing'.endswith('is', 0, 9)
      True

   Δείτε επίσης "startswith()" και "removesuffix()".

str.expandtabs(tabsize=8)

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) όπου όλοι οι
   χαρακτήρες tab αντικαθίστανται από έναν ή περισσότερα κενά, ανάλογα
   με την τρέχουσα στήλη και το δεδομένο μέγεθος των tabs.  Οι θέσεις
   tab εμφανίζονται κάθε *tabsize* χαρακτήρες (το default είναι 8,
   δίνοντας tab θέσεις στις στήλες 0, 8, 16 κ.ο.κ.).  Για την επέκταση
   της συμβολοσειράς, η τρέχουσα στήλη μηδενίζεται και η συμβολοσειρά
   εξετάζεται χαρακτήρας προς χαρακτήρα.  Εάν ο χαρακτήρας είναι tab
   ("\t"), εισάγονται ένας ή περισσότεροι χαρακτήρες κενών στο
   αποτέλεσμα μέχρι η τρέχουσα στήλη να είναι ίση με την επόμενη θέση
   tab. (Ο ίδιος ο χαρακτήρας tab δεν αντιγράφεται.) Εάν ο χαρακτήρας
   είναι νέα γραμμή ("\n") ή return ("\r"), αντιγράφεται και η
   τρέχουσα στήλη επαναφέρεται στο μηδέν.  Οποιοσδήποτε άλλος
   χαρακτήρας αντιγράφεται αμετάβλητος και η τρέχουσα στήλη αυξάνεται
   κατά ένα, ανεξάρτητα από τον τρόπο αναπαράστασης του χαρακτήρα όταν
   τυπώνεται. Για παράδειγμα:

      >>> '01\t012\t0123\t01234'.expandtabs()
      '01      012     0123    01234'
      >>> '01\t012\t0123\t01234'.expandtabs(4)
      '01  012 0123    01234'
      >>> print('01\t012\n0123\t01234'.expandtabs(4))
      01  012
      0123    01234

str.find(sub[, start[, end]])

   Επιστρέφει τον χαμηλότερο δείκτη στη συμβολοσειρά (string) όπου η
   υπό-συμβολοσειρά *sub* βρίσκεται μέσα στο υποσύνολο (slice)
   "s[start:end]".  Τα προαιρετικά ορίσματα *start* και *end*
   ερμηνεύονται όπως στο notation του υποσυνόλου.  Επιστρέφει "-1" αν
   δεν βρεθεί το *sub*. Για παράδειγμα:

      >>> 'spam, spam, spam'.find('sp')
      0
      >>> 'spam, spam, spam'.find('sp', 5)
      6

   Δείτε επίσης "rfind()" και "index()".

   Σημείωση:

     Η μέθοδος "find()" θα πρέπει να χρησιμοποιείται μόνο αν πρέπει να
     γνωρίζετε τη θέση του *sub*.  Για να ελέγξετε αν το *sub* είναι
     υποσύνολο ή όχι, χρησιμοποιήστε τον τελεστή "in":

        >>> 'Py' in 'Python'
        True

str.format(*args, **kwargs)

   Εκτέλεση μιας λειτουργίας μορφοποίησης συμβολοσειράς (string
   formatting).  Η συμβολοσειρά στην οποία αυτή η μέθοδος καλείται
   μπορεί να περιέχει κυριολεκτικό κείμενο ή πεδία αντικατάστασης που
   οριοθετούνται από αγκύλες "{}".  Κάθε πεδίο αντικατάστασης περιέχει
   είτε τον αριθμητικό δείκτη ενός ορίσματος θέσης, είτε το όνομα ενός
   keyword ορίσματος.  Επιστρέφει ένα αντίγραφο της συμβολοσειράς όπου
   κάθε πεδίο αντικατάστασης αντικαθίσταται με την τιμή της
   συμβολοσειράς του αντίστοιχου ορίσματος. Για παράδειγμα:

      >>> "The sum of 1 + 2 is {0}".format(1+2)
      'The sum of 1 + 2 is 3'
      >>> "The sum of {a} + {b} is {answer}".format(answer=1+2, a=1, b=2)
      'The sum of 1 + 2 is 3'
      >>> "{1} expects the {0} Inquisition!".format("Spanish", "Nobody")
      'Nobody expects the Spanish Inquisition!'

   Δείτε το Format String Syntax για μια περιγραφή των διαφόρων
   επιλογών μορφοποίησης που μπορούν να καθοριστούν στην μορφοποίηση
   συμβολοσειρών (format strings).

   Σημείωση:

     Κατά τη μορφοποίηση ενός αριθμού ("int", "float", "complex",
     "decimal.Decimal" και υποκλάσεις) με τον τύπο "n" (π.χ.:
     "'{:n}'.format(1234)", η συνάρτηση θέτει προσωρινά την τοποθεσία
     "LC_CTYPE" στην τοποθεσία "LC_NUMERIC" για την αποκωδικοποίηση
     των "decimal_point" και "thousands_sep" πεδίων του "localeconv()"
     αν είναι μη ASCII ή μεγαλύτερα από 1 byte, και το locale
     "LC_NUMERIC" είναι διαφορετικό από το locale "LC_CTYPE".  Αυτή η
     προσωρινή αλλαγή επηρεάζει και άλλα νήματα (threads).

   Άλλαξε στην έκδοση 3.7: Κατά τη μορφοποίηση ενός αριθμού με τον
   τύπο "n", η συνάρτηση θέτει προσωρινά το locale "LC_CTYPE" στο
   locale "LC_NUMERIC" σε κάποιες περιπτώσεις.

str.format_map(mapping, /)

   Παρόμοιο με το "str.format(**mapping)", εκτός από το ότι
   χρησιμοποιείται το "mapping" απευθείας και δεν αντιγράφεται σε μια
   "dict".  Αυτό είναι χρήσιμο αν για παράδειγμα το "mapping" είναι
   μια υποκλάση του dict:

   >>> class Default(dict):
   ...     def __missing__(self, key):
   ...         return key
   ...
   >>> '{name} was born in {country}'.format_map(Default(name='Guido'))
   'Guido was born in country'

   Added in version 3.2.

str.index(sub[, start[, end]])

   Like "find()", but raise "ValueError" when the substring is not
   found. For example:

      >>> 'spam, spam, spam'.index('eggs')
      Traceback (most recent call last):
        File "<python-input-0>", line 1, in <module>
          'spam, spam, spam'.index('eggs')
          ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
      ValueError: substring not found

   See also "rindex()".

str.isalnum()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες στη συμβολοσειρά (string)
   είναι αλφαριθμητικοί και υπάρχει τουλάχιστον ένας χαρακτήρας,
   διαφορετικά "False".  Ένας χαρακτήρας "c" είναι αλφαριθμητικό εάν
   ένα από τα ακόλουθα επιστρέφει "True": "c.isalpha()",
   "c.isdecimal()", "c.isdigit()", ή "c.isnumeric()".

str.isalpha()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες στη συμβολοσειρά (string)
   είναι αλφαβητικοί και υπάρχει τουλάχιστον ένας χαρακτήρας,
   διαφορετικά "False".  Οι αλφαβητικοί χαρακτήρες είναι χαρακτήρες
   που ορίζονται στη βάση δεδομένων χαρακτήρων Unicode ως "Letter",
   δηλαδή, εκείνοι με General Category ιδιότητα μία από τα "Lm", "Lt",
   "Lu", "Ll", ή "Lo".  Σημειώστε ότι αυτό είναι διαφορετικό από το
   Αλφαβητικό που ορίζεται στην ενότητα 4.10 'Letters, Alphabetic, and
   Ideographic' του προτύπου Unicode. Για παράδειγμα:

      >>> 'Letters and spaces'.isalpha()
      False
      >>> 'LettersOnly'.isalpha()
      True
      >>> 'µ'.isalpha()  # non-ASCII characters can be considered alphabetical too
      True

   Δείτε Unicode Properties.

str.isascii()

   Επιστρέφει "True" εάν η συμβολοσειρά (string) είναι κενή ή όλοι οι
   χαρακτήρες της συμβολοσειράς είναι ASCII, αλλιώς "False". Οι
   χαρακτήρες ASCII έχουν σημεία κωδικοποίησης στην περιοχή
   U+0000-U+007F. Για παράδειγμα:

      >>> 'ASCII characters'.isascii()
      True
      >>> 'µ'.isascii()
      False

   Added in version 3.7.

str.isdecimal()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες στη συμβολοσειρά (string)
   είναι δεκαδικοί χαρακτήρες και υπάρχει τουλάχιστον ένας χαρακτήρας,
   διαφορετικά "False". Οι δεκαδικοί χαρακτήρες είναι αυτοί που
   μπορούν να χρησιμοποιηθούν για το σχηματισμό αριθμών στη βάση 10,
   π.χ. U+0660, ARABIC-INDIC DIGIT ZERO.  Επίσημα ένας δεκαδικός
   χαρακτήρας είναι ένας χαρακτήρας του Unicode General Category "Nd".
   Για παράδειγμα:

      >>> '0123456789'.isdecimal()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isdecimal()  # Arabic-Indic digits zero to nine
      True
      >>> 'alphabetic'.isdecimal()
      False

str.isdigit()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες στη συμβολοσειρά είναι
   ψηφία και υπάρχει τουλάχιστον ένας χαρακτήρας, διαφορετικά "False".
   Τα ψηφία περιλαμβάνουν δεκαδικούς χαρακτήρες και ψηφία που
   χρειάζονται ειδικό χειρισμό, όπως τα compatibility superscript
   ψηφία. Αυτό καλύπτει τα ψηφία που δεν μπορούν να χρησιμοποιηθούν
   για το σχηματισμό αριθμών στη βάση 10, όπως οι αριθμοί Kharosthi.
   Τυπικά, ένα ψηφίο είναι ένας χαρακτήρας που έχει την τιμή της
   ιδιότητας Numeric_Type=Digit ή Numeric_Type=Decimal.

str.isidentifier()

   Επιστρέφει "True" αν η συμβολοσειρά είναι έγκυρο αναγνωριστικό
   σύμφωνα με το ορισμό της γλώσσας, ενότητα Names (identifiers and
   keywords).

   το "keyword.iskeyword()" μπορεί να χρησιμοποιηθεί για να ελέγξει αν
   η συμβολοσειρά "s" είναι ένα δεσμευμένο αναγνωριστικό, όπως τα
   "def" και "class".

   Παράδειγμα

      >>> from keyword import iskeyword

      >>> 'hello'.isidentifier(), iskeyword('hello')
      (True, False)
      >>> 'def'.isidentifier(), iskeyword('def')
      (True, True)

str.islower()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες [4] στο αλφαριθμητικό
   (string) είναι πεζοί και υπάρχει τουλάχιστον ένας cased χαρακτήρας,
   αλλιώς "False".

str.isnumeric()

   Return "True" if all characters in the string are numeric
   characters, and there is at least one character, "False" otherwise.
   Numeric characters include digit characters, and all characters
   that have the Unicode numeric value property, e.g. U+2155, VULGAR
   FRACTION ONE FIFTH.  Formally, numeric characters are those with
   the property value Numeric_Type=Digit, Numeric_Type=Decimal or
   Numeric_Type=Numeric. For example:

      >>> '0123456789'.isnumeric()
      True
      >>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # Arabic-indic digit zero to nine
      True
      >>> '⅕'.isnumeric()  # Vulgar fraction one fifth
      True
      >>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()
      (False, True, True)

   See also "isdecimal()" and "isdigit()". Numeric characters are a
   superset of decimal numbers.

str.isprintable()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες στη συμβολοσειρά μπορούν να
   εκτυπωθούν, "False" εάν περιέχει τουλάχιστον έναν μη εκτυπώσιμο
   χαρακτήρα.

   Εδώ "εκτυπώσιμος" σημαίνει ότι ο χαρακτήρας είναι κατάλληλος για
   την "repr()" για χρήση στην έξοδο του∙ το "μη εκτυπώσιμος" σημαίνει
   ότι ο χαρακτήρας στη "repr()" στους ενσωματωμένους τύπους θα
   διαφεύγει εξαγωνικά από τον χαρακτήρα. Δεν έχει καμία σχέση με τον
   χειρισμό συμβολοσειρών που γράφονται σε "sys.stdout" ή
   "sys.stderr".

   Οι εκτυπώσιμοι χαρακτήρες είναι αυτοί που στη βάση δεδομένων
   χαρακτήρων Unicode (βλ. "unicodedata") έχουν μια γενική κατηγορία
   στην ομάδα Γράμμα, Σήμα, Αριθμός, Σημεία στίξης ή Σύμβολο (L, M, N,
   P ή S), συν το διάστημα ASCII 0x20. Οι μη εκτυπώσιμοι χαρακτήρες
   είναι αυτοί που βρίσκονται στο χώρο Διαχωρισμού ομάδας ή Άλλο (Z ή
   CII).

   Για παράδειγμα:

      >>> ''.isprintable(), ' '.isprintable()
      (True, True)
      >>> '\t'.isprintable(), '\n'.isprintable()
      (False, False)

str.isspace()

   Επιστρέφει "True" αν υπάρχουν μόνο χαρακτήρες κενού (whitespace)
   στο αλφαριθμητικό (string) και υπάρχει τουλάχιστον ένας χαρακτήρας,
   διαφορετικά "False".

   Ένας χαρακτήρας είναι *whitespace* εάν στη βάση δεδομένων
   χαρακτήρων Unicode (βλέπε "unicodedata"), είτε η γενική κατηγορία
   του είναι "Zs" ("Separator, space"), είτε η αμφίδρομη κατηγορία του
   είναι μία από τις κατηγορίες "WS", "B", ή "S".

str.istitle()

   Επιστρέφει "True" αν η συμβολοσειρά (string) είναι μια titlecased
   συμβολοσειρά και υπάρχει τουλάχιστον ένας χαρακτήρας, για
   παράδειγμα, οι κεφαλαίοι χαρακτήρες μπορούν να ακολουθούν μόνο τους
   uncased χαρακτήρες και οι πεζοί χαρακτήρες μόνο cased χαρακτήρες.
   Διαφορετικά, επιστρέφει "False".

   Για παράδειγμα:

      >>> 'Spam, Spam, Spam'.istitle()
      True
      >>> 'spam, spam, spam'.istitle()
      False
      >>> 'SPAM, SPAM, SPAM'.istitle()
      False

   Δείτε επίσης "title()".

str.isupper()

   Επιστρέφει "True" αν όλοι οι χαρακτήρες [4] στο αλφαριθμητικό είναι
   κεφαλαίοι και υπάρχει τουλάχιστον ένας cased χαρακτήρας,
   διαφορετικά "False".

   >>> 'BANANA'.isupper()
   True
   >>> 'banana'.isupper()
   False
   >>> 'baNana'.isupper()
   False
   >>> ' '.isupper()
   False

str.join(iterable, /)

   Επιστρέφει μια συμβολοσειρά (string) που είναι η συνένωση των
   συμβολοσειρών στο *iterable*. Ένα "TypeError" θα γίνει raise αν
   υπάρχουν τιμές μη συμβολοσειράς (non-string) στο *iterable*,
   συμπεριλαμβανομένων των αντικειμένων "bytes".  Το διαχωριστικό
   μεταξύ των στοιχείων είναι η συμβολοσειρά που παρέχει αυτή η
   μέθοδος. Για παράδειγμα:

      >>> ', '.join(['spam', 'spam', 'spam'])
      'spam, spam, spam'
      >>> '-'.join('Python')
      'P-y-t-h-o-n'

   Δείτε επίσης "split()".

str.ljust(width, fillchar=' ', /)

   Επιστρέφει τη συμβολοσειρά (string) με αριστερή ευθυγράμμιση σε μια
   συμβολοσειρά μήκους *width*. Το padding γίνεται με τη χρήση του
   καθορισμένου *fillchar* (το default είναι ένα κενό ASCII). Η αρχική
   συμβολοσειρά επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με
   το "len(s)".

   Για παράδειγμα:

      >>> 'Python'.ljust(10)
      'Python    '
      >>> 'Python'.ljust(10, '.')
      'Python....'
      >>> 'Monty Python'.ljust(10, '.')
      'Monty Python'

   See also "rjust()".

str.lower()

   Return a copy of the string with all the cased characters [4]
   converted to lowercase. For example:

      >>> 'Lower Method Example'.lower()
      'lower method example'

   Ο αλγόριθμος που χρησιμοποιείται για την πεζογράμμιση περιγράφεται
   στην ενότητα 3.13 'Default Case Folding' του προτύπου Unicode.

str.lstrip(chars=None, /)

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με την αφαίρεση
   των αρχικών χαρακτήρων.  Τα *chars* είναι μια συμβολοσειρά  που
   καθορίζει το σύνολο των χαρακτήρων που πρέπει να αφαιρεθούν.  Εάν
   παραλειφθεί ή είναι "None", το όρισμα *chars* έχει ως default την
   αφαίρεση των κενών χαρακτήρων.  Το όρισμα *chars* δεν είναι ένα
   πρόθεμα· οπότε, όλοι οι συνδυασμοί των τιμών του αφαιρούνται:

      >>> '   spacious   '.lstrip()
      'spacious   '
      >>> 'www.example.com'.lstrip('cmowz.')
      'example.com'

   Δείτε την "str.removeprefix()" για μια μέθοδο που θα αφαιρέσει ένα
   μόνο πρόθεμα συμβολοσειράς (string) αντί για όλο το σύνολο των
   χαρακτήρων.  Για παράδειγμα:

      >>> 'Arthur: three!'.lstrip('Arthur: ')
      'ee!'
      >>> 'Arthur: three!'.removeprefix('Arthur: ')
      'three!'

static str.maketrans(dict, /)
static str.maketrans(from, to, remove='', /)

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

   Εάν υπάρχει μόνο ένα όρισμα, πρέπει να είναι ένα λεξικό
   αντιστοίχισης Unicode ordinals (ακέραιοι αριθμοί) ή χαρακτήρες
   (συμβολοσειρές - strings μήκους 1) σε ordinals Unicode,
   συμβολοσειρές (αυθαίρετου μήκους) ή "None".  Τα κλειδιά χαρακτήρων
   τότε θα μετατραπούν σε κανονικούς αριθμούς.

   Εάν υπάρχουν δύο ορίσματα, πρέπει να είναι συμβολοσειρές (strings)
   ίσου μήκους και στο λεξικό (dictionary) που θα προκύψει, κάθε
   χαρακτήρας στο *from* θα αντιστοιχιστεί στο χαρακτήρα στην ίδια
   θέση στο *to*. Αν υπάρχει τρίτο όρισμα, πρέπει να είναι
   συμβολοσειρά, του οποίου οι χαρακτήρες θα αντιστοιχιστούν στο
   αποτέλεσμα σε "None".

str.partition(sep, /)

   Διαχωρίστε τη συμβολοσειρά (string) στην πρώτη εμφάνιση του *sep*,
   και επιστρέφει ένα 3-tuple που περιέχει το μέρος πριν από το
   διαχωριστικό, το ίδιο το διαχωριστικό και το μέρος μετά το
   διαχωριστικό.  Αν ο διαχωριστής δεν βρεθεί, επιστρέφει ένα 3-σύνολο
   που περιέχει την ίδια τη συμβολοσειρά, ακολουθούμενη από δύο κενές
   συμβολοσειρές.

str.removeprefix(prefix, /)

   If the string starts with the *prefix* string, return
   "string[len(prefix):]". Otherwise, return a copy of the original
   string:

      >>> 'TestHook'.removeprefix('Test')
      'Hook'
      >>> 'BaseTestCase'.removeprefix('Test')
      'BaseTestCase'

   Added in version 3.9.

   See also "removesuffix()" and "startswith()".

str.removesuffix(suffix, /)

   If the string ends with the *suffix* string and that *suffix* is
   not empty, return "string[:-len(suffix)]". Otherwise, return a copy
   of the original string:

      >>> 'MiscTests'.removesuffix('Tests')
      'Misc'
      >>> 'TmpDirMixin'.removesuffix('Tests')
      'TmpDirMixin'

   Added in version 3.9.

   See also "removeprefix()" and "endswith()".

str.replace(old, new, /, count=-1)

   Return a copy of the string with all occurrences of substring *old*
   replaced by *new*.  If *count* is given, only the first *count*
   occurrences are replaced. If *count* is not specified or "-1", then
   all occurrences are replaced. For example:

      >>> 'spam, spam, spam'.replace('spam', 'eggs')
      'eggs, eggs, eggs'
      >>> 'spam, spam, spam'.replace('spam', 'eggs', 1)
      'eggs, spam, spam'

   Άλλαξε στην έκδοση 3.13: Το *count* υποστηρίζεται πλέον ως όρισμα
   λέξης-κλειδιού.

str.rfind(sub[, start[, end]])

   Return the highest index in the string where substring *sub* is
   found, such that *sub* is contained within "s[start:end]".
   Optional arguments *start* and *end* are interpreted as in slice
   notation.  Return "-1" on failure. For example:

      >>> 'spam, spam, spam'.rfind('sp')
      12
      >>> 'spam, spam, spam'.rfind('sp', 0, 10)
      6

   See also "find()" and "rindex()".

str.rindex(sub[, start[, end]])

   Όπως η "rfind()", αλλά κάνει raise "ValueError" όταν η
   υπό-συμβολοσειρά (sub-string) *sub* δεν βρέθηκε.

str.rjust(width, fillchar=' ', /)

   Επιστρέφει τη συμβολοσειρά (string) με δεξιό προσανατολισμό σε μια
   συμβολοσειρά μήκους *width*. Το padding γίνεται χρησιμοποιώντας το
   καθορισμένο *fillchar* (η προεπιλογή είναι ένα διάστημα ASCII). Η
   αρχική συμβολοσειρά επιστρέφεται εάν το *width* είναι μικρότερο ή
   ίσο με "len(s)".

str.rpartition(sep, /)

   Διαχωρίζει τη συμβολοσειρά (string) στην τελευταία εμφάνιση του
   *sep* και επιστρέφει ένα 3-tuple που περιέχει το τμήμα πριν από το
   διαχωριστικό, το ίδιο το διαχωριστικό και το μέρος μετά το
   διαχωριστικό.  Εάν το διαχωριστικό δεν βρεθεί, επιστρέφει ένα
   3-tuple που περιέχει δύο κενές συμβολοσειρές, ακολουθούμενες από
   την ίδια τη συμβολοσειρά.

   Για παράδειγμα:

      >>> 'Monty Python'.rpartition(' ')
      ('Monty', ' ', 'Python')
      >>> "Monty Python's Flying Circus".rpartition(' ')
      ("Monty Python's Flying", ' ', 'Circus')
      >>> 'Monty Python'.rpartition('-')
      ('', '', 'Monty Python')

   See also "partition()".

str.rsplit(sep=None, maxsplit=-1)

   Επιστρέφει μια λίστα με τις λέξεις στη συμβολοσειρά (string),
   χρησιμοποιώντας το *sep* ως οριοθέτη. Εάν δοθεί το *maxsplit*, θα
   γίνουν το πολύ *maxsplit* διαχωρισμοί, ξεκινώντας από τα δεξιά.
   Εάν το *sep* δεν έχει καθοριστεί ή είναι "None", οποιοδήποτε κενό
   διάστημα γίνεται διαχωριστικό. Εκτός από το διαχωρισμό από τα
   δεξιά, η "rsplit()" συμπεριφέρεται όπως η "split()" που
   περιγράφεται λεπτομερώς παρακάτω.

str.rstrip(chars=None, /)

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με τους
   χαρακτήρες που έχουν αφαιρεθεί.  Τα όρισμα *chars* είναι μια
   συμβολοσειρά που καθορίζει το σύνολο των χαρακτήρων που πρέπει να
   αφαιρεθούν.  Εάν παραληφθεί ή είναι "None", το όρισμα *chars* έχει
   ως προεπιλογή την αφαίρεση των κενών διαστημάτων.  Το όρισμα
   *chars* δεν είναι suffix, αλλά όλοι οι συνδυασμοί των τιμών του
   αφαιρούνται:

      >>> '   spacious   '.rstrip()
      '   spacious'
      >>> 'mississippi'.rstrip('ipz')
      'mississ'

   Δείτε τη "str.removesuffix()" για μια μέθοδο που θα αφαιρέσει ένα
   απλό suffix αντί για όλο το σύνολο των χαρακτήρων.  Για παράδειγμα:

      >>> 'Monty Python'.rstrip(' Python')
      'M'
      >>> 'Monty Python'.removesuffix(' Python')
      'Monty'

str.split(sep=None, maxsplit=-1)

   Επιστρέφει μια λίστα με τις λέξεις της συμβολοσειράς (string),
   χρησιμοποιώντας το *sep* ως διαχωριστικό.  Αν δοθεί το *maxsplit*,
   γίνονται το πολύ *maxsplit* διαχωρισμοί (έτσι, η λίστα θα έχει το
   πολύ "maxsplit+1" στοιχεία).  Εάν το *maxsplit* δεν καθοριστεί ή
   είναι "-1", τότε δεν υπάρχει όριο στον αριθμό των διαχωρισμών
   (γίνονται όλες οι πιθανές διασπάσεις).

   Αν δοθεί το *sep*, οι διαδοχικά οριοθέτες δεν ομαδοποιούνται μαζί
   και θεωρείται ότι οριοθετούν κενές συμβολοσειρές (strings) (για
   παράδειγμα, το "'1,,2'.split(',')" επιστρέφει "['1', '', '2']").
   Το όρισμα *sep* μπορεί να αποτελείται από πολλούς χαρακτήρες ως
   μεμονωμένο οριοθέτη (για διαχωρισμό με πολλαπλούς οριοθέτες,
   χρησιμοποιήστε την "re.split()"). Ο διαχωρισμός μιας κενής
   συμβολοσειράς με ένα καθορισμένο διαχωριστικό επιστρέφει το "['']".

   Για παράδειγμα:

      >>> '1,2,3'.split(',')
      ['1', '2', '3']
      >>> '1,2,3'.split(',', maxsplit=1)
      ['1', '2,3']
      >>> '1,2,,3,'.split(',')
      ['1', '2', '', '3', '']
      >>> '1<>2<>3<4'.split('<>')
      ['1', '2', '3<4']

   Αν το *sep* καθοριστεί ή είναι "None", εφαρμόζεται ένας
   διαφορετικός αλγόριθμος διαχωρισμού: οι εμφανίσεις διαδοχικών κενών
   θεωρούνται ως ένα ενιαίο διαχωριστικό, και το αποτέλεσμα δεν θα
   περιέχει κενές συμβολοσειρές (strings) στην αρχή ή στο τέλος, αν η
   συμβολοσειρά έχει κενό διάστημα στην αρχή ή στο τέλος.  Κατά
   συνέπεια, η διάσπαση μιας κενής συμβολοσειράς ή μιας συμβολοσειράς
   που αποτελείται μόνο από κενά διαστήματα με ένα "None" ως
   διαχωριστικό επιστρέφει "[]".

   Για παράδειγμα:

      >>> '1 2 3'.split()
      ['1', '2', '3']
      >>> '1 2 3'.split(maxsplit=1)
      ['1', '2 3']
      >>> '   1   2   3   '.split()
      ['1', '2', '3']

   Εάν δεν καθοριστεί *sep* ή είναι "None" και το *maxsplit* είναι
   "0", λαμβάνοντας υπόψη μόνο οι πρώτες εκτελέσεις διαδοχικού κενού
   διαστήματος.

   Για παράδειγμα:

      >>> "".split(None, 0)
      []
      >>> "   ".split(None, 0)
      []
      >>> "   foo   ".split(maxsplit=0)
      ['foo   ']

   Δείτε επίσης "join()".

str.splitlines(keepends=False)

   Επιστρέφει μια λίστα με τις γραμμές της συμβολοσειράς (string),
   διαχωρίζοντας στα όρια των γραμμών.  Τα διαχωριστικά των γραμμών
   δεν περιλαμβάνονται στην νέα λίστα, εκτός αν δοθεί το *keepends*
   και είναι true.

   Αυτή η μέθοδος διαχωρίζει στα ακόλουθα όρια γραμμών.  Πιο
   συγκεκριμένα, τα όρια είναι ένα υπερσύνολο του *universal
   newlines*.

   +-------------------------+-------------------------------+
   | Αναπαράσταση            | Περιγραφή                     |
   |=========================|===============================|
   | "\n"                    | Line Feed                     |
   +-------------------------+-------------------------------+
   | "\r"                    | Carriage Return               |
   +-------------------------+-------------------------------+
   | "\r\n"                  | Carriage Return + Line Feed   |
   +-------------------------+-------------------------------+
   | "\v" or "\x0b"          | Line Tabulation               |
   +-------------------------+-------------------------------+
   | "\f" or "\x0c"          | Form Feed                     |
   +-------------------------+-------------------------------+
   | "\x1c"                  | Διαχωριστής Αρχείου           |
   +-------------------------+-------------------------------+
   | "\x1d"                  | Διαχωριστής Group             |
   +-------------------------+-------------------------------+
   | "\x1e"                  | Διαχωριστής Εγγραφών          |
   +-------------------------+-------------------------------+
   | "\x85"                  | Επόμενη Γραμμή (C1 Control    |
   |                         | Code)                         |
   +-------------------------+-------------------------------+
   | "\u2028"                | Διαχωριστής Γραμμής           |
   +-------------------------+-------------------------------+
   | "\u2029"                | Διαχωριστής Παραγράφου        |
   +-------------------------+-------------------------------+

   Άλλαξε στην έκδοση 3.2: Τα "\v" και "\f" προστίθενται στην λίστα
   ορίων των γραμμών.

   Για παράδειγμα:

      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
      ['ab c', '', 'de fg', 'kl']
      >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
      ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

   Σε αντίθεση με την "split()" όταν δίνεται μια συμβολοσειρά (string)
   οριοθέτησης *sep*, αυτή η μέθοδος επιστρέφει μια κενή λίστα για το
   κενό αλφαριθμητικό, και μια τερματικό break γραμμής δεν οδηγεί σε
   μια επιπλέον γραμμή:

      >>> "".splitlines()
      []
      >>> "One line\n".splitlines()
      ['One line']

   Συγκριτικά, η "split('\n')" δίνει:

      >>> ''.split('\n')
      ['']
      >>> 'Two lines\n'.split('\n')
      ['Two lines', '']

str.startswith(prefix[, start[, end]])

   Επιστρέφει "True" αν η συμβολοσειρά (string) αρχίζει με το
   *prefix*, αλλιώς επιστρέφει "False". Το *prefix* μπορεί επίσης να
   είναι μια πλειάδα (tuple) prefix προς αναζήτηση.  Με το προαιρετικό
   *start*, ελέγχεται το αλφαριθμητικό που αρχίζει από τη συγκεκριμένη
   θέση.  Με το προαιρετικό *end*, σταματά η σύγκριση της
   συμβολοσειράς σε αυτή τη θέση.

str.strip(chars=None, /)

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με τους πρώτους
   και τους τελευταίους χαρακτήρες να έχουν αφαιρεθεί. Το όρισμα
   *chars* είναι μια συμβολοσειρά που καθορίζει το σύνολο των
   χαρακτήρων που πρέπει να αφαιρεθούν. Εάν παραλειφθεί ή είναι
   "None", το όρισμα *chars* έχει ως default την αφαίρεση των κενών
   διαστημάτων. Το όρισμα *chars* δεν είναι prefix ή suffix· μάλλον,
   όλοι οι συνδυασμοί των τιμών του αφαιρούνται:

      >>> '   spacious   '.strip()
      'spacious'
      >>> 'www.example.com'.strip('cmowz.')
      'example'

   Οι ακραίες αρχικές και τελικές τιμές του ορίσματος *chars*
   αφαιρούνται από τη συμβολοσειρά (string). Οι χαρακτήρες αφαιρούνται
   από το μπροστινό άκρο μέχρι να φτάσουν στο χαρακτήρα της
   συμβολοσειράς (string) που δεν περιέχεται στο σύνολο χαρακτήρων του
   *chars*. Μια παρόμοια ενέργεια λαμβάνει χώρα στο τέλος της ουράς.
   Για παράδειγμα:

      >>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
      >>> comment_string.strip('.#! ')
      'Section 3.2.1 Issue #32'

str.swapcase()

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με κεφαλαίους
   χαρακτήρες που έχουν μετατραπεί σε πεζούς και αντίστροφα. Σημειώστε
   ότι δεν είναι απαραίτητα αληθές ότι "s.swapcase().swapcase() == s".

str.title()

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

   Για παράδειγμα:

      >>> 'Hello world'.title()
      'Hello World'

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

      >>> "they're bill's friends from the UK".title()
      "They'Re Bill'S Friends From The Uk"

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

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

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0).capitalize(),
      ...                   s)
      ...
      >>> titlecase("they're bill's friends.")
      "They're Bill's Friends."

   Δείτε επίσης "istitle()".

str.translate(table, /)

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) στο οποίο κάθε
   χαρακτήρας έχει αντιστοιχιστεί μέσω του πίνακα μετάφρασης.  Ο
   πίνακας πρέπει να είναι ένα αντικείμενο που υλοποιεί
   ευρετηριοποίηση μέσω της "__getitem__()", συνήθως ένα *mapping* ή
   ένα *sequence*.  Όταν το indexing γίνεται με ένα Unicode ordinal
   (ένας ακέραιος), το αντικείμενο του πίνακα μπορεί να κάνει
   οποιοδήποτε από τα ακόλουθα: να επιστρέψει ένα Unicode ordinal ή
   μια συμβολοσειρά (string), να αντιστοιχίσει τον χαρακτήρα σε έναν ή
   περισσότερους άλλους χαρακτήρες· να επιστρέψει "None", για να
   διαγράψει τον χαρακτήρα από τη συμβολοσειρά που επιστρέφεται· ή να
   κάνει raise ένα "LookupError", για να αντιστοιχίσει τον χαρακτήρα
   στον εαυτό του.

   Μπορείτε να χρησιμοποιήσετε το "str.maketrans()" για να
   δημιουργήσετε ένα χάρτη μετάφρασης αντιστοίχισης από
   χαρακτήρα-σε-χαρακτήρα σε διαφορετικές μορφές.

   Δείτε επίσης την ενότητα "codecs" για μια πιο ευέλικτη προσέγγιση
   σε προσαρμοσμένα mappings χαρακτήρων.

str.upper()

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με όλους τους
   χαρακτήρες [4] που έχουν μετατραπεί σε κεφαλαία.  Σημειώστε ότι το
   "s.upper().isupper()" μπορεί να είναι "False" αν το "s" περιέχει
   χαρακτήρες χωρίς πεζά γράμματα ή αν η κατηγορία Unicode του
   προκύπτοντος χαρακτήρα(ων) δεν είναι  "Lu" (Γράμμα, κεφαλαίο), αλλά
   π.χ. "Lt" (Γράμμα, titlecase).

   Ο αλγόριθμος που κάνει τα γράμματα κεφαλαία που χρησιμοποιείται
   περιγράφεται στην ενότητα 3.13 'Default Case Folding' του προτύπου
   Unicode.

str.zfill(width, /)

   Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) που έμεινε
   γεμάτη με ψηφία ASCII "'0'`" για να δημιουργήσει μία συμβολοσειρά
   μήκους *width*. Χειρίζεται ένα leading sign prefix ("'+'"/"'-'")
   εισάγοντας την συμπλήρωση *μετά* τον χαρακτήρα sign αντί για πριν.
   Η αρχική συμβολοσειρά επιστρέφεται εάν το *width* είναι μικρότερο ή
   ίσο με "len(s)".

   Για παράδειγμα:

      >>> "42".zfill(5)
      '00042'
      >>> "-42".zfill(5)
      '-0042'


Διαμορφωμένες Κυριολεκτικές Συμβολοσειρές (f-strings)
-----------------------------------------------------

Added in version 3.6.

Άλλαξε στην έκδοση 3.7: Τα "await" και "async for" μπορούν να
χρησιμοποιηθούν σε εκφράσεις μέσα σε f-strings.

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

Άλλαξε στην έκδοση 3.12: Πολλοί περιορισμοί στις εκφράσεις μέσα σε
f-strings έχουν αφαιρεθεί. Ιδιαίτερα, πλέον επιτρέπονται οι
εμφωλευμένες συμβολοσειρές, τα σχόλια και οι κάθετοι.

An *f-string* (formally a *formatted string literal*) is a string
literal that is prefixed with "f" or "F". This type of string literal
allows embedding the results of arbitrary Python expressions within
*replacement fields*, which are delimited by curly brackets ("{}").
Each replacement field must contain an expression, optionally followed
by:

* a *debug specifier* -- an equal sign ("=");

* a *conversion specifier* -- "!s", "!r" or "!a"; and/or

* a *format specifier* prefixed with a colon (":").

See the Lexical Analysis section on f-strings for details on the
syntax of these fields.


Debug specifier
~~~~~~~~~~~~~~~

Added in version 3.8.

If a debug specifier -- an equal sign ("=") -- appears after the
replacement field expression, the resulting f-string will contain the
expression's source, the equal sign, and the value of the expression.
This is often useful for debugging:

   >>> number = 14.3
   >>> f'{number=}'
   'number=14.3'

Whitespace before, inside and after the expression, as well as
whitespace after the equal sign, is significant --- it is retained in
the result:

   >>> f'{ number  -  4  = }'
   ' number  -  4  = 10.3'


Conversion specifier
~~~~~~~~~~~~~~~~~~~~

By default, the value of a replacement field expression is converted
to a string using "str()":

   >>> from fractions import Fraction
   >>> one_third = Fraction(1, 3)
   >>> f'{one_third}'
   '1/3'

When a debug specifier but no format specifier is used, the default
conversion instead uses "repr()":

   >>> f'{one_third = }'
   'one_third = Fraction(1, 3)'

The conversion can be specified explicitly using one of these
specifiers:

* "!s" for "str()"

* "!r" for "repr()"

* "!a" for "ascii()"

Για παράδειγμα:

   >>> str(one_third)
   '1/3'
   >>> repr(one_third)
   'Fraction(1, 3)'

   >>> f'{one_third!s} is {one_third!r}'
   '1/3 is Fraction(1, 3)'

   >>> string = "¡kočka 😸!"
   >>> ascii(string)
   "'\\xa1ko\\u010dka \\U0001f638!'"

   >>> f'{string = !a}'
   "string = '\\xa1ko\\u010dka \\U0001f638!'"


Format specifier
~~~~~~~~~~~~~~~~

After the expression has been evaluated, and possibly converted using
an explicit conversion specifier, it is formatted using the "format()"
function. If the replacement field includes a *format specifier*
introduced by a colon (":"), the specifier is passed to "format()" as
the second argument. The result of "format()" is then used as the
final value for the replacement field. For example:

   >>> from fractions import Fraction
   >>> one_third = Fraction(1, 3)
   >>> f'{one_third:.6f}'
   '0.333333'
   >>> f'{one_third:_^+10}'
   '___+1/3___'
   >>> >>> f'{one_third!r:_^20}'
   '___Fraction(1, 3)___'
   >>> f'{one_third = :~>10}~'
   'one_third = ~~~~~~~1/3~'


Template String Literals (t-strings)
------------------------------------

An *t-string* (formally a *template string literal*) is a string
literal that is prefixed with "t" or "T".

These strings follow the same syntax and evaluation rules as formatted
string literals, with for the following differences:

* Rather than evaluating to a "str" object, template string literals
  evaluate to a "string.templatelib.Template" object.

* The "format()" protocol is not used. Instead, the format specifier
  and conversions (if any) are passed to a new "Interpolation" object
  that is created for each evaluated expression. It is up to code that
  processes the resulting "Template" object to decide how to handle
  format specifiers and conversions.

* Format specifiers containing nested replacement fields are evaluated
  eagerly, prior to being passed to the "Interpolation" object. For
  instance, an interpolation of the form "{amount:.{precision}f}" will
  evaluate the inner expression "{precision}" to determine the value
  of the "format_spec" attribute. If "precision" were to be "2", the
  resulting format specifier would be "'.2f'".

* When the equals sign "'='" is provided in an interpolation
  expression, the text of the expression is appended to the literal
  string that precedes the relevant interpolation. This includes the
  equals sign and any surrounding whitespace. The "Interpolation"
  instance for the expression will be created as normal, except that
  "conversion" will be set to '"r"' ("repr()") by default. If an
  explicit conversion or format specifier are provided, this will
  override the default behaviour.


"printf"-style String Formatting
--------------------------------

Σημείωση:

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

Τα αντικείμενα string έχουν μια μοναδική ενσωματωμένη λειτουργία: τον
τελεστή "%" (modulo). Αυτός είναι επίσης γνωστός ως τελεστής
*formatting* ή * interpolation*. Δεδομένων των "format % values" (όπου
*format* είναι μία συμβολοσειρά), "%" οι προδιαγραφές μετατροπής στο
*format* αντικαθίστανται από μηδέν ή περισσότερα στοιχεία των
*values*. Το αποτέλεσμα είναι παρόμοιο με τη χρήση του "sprintf()" στη
γλώσσα C. Για παράδειγμα:

   >>> print('%s has %d quote types.' % ('Python', 2))
   Python has 2 quote types.

Εάν το *format* απαιτεί ένα μεμονωμένο όρισμα, το *values* μπορεί να
είναι ένα μεμονωμένο non-tuple αντικείμενο. [5] Διαφορετικά, τα
*values* πρέπει να είναι ένα tuple με ακριβώς τον ίδιο αριθμό των
στοιχείων που καθορίζονται από το format string ή ένα μεμονωμένο
αντικείμενο αντιστοίχισης (για παράδειγμα, ένα λεξικό).

Ένας προσδιοριστής μετατροπής περιέχει δύο ή περισσότερους χαρακτήρες
και έχει τους εξής components, οι οποίοι πρέπει να εμφανίζονται με
αυτή τη σειρά:

1. Ο χαρακτήρας "`%''", που σηματοδοτεί την αρχή του προσδιοριστή.

2. Κλειδί mapping (προαιρετικό), που αποτελείται από μια ακολουθία
   χαρακτήρων σε παρένθεση (για παράδειγμα, "(somename)").

3. Δείκτες μετατροπής (προαιρετικό), που επηρεάζουν το αποτέλεσμα
   κάποιων τύπων μετατροπής.

4. Ελάχιστο πλάτος πεδίου (προαιρετικό). Εάν ορίζεται ως "'*'"
   (αστερίσκος), το πραγματικό πλάτος διαβάζεται από το επόμενο
   στοιχείο του tuple στα *values*, και το αντικείμενο προς μετατροπή
   έρχεται μετά από το ελάχιστο πλάτος πεδίου και το προαιρετικό
   precision.

5. Ακρίβεια (προαιρετικό), δίνεται ως "'.'" (τελεία) ακολουθούμενη από
   το precision.Εάν ορίζεται ως "'*'" (αστερίσκος), το πραγματικό
   precision διαβάζεται από το επόμενο στοιχείο του tuple στα
   *values*, και η τιμή προς μετατροπή έρχεται μετά το precision.

6. Μετατροπέας του length (προαιρετικό).

7. Τύπος conversion.

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

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

Σε αυτήν την περίπτωση δεν μπορεί να υπάρχουν προσδιοριστές "*" σε μια
μορφή (καθώς απαιτούν μια διαδοχική λίστα παραμέτρων).

Οι δείκτες μετατροπής είναι:

+-----------+-----------------------------------------------------------------------+
| Flag      | Έννοια                                                                |
|===========|=======================================================================|
| "'#'"     | Οι μετατροπή τιμής θα χρησιμοποιήσει την "εναλλακτική φόρμα" (όπου    |
|           | ορίζεται παρακάτω).                                                   |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | Η μετατροπή θα έχει μηδενική συμπλήρωση για αριθμητικές τιμές.        |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | Η τιμή μετατροπής αφήνεται προσαρμοσμένη (παρακάμπτει τη μετατροπή    |
|           | "'0'" εάν δίνονται και τα δύο).                                       |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (ένα κενό) Πρέπει να προστεθεί ένα κενό πριν από έναν θετικό αριθμό   |
|           | (ή κενή συμβολοσειρά) που παράγεται από μια υπογεγραμμένη μετατροπή.  |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | Ένα χαρακτήρας προσήμου ("'+'" ή "'-'") θα προηγείται της μετατροπής  |
|           | (παρακάμπτει ένα "κενό" δείκτη).                                      |
+-----------+-----------------------------------------------------------------------+

Ένας τροποποιητής μήκους ("h", "l", or "L") μπορεί να υπάρχει, αλλά
αγνοείται καθώς δεν είναι απαραίτητος για την Python -- οπότε π.χ.
"%ld" είναι πανομοιότυπο σε "%d".

Οι τύποι μετατροπής είναι:

+--------------+-------------------------------------------------------+---------+
| Μετατροπή    | Έννοια                                                | Σημειώ  |
|              |                                                       | σεις    |
|==============|=======================================================|=========|
| "'d'"        | Υπογεγραμμένος δεκαδικός ακέραιος.                    |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | Υπογεγραμμένος δεκαδικός ακέραιος.                    |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | Υπογεγραμμένη οκταδική τιμή.                          | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | Απαρχαιωμένος τύπος -- είναι πανομοιότυπος με το      | (6)     |
|              | "'d'".                                                |         |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | Υπογεγραμμένο δεκαεξαδικό (πεζά).                     | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | Υπογεγραμμένο δεκαεξαδικό (κεφαλαίο).                 | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | Εκθετική μορφή κινητής υποδιαστολής (πεζά)            | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | Εκθετική μορφή κινητής υποδιαστολής (κεφαλαία)        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | Δεκαδική μορφή κινητής υποδιαστολής.                  | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | Δεκαδική μορφή κινητής υποδιαστολής.                  | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | Μορφή κινητής υποδιαστολής. Χρησιμοποιεί εκθετική     | (4)     |
|              | μορφή πεζών αν ο εκθέτης είναι μικρότερος από -4 ή    |         |
|              | όχι μικρότερος από την ακρίβεια, διαφορετικά          |         |
|              | χρησιμοποιεί δεκαδική μορφή.                          |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | Μορφή κινητής υποδιαστολής. Χρησιμοποιεί εκθετική     | (4)     |
|              | μορφή κεφαλαίων εάν ο εκθέτης είναι μικρότερος από -4 |         |
|              | ή όχι μικρότερος από την ακρίβεια, διαφορετικά        |         |
|              | χρησιμοποιεί δεκαδική μορφή.                          |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | Μεμονωμένος χαρακτήρας (δέχεται ακέραιο ή μονό        |         |
|              | χαρακτήρα συμβολοσειράς).                             |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | Συμβολοσειρά (μετατρέπει οποιοδήποτε αντικείμενο      | (5)     |
|              | Python χρησιμοποιώντας "repr()").                     |         |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | Συμβολοσειρά (μετατρέπει οποιοδήποτε αντικείμενο      | (5)     |
|              | Python χρησιμοποιώντας "str()").                      |         |
+--------------+-------------------------------------------------------+---------+
| "'a'"        | Συμβολοσειρά (μετατρέπει οποιοδήποτε αντικείμενο      | (5)     |
|              | Python χρησιμοποιώντας "ascii()").                    |         |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | Κανένα όρισμα δεν μετατρέπεται, έχει ως αποτέλεσμα    |         |
|              | έναν χαρακτήρα "'%'" το αποτέλεσμα.                   |         |
+--------------+-------------------------------------------------------+---------+

Σημειώσεις:

1. Η εναλλακτική μορφή προκαλεί την εισαγωγή ενός πρώτου οκταδικού
   προσδιοριστή ("'0o'") πριν από το πρώτο ψηφίο.

2. Η εναλλακτική φόρμα προκαλεί την εισαγωγή ενός αρχικού "'0x'" ή
   "'0X'" (ανάλογα με το εάν χρησιμοποιήθηκε η μορφή "'x'" ή "'X'")
   πριν το πρώτο ψηφίο.

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

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

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

   Η ακρίβεια καθορίζει τον αριθμό των σημαντικών ψηφίων πριν και μετά
   την υποδιαστολή και ορίζει το 6.

5. Εάν η ακρίβεια είναι "N", η έξοδος περικόπτεται σε "N" χαρακτήρες.

6. Βλέπε **PEP 237**.

Δεδομένου ότι οι συμβολοσειρές Python έχουν ρητό μήκος, οι "%s"
μετατροπές δεν υποθέτουν ότι το "'\0'" είναι το τέλος της
συμβολοσειράς.

Άλλαξε στην έκδοση 3.1: Οι μετατροπείς "%f" για αριθμούς των οποίων η
απόλυτη τιμή είναι μεγαλύτερη από 1e50 δεν αντικαθίστανται πλέον από
μετατροπές "%g".


Τύποι δυαδικής ακολουθίας --- "bytes", "bytearray", "memoryview"
================================================================

Οι βασικοί ενσωματωμένοι (built-in) τύποι για τον χειρισμό δυαδικών
δεδομένων είναι "bytes" και "bytearray". Υποστηρίζονται από τη
"memoryview" που χρησιμοποιεί το πρωτόκολλο buffer protocol για την
πρόσβαση στη μνήμη άλλων δυαδικών αντικειμένων χωρίς να χρειάζεται η
δημιουργία αντιγράφου.

Το module "array" υποστηρίζει αποδοτική αποθήκευση για βασικούς τύπους
δεδομένων όπως 32-bit ακέραιους και IEEE754 διπλής ακρίβειας κινητής
υποδιαστολής τιμές.


Αντικείμενα Bytes
-----------------

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

class bytes(source=b'')
class bytes(source, encoding, errors='strict')

   Πρώτον, η σύνταξη για τα bytes literals είναι σε μεγάλο βαθμό η
   ίδια με αυτή για τα literals συμβολοσειρών, με τη διαφορά ότι
   προστίθεται ένα πρόθεμα "b":

   * Μονά εισαγωγικά: "b'ακόμα επιτρέπει ενσωματωμένα "διπλά"
     εισαγωγικά'"

   * Διπλά εισαγωγικά: "b"εξακολουθεί να επιτρέπει ενσωματωμένα 'μονά'
     εισαγωγικά""

   * Τριπλά εισαγωγικά: "b'''3 μονά εισαγωγικά'''", "b"""3 διπλά
     εισαγωγικά""""

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

   Όπως και με τα literals συμβολοσειρών, τα bytes literals μπορούν
   επίσης να χρησιμοποιήσουν ένα πρόθεμα "r" για να απενεργοποιήσουν
   την επεξεργασία των ακολουθιών διαφυγής χαρακτήρων. Βλέπε String
   and Bytes literals για περισσότερες πληροφορίες σχετικά με τις
   διάφορες μορφές bytes literal, συμπεριλαμβανομένων των
   υποστηριζόμενων ακολουθιών διαφυγής χαρακτήρων.

   Ενώ τα bytes literals και οι αναπαραστάσεις βασίζονται σε κείμενο
   ASCII, τα αντικείμενα bytes συμπεριφέρονται στην πραγματικότητα σαν
   αμετάβλητες ακολουθίες ακεραίων με κάθε τιμή στην ακολουθία
   περιορισμένη έτσι ώστε "0 <= x < 256" (προσπάθειες παραβίασης αυτού
   του περιορισμού θα κάνουν raise την "ValueError"). Αυτό γίνεται
   σκόπιμα για να τονιστεί ότι, ενώ πολλές δυαδικές μορφές
   περιλαμβάνουν στοιχεία που βασίζονται σε ASCII και μπορούν να
   χρησιμοποιηθούν χρήσιμα με ορισμένους αλγορίθμους
   προσανατολισμένους στο κείμενο, αυτό δεν ισχύει γενικά για
   αυθαίρετα δυαδικά δεδομένα (τυφλή εφαρμογή αλγορίθμων επεξεργασίας
   κειμένου σε δυαδικές μορφές δεδομένων που δεν είναι συμβατές με
   ASCII συνήθως οδηγεί σε καταστροφή δεδομένων).

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

   * Ένα μηδενικό αντικείμενο bytes με καθορισμένο μήκος: "bytes(10)"

   * Από ένα iterable ακεραίων αριθμών: "bytes(range(20))"

   * Αντιγραφή υπαρχόντων δυαδικών δεδομένων μέσω του πρωτοκόλλου
     buffer:  "bytes(obj)"

   Δείτε επίσης το ενσωματωμένο bytes.

   Δεδομένου ότι 2 δεκαεξαδικά ψηφία αντιστοιχούν ακριβώς σε ένα μόνο
   byte, οι δεκαεξαδικοί αριθμοί είναι μια συνήθως χρησιμοποιούμενη
   μορφή για την περιγραφή δυαδικών δεδομένων. Συνεπώς, ο τύπος bytes
   έχει μια πρόσθετη μέθοδο κλάσης για την ανάγνωση δεδομένων σε αυτήν
   την μορφή:

   classmethod fromhex(string, /)

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

      >>> bytes.fromhex('2Ef0 F1f2  ')
      b'.\xf0\xf1\xf2'

      Άλλαξε στην έκδοση 3.7: Το "bytes.fromhex()" παρακάμπτει πλέον
      όλα τα κενά ASCII στη συμβολοσειρά, όχι μόνο τα κενά.

      Άλλαξε στην έκδοση 3.14: Η "bytes.fromhex()" δέχεται πλέον ASCII
      "bytes" και *bytes-like objects* ως είσοδο.

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

   hex(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

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

      >>> b'\xf0\xf1\xf2'.hex()
      'f0f1f2'

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

      >>> value = b'\xf0\xf1\xf2'
      >>> value.hex('-')
      'f0-f1-f2'
      >>> value.hex('_', 2)
      'f0_f1f2'
      >>> b'UUDDLRLRAB'.hex(' ', -4)
      '55554444 4c524c52 4142'

      Added in version 3.5.

      Άλλαξε στην έκδοση 3.8: Η "bytes.hex()" υποστηρίζει πλέον
      προαιρετικές παραμέτρους *sep* και *bytes_per_sep* για την
      εισαγωγή διαχωριστικών μεταξύ των byte στην έξοδο δεκαεξαδικού.

Δεδομένου ότι τα αντικείμενα bytes είναι ακολουθίες ακεραίων αριθμών
(όμοια με μια πλειάδα (tuple)), για ένα αντικείμενο bytes *b*, το
"b[0]" θα είναι ένας ακέραιος αριθμός, ενώ το "b[0:1]" θα είναι ένα
αντικείμενο bytes μήκους 1. (Αυτό έρχεται σε αντίθεση με τις
συμβολοσειρές κειμένου, όπου τόσο η λειτουργία πρόσβασης ως ευρετήριο
όσο και η λειτουργία τμηματοποίησης θα παράγουν μια συμβολοσειρά
μήκους 1)

Η αναπαράσταση αντικειμένων bytes χρησιμοποιεί την literal μορφή
("b'...'") , καθώς είναι συχνά πιο χρήσιμη από π.χ. "bytes([46, 46,
46])".  Μπορείτε πάντα να μετατρέψετε ένα αντικείμενο bytes σε μια
λίστα ακέραιων αριθμών που χρησιμοποιούν "list(b)".


Αντικείμενα Bytearray
---------------------

Τα αντικείμενα "bytearray" είναι ένα μεταβλητό, αντίστοιχο, των
αντικειμένων "bytes".

class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')

   Δεν υπάρχει αποκλειστική literal σύνταξη για αντικείμενα bytearray,
   αντίθετα δημιουργούνται πάντα καλώντας τον constructor:

   * Δημιουργία ενός κενού στιγμιοτύπου: "bytearray()"

   * Δημιουργία μηδενικού στιγμιοτύπου με δεδομένο μήκος:
     "bytearray(10)"

   * Από έναν iterable αριθμό ακεραίων: "bytearray(range(20))"

   * Αντιγραφή υπαρχόντων δυαδικών δεδομένων μέσω του πρωτοκόλλου
     buffer:  "bytearray(b'Hi!')"

   Καθώς τα αντικείμενα του bytearray είναι μεταβλητά, υποστηρίζουν
   τις λειτουργίες της ακολουθίας mutable επιπλέον των κοινών
   λειτουργιών bytes και bytearray που περιγράφονται στο Λειτουργίες
   Bytes και Bytearray.

   Δείτε επίσης το ενσωματωμένο bytearray.

   Δεδομένου ότι 2 δεκαεξαδικά ψηφία αντιστοιχούν ακριβώς σε ένα μόνο
   byte, οι δεκαεξαδικοί αριθμοί είναι συνήθως χρησιμοποιούμενη μορφή
   για την περιγραφή δυαδικών δεδομένων. Συνεπώς, ο τύπος bytearray
   έχει μια πρόσθετη μέθοδο κλάσης για την ανάγνωση δεδομένων σε αυτήν
   την μορφή:

   classmethod fromhex(string, /)

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

      >>> bytearray.fromhex('2Ef0 F1f2  ')
      bytearray(b'.\xf0\xf1\xf2')

      Άλλαξε στην έκδοση 3.7: Το "bytearray.fromhex()" παρακάμπτει
      τώρα όλα τα κενά ASCII στη συμβολοσειρά, όχι μόνο τα κενά.

      Άλλαξε στην έκδοση 3.14: Η "bytearray.fromhex()" δέχεται πλέον
      το ASCII "bytes" και *bytes-like objects* ως είσοδο.

   Υπάρχει μια συνάρτηση αντίστροφης μετατροπής για να μετατρέψει ένα
   αντικείμενο bytearray στη δεκαεξαδική αναπαράσταση του.

   hex(*, bytes_per_sep=1)
   hex(sep, bytes_per_sep=1)

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

      >>> bytearray(b'\xf0\xf1\xf2').hex()
      'f0f1f2'

      Added in version 3.5.

      Άλλαξε στην έκδοση 3.8: Παρόμοια με το "bytes.hex()", το
      "bytearray.hex()" υποστηρίζει τώρα προαιρετικές παραμέτρους
      *sep* και *bytes_per_sep* για την εισαγωγή διαχωριστικών μεταξύ
      των byte στην δεκαεξαδική έξοδο.

   resize(size, /)

      Αλλάζει το μέγεθος του "bytearray" ώστε αν περιέχει *size*
      bytes. Το *size* πρέπει να είναι μεγαλύτερο ή ίσο με το 0.

      Εάν η "bytearray" χρειάζεται να συρρικνωθεί, τα bytes πέραν του
      *size* περικόπτονται.

      Εάν η "bytearray" χρειάζεται να αυξηθεί, όλα τα νέα bytes, αυτά
      που είναι πέρα από το *size*, θα οριστούν σε null bytes.

      Ισοδύναμο με:

      >>> def resize(ba, size):
      ...     if len(ba) > size:
      ...         del ba[size:]
      ...     else:
      ...         ba += b'\0' * (size - len(ba))

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

      >>> shrink = bytearray(b'abc')
      >>> shrink.resize(1)
      >>> (shrink, len(shrink))
      (bytearray(b'a'), 1)
      >>> grow = bytearray(b'abc')
      >>> grow.resize(5)
      >>> (grow, len(grow))
      (bytearray(b'abc\x00\x00'), 5)

      Added in version 3.14.

Δεδομένου ότι τα αντικείμενα bytearray είναι ακολουθίες ακεραίων
αριθμών (παρόμοια με μια λίστα), για ένα αντικείμενο bytearray *b*, το
"b[0]" θα είναι ένας ακέραιος αριθμός, ενώ το "b[0:1]" θα είναι ένα
αντικείμενο bytearray μήκους 1.  (Αυτό έρχεται σε αντίθεση με τις
συμβολοσειρές κειμένου, όπου τόσο το indexing και το slicing θα
παράγουν μια συμβολοσειρά μήκους 1)

Η αναπαράσταση αντικειμένων bytearray χρησιμοποιεί τη μορφή bytes
literal ("bytearray(b'...')"), καθώς είναι συχνά πιο χρήσιμη από π.χ.
"bytearray([46, 46, 46])".  Μπορείτε πάντα να μετατρέψετε ένα
αντικείμενο bytearray σε λίστα ακεραίων χρησιμοποιώντας το "list(b)".


Λειτουργίες Bytes και Bytearray
-------------------------------

Τόσο τα byte όσο και τα αντικείμενα του πίνακα byte υποστηρίζουν τις
λειτουργίες της ακολουθίας common. Αλληλεπιδρούν όχι μόνο με τελεστές
του ίδιου τύπου, αλλά και με οποιοδήποτε αντικείμενο *bytes-like
object*. Λόγω αυτής της ευελιξίας, μπορούν να αναμειχθούν ελεύθερα σε
λειτουργίες χωρίς να προκαλούνται σφάλματα. Ωστόσο, ο τύπος επιστροφής
του αποτελέσματος μπορεί να εξαρτάται από τη σειρά των τελεστών.

Σημείωση:

  Οι μέθοδοι στα bytes και τα αντικείμενα bytearray δεν δέχονται
  συμβολοσειρές ως ορίσματά τους, όπως και οι μέθοδοι σε συμβολοσειρές
  δεν δέχονται bytes ως ορίσματα.  Για παράδειγμα, πρέπει να γράψετε:

     a = "abc"
     b = a.replace("a", "f")

  και:

     a = b"abc"
     b = a.replace(b"a", b"f")

Ορισμένες λειτουργίες byte και bytearray προϋποθέτουν τη χρήση
δυαδικών μορφών συμβατών με ASCII και, ως εκ τούτου, θα πρέπει να
αποφεύγονται όταν εργάζεστε με αυθαίρετα δυαδικά δεδομένα. Αυτοί οι
περιορισμοί καλύπτονται παρακάτω.

Σημείωση:

  Η χρήση αυτών των λειτουργιών βασίζονται στο ASCII για τον χειρισμό
  δυαδικών δεδομένων που δεν είναι αποθηκευμένα σε μορφή που βασίζεται
  σε ASCII μπορεί να οδηγήσει σε καταστροφή δεδομένων.

Οι ακόλουθες μέθοδοι σε byte και αντικείμενα bytearray μπορούν να
χρησιμοποιηθούν με αυθαίρετα δυαδικά δεδομένα.

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

   Επιστρέφει τον αριθμό των μη επικαλυπτόμενων εμφανίσεων της
   δευτερεύουσας ακολουθίας *sub* στο εύρος [*start*, *end*]. Τα
   προαιρετικά ορίσματα *start* και *end* ερμηνεύονται όπως στη
   σημειογραφία τμηματοποίησης.

   Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object* ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

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

   Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο
   εύρος 0 έως 255 ως υποακολουθία.

bytes.removeprefix(prefix, /)
bytearray.removeprefix(prefix, /)

   Εάν τα δυαδικά δεδομένα ξεκινούν με τη συμβολοσειρά *prefix*,
   επιστρέφει "bytes[len(prefix):]". Διαφορετικά επιστρέψτε ένα
   αντίγραφο των αρχικών δυαδικών δεδομένων:

      >>> b'TestHook'.removeprefix(b'Test')
      b'Hook'
      >>> b'BaseTestCase'.removeprefix(b'Test')
      b'BaseTestCase'

   Το *prefix* μπορεί να είναι οποιοδήποτε *bytes-like object*.

   Σημείωση:

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

   Added in version 3.9.

bytes.removesuffix(suffix, /)
bytearray.removesuffix(suffix, /)

   Εάν τα δυαδικά δεδομένα τελειώνουν με τη συμβολοσειρά *suffix* και
   αυτό το *suffix* δεν είναι κενό, επιστρέφει "bytes[:-len(suffix)]".
   Διαφορετικά, επιστρέφει ένα αντίγραφο των αρχικών δυαδικών
   δεδομένων:

      >>> b'MiscTests'.removesuffix(b'Tests')
      b'Misc'
      >>> b'TmpDirMixin'.removesuffix(b'Tests')
      b'TmpDirMixin'

   Το *suffix* μπορεί να είναι οποιοδήποτε *bytes-like object*.

   Σημείωση:

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

   Added in version 3.9.

bytes.decode(encoding='utf-8', errors='strict')
bytearray.decode(encoding='utf-8', errors='strict')

   Επιστρέφει τα bytes που έχουν αποκωδικοποιηθεί σε μια "str".

   το *encoding* έχει default σε "'utf-8'"- δείτε Standard Encodings
   για πιθανές τιμές.

   Το *errors* ελέγχει τον τρόπο χειρισμού των σφαλμάτων
   αποκωδικοποίησης. Εάν "'strict'" (η προεπιλογή), γίνεται raise μια
   εξαίρεση "UnicodeError". Άλλες πιθανές τιμές είναι το "'ignore'",
   "'replace'", και οποιοδήποτε άλλο όνομα που έχει καταχωρηθεί από
   την "codecs.register_error()". Βλέπε Error Handlers για
   λεπτομέρειες.

   Για λόγους απόδοσης, η τιμή του *errors* δεν ελέγχεται ως προς την
   εγκυρότητα του, εκτός εάν παρουσιαστεί ένα σφάλμα αποκωδικοποίησης,
   είναι ενεργοποιημένο το Python Development Mode ή χρησιμοποιείται
   ένα debug build.

   Σημείωση:

     Η μετάδοση του ορίσματος *encoding* στην "str" επιτρέπει την
     αποκωδικοποίηση οποιουδήποτε *bytes-like object* απευθείας, χωρίς
     να χρειάζεται να δημιουργήσετε ένα προσωρινό αντικείμενο "bytes"
     ή "bytearray".

   Άλλαξε στην έκδοση 3.1: Επιπρόσθετη υποστήριξη για keyword
   ορίσματα.

   Άλλαξε στην έκδοση 3.9: Η τιμή του όρου *errors* ελέγχεται τώρα στο
   Python Development Mode και στο debug mode.

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

   Επιστρέφει "True" εάν τα δυαδικά δεδομένα τελειώνουν με το
   καθορισμένο *suffix*, διαφορετικά επιστρέφει "False".  Το *suffix*
   μπορεί επίσης να είναι μια πλειάδα από επιθέματα που πρέπει να
   αναζητήσετε.  Με το προαιρετικό *start*, η δοκιμή ξεκινά από αυτή
   τη θέση.  Με το προαιρετικό *end*, σταματήστε να συγκρίνετε σε αυτή
   τη θέση.

   Το(α) επίθεμα(τα) για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object*.

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

   Επιστρέφει το χαμηλότερο index στα δεδομένα όπου βρίσκεται η
   υποακολουθία *sub*, έτσι ώστε το *sub* να περιέχεται  στο slice
   "s[start:end]".  Τα προαιρετικά ορίσματα *start* και *end*
   ερμηνεύονται ως συμβολισμό τμηματοποίησης.  Επιστρέφει "-1" εάν το
   *sub* δεν βρεθεί.

   Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object* ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

   Σημείωση:

     Η μέθοδος "find()" θα πρέπει να χρησιμοποιείται μόνο εάν
     χρειάζεται να γνωρίζετε τη θέση του *sub*.  Για να ελέγξετε εάν
     το *sub* είναι υποσυμβολοσειρά ή όχι, χρησιμοποιήστε τον τελεστή
     "in":

        >>> b'Py' in b'Python'
        True

   Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο
   εύρος 0 έως 255 ως υποακολουθία.

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

   Όπως η "find()", αλλά κάνει raise μια "ValueError" όταν δεν βρεθεί
   η δευτερεύουσα ακολουθία.

   Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object* ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

   Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο
   εύρος 0 έως 255 ως υποακολουθία.

bytes.join(iterable, /)
bytearray.join(iterable, /)

   Επιστρέφει ένα αντικείμενο bytes ή bytearray που είναι η συνένωση
   των δυαδικών ακολουθιών δεδομένων στο *iterable*.  Μια "TypeError"
   θα γίνει raise εάν υπάρχουν τιμές στο *iterable* που δεν είναι σαν
   *bytes-like objects*, συμπεριλαμβανομένων των αντικειμένων "str".
   Το διαχωριστικό μεταξύ των στοιχειών είναι τα περιεχόμενα των byte
   ή του αντικειμένου bytearray που παρέχει αυτή τη μέθοδο.

static bytes.maketrans(from, to, /)
static bytearray.maketrans(from, to, /)

   Αυτή η στατική μέθοδος επιστρέφει έναν πίνακα μετάφρασης που μπορεί
   να χρησιμοποιηθεί για την "bytes.translate()" που θα αντιστοιχίσει
   κάθε χαρακτήρα στο *from* στον χαρακτήρα στην ίδια θέση στο *to*·
   τα *from* και *to* πρέπει να είναι και τα δύο *bytes-like objects*
   και να έχουν το ίδιο μήκος.

   Added in version 3.1.

bytes.partition(sep, /)
bytearray.partition(sep, /)

   Διαχωρίζει την ακολουθία κατά την πρώτη εμφάνιση του *sep*, και
   επιστρέφει μια 3-πλειάδα που περιέχει το τμήμα πριν από το
   διαχωριστικό ή το αντίγραφο του bytearray του και το τμήμα μετά το
   διαχωριστικό. Εάν δεν βρεθεί το διαχωριστικό, επιστρέφει μια
   3-πλειάδα που περιέχει ένα αντίγραφο της αρχικής ακολουθίας,
   ακολουθούμενη από δύο κενά byte ή αντικείμενα bytearray.

   Το διαχωριστικό για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object*.

bytes.replace(old, new, count=-1, /)
bytearray.replace(old, new, count=-1, /)

   Επιστρέφει ένα αντίγραφο της ακολουθίας με όλες τις εμφανίσεις της
   δευτερεύουσας ακολουθίας *old* αντικαθιστούμενη από την *new*.  Εάν
   δοθεί το προαιρετικό όρισμα *count*, αντικαθίστανται μόνο οι πρώτες
   εμφανίσεις *count*.

   Η ακολουθία για αναζήτηση και αντικατάσταση της μπορεί να είναι
   οποιοδήποτε *bytes-like object*.

   Σημείωση:

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

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])

   Επιστρέφει τον υψηλότερο δείκτη στην ακολουθία όπου βρίσκεται η
   υποακολουθία *sub*, έτσι ώστε το *sub* να περιέχεται στο
   "s[start:end]".  Τα προαιρετικά ορίσματα *start* και *end*
   ερμηνεύονται με συμβολισμό τμηματοποίησης. Επιστρέφει "-1" σε
   περίπτωση αποτυχίας.

   Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object* ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

   Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο
   εύρος 0 έως 255 ως υποακολουθία.

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

   Όπως η "rfind()" αλλά κάνει raise μια "ValueError" όταν δεν βρεθεί
   η υποακολουθία *sub*.

   Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object* ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

   Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο
   εύρος 0 έως 255 ως υποακολουθία.

bytes.rpartition(sep, /)
bytearray.rpartition(sep, /)

   Διαχωρίζει την ακολουθία στην τελευταία εμφάνιση του *sep*, και
   επιστρέφει μια 3-πλειάδα που περιέχει το τμήμα πριν από το
   διαχωριστικό, το ίδιο το διαχωριστικό ή το αντίγραφο του bytearray
   και το τμήμα μετά το διαχωριστικό. Εάν δεν βρεθεί το διαχωριστικό
   επιστρέφει μια 3-πλειάδα που περιέχει δύο κενά byte ή αντικείμενα
   bytearray, ακολουθούμενα από ένα αντίγραφο της αρχικής ακολουθίας.

   Το διαχωριστικό για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object*.

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

   Επιστρέφει "True" εάν τα δυαδικά δεδομένα ξεκινούν με το
   καθορισμένο *prefix*, διαφορετικά επιστρέφει "False". Το *prefix*
   μπορεί επίσης να είναι μια πλειάδα από προθέματα προς αναζήτηση.
   Με το προαιρετικό *start*, η δοκιμή ξεκινά από αυτή τη θέση.  Με το
   προαιρετικό *end*, σταματάει να συγκρίνει σε αυτή τη θέση.

   Το(α) πρόθεμα(τα) για αναζήτηση μπορεί να είναι οποιοδήποτε *bytes-
   like object*.

bytes.translate(table, /, delete=b'')
bytearray.translate(table, /, delete=b'')

   Επιστρέφει ένα αντίγραφο των bytes ή του αντικειμένου bytearray
   όπου αφαιρούνται όλα τα byte που εμφανίζονται στο προαιρετικό
   όρισμα *delete* και τα υπόλοιπα byte έχουν αντιστοιχιστεί μέσω του
   δεδομένου πίνακα μετάφρασης, ο οποίος πρέπει να είναι ένα
   αντικείμενο bytes μήκους 256.

   Μπορείτε να χρησιμοποιήσετε τη μέθοδο "bytes.maketrans()" για να
   δημιουργήσετε έναν πίνακα μετάφρασης.

   Ορίζει το όρισμα *table* σε "None" για μεταφράσεις που διαγράφουν
   μόνο χαρακτήρες:

      >>> b'read this short text'.translate(None, b'aeiou')
      b'rd ths shrt txt'

   Άλλαξε στην έκδοση 3.6: Το *delete* υποστηρίζεται πλέον ως όρισμα
   λέξης-κλειδιού.

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

bytes.center(width, fillbyte=b' ', /)
bytearray.center(width, fillbyte=b' ', /)

   Επιστρέφει ένα αντίγραφο του αντικειμένου με κέντρο σε μια
   ακολουθία μήκους *width*. Η συμπλήρωση πραγματοποιείται
   χρησιμοποιώντας το καθορισμένο *fillbyte* (η προεπιλογή είναι ένα
   διάστημα ASCII). Για αντικείμενα "bytes", η αρχική ακολουθία
   επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με "len(s)".

   Σημείωση:

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

bytes.ljust(width, fillbyte=b' ', /)
bytearray.ljust(width, fillbyte=b' ', /)

   Επιστρέφει ένα αντίγραφο του αντικειμένου αριστερά ευθυγραμμισμένο
   σε μια ακολουθία μήκους *width*. Η συμπλήρωση πραγματοποιείται
   χρησιμοποιώντας το καθορισμένο *fillbyte* (η προεπιλογή είναι ένα
   διάστημα ASCII). Για αντικείμενα "bytes", η αρχική ακολουθία
   επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με "len(s)".

   Σημείωση:

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

bytes.lstrip(bytes=None, /)
bytearray.lstrip(bytes=None, /)

   Επιστρέφει ένα αντίγραφο της ακολουθίας με καθορισμένα βασικά byte
   που έχουν αφαιρεθεί.  Το όρισμα *bytes* είναι μια δυαδική ακολουθία
   που καθορίζει το σύνολο των τιμών byte που πρέπει να αφαιρεθούν.
   Εάν παραληφθεί ή είναι "None", το όρισμα *bytes* έχει ως προεπιλογή
   την αφαίρεση  του κενού διαστήματος  ASCII.  Το όρισμα *bytes* δεν
   είναι πρόθεμα∙ αλλά οι συνδυασμοί των τιμών του αφαιρούνται:

      >>> b'   spacious   '.lstrip()
      b'spacious   '
      >>> b'www.example.com'.lstrip(b'cmowz.')
      b'example.com'

   Η δυαδική ακολουθία τιμών byte προς κατάργηση μπορεί να είναι
   οποιαδήποτε *bytes-like object*. Βλέπε "removeprefix()" για μια
   μέθοδο που θα αφαιρέσει μια μεμονωμένη συμβολοσειρά προθέματος αντί
   όλο το σύνολο χαρακτήρων.  Για παράδειγμα:

      >>> b'Arthur: three!'.lstrip(b'Arthur: ')
      b'ee!'
      >>> b'Arthur: three!'.removeprefix(b'Arthur: ')
      b'three!'

   Σημείωση:

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

bytes.rjust(width, fillbyte=b' ', /)
bytearray.rjust(width, fillbyte=b' ', /)

   Επιστρέφει ένα αντίγραφο του αντικειμένου ευθυγραμμισμένο δεξιά που
   δικαιολογείται σε μια ακολουθία μήκους *width*. Η συμπλήρωση
   πραγματοποιείται χρησιμοποιώντας το καθορισμένο *fillbyte* (η
   προεπιλογή είναι ένα διάστημα ASCII). Για αντικείμενα "bytes", η
   αρχική ακολουθία επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο
   με "len(s)".

   Σημείωση:

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

bytes.rsplit(sep=None, maxsplit=-1)
bytearray.rsplit(sep=None, maxsplit=-1)

   Διαχωρίζει τη δυαδική ακολουθία σε υποακολουθίες του ίδιου τύπου,
   χρησιμοποιώντας το *sep* ως συμβολοσειρά οριοθέτησης. Εάν δοθεί
   *maxsplit*, γίνονται το πολύ *maxsplit* διαχωρισμοί, οι
   *rightmost*.  Εάν δεν καθορίζεται *sep* ή "None", οποιαδήποτε
   υποακολουθία που αποτελείται αποκλειστικά από κενό διάστημα ASCII
   είναι διαχωριστικό, εκτός από το διαχωρισμό από τα δεξιά, η
   "rsplit()" συμπεριφέρεται όπως "split()" που περιγράφεται
   λεπτομερώς παρακάτω.

bytes.rstrip(bytes=None, /)
bytearray.rstrip(bytes=None, /)

   Επιστρέφει ένα αντίγραφο της ακολουθίας με τα καθορισμένα
   δευτερεύοντα bytes που έχουν αφαιρεθεί.  Το όρισμα *bytes* είναι
   μια δυαδική ακολουθία που καθορίζει το σύνολο των τιμών byte που
   πρέπει να αφαιρεθούν. Εάν παραληφθεί ή είναι "None", το όρισμα
   *bytes* έχει ως προεπιλογή την αφαίρεση του κενού διαστήματος
   ASCII.  Το όρισμα *bytes* δεν είναι επίθημα, αλλά αφαιρούνται όλοι
   οι συνδυασμοί των τιμών του:

      >>> b'   spacious   '.rstrip()
      b'   spacious'
      >>> b'mississippi'.rstrip(b'ipz')
      b'mississ'

   Η δυαδική ακολουθία τιμών byte προς κατάργηση μπορεί να είναι
   οποιοδήποτε *bytes-like object*.  Βλέπε τη "removesuffix()" για μια
   μέθοδο που θα αφαιρέσει μια συμβολοσειρά επιθέματος και όχι όλο το
   σύνολο χαρακτήρων.  Για παράδειγμα:

      >>> b'Monty Python'.rstrip(b' Python')
      b'M'
      >>> b'Monty Python'.removesuffix(b' Python')
      b'Monty'

   Σημείωση:

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

bytes.split(sep=None, maxsplit=-1)
bytearray.split(sep=None, maxsplit=-1)

   Διαχωρίζει την δυαδική ακολουθία σε υποακολουθίες του ίδιου τύπου,
   χρησιμοποιώντας το *sep* ως συμβολοσειρά οριοθέτησης Εάν δοθεί
   *maxsplit* και μη αρνητικό, γίνονται το πολύ *maxsplit* διαχωρισμοί
   (άρα, η λίστα θα έχε το πολύ "maxsplit+1" στοιχεία).  Εάν το
   *maxsplit* δεν έχει καθοριστεί ή είναι "-1", τότε δεν υπάρχει όριο
   στον αριθμό των διαχωρισμών (όλες οι πιθανές διασπάσεις γίνονται).

   Αν δοθεί το *sep*, οι διαδοχικοί οριοθέτες δεν ομαδοποιούνται και
   θεωρείται ότι οριοθετούν κενές υποακολουθίες (για παράδειγμα,
   "b'1,,2'.split(b',')" επιστρέφει το "[b'1', b'', b'2']").  Το
   όρισμα *sep* μπορεί να αποτελείται από μια ακολουθία πολλών byte ως
   μεμονωμένο οριοθέτη. Ο διαχωρισμός μιας κενής ακολουθίας με ένα
   καθορισμένο διαχωριστικό επιστρέφει το "[b'']" ή το
   "[bytearray(b'')]" ανάλογα με τον τύπο του αντικειμένου που
   χωρίζεται. Το όρισμα *sep* μπορεί να είναι οποιοδήποτε *bytes-like
   object*.

   Για παράδειγμα:

      >>> b'1,2,3'.split(b',')
      [b'1', b'2', b'3']
      >>> b'1,2,3'.split(b',', maxsplit=1)
      [b'1', b'2,3']
      >>> b'1,2,,3,'.split(b',')
      [b'1', b'2', b'', b'3', b'']
      >>> b'1<>2<>3<4'.split(b'<>')
      [b'1', b'2', b'3<4']

   Εάν το *sep* δεν έχει καθοριστεί ή είναι "None", εφαρμόζεται ένας
   διαφορετικός αλγόριθμος διαχωρισμού: οι εκτελέσεις διαδοχικών κενών
   διαστημάτων ASCII θεωρούνται ως ένα ενιαίο διαχωριστικό, και το
   αποτέλεσμα δεν θα περιέχει κενές συμβολοσειρές στην αρχή ή στο
   τέλος, εάν η ακολουθία έχει κενό που έπεται ή προηγείται. Κατά
   συνέπεια, ο διαχωρισμός μιας κενής ακολουθίας ή μιας ακολουθίας που
   αποτελείται αποκλειστικά από κενό διάστημα ASCII χωρίς καθορισμένο
   διαχωριστικό επιστρέφει το "[]".

   Για παράδειγμα:

      >>> b'1 2 3'.split()
      [b'1', b'2', b'3']
      >>> b'1 2 3'.split(maxsplit=1)
      [b'1', b'2 3']
      >>> b'   1   2   3   '.split()
      [b'1', b'2', b'3']

bytes.strip(bytes=None, /)
bytearray.strip(bytes=None, /)

   Επιστρέφει ένα αντίγραφο της ακολουθίας με τα καθορισμένα bytes που
   προηγούνται και τα bytes που έπονται. Το όρισμα *bytes* είναι μια
   δυαδική ακολουθία που καθορίζει το σύνολο των τιμών byte που πρέπει
   να αφαιρεθούν. Εάν παραλείπεται ή είναι "None", το όρισμα *bytes*
   από προεπιλογή αφαιρεί το ASCII λευκό διάστημα. To όρισμα *bytes*
   δεν είναι πρόθεμα ή επίθημα, αλλά αφαιρούνται όλοι οι συνδυασμοί
   των τιμών του:

      >>> b'   spacious   '.strip()
      b'spacious'
      >>> b'www.example.com'.strip(b'cmowz.')
      b'example'

   Η δυαδική ακολουθία τιμών byte προς αφαίρεση μπορεί να είναι
   οποιοδήποτε *bytes-like object*.

   Σημείωση:

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

Οι ακόλουθες μέθοδοι σε byte και αντικείμενα bytearray προϋποθέτουν τη
χρήση δυαδικών μορφών συμβατών με ASCII και δεν πρέπει να εφαρμόζονται
σε αυθαίρετα δυαδικά δεδομένα. Σημειώστε ότι όλες οι μέθοδοι bytearray
σε αυτήν την ενότητα *δεν* λειτουργούν στη θέση τους και αντ' αυτού
παράγουν νέα αντικείμενα.

bytes.capitalize()
bytearray.capitalize()

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

   Σημείωση:

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

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

   Επιστρέφει ένα αντίγραφο της ακολουθίας όπου όλοι οι tab χαρακτήρες
   ASCII αντικαθίστανται από ένα ή περισσότερα κενά ASCII, ανάλογα με
   την τρέχουσα στήλη και το δεδομένο μέγεθος tab.  Οι θέσεις των tab
   εμφανίζονται κάθε *tabsize* bytes (η προεπιλογή είναι 8, δίνοντας
   θέσεις καρτελών στις στήλες 0, 8, 16 και ούτω καθεξής).  Για την
   επέκταση της ακολουθίας, η τρέχουσα στήλη ορίζεται στο μηδέν και η
   ακολουθία εξετάζεται byte προς byte.  Εάν το byte είναι tab
   χαρακτήρας ASCII ("b'\t'"), ένας ή περισσότεροι χαρακτήρες
   διαστήματος εισάγονται στο αποτέλεσμα έως ότου η τρέχουσα στήλη
   ισούται με την επόμενη θέση tab. (Ο ίδιος tab χαρακτήρας δεν
   αντιγράφεται.)  Εάν το τρέχον byte είναι μια νέα γραμμή ASCII
   ("b'\n'"), αντιγράφεται και η τρέχουσα στήλη επαναφέρεται στο
   μηδέν.  Οποιαδήποτε άλλη τιμή byte αντιγράφεται αμετάβλητη και η
   τρέχουσα στήλη προσαυξάνεται κατά ένα, ανεξάρτητα από το πώς
   αναπαρίσταται η τιμή byte όταν εκτυπώνεται:

      >>> b'01\t012\t0123\t01234'.expandtabs()
      b'01      012     0123    01234'
      >>> b'01\t012\t0123\t01234'.expandtabs(4)
      b'01  012 0123    01234'

   Σημείωση:

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

bytes.isalnum()
bytearray.isalnum()

   Επιστρέφει "True" εάν όλα τα byte της ακολουθίας είναι αλφαβητικοί
   χαρακτήρες ASCII ή ASCII δεκαδικά ψηφία και η ακολουθία δεν είναι
   κενή, "False" διαφορετικά. Οι αλφαβητικοί χαρακτήρες ASCII είναι
   εκείνες οι τιμές byte στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'". Τα
   δεκαδικά ψηφία ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'0123456789'".

   Για παράδειγμα:

      >>> b'ABCabc1'.isalnum()
      True
      >>> b'ABC abc1'.isalnum()
      False

bytes.isalpha()
bytearray.isalpha()

   Επιστρέφει "True" εάν όλα τα bytes της ακολουθίας είναι αλφαβητικοί
   χαρακτήρες ASCII και η ακολουθία δεν είναι κενή, "False"
   διαφορετικά.  Οι αλφαβητικοί χαρακτήρες ASCII είναι εκείνες οι
   τιμές bytes στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Για παράδειγμα:

      >>> b'ABCabc'.isalpha()
      True
      >>> b'ABCabc1'.isalpha()
      False

bytes.isascii()
bytearray.isascii()

   Επιστρέφει "True" εάν η ακολουθία είναι κενή ή όλα τα byte της
   ακολουθίας είναι ASCII, "False" διαφορετικά. Τα bytes ASCII
   βρίσκονται στο εύρος 0-0x7F.

   Added in version 3.7.

bytes.isdigit()
bytearray.isdigit()

   Επιστρέφει "True" εάν όλα τα bytes στην ακολουθία είναι δεκαδικά
   ψηφία ASCII και η ακολουθία δεν είναι κενή, "False" διαφορετικά. Τα
   δεκαδικά ψηφία ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'0123456789'".

   Για παράδειγμα:

      >>> b'1234'.isdigit()
      True
      >>> b'1.23'.isdigit()
      False

bytes.islower()
bytearray.islower()

   Επιστρέφει "True" εάν υπάρχει τουλάχιστον ένας πεζός χαρακτήρας
   ASCII στην ακολουθία και κανένας κεφαλαίος χαρακτήρας ASCII,
   "False" διαφορετικά.

   Για παράδειγμα:

      >>> b'hello world'.islower()
      True
      >>> b'Hello world'.islower()
      False

   Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyz'". Οι κεφαλαίοι χαρακτήρες ASCII
   είναι αυτές οι τιμές byte στην ακολουθία
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

bytes.isspace()
bytearray.isspace()

   Επιστρέφει "True" εάν όλα τα byte στην ακολουθία είναι κενά ASCII
   και η ακολουθία δεν είναι κενή, "False" διαφορετικά.  Οι χαρακτήρες
   κενού διαστήματος ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b' \t\n\r\x0b\f'" (κενό, tab, νέα γραμμή, επιστροφή μεταφοράς,
   κάθετο tab, μορφή ροής).

bytes.istitle()
bytearray.istitle()

   Επιστρέφει "True" εάν η ακολουθία είναι ASCII κεφαλαία τίτλου
   (δηλαδή τα πρώτα γράμματα των λέξεων κεφαλαία) και η ακολουθία δεν
   είναι κενή, "False" διαφορετικά. Δείτε "bytes.title()" για
   περισσότερες λεπτομέρειες σχετικά με τον ορισμό του "titlecase".

   Για παράδειγμα:

      >>> b'Hello World'.istitle()
      True
      >>> b'Hello world'.istitle()
      False

bytes.isupper()
bytearray.isupper()

   Επιστρέφει "True" εάν υπάρχει τουλάχιστον ένας κεφαλαίος
   αλφαβητικός χαρακτήρας ASCII στην ακολουθία και κανένας πεζός
   χαρακτήρας ASCII, διαφορετικά "False".

   Για παράδειγμα:

      >>> b'HELLO WORLD'.isupper()
      True
      >>> b'Hello world'.isupper()
      False

   Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyz'". Οι κεφαλαίοι χαρακτήρες ASCII
   είναι αυτές οι τιμές byte στην ακολουθία
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

bytes.lower()
bytearray.lower()

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

   Για παράδειγμα:

      >>> b'Hello World'.lower()
      b'hello world'

   Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyz'". Οι κεφαλαίοι χαρακτήρες ASCII
   είναι αυτές οι τιμές byte στην ακολουθία
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Σημείωση:

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

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

   Επιστρέφει μια λίστα με τις γραμμές στη δυαδική ακολουθία,
   σπάζοντας τα όρια γραμμής του ASCII. Αυτή η μέθοδος χρησιμοποιεί
   την προσέγγιση *universal newlines* για τον διαχωρισμό των γραμμών.
   Οι αλλαγές γραμμής δεν περιλαμβάνονται στη λίστα που προκύπτει
   εκτός εάν δοθεί *keepends* και είναι αληθής.

   Για παράδειγμα:

      >>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
      [b'ab c', b'', b'de fg', b'kl']
      >>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
      [b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

   Σε αντίθεση με το "split()" όταν δίνεται μια οριοθετημένη
   συμβολοσειρά *sep*, αυτή η μέθοδος επιστρέφει μια κενή λίστα για
   την κενή συμβολοσειρά και μια αλλαγή γραμμής τερματικού δεν οδηγεί
   σε μια επιπλέον γραμμή:

      >>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
      ([b''], [b'Two lines', b''])
      >>> b"".splitlines(), b"One line\n".splitlines()
      ([], [b'One line'])

bytes.swapcase()
bytearray.swapcase()

   Επιστρέφει ένα αντίγραφο της ακολουθίας με όλους τους πεζούς
   χαρακτήρες ASCII να έχουν μετατραπεί στο αντίστοιχο ισοδύναμο
   κεφαλαίο και αντίστροφα.

   Για παράδειγμα:

      >>> b'Hello World'.swapcase()
      b'hELLO wORLD'

   Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyz'". Οι κεφαλαίοι χαρακτήρες ASCII
   είναι αυτές οι τιμές byte στην ακολουθία
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Σε αντίθεση με το "str.swapcase()", συμβαίνει πάντα ότι
   "bin.swapcase().swapcase() == bin" για τις δυαδικές εκδόσεις. Οι
   μετατροπές κεφαλαίων είναι συμμετρικές στο ASCII, παρόλο που αυτό
   δεν ισχύει γενικά για αυθαίρετα σημεία Unicode κώδικα.

   Σημείωση:

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

bytes.title()
bytearray.title()

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

   Για παράδειγμα:

      >>> b'Hello world'.title()
      b'Hello World'

   Οι πεζοί χαρακτήρες ASCII είναι εκείνες οι τιμές byte στην
   ακολουθία "b'abcdefghijklmnopqrstuvwxyz'". Οι κεφαλαίο χαρακτήρες
   ASCII είναι εκείνες οι τιμές byte στην ακολουθία
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'". Όλες οι άλλες τιμές byte είναι
   χωρίς κεφαλαία.

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

      >>> b"they're bill's friends from the UK".title()
      b"They'Re Bill'S Friends From The Uk"

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

      >>> import re
      >>> def titlecase(s):
      ...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
      ...                   lambda mo: mo.group(0)[0:1].upper() +
      ...                              mo.group(0)[1:].lower(),
      ...                   s)
      ...
      >>> titlecase(b"they're bill's friends.")
      b"They're Bill's Friends."

   Σημείωση:

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

bytes.upper()
bytearray.upper()

   Επιστρέφει ένα αντίγραφο της ακολουθίας με όλους τους πεζούς
   χαρακτήρες ASCII να έχουν μετατραπεί στο αντίστοιχο ισοδύναμο
   κεφαλαίο.

   Για παράδειγμα:

      >>> b'Hello World'.upper()
      b'HELLO WORLD'

   Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία
   "b'abcdefghijklmnopqrstuvwxyz'". Οι κεφαλαίοι χαρακτήρες ASCII
   είναι αυτές οι τιμές byte στην ακολουθία
   "b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'".

   Σημείωση:

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

bytes.zfill(width, /)
bytearray.zfill(width, /)

   Επιστρέφει ένα αντίγραφο της ακολουθίας που έχει απομείνει γεμάτο
   με ψηφία ASCII "b'0'" για να δημιουργήσετε μια ακολουθία μήκους
   *width*. Ένα πρόθεμα προπορευόμενου σήματος ("b'+'"/ "b'-'")
   αντιμετωπίζεται με την εισαγωγή της συμπλήρωσης του *after*
   χαρακτήρα προσήμου και όχι πριν. Για αντικείμενα "bytes", η αρχική
   ακολουθία επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με
   "len(seq)".

   Για παράδειγμα:

      >>> b"42".zfill(5)
      b'00042'
      >>> b"-42".zfill(5)
      b'-0042'

   Σημείωση:

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


Μορφοποίηση Bytes τύπου "printf"
--------------------------------

Σημείωση:

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

Τα αντικείμενα bytes ("bytes"/"bytearray") έχουν μια μοναδική
ενσωματωμένη λειτουργία: τον τελεστή "%" (modulo). Αυτό είναι επίσης
γνωστό ως τελεστής bytes *formatting* ή *interpolation*. Δεδομένων των
"format % values" (όπου το *format* είναι αντικείμενο bytes), οι
προδιαγραφές μετατροπής "%" σε *format* αντικαθιστά με μηδέν ή
περισσότερα στοιχεία *values*. Το αποτέλεσμα είναι παρόμοιο με τη
χρήση του "sprintf()" στη γλώσσας C.

Εάν το *format* απαιτεί ένα μεμονωμένο όρισμα, το *values* μπορεί να
είναι ένα μεμονωμένο μη πολλαπλό αντικείμενο. [5] Διαφορετικά, το
*values* πρέπει να είναι πλειάδα με ακριβώς τον αριθμό των στοιχείων
που καθορίζονται από το αντικείμενο μορφής bytes ή μεμονωμένο mapping
αντικείμενο (για παράδειγμα, ένα λεξικό).

Ένας προσδιοριστής μετατροπής περιέχει δύο ή περισσότερους χαρακτήρες
και έχει τους εξής components, οι οποίοι πρέπει να εμφανίζονται με
αυτή τη σειρά:

1. Ο χαρακτήρας "`%''", που σηματοδοτεί την αρχή του προσδιοριστή.

2. Κλειδί mapping (προαιρετικό), που αποτελείται από μια ακολουθία
   χαρακτήρων σε παρένθεση (για παράδειγμα, "(somename)").

3. Δείκτες μετατροπής (προαιρετικό), που επηρεάζουν το αποτέλεσμα
   κάποιων τύπων μετατροπής.

4. Ελάχιστο πλάτος πεδίου (προαιρετικό). Εάν ορίζεται ως "'*'"
   (αστερίσκος), το πραγματικό πλάτος διαβάζεται από το επόμενο
   στοιχείο του tuple στα *values*, και το αντικείμενο προς μετατροπή
   έρχεται μετά από το ελάχιστο πλάτος πεδίου και το προαιρετικό
   precision.

5. Ακρίβεια (προαιρετικό), δίνεται ως "'.'" (τελεία) ακολουθούμενη από
   το precision.Εάν ορίζεται ως "'*'" (αστερίσκος), το πραγματικό
   precision διαβάζεται από το επόμενο στοιχείο του tuple στα
   *values*, και η τιμή προς μετατροπή έρχεται μετά το precision.

6. Μετατροπέας του length (προαιρετικό).

7. Τύπος conversion.

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

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

Σε αυτήν την περίπτωση δεν μπορεί να υπάρχουν προσδιοριστές "*" σε μια
μορφή (καθώς απαιτούν μια διαδοχική λίστα παραμέτρων).

Οι δείκτες μετατροπής είναι:

+-----------+-----------------------------------------------------------------------+
| Flag      | Έννοια                                                                |
|===========|=======================================================================|
| "'#'"     | Οι μετατροπή τιμής θα χρησιμοποιήσει την "εναλλακτική φόρμα" (όπου    |
|           | ορίζεται παρακάτω).                                                   |
+-----------+-----------------------------------------------------------------------+
| "'0'"     | Η μετατροπή θα έχει μηδενική συμπλήρωση για αριθμητικές τιμές.        |
+-----------+-----------------------------------------------------------------------+
| "'-'"     | Η τιμή μετατροπής αφήνεται προσαρμοσμένη (παρακάμπτει τη μετατροπή    |
|           | "'0'" εάν δίνονται και τα δύο).                                       |
+-----------+-----------------------------------------------------------------------+
| "' '"     | (ένα κενό) Πρέπει να προστεθεί ένα κενό πριν από έναν θετικό αριθμό   |
|           | (ή κενή συμβολοσειρά) που παράγεται από μια υπογεγραμμένη μετατροπή.  |
+-----------+-----------------------------------------------------------------------+
| "'+'"     | Ένα χαρακτήρας προσήμου ("'+'" ή "'-'") θα προηγείται της μετατροπής  |
|           | (παρακάμπτει ένα "κενό" δείκτη).                                      |
+-----------+-----------------------------------------------------------------------+

Ένας τροποποιητής μήκους ("h", "l", or "L") μπορεί να υπάρχει, αλλά
αγνοείται καθώς δεν είναι απαραίτητος για την Python -- οπότε π.χ.
"%ld" είναι πανομοιότυπο σε "%d".

Οι τύποι μετατροπής είναι:

+--------------+-------------------------------------------------------+---------+
| Μετατροπή    | Έννοια                                                | Σημειώ  |
|              |                                                       | σεις    |
|==============|=======================================================|=========|
| "'d'"        | Υπογεγραμμένος δεκαδικός ακέραιος.                    |         |
+--------------+-------------------------------------------------------+---------+
| "'i'"        | Υπογεγραμμένος δεκαδικός ακέραιος.                    |         |
+--------------+-------------------------------------------------------+---------+
| "'o'"        | Υπογεγραμμένη οκταδική τιμή.                          | (1)     |
+--------------+-------------------------------------------------------+---------+
| "'u'"        | Απαρχαιωμένος τύπος -- είναι πανομοιότυπος με το      | (8)     |
|              | "'d'".                                                |         |
+--------------+-------------------------------------------------------+---------+
| "'x'"        | Υπογεγραμμένο δεκαεξαδικό (πεζά).                     | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'X'"        | Υπογεγραμμένο δεκαεξαδικό (κεφαλαίο).                 | (2)     |
+--------------+-------------------------------------------------------+---------+
| "'e'"        | Εκθετική μορφή κινητής υποδιαστολής (πεζά)            | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'E'"        | Εκθετική μορφή κινητής υποδιαστολής (κεφαλαία)        | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'f'"        | Δεκαδική μορφή κινητής υποδιαστολής.                  | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'F'"        | Δεκαδική μορφή κινητής υποδιαστολής.                  | (3)     |
+--------------+-------------------------------------------------------+---------+
| "'g'"        | Μορφή κινητής υποδιαστολής. Χρησιμοποιεί εκθετική     | (4)     |
|              | μορφή πεζών αν ο εκθέτης είναι μικρότερος από -4 ή    |         |
|              | όχι μικρότερος από την ακρίβεια, διαφορετικά          |         |
|              | χρησιμοποιεί δεκαδική μορφή.                          |         |
+--------------+-------------------------------------------------------+---------+
| "'G'"        | Μορφή κινητής υποδιαστολής. Χρησιμοποιεί εκθετική     | (4)     |
|              | μορφή κεφαλαίων εάν ο εκθέτης είναι μικρότερος από -4 |         |
|              | ή όχι μικρότερος από την ακρίβεια, διαφορετικά        |         |
|              | χρησιμοποιεί δεκαδική μορφή.                          |         |
+--------------+-------------------------------------------------------+---------+
| "'c'"        | Μονό byte (δέχεται ακέραια ή μεμονωμένα byte          |         |
|              | αντικείμενα).                                         |         |
+--------------+-------------------------------------------------------+---------+
| "'b'"        | Bytes (κάθε αντικείμενο που ακολουθεί το buffer       | (5)     |
|              | protocol ή έχει "__bytes__()").                       |         |
+--------------+-------------------------------------------------------+---------+
| "'s'"        | Το "'s'" είναι ένα ψευδώνυμο για το "'b'" και θα      | (6)     |
|              | πρέπει να χρησιμοποιείται μόνο για κώδικα βάσει       |         |
|              | Python2/3.                                            |         |
+--------------+-------------------------------------------------------+---------+
| "'a'"        | Bytes (μετατρέπει οποιοδήποτε αντικείμενο Python      | (5)     |
|              | χρησιμοποιώντας "repr(obj).encode('ascii',            |         |
|              | 'backslashreplace')").                                |         |
+--------------+-------------------------------------------------------+---------+
| "'r'"        | Το "'r'" είναι ένα ψευδώνυμο για "'a'" και θα πρέπει  | (7)     |
|              | να χρησιμοποιείται μόνο για βάσεις κώδικα Python2/3.  |         |
+--------------+-------------------------------------------------------+---------+
| "'%'"        | Κανένα όρισμα δεν μετατρέπεται, έχει ως αποτέλεσμα    |         |
|              | έναν χαρακτήρα "'%'" το αποτέλεσμα.                   |         |
+--------------+-------------------------------------------------------+---------+

Σημειώσεις:

1. Η εναλλακτική μορφή προκαλεί την εισαγωγή ενός πρώτου οκταδικού
   προσδιοριστή ("'0o'") πριν από το πρώτο ψηφίο.

2. Η εναλλακτική φόρμα προκαλεί την εισαγωγή ενός αρχικού "'0x'" ή
   "'0X'" (ανάλογα με το εάν χρησιμοποιήθηκε η μορφή "'x'" ή "'X'")
   πριν το πρώτο ψηφίο.

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

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

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

   Η ακρίβεια καθορίζει τον αριθμό των σημαντικών ψηφίων πριν και μετά
   την υποδιαστολή και ορίζει το 6.

5. Εάν η ακρίβεια είναι "N", η έξοδος περικόπτεται σε "N" χαρακτήρες.

6. Το "b'%s'" έχει καταργηθεί, αλλά δεν θα αφαιρεθεί κατά τη διάρκεια
   της σειράς 3.x.

7. Το "b'%r'" έχει καταργηθεί, αλλά δεν θα αφαιρεθεί κατά τη διάρκεια
   της σειράς 3.x.

8. Βλέπε **PEP 237**.

Σημείωση:

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

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

  **PEP 461** - Προσθήκη % για μορφοποίηση σε bytes και bytearray

Added in version 3.5.


Όψεις Μνήμης
------------

Τα αντικείμενα "memoryview" επιτρέπουν στον κώδικα Python να έχει
πρόσβαση στα εσωτερικά δεδομένα ενός αντικειμένου που υποστηρίζει το
πρωτόκολλο buffer protocol χωρίς αντιγραφή.

class memoryview(object)

      Δημιουργεί μια "memoryview" που αναφέρεται στο *object*.  Το
      *object* πρέπει να υποστηρίζει το πρωτόκολλο buffer.  Τα
      ενσωματωμένα αντικείμενα που υποστηρίζουν το πρωτόκολλο buffer
      περιλαμβάνουν "bytes" και "bytearray".

      Μια "memoryview" έχει την έννοια ενός *στοιχείου*, το οποίο
      είναι η μονάδα ατομικής μνήμης που χειρίζεται το αρχικό
      *object*.  Για πολλούς απλούς τύπους όπως "bytes" και
      "bytearray", ένα στοιχείο είναι ένα μεμονωμένο byte, αλλά άλλοι
      τύποι όπως "array.array" μπορεί να έχουν μεγαλύτερα στοιχεία.

      Το "len(view)" ισούται με το μήκος του "tolist", το οποίο είναι
      η ένθετη αναπαράσταση κατά την προβολή της λίστας. Εάν
      "view.ndim = 1", αυτό ισούται με τον αριθμό των στοιχείων για
      την προβολή.

      Άλλαξε στην έκδοση 3.12: Εάν "view.ndim == 0", το "len(view)"
      τώρα κάνει raise μια "TypeError" αντί να επιστρέψει 1.

      Το χαρακτηριστικό "itemsize" θα σας δώσει τον αριθμό των byte σε
      ένα μόνο στοιχείο.

      Μια "memoryview" υποστηρίζει λειτουργίες τμηματοποίησης και
      πρόσβαση μέσω ευρετηρίου στα δεδομένα του. Μια μονοδιάστατη
      τμηματοποίηση θα έχει ως αποτέλεσμα μια δευτερεύουσα προβολή:

         >>> v = memoryview(b'abcefg')
         >>> v[1]
         98
         >>> v[-1]
         103
         >>> v[1:4]
         <memory at 0x7f3ddc9f4350>
         >>> bytes(v[1:4])
         b'bce'

      Εάν το "format" είναι ένας από τους προσδιοριστές εγγενούς
      μορφής από το module "struct", η πρόσβαση μέσω ευρετηρίου με
      έναν ακέραιο ή μια πλειάδα (tuple) ακεραίων υποστηρίζεται επίσης
      και επιστρέφει ένα μεμονωμένο *στοιχείο* με το σωστό τύπο.  Τα
      μονοδιάστατα memoryviews μπορούν να γίνουν indexed με έναν
      ακέραιο ή έναν ακέραιο πλειάδα (tuple).  Τα πολυδιάστατα
      memoryviews μπορούν αν γίνουν indexed με πλειάδες (tuples)
      ακριβώς *ndim* ακεραίων όπου *ndim* είναι ο αριθμός των
      διαστάσεων.  Τα μηδενικών διαστάσεων memoryviews μπορούν να
      γίνουν indexed με την κενή πλειάδα (tuple).

      Ακολουθεί ένα παράδειγμα με μη-byte μορφή:

         >>> import array
         >>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
         >>> m = memoryview(a)
         >>> m[0]
         -11111111
         >>> m[-1]
         44444444
         >>> m[::2].tolist()
         [-11111111, -33333333]

      Εάν το βασικό αντικείμενο είναι εγγράψιμο, το memoryview
      υποστηρίζει μονοδιάστατη εκχώρηση τμηματοποίησης. Δεν
      επιτρέπεται η αλλαγή μεγέθους:

         >>> data = bytearray(b'abcefg')
         >>> v = memoryview(data)
         >>> v.readonly
         False
         >>> v[0] = ord(b'z')
         >>> data
         bytearray(b'zbcefg')
         >>> v[1:4] = b'123'
         >>> data
         bytearray(b'z123fg')
         >>> v[2:3] = b'spam'
         Traceback (most recent call last):
           File "<stdin>", line 1, in <module>
         ValueError: memoryview assignment: lvalue and rvalue have different structures
         >>> v[2:6] = b'spam'
         >>> data
         bytearray(b'z1spam')

      Τα μονοδιάστατα memoryviews των τύπων *hashable* (μόνο για
      ανάγνωση) με μορφές 'B', 'b' ή 'c' μπορούν επίσης να
      κατακερματιστούν. Ο κατακερματισμός ορίζεται ως "hash(m) ==
      hash(m.tobytes())":

         >>> v = memoryview(b'abcefg')
         >>> hash(v) == hash(b'abcefg')
         True
         >>> hash(v[2:4]) == hash(b'ce')
         True
         >>> hash(v[::-2]) == hash(b'abcefg'[::-2])
         True

      Άλλαξε στην έκδοση 3.3: Τα μονοδιάστατα memoryviews μπορούν
      πλέον να τμηματοποιηθούν. Τα μονοδιάστατα memoryviews με μορφές
      'B', 'b' ή 'c' είναι πλέον *hashable*.

      Άλλαξε στην έκδοση 3.4: το memoryview εγγράφεται πλέον αυτόματα
      με "collections.abc.Sequence"

      Άλλαξε στην έκδοση 3.5: τα memoryviews μπορούν τώρα να γίνουν
      ευρετηριοποίηση με πλειάδα (tuple) ακεραίων.

      Άλλαξε στην έκδοση 3.14: το memoryview είναι πλέον ένα *generic
      type*.

      το "memoryview" έχει διάφορες μεθόδους:

      __eq__(exporter)

         Ένα memoryview και ένας εξαγωγέας **PEP 3118** είναι ίσοι εάν
         τα σχήματα τους είναι ισοδύναμα και εάν όλες οι αντίστοιχες
         τιμές είναι ίσες όταν οι αντίστοιχοι κωδικοί μορφής των
         τελεστών ερμηνεύονται χρησιμοποιώντας τη σύνταξη "struct".

         Για το υποσύνολο του "struct" οι συμβολοσειρές μορφής που
         υποστηρίζονται αυτή τη στιγμή από το "tolist()", "v" και "w"
         είναι ίσες εάν "v.tolist() == w.tolist()":

            >>> import array
            >>> a = array.array('I', [1, 2, 3, 4, 5])
            >>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
            >>> c = array.array('b', [5, 3, 1])
            >>> x = memoryview(a)
            >>> y = memoryview(b)
            >>> x == a == y == b
            True
            >>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
            True
            >>> z = y[::-2]
            >>> z == c
            True
            >>> z.tolist() == c.tolist()
            True

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

            >>> from ctypes import BigEndianStructure, c_long
            >>> class BEPoint(BigEndianStructure):
            ...     _fields_ = [("x", c_long), ("y", c_long)]
            ...
            >>> point = BEPoint(100, 200)
            >>> a = memoryview(point)
            >>> b = memoryview(point)
            >>> a == point
            False
            >>> a == b
            False

         Λάβετε υπόψη ότι, όπως και με τους αριθμούς κινητής
         υποδιαστολής, "v is w" *δεν* σημαίνει "v == w" για
         αντικείμενα memoryview.

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

      tobytes(order='C')

         Επιστρέφει τα δεδομένα στο buffer ως ένα bytestring.  Αυτό
         ισοδυναμεί με την κλήση του κατασκευαστή "bytes" στο
         memoryview.

            >>> m = memoryview(b"abc")
            >>> m.tobytes()
            b'abc'
            >>> bytes(m)
            b'abc'

         Για μη συνεχόμενους πίνακες, το αποτέλεσμα είναι ίσο με την
         αναπαράσταση της ισοπεδωμένης λίστας με όλα τα στοιχεία να
         μετατρέπονται σε bytes. Η "tobytes()" υποστηρίζει όλες τις
         συμβολοσειρές μορφής, συμπεριλαμβανομένων εκείνων που δεν
         είναι στη σύνταξη του module "struct".

         Added in version 3.8: Το *order* μπορεί να είναι {'C', 'F',
         'A'}.  Όταν το *order* είναι 'C' ή 'F', τα δεδομένα του
         αρχικού πίνακα μετατρέπονται σε C ή σε σειρά Fortran. Για
         συνεχόμενες όψεις, το 'A' επιστρέφει ένα ακριβές αντίγραφο
         της φυσικής μνήμης. Συγκεκριμένα, διατηρείται σειρά Fortran
         στη μνήμη. Για μη συνεχόμενες προβολές, τα δεδομένα
         μετατρέπονται πρώτα σε C. Το *order=None* είναι το ίδιο με το
         *order='C'*.

      hex(*, bytes_per_sep=1)
      hex(sep, bytes_per_sep=1)

         Επιστρέφει ένα αντικείμενο συμβολοσειράς που περιέχει δύο
         δεκαεξαδικά ψηφία για κάθε byte στο buffer.

            >>> m = memoryview(b"abc")
            >>> m.hex()
            '616263'

         Added in version 3.5.

         Άλλαξε στην έκδοση 3.8: Παρόμοιο με το "bytes.hex()", το
         "memoryview.hex()" τώρα υποστηρίζει προαιρετικές παραμέτρους
         *sep* και *bytes_per_sep* για να εισάγετε διαχωριστικά μεταξύ
         των byte στην εξαγωγή δεκαεξαδικού.

      tolist()

         Επιστρέψτε τα δεδομένα στο buffer ως λίστα στοιχείων.

            >>> memoryview(b'abc').tolist()
            [97, 98, 99]
            >>> import array
            >>> a = array.array('d', [1.1, 2.2, 3.3])
            >>> m = memoryview(a)
            >>> m.tolist()
            [1.1, 2.2, 3.3]

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

      toreadonly()

         Επιστρέφει μια έκδοση μόνο για ανάγνωση του αντικειμένου
         memoryview.  Το αρχικό αντικείμενο memoryview είναι
         αμετάβλητο.

            >>> m = memoryview(bytearray(b'abc'))
            >>> mm = m.toreadonly()
            >>> mm.tolist()
            [97, 98, 99]
            >>> mm[0] = 42
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            TypeError: cannot modify read-only memory
            >>> m[0] = 43
            >>> mm.tolist()
            [43, 98, 99]

         Added in version 3.8.

      release()

         Απελευθερώνει το υποκείμενο buffer που εκτίθεται από το
         αντικείμενο memoryview.  Πολλά αντικείμενα πραγματοποιούν
         ειδικές ενέργειες όταν διατηρείται μια προβολή σε αυτά (για
         παράδειγμα, μια "bytearray" θα απαγόρευε προσωρινά την αλλαγή
         μεγέθους)· επομένως, η κλήση της release() είναι βολική για
         την κατάργηση αυτών των περιορισμών (και απελευθερώνει
         οποιουσδήποτε αιωρούμενους πόρους) το συντομότερο δυνατό.

         Μετά την κλήση αυτής της μεθόδου, οποιαδήποτε περαιτέρω
         λειτουργία στην προβολή δημιουργεί μια "ValueError" (εκτός
         από την ίδια την "release()" που μπορεί να κληθεί πολλές
         φορές):

            >>> m = memoryview(b'abc')
            >>> m.release()
            >>> m[0]
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            ValueError: operation forbidden on released memoryview object

         Το πρωτόκολλο διαχείρισης περιεχομένου μπορεί να
         χρησιμοποιηθεί για παρόμοιο αποτέλεσμα, χρησιμοποιώντας τη
         δήλωση "with":

            >>> with memoryview(b'abc') as m:
            ...     m[0]
            ...
            97
            >>> m[0]
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            ValueError: operation forbidden on released memoryview object

         Added in version 3.2.

      cast(format, /)
      cast(format, shape, /)

         Μορφοποιεί ένα memoryview σε νέα μορφή ή σχήμα. Το *shape*
         είναι από προεπιλογή "[byte_length//new_itemsize]", που
         σημαίνει ότι η προβολή αποτελέσματος θα είναι μονοδιάστατη. Η
         επιστρεφόμενη τιμή είναι ένα νέο memoryview, αλλά το ίδιο το
         buffer δεν αντιγράφεται. Οι υποστηριζόμενες μετατροπές είναι
         1D -> C-*contiguous* και C-contiguous -> 1D.

         Η μορφή προορισμού περιορίζεται σε μια εγγενή μορφή
         μεμονωμένου στοιχείου στη σύνταξη "struct". Μία από τις
         μορφές πρέπει να είναι μορφή byte ('B', 'b' ή 'c'). Το μήκος
         byte του αποτελέσματος πρέπει να είναι το ίδιο με το αρχικό
         μήκος. Σημειώστε ότι όλα τα μήκη byte μπορεί να εξαρτώνται
         από το λειτουργικό σύστημα.

         Μορφοποίηση από 1D/long σε 1D/unsigned bytes:

            >>> import array
            >>> a = array.array('l', [1,2,3])
            >>> x = memoryview(a)
            >>> x.format
            'l'
            >>> x.itemsize
            8
            >>> len(x)
            3
            >>> x.nbytes
            24
            >>> y = x.cast('B')
            >>> y.format
            'B'
            >>> y.itemsize
            1
            >>> len(y)
            24
            >>> y.nbytes
            24

         Μορφοποίηση από 1D/unsigned bytes σε 1D/char:

            >>> b = bytearray(b'zyz')
            >>> x = memoryview(b)
            >>> x[0] = b'a'
            Traceback (most recent call last):
              ...
            TypeError: memoryview: invalid type for format 'B'
            >>> y = x.cast('c')
            >>> y[0] = b'a'
            >>> b
            bytearray(b'ayz')

         Μορφοποίηση από 1D/bytes σε 3D/ints σε 1D/signed char:

            >>> import struct
            >>> buf = struct.pack("i"*12, *list(range(12)))
            >>> x = memoryview(buf)
            >>> y = x.cast('i', shape=[2,2,3])
            >>> y.tolist()
            [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
            >>> y.format
            'i'
            >>> y.itemsize
            4
            >>> len(y)
            2
            >>> y.nbytes
            48
            >>> z = y.cast('b')
            >>> z.format
            'b'
            >>> z.itemsize
            1
            >>> len(z)
            48
            >>> z.nbytes
            48

         Μορφοποίηση από 1D/unsigned long σε 2D/unsigned long:

            >>> buf = struct.pack("L"*6, *list(range(6)))
            >>> x = memoryview(buf)
            >>> y = x.cast('L', shape=[2,3])
            >>> len(y)
            2
            >>> y.nbytes
            48
            >>> y.tolist()
            [[0, 1, 2], [3, 4, 5]]

         Added in version 3.3.

         Άλλαξε στην έκδοση 3.5: Η πηγαία μορφή δεν είναι πλέον
         περιορισμένη κατά τη μορφοποίηση σε μια όψη byte.

      count(value, /)

         Μετράει τον αριθμό των εμφανίσεων του *value*.

         Added in version 3.14.

   index(value, start=0, stop=sys.maxsize, /)

         Επιστρέφει τον δείκτη της πρώτης εμφάνισης του *value* (στην
         ή μετά τον δείκτη *start* και πριν από τον δείκτη *stop*).

         Κάνει raise μια "ValueError" αν δεν μπορεί να βρεθεί η τιμή
         *value*.

         Added in version 3.14.

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

      obj

         Το βασικό αντικείμενο του memoryview:

            >>> b  = bytearray(b'xyz')
            >>> m = memoryview(b)
            >>> m.obj is b
            True

         Added in version 3.3.

      nbytes

         "nbytes == product(shape) * itemsize == len(m.tobytes())".
         Αυτή είναι η ποσότητα χώρου σε byte που θα χρησιμοποιούσε ο
         πίνακας σε μια συνεχόμενη αναπαράσταση. Δεν ισούται
         απαραίτητα με "len(m)":

            >>> import array
            >>> a = array.array('i', [1,2,3,4,5])
            >>> m = memoryview(a)
            >>> len(m)
            5
            >>> m.nbytes
            20
            >>> y = m[::2]
            >>> len(y)
            3
            >>> y.nbytes
            12
            >>> len(y.tobytes())
            12

         Πολυδιάστατοι πίνακες:

            >>> import struct
            >>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
            >>> x = memoryview(buf)
            >>> y = x.cast('d', shape=[3,4])
            >>> y.tolist()
            [[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
            >>> len(y)
            3
            >>> y.nbytes
            96

         Added in version 3.3.

      readonly

         Ένα bool που υποδεικνύει εάν η μνήμη είναι μόνο για ανάγνωση.

      format

         Μια συμβολοσειρά που περιέχει τη μορφή (σε module style
         "struct") για κάθε στοιχείο σε μια όψη. Μπορεί να
         δημιουργηθεί ένα memoryview από εξαγωγείς με συμβολοσειρές
         αυθαίρετης μορφής, αλλά ορισμένες μέθοδοι (π.χ. "tolist()")
         είναι περιορισμένες σε εγγενείς μορφές ενός στοιχείου.

         Άλλαξε στην έκδοση 3.3: η μορφή "'B'" αντιμετωπίζεται πλέον
         σύμφωνα με τη σύνταξη ενός struct module. Αυτό σημαίνει ότι
         "memoryview(b'abc')[0] == b'abc'[0] == 97".

      itemsize

         Το μέγεθος σε bytes κάθε στοιχείου στο memoryview:

            >>> import array, struct
            >>> m = memoryview(array.array('H', [32000, 32001, 32002]))
            >>> m.itemsize
            2
            >>> m[0]
            32000
            >>> struct.calcsize('H') == m.itemsize
            True

      ndim

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

      shape

         Μια πλειάδα (tuple) ακεραίων με μήκος "ndim" δίνοντας το
         σχήμα της μνήμης ως πίνακα N-διαστάσεων.

         Άλλαξε στην έκδοση 3.3: Μια κενή πλειάδα (tuple) αντί για
         "None" όταν ndim = 0.

      strides

         Μια πλειάδα ακεραίων με μήκος "ndim" που δίνει το μέγεθος σε
         bytes για την πρόσβαση σε κάθε στοιχείο για κάθε διάσταση του
         πίνακα.

         Άλλαξε στην έκδοση 3.3: Μια κενή πλειάδα (tuple) αντί για
         "None" όταν ndim = 0.

      suboffsets

         Χρησιμοποιείται εσωτερικά για συστοιχίες τύπου PIL. Η τιμή
         είναι μόνο ενημερωτική.

      c_contiguous

         Ένα bool που υποδεικνύει εάν η μνήμη είναι C-*contiguous*.

         Added in version 3.3.

      f_contiguous

         Ένα bool που υποδεικνύει εάν η μνήμη είναι Fortran
         *contiguous*.

         Added in version 3.3.

      contiguous

         Ένα bool που υποδεικνύει εάν η μνήμη είναι *contiguous*.

         Added in version 3.3.


Τύποι Συνόλου (Set) --- "set", "frozenset"
==========================================

Ένα αντικείμενο *set* είναι μια μη ταξινομημένη συλλογή από διακριτά
αντικείμενα *hashable*. Οι συνήθεις χρήσεις περιλαμβάνουν τη δοκιμή
ιδιότητας μέλους, την αφαίρεση διπλότυπων από μια ακολουθία και τον
υπολογισμό μαθηματικών πράξεων όπως τομή, ένωση, διαφορά, και
συμμετρική διαφορά. (Για άλλα containers, δείτε τις ενσωματωμένες
κλάσεις "dict", "list", και "tuple" και το module "collections").

Όπως και άλλες συλλογές, τα σύνολα (sets) υποστηρίζουν "x in set",
"len(set)", και "for x in set".  Όντως μια μη ταξινομημένη συλλογή, τα
σύνολα δεν καταγράφουν τη θέση του στοιχείου ή τη σειρά εισαγωγής.
Συνεπώς, τα σύνολα (sets) δεν υποστηρίζουν λειτουργίες
ευρετηριοποίησης, τμηματοποίησης ή άλλη συμπεριφορά ακολουθίας.

There are currently two built-in set types, "set" and "frozenset". The
"set" type is mutable --- the contents can be changed using methods
like "add()" and "remove()". Since it is mutable, it has no hash value
and cannot be used as either a dictionary key or as an element of
another set. The "frozenset" type is immutable and *hashable* --- its
contents cannot be altered after it is created; it can therefore be
used as a dictionary key or as an element of another set.

Μπορούν να δημιουργηθούν μη κενά σύνολα (όχι παγωμένα σύνολα
(frozensets)) τοποθετώντας μια λίστα στοιχείων διαχωρισμένων με κόμμα
μέσα σε αγκύλες, για παράδειγμα: "{'jack', 'sjoerd'}", επιπλέον με τη
χρήση του constructor του "set".

Οι constructors και για τις δύο κλάσεις λειτουργούν το ίδιο:

class set(iterable=(), /)
class frozenset(iterable=(), /)

   Επιστρέφει ένα νέο σύνολο (set) ή ένα παγωμένο σύνολο (frozenset)
   των οποίων τα στοιχεία έχουν ληφθεί από το *iterable*.  Τα στοιχεία
   ενός συνόλου πρέπει να είναι *hashable*.  Για να αναπαραστήσουν
   σύνολα συνόλων, τα εσωτερικά σύνολα πρέπει να είναι "frozenset"
   αντικείμενα.  Εάν δεν έχει καθοριστεί το *iterable*, επιστρέφεται
   ένα νέο κενό σύνολο.

Τα σύνολα μπορούν να δημιουργηθούν με διάφορους τρόπους:

* Χρησιμοποιώντας μια λίστα στοιχείων διαχωρισμένη με κόμματα:
  "{'jack', 'sjoerd'}"

* Χρησιμοποιώντας ένα set comprehension: "{c for c in 'abracadabra' if
  c not in 'abc'}"

* Χρησιμοποιώντας τον τύπο constructor: "set()", "set('foobar')",
  "set(['a', 'b', 'foo'])"

Τα στιγμιότυπα των "set" και "frozenset" παρέχουν τις ακόλουθες
λειτουργίες:

len(s)

   Επιστρέφει τον αριθμό των στοιχείων στο σύνολο *s* (πληθικότητα του
   *s*).

x in s

   Ελέγχει αν το *x* είναι μέρος στο *s*.

x not in s

   Ελέγχει αν το *x* δεν είναι μέρος στο *s*.

frozenset.isdisjoint(other, /)
set.isdisjoint(other, /)

   Επιστρέφει "True" εάν το σύνολο δεν έχει κοινά στοιχεία με το
   *other*.  Τα σύνολα είναι ασύνδετα εάν και μόνο εάν η τομή τους
   είναι το κενό σύνολο.

frozenset.issubset(other, /)
set.issubset(other, /)

set <= other

   Ελέγχει εάν κάθε στοιχείο στο σύνολο βρίσκεται στο *other*.

set < other

   Ελέγχει εάν το σύνολο είναι σωστό υποσύνολο του *other*, δηλαδή,
   "set <= other and set != other".

frozenset.issuperset(other, /)
set.issuperset(other, /)

set >= other

   Ελέγχει αν κάθε στοιχείο του *other* είναι στο σύνολο.

set > other

   Ελέγχει αν το σύνολο είναι σωστό υπερσύνολο του *other*, δηλαδή,
   "set >= other and set != other".

frozenset.union(*others)
set.union(*others)

set | other | ...

   Επιστρέφει ένα νέο σύνολο με στοιχεία από το σύνολο και όλα τα
   άλλα.

frozenset.intersection(*others)
set.intersection(*others)

set & other & ...

   Επιστρέφει ένα νέο σύνολο με στοιχεία κοινά στο σύνολο και σε όλα
   τα άλλα.

frozenset.difference(*others)
set.difference(*others)

set - other - ...

   Επιστρέφει ένα νέο σύνολο με στοιχεία στο σύνολο που δεν υπάρχουν
   στα άλλα.

frozenset.symmetric_difference(other, /)
set.symmetric_difference(other, /)

set ^ other

   Επιστρέφει ένα νέο σύνολο με στοιχεία είτε στο σύνολο είτε στο
   *other* αλλά όχι και στα δύο.

frozenset.copy()
set.copy()

   Επιστρέφει ένα ρηχό αντίγραφο του συνόλου.

Note, the non-operator versions of "union()", "intersection()",
"difference()", "symmetric_difference()", "issubset()", and
"issuperset()" methods will accept any iterable as an argument.  In
contrast, their operator based counterparts require their arguments to
be sets.  This precludes error-prone constructions like "set('abc') &
'cbs'" in favor of the more readable "set('abc').intersection('cbs')".

Τόσο το "set" και "frozenset" υποστηρίζουν τη σύγκριση μεταξύ συνόλων.
Δύο σύνολα είναι ίσα εάν και μόνο εάν κάθε στοιχείο κάθε συνόλου
περιέχεται στο άλλο (το καθένα είναι υποσύνολο του άλλου). Ένα σύνολο
είναι μικρότερο από ένα άλλο σύνολο εάν και μόνο αν το πρώτο σύνολο
είναι σωστό υποσύνολο του δεύτερου συνόλου (είναι υποσύνολο, αλλά δεν
είναι ίσο), ένα σύνολο είναι μεγαλύτερο από ένα άλλο σύνολο, αν και
μόνο αν το πρώτο σύνολο είναι σωστό υπερσύνολο του δεύτερου συνόλου
(είναι υπερσύνολο αλλά δεν είναι ίσο).

Τα στιγμιότυπα της "set" συγκρίνονται με τα στιγμιότυπα της
"frozenset" με βάση τα μέλη τους.  Για παράδειγμα, το "set('abc') ==
frozenset('abc')" επιστρέφει "True" και το ίδιο συμβαίνει και με το
"set('abc') in set([frozenset('abc')])".

Οι συγκρίσεις υποσυνόλου και ισότητας δεν γενικεύονται σε μια
συνάρτηση ολικής ταξινόμησης.  Για παράδειγμα, οποιαδήποτε δύο μη κενά
συνεχή σύνολα δεν είναι ίσα και δεν είναι υποσύνολα το ένα του άλλου,
επομένως *όλα* τα ακόλουθα επιστρέφουν "False": "a<b", "a==b", or
"a>b".

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

Τα στοιχεία συνόλου, όπως τα κλειδιά λεξικού, πρέπει να είναι
*hashable*.

Δυαδικές πράξεις που συνδυάζουν στιγμιότυπα "set" με "frozenset"
επιστρέφουν τον τύπο του πρώτου τελεστή.  Για παράδειγμα:
"frozenset('ab') | set('bc')" επιστρέφει ένα στιγμιότυπο του
"frozenset".

Ο παρακάτω πίνακας παραθέτει λειτουργίες που είναι διαθέσιμες για
"set" που δεν ισχύουν για αμετάβλητα στιγμιότυπα της "frozenset":

set.update(*others)

set |= other | ...

   Ενημερώνει το σύνολο (set), προσθέτοντας στοιχεία από όλα τα άλλα.

set.intersection_update(*others)

set &= other & ...

   Ενημερώνει το σύνολο, διατηρώντας μόνο τα στοιχεία που βρίσκονται
   σε αυτό και όλα τα άλλα.

set.difference_update(*others)

set -= other | ...

   Ενημερώνει το σύνολο, αφαιρώντας στοιχεία που βρίσκονται σε άλλα.

set.symmetric_difference_update(other, /)

set ^= other

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

set.add(elem, /)

   Προσθέτει το στοιχείο *elem* στο σύνολο.

set.remove(elem, /)

   Αφαιρεί το στοιχείο *elem* από το σύνολο.  Κάνει raise τη
   "KeyError" εάν το *elem* δεν περιέχεται στο σύνολο.

set.discard(elem, /)

   Αφαιρεί το στοιχείο *elem* από το σύνολο εάν υπάρχει.

set.pop()

   Αφαιρεί και επιστρέφει ένα αυθαίρετο στοιχείο από το σύνολο.  Κάνει
   raise μια "KeyError" εάν το σύνολο είναι κενό.

set.clear()

   Αφαιρεί όλα τα στοιχεία από το σύνολο (set).

Note, the non-operator versions of the "update()",
"intersection_update()", "difference_update()", and
"symmetric_difference_update()" methods will accept any iterable as an
argument.

Note, the *elem* argument to the "__contains__()", "remove()", and
"discard()" methods may be a set.  To support searching for an
equivalent frozenset, a temporary one is created from *elem*.


Τύποι αντιστοίχισης --- "dict"
==============================

Ένα αντικείμενο *mapping* αντιστοιχίζει *hashable* τιμές σε αυθαίρετα
αντικείμενα. Οι αντιστοιχίσεις είναι μεταβλητά αντικείμενα.  Υπάρχει
επί του παρόντος μόνο ένα τυπικός τύπο αντιστοίχισης, το *dictionary*.
(Για άλλα containers δείτε τις ενσωματωμένες (built-in) "list", "set",
και "tuple" κλάσεις, και το module "collections".)

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

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

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

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

   * Χρησιμοποιήστε μια λίστα διαχωρισμένων με κόμματα ζευγών "key:
     value" μέσα σε αγκύλες: "{'jack': 4098, 'sjoerd': 4127}" or
     "{4098: 'jack', 4127: 'sjoerd'}"

   * Χρησιμοποιήστε ένα comprehension λεξικού: "{}", "{x: x ** 2 for x
     in range(10)}"

   * Χρησιμοποιήστε τον κατασκευαστή τύπου: "dict()", "dict([('foo',
     100), ('bar', 200)])", "dict(foo=100, bar=200)"

   Εάν δεν δοθεί όρισμα θέσης, δημιουργείται ένα κενό λεξικό. Εάν
   δοθεί ένα όρισμα θέσης και ορίζει μια μέθοδο "keys()",
   δημιουργείται ένα λεξικό καλώντας το "__getitem__()" στο όρισμα με
   κάθε κλειδί που επιστρέφεται από τη μέθοδο. Διαφορετικά, το όρισμα
   θέσης πρέπει να είναι ένα αντικείμενο *iterable*. Κάθε στοιχείο στο
   iterable πρέπει από μόνο του να είναι ένας iterable με ακριβώς δύο
   στοιχεία. Το πρώτο στοιχείο κάθε στοιχείου γίνεται κλειδί στο νέο
   λεξικό και το δεύτερο στοιχείο η αντίστοιχη τιμή. Εάν ένα κλειδί
   εμφανίζεται περισσότερες από μία φορές, η τελευταία τιμή για αυτό
   το κλειδί γίνεται η αντίστοιχη τιμή στο νέο λεξικό.

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

   Τα λεξικά συγκρίνονται ως ίσα εάν και μόνο εάν έχουν τα ίδια ζεύγη
   "(key, value)" (ανεξάρτητα από τη σειρά). Οι συγκρίσεις διάταξης
   ('<', '<=', '>=', '>') κάνουν raise την "TypeError".  Για να
   επεξηγηθεί η δημιουργία λεξικού και η ισότητα, τα ακόλουθα
   παραδείγματα επιστρέφουν όλα ένα λεξικό ίσο με "{"one": 1, "two":
   2, "three": 3}":

      >>> a = dict(one=1, two=2, three=3)
      >>> b = {'one': 1, 'two': 2, 'three': 3}
      >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
      >>> d = dict([('two', 2), ('one', 1), ('three', 3)])
      >>> e = dict({'three': 3, 'one': 1, 'two': 2})
      >>> f = dict({'one': 1, 'three': 3}, two=2)
      >>> a == b == c == d == e == f
      True

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

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

      >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
      >>> d
      {'one': 1, 'two': 2, 'three': 3, 'four': 4}
      >>> list(d)
      ['one', 'two', 'three', 'four']
      >>> list(d.values())
      [1, 2, 3, 4]
      >>> d["one"] = 42
      >>> d
      {'one': 42, 'two': 2, 'three': 3, 'four': 4}
      >>> del d["two"]
      >>> d["two"] = None
      >>> d
      {'one': 42, 'three': 3, 'four': 4, 'two': None}

   Άλλαξε στην έκδοση 3.7: Η σειρά λεξικού είναι εγγυημένη ότι είναι η
   σειρά εισαγωγής.  Αυτή η συμπεριφορά ήταν μια λεπτομέρεια υλοποίηση
   της CPython από την έκδοση 3.6.

   Αυτές είναι οι λειτουργίες που υποστηρίζουν τα λεξικά (και
   επομένως, θα πρέπει να υποστηρίζουν και προσαρμοσμένους τύπους
   αντιστοίχισης επίσης):

   list(d)

      Επιστρέφει μια λίστα με όλα τα κλειδιά που χρησιμοποιούνται στο
      λεξικό *d*.

   len(d)

      Επιστρέφει τον αριθμό των στοιχείων στο λεξικό *d*.

   d[key]

      Επιστρέφει το στοιχείο του *d* με το κλειδί *key*.  Κάνει raise
      μια "KeyError" εάν το *key* δεν υπάρχει για να αντιστοιχηθεί.

      Εάν μια υποκλάση ενός λεξικού ορίζει μια μέθοδο "__missing__()"
      και το *key* δεν υπάρχει, η λειτουργία "d[key]" καλεί αυτήν την
      μέθοδο με το κλειδί *key* ως όρισμα. Στη συνέχεια, η λειτουργία
      "d[key]" επιστρέφει ή κάνει raise ό, τι επιστρέφεται ή γίνεται
      raise από την κλήση "__missing__(key)". Καμία άλλη λειτουργία ή
      μέθοδος δεν επικαλεί την "__missing__()". Εάν το "__missing__()"
      δεν έχει οριστεί, γίνεται raise "KeyError". To "__missing__()"
      πρέπει να είναι μέθοδος∙ δεν μπορεί να είναι ένα στιγμιότυπο
      μεταβλητής:

         >>> class Counter(dict):
         ...     def __missing__(self, key):
         ...         return 0
         ...
         >>> c = Counter()
         >>> c['red']
         0
         >>> c['red'] += 1
         >>> c['red']
         1

      Το παραπάνω παράδειγμα δείχνει μέρος της υλοποίησης του
      "collections.Counter".  Μια διαφορετική μέθοδος "__missing__()"
      χρησιμοποιείται από την "collections.defaultdict".

   d[key] = value

      Ορίζει το "d[key]" στο *value*.

   del d[key]

      Αφαιρεί το "d[key]" από το *d*.  Κάνει raise ένα "KeyError" εάν
      το *key* δεν υπάρχει για αντιστοίχιση.

   key in d

      Επιστρέφει "True" εάν το *d* έχει ένα κλειδί *key*, διαφορετικά
      "False".

   key not in d

      Ισοδυναμεί με "not key in d".

   iter(d)

      Επιστρέφει έναν iterator πάνω από τα κλειδιά του λεξικού.  Αυτή
      είναι μια συντόμευση για "iter(d.keys())".

   clear()

      Αφαιρεί όλα τα στοιχεία από το λεξικό.

   copy()

      Επιστρέφει ένα ρηχό αντίγραφο του λεξικού.

   classmethod fromkeys(iterable, value=None, /)

      Δημιουργεί ένα νέο λεξικό με κλειδιά από το *iterable* και τιμές
      ως *value*.

      Το "fromkeys()" είναι μια μέθοδος κλάσης που επιστρέφει ένα νέο
      λεξικό. Η τιμή *value* ορίζεται από προεπιλογή σε "None".  Όλες
      οι τιμές αναφέρονται σε ένα μόνο στιγμιότυπο, επομένως γενικά
      δεν έχει νόημα για το *value* να είναι μεταβλητό αντικείμενο,
      όπως μια κενή λίστα.  Για να λάβετε διαφορετικές τιμές,
      χρησιμοποιήστε αντ' αυτού ένα dict comprehension.

   get(key, default=None, /)

      Επιστρέφει την τιμή για το *key* εάν το *key* είναι στο λεξικό,
      αλλιώς *default*. Εάν το *default* δεν δίνεται, ορίζεται από
      προεπιλογή σε "None", έτσι ώστε αυτή η μέθοδος να μην κάνει
      raise μια "KeyError".

   items()

      Επιστρέφει μια νέα όψη των στοιχείων του λεξικού ("(key, value)"
      ζεύγη). Δείτε την documentation of view objects.

   keys()

      Επιστρέφει μια νέα όψη των κλειδιών του λεξικού.  Δείτε το
      documentation of view objects.

   pop(key, /)
   pop(key, default, /)

      Εάν το *key* βρίσκεται στο λεξικό, αφαιρείται και επιστρέφει την
      τιμή του, διαφορετικά επιστρέφει *default*.  Εάν *default* δεν
      δίνεται και το *key* δεν είναι στο λεξικό, γίνεται raise ένα
      "KeyError".

   popitem()

      Αφαιρεί και επιστρέφει ένα ζεύγος "(key, value)" από το λεξικό.
      Τα ζεύγη επιστρέφονται με τη σειρά LIFO (last-in, first-out).

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

      Άλλαξε στην έκδοση 3.7: Η σειρά LIFO είναι πλέον εγγυημένη. Σε
      προηγούμενες εκδόσεις, η "popitem()" επιστρέφει ένα αυθαίρετο
      ζεύγος κλειδιού/τιμής.

   reversed(d)

      Επιστρέφει έναν αντίστροφο iterator πάνω από τα κλειδιά του
      λεξικού. Αυτή είναι μια συντόμευση για "reversed(d.keys())".

      Added in version 3.8.

   setdefault(key, default=None, /)

      Εάν το *key* βρίσκεται στο λεξικό, επιστρέφει την τιμή του.  Εάν
      όχι, εισάγετε το *key* με τιμή *default* και επιστρέφει
      *default*.  Το *default* από προεπιλογή είναι "None".

   update(**kwargs)
   update(mapping, /, **kwargs)
   update(iterable, /, **kwargs)

      Ενημερώνει το λεξικό με τα ζεύγη κλειδιών/τιμών από το *mapping*
      ή *iterable* και *kwargs*, αντικαθιστώντας τα υπάρχοντα κλειδιά.
      Επιστρέφει "None".

      Η "update()" δέχεται είτε ένα άλλο αντικείμενο με τη μέθοδο
      "keys()" (στην περίπτωση αυτή το "__getitem__()" καλείται με
      κάθε κλειδί που επιστρέφεται από τη μέθοδο) είτε ένα iterable
      από ζεύγη κλειδιών/τιμών (ως πλειάδες ή άλλα iterables μήκους
      δύο). Εάν καθορίζονται ορίσματα λέξεων-κλειδιών, το λεξικό
      ενημερώνεται στη συνέχεια με αυτά τα ζεύγη κλειδιών/τιμών:
      "d.update(red=1, blue=2)".

   values()

      Επιστρέφει μια νέα όψη των τιμών του λεξικού.  Δείτε την
      documentation of view objects.

      Μια σύγκριση ισότητας μεταξύ μιας όψης "dict.values()" και μιας
      άλλης θα επιστρέφει πάντα "False". Αυτό ισχύει επίσης όταν
      συγκρίνετε το "dict.values()" με τον εαυτό της:

         >>> d = {'a': 1}
         >>> d.values() == d.values()
         False

   d | other

      Δημιουργεί ένα νέο λεξικό με τα συγχωνευμένα κλειδιά και τις
      τιμές των *d* και *other*, τα οποία πρέπει να είναι και τα δύο
      λεξικά. Οι τιμές του *other* έχουν προτεραιότητα όταν τα κλειδιά
      των *d* και *other* είναι κοινά.

      Added in version 3.9.

   d |= other

      Ενημερώνει το λεξικό *d* με κλειδιά και τιμές από το *other*,
      που μπορεί να είναι είτε *mapping* είτε *iterable* ζευγάρι
      κλειδιών/τιμών. Οι τιμές του *other* έχουν προτεραιότητα όταν τα
      κλειδιά των το *d* και *other* είναι κοινά.

      Added in version 3.9.

   Τα λεξικά και οι όψεις λεξικών είναι αναστρέψιμες.

      >>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
      >>> d
      {'one': 1, 'two': 2, 'three': 3, 'four': 4}
      >>> list(reversed(d))
      ['four', 'three', 'two', 'one']
      >>> list(reversed(d.values()))
      [4, 3, 2, 1]
      >>> list(reversed(d.items()))
      [('four', 4), ('three', 3), ('two', 2), ('one', 1)]

   Άλλαξε στην έκδοση 3.8: Τα λεξικά είναι πλέον αναστρέψιμα.

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

  Η "types.MappingProxyType" μπορεί να χρησιμοποιηθεί για τη
  δημιουργία μιας όψης μόνο για ανάγνωση μιας "dict".


Αντικείμενα όψης λεξικού
------------------------

Τα αντικείμενα που επιστρέφονται από τις "dict.keys()",
"dict.values()" and "dict.items()" είναι *όψεις αντικειμένων (view
objects)*.  Παρέχουν μια δυναμική όψη στις εγγραφές του λεξικού, που
σημαίνει ότι όταν αλλάζει το λεξικό, η όψη αντικατοπτρίζει αυτές τις
αλλαγές.

Οι όψεις λεξικού μπορούν να γίνουν iterate για την απόδοση των
αντίστοιχων δεδομένων τους και την υποστήριξη ελέγχων για το αν είναι
μέρος του:

len(dictview)

   Επιστρέφει τον αριθμό των καταχωρήσεων στο λεξικό.

iter(dictview)

   Επιστρέφει έναν iterator πάνω στα κλειδιά, τις τιμές ή τα στοιχεία
   (που αντιπροσωπεύονται ως πλειάδες (tuples) του "(key, value)" στο
   λεξικό.

   Τα κλειδιά και οι τιμές επαναλαμβάνονται με την σειρά εισαγωγής.
   Αυτό επιτρέπει τη δημιουργία ζευγών "(value, key)" χρησιμοποιώντας
   τη "zip()": "pairs = zip(d.values(), d.keys())".  Ένας άλλος τρόπος
   είναι να δημιουργήσετε την ίδια λίστα είναι "pairs = [(v, k) for
   (k, v) in d.items()]".

   Το iterate όψεων κατά την προσθήκη ή τη διαγραφή καταχωρήσεων στο
   λεξικό μπορεί να κάνει raise μια "RuntimeError" ή να αποτύχει το
   iterate σε όλες τις καταχωρήσεις.

   Άλλαξε στην έκδοση 3.7: Η σειρά λεξικού είναι εγγυημένη σειρά
   εισαγωγής.

x in dictview

   Επιστρέφει "True" εάν το *x* βρίσκεται στα κλειδιά του λεξικού, τις
   τιμές ή τα στοιχεία του υποκείμενου λεξικού (στην τελευταία
   περίπτωση, το *x* θα πρέπει να είναι μια "(key, value)" πλειάδα
   (tuple)).

reversed(dictview)

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

   Άλλαξε στην έκδοση 3.8: Οι όψεις λεξικού είναι πλέον αναστρέψιμες.

dictview.mapping

   Επιστρέφει μια "types.MappingProxyType" που αναδιπλώνει το αρχικό
   λεξικό στο οποίο αναφέρεται η όψη.

   Added in version 3.10.

Οι όψεις κλειδιών μοιάζουν με σύνολο καθώς οι καταχωρίσεις τους είναι
μοναδικές και *hashable*. Οι όψεις στοιχείων έχουν επίσης λειτουργίες
που μοιάζουν με σύνολο, καθώς τα ζεύγη (κλειδί, τιμή) είναι μοναδικά
και τα κλειδιά μπορούν να κατακερματιστούν. Εάν όλες οι τιμές σε μία
όψη στοιχείων μπορούν επίσης να κατακερματιστούν, τότε η όψη στοιχείων
μπορεί να διαλειτουργήσει με άλλα σύνολα. (Οι όψεις  τιμών δεν
αντιμετωπίζονται ως σύνολο, καθώς οι καταχωρίσεις δεν είναι γενικά
μοναδικές.)  Για όψεις που μοιάζουν με σύνολο, όλες οι λειτουργίες που
ορίζονται για την αφηρημένη βασική κλάση "collections.abc.Set" είναι
διαθέσιμες (για παράδειγμα, "==", "<", ή "^").  Κατά τη χρήση τελεστών
συνόλου, οι όψεις που μοιάζουν με σύνολο δέχονται οποιοδήποτε iterable
ως άλλο τελεστή, σε αντίθεση με τα σύνολα που δέχονται μόνο σύνολα ως
είσοδο.

Ένα παράδειγμα χρήσης όψης λεξικού:

   >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
   >>> keys = dishes.keys()
   >>> values = dishes.values()

   >>> # iteration
   >>> n = 0
   >>> for val in values:
   ...     n += val
   ...
   >>> print(n)
   504

   >>> # keys and values are iterated over in the same order (insertion order)
   >>> list(keys)
   ['eggs', 'sausage', 'bacon', 'spam']
   >>> list(values)
   [2, 1, 1, 500]

   >>> # view objects are dynamic and reflect dict changes
   >>> del dishes['eggs']
   >>> del dishes['sausage']
   >>> list(keys)
   ['bacon', 'spam']

   >>> # set operations
   >>> keys & {'eggs', 'bacon', 'salad'}
   {'bacon'}
   >>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}
   True
   >>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
   True

   >>> # get back a read-only proxy for the original dictionary
   >>> values.mapping
   mappingproxy({'bacon': 1, 'spam': 500})
   >>> values.mapping['spam']
   500


Τύποι Διαχείρισης Περιεχομένου
==============================

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

contextmanager.__enter__()

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

   Ένα παράδειγμα ενός διαχειριστή περιεχομένου που επιστρέφει ο ίδιος
   είναι ένα *file object*. Τα αντικείμενα αρχείου επιστρέφουν μόνα
   τους από __enter__() για να επιτρέψουν στο "open()" να
   χρησιμοποιηθεί ως έκφραση περιεχομένου σε μια δήλωση "with".

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

contextmanager.__exit__(exc_type, exc_val, exc_tb)

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

   Returning a true value from this method will cause the "with"
   statement to suppress the exception and continue execution with the
   statement immediately following the "with" statement. Otherwise the
   exception continues propagating after this method has finished
   executing.

   If this method raises an exception while handling an earlier
   exception from the "with" block, the new exception is raised, and
   the original exception is stored in its "__context__" attribute.

   Η εξαίρεση που διαβιβάστηκε δεν θα πρέπει ποτέ να επανατοποθετηθεί
   ρητά - αντίθετα, αυτή η μέθοδος θα πρέπει να επιστρέψει μια ψευδή
   τιμή για να υποδείξει ότι η μέθοδος ολοκληρώθηκε με επιτυχία και
   δεν θέλει να αποκρύψει την εξαίρεση που έχει γίνει raise. Αυτό
   επιτρέπει στον κώδικα διαχείρισης περιεχομένου να εντοπίζει εύκολα
   εάν μια μέθοδος "__exit__()" έχει  πράγματι αποτύχει.

Η Python ορίζει  αρκετούς διαχειριστές περιεχομένου για να
υποστηρίζουν τον εύκολο συγχρονισμό νημάτων, το  άμεσο κλείσιμο
αρχείων ή άλλων αντικειμένων και τον απλούστερο χειρισμό του ενεργού
δεκαδικού αριθμητικού περιεχομένου. Οι συγκεκριμένοι τύποι δεν
αντιμετωπίζονται ειδικά πέρα από την εφαρμογή τους πρωτοκόλλου
διαχείρισης περιεχομένου. Δείτε το module "contextlib" για μερικά
παραδείγματα.

Οι decorators της Python *generator*s και "contextlib.contextmanager"
παρέχουν έναν βολικό τρόπο υλοποίησης αυτών των πρωτοκόλλων.  Εάν μια
συνάρτηση γεννήτριας είναι decorated με τον
"contextlib.contextmanager" decorator, θα επιστρέψει έναν διαχειριστή
περιεχομένου που εφαρμόζει τις απαραίτητες μεθόδους "__enter__()" και
"__exit__()", αντί του iterator που παράγεται από μια undecorated
συνάρτηση γεννήτριας.

Λάβετε υπόψη ότι δεν υπάρχει συγκεκριμένη υποδοχή για καμία από αυτές
τις μεθόδους στη δομή τύπου για αντικείμενα Python στο Python/C API.
Οι τύποι επεκτάσεων που θέλουν να ορίσουν αυτές τις μεθόδους πρέπει να
τις παρέχουν ως μια κανονική μέθοδο προσβάσιμη στην Python. Σε
σύγκριση με την επιβάρυνση της ρύθμισης στο πλαίσιο του χρόνου
εκτέλεσης, η επιβάρυνση μιας απλής αναζήτησης κλάσης λεξικού είναι
αμελητέα.


Τύποι Annotation τύπου --- Generic Alias, Union
===============================================

Οι βασικοί ενσωματωμένοι τύποι για *type annotations* είναι Generic
Alias και Union.


Τύπος Generic Alias
-------------------

Τα αντικείμενα "GenericAlias" δημιουργούνται γενικά με subscripting
κλάση. Χρησιμοποιούνται πιο συχνά με container classes, όπως "list" ή
"dict".Για παράδειγμα, το "list[int]" είναι ένα αντικείμενο
"GenericAlias" που δημιουργήθηκε με την εγγραφή της κλάσης "list" με
το όρισμα "int". Τα αντικείμενα "GenericAlias" προορίζονται κυρίως για
χρήση με *type annotations*.

Σημείωση:

  Γενικά είναι δυνατή η εγγραφή μιας κλάσης μόνο εάν η κλάση εφαρμόζει
  την ειδική μέθοδο "__class_getitem__()".

Ένα αντικείμενο "GenericAlias" λειτουργεί ως διακομιστής μεσολάβησης
(proxy) για έναν *generic type*, υλοποιώντας *parameterized generics*.

Για μια κλάση container, το(α) όρισμα(τα) που παρέχει σε μια
subscription της κλάσης μπορεί να υποδεικνύει τον(ους) τύπο(ους) των
στοιχείων που περιέχει ένα αντικείμενο. Για παράδειγμα, το
"set[bytes]" μπορεί να χρησιμοποιηθεί σε annotations τύπου για  να
υποδηλώσει ένα "set" στο  οποίο όλα τα στοιχεία είναι τύπου "bytes".

Για μια κλάση που ορίζει "__class_getitem__()" αλλά δεν είναι
container, τα ορίσματα που παρέχονται σε μια συνδρομή της κλάσης θα
υποδεικνύουν συχνά τον τύπο ή τους τύπους επιστροφής μιας ή
περισσότερων μεθόδων που ορίζονται σε ένα αντικείμενο. Για παράδειγμα,
το "regular expressions" μπορούν να χρησιμοποιηθούν τόσο στον τύπο
δεδομένων "str" όσο και στον τύπο δεδομένων "bytes":

* Εάν "x = re.search('foo', 'foo')", το "x" θα είναι ένα αντικείμενο
  re.Match όπου επιστρέφονται οι τιμές του το "x.group(0)" και το
  "x[0]" θα είναι και τα δύο τύπου "str". Μπορούμε να αναπαραστήσουμε
  αυτό το είδος  αντικειμένου σε σχολιασμούς τύπου με το
  "GenericAlias" "re.Match[str]".

* Εάν "y = re.search(b'bar', b'bar')", (σημειώστε το "b" για "bytes"),
  το "y" θα είναι επίσης μια παρουσία του "re.Match", αλλά οι
  επιστρεφόμενες τιμές των "y.group(0)" και "y[0]" θα είναι και οι δύο
  τύπου "bytes". Στους τύπους annotations, θα αντιπροσωπεύαμε αυτήν
  την ποικιλία αντικειμένων re.Match με το "re.Match[bytes]".

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

T[X, Y, ...]

   Δημιουργεί ένα "GenericAlias" που αντιπροσωπεύει έναν τύπο "T"
   παραμετροποιημένο από τύπους *X*, *Y*, και άλλα ανάλογα με το "T"
   που χρησιμοποιείται. Για παράδειγμα, μια συνάρτηση που αναμένει μια
   "list" που περιέχει στοιχεία της  "float":

      def average(values: list[float]) -> float:
          return sum(values) / len(values)

   Ένα άλλο παράδειγμα για αντικείμενα *mapping*, χρησιμοποιώντας ένα
   "dict",που είναι ένας generic τύπος που αναμένει δύο παραμέτρους
   τύπου που αντιπροσωπεύουν τον τύπο κλειδιού και τον τύπο τιμής.  Σε
   αυτό το παράδειγμα, η συνάρτηση αναμένει ένα "dict" με κλειδιά
   τύπου "str" και τιμές τύπου "int":

      def send_post_request(url: str, body: dict[str, int]) -> None:
          ...

Οι ενσωματωμένες συναρτήσεις (built-in) "isinstance()" και
"issubclass()" δεν δέχονται τους τύπους "GenericAlias" για το δεύτερο
όρισμά τους:

   >>> isinstance([1, 2], list[str])
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: isinstance() argument 2 cannot be a parameterized generic

Ο χρόνος εκτέλεσης Python δεν επιβάλλει *type annotations*. Αυτό
επεκτείνεται σε generic τύπους και στις παραμέτρους τύπου τους. Κατά
τη δημιουργία ενός αντικειμένου container από ένα "GenericAlias", τα
στοιχεία στο container δεν ελέγχονται ως προς τον τύπο τους. Για
παράδειγμα, ο ακόλουθος κώδικας αποθαρρύνεται, αλλά θα εκτελεστεί
χωρίς σφάλματα:

   >>> t = list[str]
   >>> t([1, 2, 3])
   [1, 2, 3]

Επιπλέον, τα παραμετροποιημένα generics διαγράφουν τις παραμέτρους
τύπου κατά τη δημιουργία αντικειμένου:

   >>> t = list[str]
   >>> type(t)
   <class 'types.GenericAlias'>

   >>> l = t()
   >>> type(l)
   <class 'list'>

Η κλήση "repr()" ή "str()" σε ένα generic δείχνει τον
παραμετροποιημένο τύπο:

   >>> repr(list[int])
   'list[int]'

   >>> str(list[int])
   'list[int]'

Η μέθοδος "__getitem__()" των generic containers θα κάνει raise μια
εξαίρεση για την απαγόρευση λαθών όπως "dict[str][str]":

   >>> dict[str][str]
   Traceback (most recent call last):
     ...
   TypeError: dict[str] is not a generic class

Ωστόσο, τέτοιες εκφράσεις είναι έγκυρες όταν χρησιμοποιούνται
μεταβλητές τύπου type variables.  Το ευρετήριο πρέπει να έχει τόσα
στοιχεία όσα και τα στοιχεία μεταβλητής τύπου στο αντικείμενο
"GenericAlias" "__args__".

   >>> from typing import TypeVar
   >>> Y = TypeVar('Y')
   >>> dict[str, Y][int]
   dict[str, int]


Τυπικές Γενικές Κλάσεις
~~~~~~~~~~~~~~~~~~~~~~~

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

* "tuple"

* "list"

* "dict"

* "set"

* "frozenset"

* "type"

* "asyncio.Future"

* "asyncio.Task"

* "collections.deque"

* "collections.defaultdict"

* "collections.OrderedDict"

* "collections.Counter"

* "collections.ChainMap"

* "collections.abc.Awaitable"

* "collections.abc.Coroutine"

* "collections.abc.AsyncIterable"

* "collections.abc.AsyncIterator"

* "collections.abc.AsyncGenerator"

* "collections.abc.Iterable"

* "collections.abc.Iterator"

* "collections.abc.Generator"

* "collections.abc.Reversible"

* "collections.abc.Container"

* "collections.abc.Collection"

* "collections.abc.Callable"

* "collections.abc.Set"

* "collections.abc.MutableSet"

* "collections.abc.Mapping"

* "collections.abc.MutableMapping"

* "collections.abc.Sequence"

* "collections.abc.MutableSequence"

* "collections.abc.ByteString"

* "collections.abc.MappingView"

* "collections.abc.KeysView"

* "collections.abc.ItemsView"

* "collections.abc.ValuesView"

* "contextlib.AbstractContextManager"

* "contextlib.AbstractAsyncContextManager"

* "dataclasses.Field"

* "functools.cached_property"

* "functools.partialmethod"

* "os.PathLike"

* "queue.LifoQueue"

* "queue.Queue"

* "queue.PriorityQueue"

* "queue.SimpleQueue"

* re.Pattern

* re.Match

* "shelve.BsdDbShelf"

* "shelve.DbfilenameShelf"

* "shelve.Shelf"

* "types.MappingProxyType"

* "weakref.WeakKeyDictionary"

* "weakref.WeakMethod"

* "weakref.WeakSet"

* "weakref.WeakValueDictionary"


Ειδικά Χαρακτηριστικά αντικειμένων "GenericAlias"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Όλα τα παραμετροποιημένα generics εφαρμόζουν ειδικά χαρακτηριστικά
μόνο για ανάγνωση.

genericalias.__origin__

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

      >>> list[int].__origin__
      <class 'list'>

genericalias.__args__

   Αυτό το χαρακτηριστικό είναι μια "tuple" (πιθανώς μήκους 1) generic
   τύπων που μεταβιβάστηκαν στο αρχικό "__class_getitem__()" της
   generic κλάσης:

      >>> dict[str, list[int]].__args__
      (<class 'str'>, list[int])

genericalias.__parameters__

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

      >>> from typing import TypeVar

      >>> T = TypeVar('T')
      >>> list[T].__parameters__
      (~T,)

   Σημείωση:

     Ένα αντικείμενο "GenericAlias" με παραμέτρους "typing.ParamSpec"
     ενδέχεται να μην έχει σωστές "__parameters__" μετά την
     αντικατάσταση επειδή το "typing.ParamSpec" προορίζεται κυρίως για
     έλεγχο στατικού τύπου.

genericalias.__unpacked__

   Ένα boolean που ισχύει αν το alias έχει αποσυμπιεστεί
   χρησιμοποιώντας τον τελεστή "*" (δείτε το "TypeVarTuple").

   Added in version 3.11.

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

  **PEP 484** - Type Hints
     Παρουσιάζοντας το framework της Python για τύπους annotations.

  **PEP 585** - Τύπος Generics Συμβουλών στις Τυπικές Συλλογές
     Εισαγωγή της δυνατότητας εγγενούς παραμετροποίησης κλάσεων
     τυπικής βιβλιοθήκης, υπό την προϋπόθεση ότι εφαρμόζουν τη μέθοδο
     ειδικής κλάσης "__class_getitem__()".

  Τα Generics, user-defined generics και "typing.Generic"
     Τεκμηρίωση για τον τρόπο υλοποίησης generic κλάσεων που μπορούν
     να παραμετροποιηθούν κατά το χρόνο εκτέλεσης και να κατανοηθούν
     από στατικούς ελεγκτές τύπων.

Added in version 3.9.


Τύπος Ένωσης
------------

Ένα αντικείμενο ένωσης διατηρεί την τιμή της λειτουργίας "|" (bitwise
or) σε πολλαπλά αντικείμενα type objects.  Αυτοί οι τύποι προορίζονται
κυρίως για *type annotations*. Η έκφραση τύπου ένωσης επιτρέπει την
καθαρότερη σύνταξη υποδείξεων σε σύγκριση με την εγγραφή
"typing.Union".

X | Y | ...

   Ορίζει ένα αντικείμενο ένωσης που περιέχει τύπους *X*, *Y*, και
   ούτω καθεξής. Το "X | Y" σημαίνει είτε X είτε Y.  Είναι ισοδύναμο
   με το "typing.Union[X, Y]". Για παράδειγμα, η ακόλουθη συνάρτηση
   αναμένει ένα όρισμα τύπου "int" or "float":

      def square(number: int | float) -> int | float:
          return number ** 2

   Σημείωση:

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

union_object == other

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

   * Οι ενώσεις των ενώσεων ισοπεδώνονται:

        (int | str) | float == int | str | float

   * Οι περιττοί τύποι καταργούνται:

        int | str | int == int | str

   * Κατά τη σύγκριση των ενώσεων, η σειρά αγνοείται:

        int | str == str | int

   * Δημιουργεί στιγμιότυπα της "typing.Union":

        int | str == typing.Union[int, str]
        type(int | str) is typing.Union

   * Οι προαιρετικοί τύποι μπορούν να γραφτούν ως ένωση με "None":

        str | None == typing.Optional[str]

isinstance(obj, union_object)

issubclass(obj, union_object)

   Οι κλήσεις σε "isinstance()" και "issubclass()" υποστηρίζονται
   επίσης με ένα αντικείμενο ένωσης:

      >>> isinstance("", int | str)
      True

   Ωστόσο, το parameterized generics σε αντικείμενα ένωσης δεν μπορούν
   να ελεγχθούν:

      >>> isinstance(1, int | list[int])  # short-circuit evaluation
      True
      >>> isinstance([1], int | list[int])
      Traceback (most recent call last):
        ...
      TypeError: isinstance() argument 2 cannot be a parameterized generic

Ο τύπος που εκτίθεται από τον χρήστη για το αντικείμενο ένωσης μπορεί
να προσπελαστεί από το "typing.Union" και να χρησιμοποιηθεί για
ελέγχους "isinstance()":

   >>> import typing
   >>> isinstance(int | str, typing.Union)
   True
   >>> typing.Union()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: cannot create 'typing.Union' instances

Σημείωση:

  Η μέθοδος "__or__()" για αντικείμενα τύπου προστέθηκε για να
  υποστηρίξει τη σύνταξη "X | Y".  Εάν μια μετακλάση υλοποιεί
  "__or__()", η Ένωση μπορεί να την παρακάμψει:

     >>> class M(type):
     ...     def __or__(self, other):
     ...         return "Hello"
     ...
     >>> class C(metaclass=M):
     ...     pass
     ...
     >>> C | int
     'Hello'
     >>> int | C
     int | C

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

  **PEP 604** -- Το PEP προτείνει τη σύνταξη "X | Y" και τον τύπο
  Ένωση.

Added in version 3.10.

Άλλαξε στην έκδοση 3.14: Τα αντικείμενα Union είναι πλέον στιγμιότυπα
του "typing.Union". Προηγουμένως, ήταν στιγμιότυπα της
"types.UnionType", το οποίο παραμείνει ένα ψευδώνυμο για τη
"typing.Union".


Άλλοι Ενσωματωμένοι (built-in) Τύποι
====================================

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


Modules
-------

Η μόνη ειδική λειτουργία σε ένα module είναι η πρόσβαση
χαρακτηριστικών: "m.name", όπου το *m* είναι ένα module και το *name*
έχει πρόσβαση σε ένα όνομα που ορίζεται στον πίνακα συμβόλων του *m*.
Τα χαρακτηριστικά του module μπορούν να εκχωρηθούν.  (Σημειώστε ότι η
δήλωση "import" δεν είναι, αυστηρά, μια λειτουργία σε ένα αντικείμενο
module· το "import foo" δεν απαιτεί να υπάρχει ένα αντικείμενο module
με το όνομα *foo* αλλά απαιτεί έναν (εξωτερικό) *definition* για ένα
module που ονομάζεται *foo* κάπου.)

Ένα ειδικό χαρακτηριστικό κάθε module είναι "__dict__". Αυτό είναι το
λεξικό που περιέχει τον πίνακα συμβόλων της ενότητας. Η τροποποίηση
αυτού του λεξικού θα αλλάξει στην πραγματικότητα τον πίνακα συμβόλων
του module, αλλά η απευθείας εκχώρηση στο χαρακτηριστικό "__dict__"
δεν είναι δυνατή (μπορείτε να γράψετε "m.__dict__['a'] = 1", που
ορίζει το "m.a" να είναι "1", αλλά δεν μπορείτε να γράψετε "m.__dict__
= {}").  Δεν συνίσταται η απευθείας τροποποίηση του "__dict__".

Τα modules που είναι ενσωματωμένες στον διερμηνέα γράφονται ως εξής:
"<module 'sys' (built-in)>".  Εάν φορτωθούν από ένα αρχείο, γράφονται
ως "<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>".


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

Δείτε Αντικείμενα, τιμές και τύποι και Class definitions για αυτά.


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

Τα αντικείμενα συναρτήσεων δημιουργούνται από ορισμούς συναρτήσεων.  Η
μόνη λειτουργία σε ένα αντικείμενο συνάρτησης είναι να το ονομάσουμε:
"func(argument-list)".

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

Δείτε το Function definitions για περισσότερες πληροφορίες.


Μέθοδοι
-------

Οι μέθοδοι είναι συναρτήσεις που καλούνται χρησιμοποιώντας το notation
χαρακτηριστικών. Υπάρχουν δύο είδη: built-in methods (όπως η
"append()" στις λίστες) και class instance method. Οι ενσωματωμένες
μέθοδοι περιγράφονται με τους τύπους που τις υποστηρίζουν.

Εάν αποκτήσετε πρόσβαση σε μια μέθοδο (μια συνάρτηση που ορίζεται μια
namespace κλάση) μέσω ενός στιγμιοτύπου, λαμβάνετε ένα ειδικό
αντικείμενο: ένα αντικείμενο *bound method* (ονομάζεται επίσης
instance method). Όταν καλείται, θα προσθέσει το όρισμα "self" στη
λίστα ορισμάτων.  Οι δεσμευμένες μέθοδοι έχουν δύο ειδικά
χαρακτηριστικά μόνο για ανάγνωση: "m.__self__" είναι το αντικείμενο
στο οποίο λειτουργεί η μέθοδος και "m.__func__" είναι η συνάρτηση που
υλοποιεί την μέθοδο.  Η κλήση του "m(arg-1, arg-2, ..., arg-n)" είναι
απολύτως ισοδύναμη με την κλήση του "m.__func__(m.__self__, arg-1,
arg-2, ..., arg-n)".

Όπως τα function objects, τα αντικείμενα δεσμευμένης μεθόδου
υποστηρίζουν τη λήψη αυθαίρετων χαρακτηριστικών. Ωστόσο, δεδομένου ότι
τα χαρακτηριστικά της μεθόδου αποθηκεύονται στην πραγματικότητα στο
υποκείμενο αντικείμενο συνάρτησης ("method.__func__"), ο ορισμός
χαρακτηριστικών μεθόδου σε δεσμευμένες μεθόδους δεν επιτρέπεται.  Η
προσπάθεια ορισμού ενός χαρακτηριστικού σε μια μέθοδο έχει ως
αποτέλεσμα να γίνει raise η "AttributeError".  Για να ορίσετε ένα
χαρακτηριστικό μεθόδου πρέπει να το ορίσετε ρητά στο υποκείμενο
αντικείμενο συνάρτησης:

   >>> class C:
   ...     def method(self):
   ...         pass
   ...
   >>> c = C()
   >>> c.method.whoami = 'my name is method'  # can't set on the method
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   AttributeError: 'method' object has no attribute 'whoami'
   >>> c.method.__func__.whoami = 'my name is method'
   >>> c.method.whoami
   'my name is method'

Δείτε το Μέθοδοι Στιγμιοτύπου για περισσότερες πληροφορίες.


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

Τα αντικείμενα κώδικα χρησιμοποιούνται από την υλοποίηση για να
αναπαραστήσουν τον "ψευδο-μεταγλωττισμένο" εκτελέσιμο κώδικα Python,
όπως ένα σώμα συνάρτησης. Διαφέρουν από τα αντικείμενα συνάρτησης
επειδή δεν περιέχουν αναφορά στο παγκόσμιο (global) περιβάλλον
εκτέλεσης τους.  Τα αντικείμενα κώδικα επιστρέφονται από την
ενσωματωμένη συνάρτηση "compile()" και μπορεί να εξαχθεί από τα
αντικείμενα συνάρτησης μέσω του χαρακτηριστικού τους "__code__". Δείτε
επίσης το module "code".

Η πρόσβαση στη "__code__" κάνει raise ένα auditing event
"object.__getattr__" με ορίσματα "obj" και ""__code__"".

Ένα αντικείμενο κώδικα μπορεί να εκτελεστεί ή να αξιολογηθεί περνώντας
το (αντί για πηγαία συμβολοσειρά) στις ενσωματωμένες συναρτήσεις
"exec()" ή "eval()".

Δείτε Η τυπική ιεραρχία τύπου για περισσότερες πληροφορίες.


Τύποι Αντικειμένων
------------------

Τα αντικείμενα τύπου αντιπροσωπεύουν τους διάφορους τύπους
αντικειμένων.  Ο τύπος ενός αντικειμένου προσεγγίζεται από την
ενσωματωμένη συνάρτηση "type()".  Δεν υπάρχουν ειδικές λειτουργίες
στους τύπους.  Το τυπικό (standard) module "types" ορίζει ονόματα για
όλους τους τυπικούς ενσωματωμένους τύπους.

Οι τύποι γράφονται ως εξής: "<class 'int'>".


Το Αντικείμενο Null
-------------------

Αυτό το αντικείμενο επιστρέφεται από συναρτήσεις που δεν επιστρέφουν
ρητά μια τιμή.  Δεν υποστηρίζει ειδικές λειτουργίες.  Υπάρχει ακριβώς
ένα μηδενικό αντικείμενο, που ονομάζεται "None" (ένα ενσωματωμένο
όνομα).  Το "type(None)()" παράγει το ίδιο singleton.

Γράφεται ως "None".


Το αντικείμενο Ellipsis
-----------------------

Αυτό το αντικείμενο χρησιμοποιείται συχνά για να δηλωθεί ότι κάτι
παραλείπεται. Δεν υποστηρίζει καμία ειδική λειτουργία. Υπάρχει ακριβώς
ένα αντικείμενο ellipsis, με το όνομα "Ellipsis" (ένα ενσωματωμένο
όνομα). Το "type(Ellipsis)()" παράγει το μοναδικό αντικείμενο
"Ellipsis".

Γράφεται ως "Ellipsis" ή "...".

Στην τυπική χρήση, το "..." ως αντικείμενο "Ellipsis" εμφανίζεται σε
μερικές διαφορετικές θέσεις, για παράδειγμα:

* Σε υποδείξεις τύπου, όπως callable arguments ή tuple elements.

* Ως το σώμα μιας συνάρτησης αντί για μια pass statement.

* Σε βιβλιοθήκες τρίτων, όπως το Numpy's slicing and striding.

Η Python χρησιμοποιεί επίσης τρεις τελείες με τρόπους που δεν είναι
αντικείμενα "Ellipsis", για παράδειγμα:

* Το "ELLIPSIS" του doctest, ως ένα μοτίβο για ελλιπές περιεχόμενο.

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

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


Το NotImplemented Αντικείμενο
-----------------------------

Αυτό το αντικείμενο επιστρέφεται από συγκρίσεις και δυαδικές
λειτουργίες όταν τους ζητείται να λειτουργήσουν σε τύπους που δεν
υποστηρίζουν. Δείτε το Comparisons για περισσότερες πληροφορίες.
Υπάρχει ακριβώς ένα αντικείμενο "NotImplemented". Το
"type(NotImplemented)()" παράγει το στιγμιότυπο singleton.

Είναι γραμμένο ως "NotImplemented".


Εσωτερικά Αντικείμενα
---------------------

Δείτε Η τυπική ιεραρχία τύπου για αυτές τις πληροφορίες.  Περιγράφει
stack frame objects, traceback objects, και αντικείμενα
τμηματοποίησης.


Ειδικά Χαρακτηριστικά
=====================

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

definition.__name__

   Το όνομα της κλάσης, της συνάρτησης, της μεθόδου, του descriptor ή
   του στιγμιοτύπου generator.

definition.__qualname__

   Το *qualified name* της κλάσης, της συνάρτησης, της μεθόδου, του
   descriptor, ή του στιγμιοτύπου generator.

   Added in version 3.3.

definition.__module__

   Το όνομα του module στο οποίο ορίστηκε μια κλάση ή μια συνάρτηση.

definition.__doc__

   Η συμβολοσειρά τεκμηρίωσης μιας κλάσης ή συνάρτησης ή "None" εάν
   δεν έχει οριστεί.

definition.__type_params__

   Οι παράμετροι type parameters των γενικών κλάσεων, συναρτήσεων και
   type aliases. Για κλάσεις και συναρτήσεις που δεν είναι γενικές,
   αυτή θα είναι μια κενή πλειάδα.

   Added in version 3.12.


Περιορισμός μήκους μετατροπής συμβολοσειράς ακέραιου αριθμού
============================================================

Η CPython έχει ένα παγκόσμιο όριο για τη μετατροπή μεταξύ "int" and
"str" για τον μετριασμό των επιθέσεων άρνησης υπηρεσίας. Αυτό το όριο
ισχύει *μόνο* για δεκαδικές ή άλλες βάσεις αριθμών που δεν έχουν την
δύναμη του δύο. Οι δεξαεξαδικές, οκταδικές, και δυαδικές μετατροπές
είναι απεριόριστες. Το όριο μπορεί να διαμορφωθεί.

Ο τύπος "int" στην CPython είναι ένας αυθαίρετος αριθμός μήκους που
είναι αποθηκευμένος σε δυαδική μορφή (κοινώς γνωστός ως "bignum"). Δεν
υπάρχει αλγόριθμος που να μπορεί να μετατρέψει μια συμβολοσειρά σε
δυαδικό ακέραιο ή δυαδικό ακέραιο σε μια συμβολοσειρά σε γραμμικό
χρόνο, *εκτός* εάν η βάση είναι δύναμη του 2. Ακόμη και οι πιο γνωστοί
αλγόριθμοι για τη βάση 10 έχουν υποτετραγωνική πολυπλοκότητα. Η
μετατροπή μιας μεγάλης τιμής όπως "int('1' * 500_000)" μπορεί να
διαρκέσει περισσότερο από ένα δευτερόλεπτο σε μια γρήγορη CPU.

Ο περιορισμός του μεγέθους μετατροπής προσφέρει έναν πρακτικό τρόπο
αποφυγής του **CVE 2020-10735**.

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

Όταν μια λειτουργία υπερβαίνει το όριο, γίνεται raise μια
"ValueError":

   >>> import sys
   >>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
   >>> _ = int('2' * 5432)
   Traceback (most recent call last):
   ...
   ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit
   >>> i = int('2' * 4300)
   >>> len(str(i))
   4300
   >>> i_squared = i*i
   >>> len(str(i_squared))
   Traceback (most recent call last):
   ...
   ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
   >>> len(hex(i_squared))
   7144
   >>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

Το προεπιλεγμένο όριο είναι 4300 ψηφία όπως προβλέπεται στο
"sys.int_info.default_max_str_digits". Το κατώτατο όριο που μπορεί να
διαμορφωθεί είναι 640 ψηφία όπως προβλέπεται στο
"sys.int_info.str_digits_check_threshold".

Επαλήθευση:

   >>> import sys
   >>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
   >>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
   >>> msg = int('578966293710682886880994035146873798396722250538762761564'
   ...           '9252925514383915483333812743580549779436104706260696366600'
   ...           '571186405732').to_bytes(53, 'big')
   ...

Added in version 3.11.


Επηρεασμένα APIs
----------------

Ο περιορισμός ισχύει μόνο για δυνητικά αργές μετατροπές μεταξύ "int"
και "str" ή "bytes":

* "int(string)" με default βάση το 10.

* "int(string, base)" για όλες τις βάσεις που δεν είναι δύναμη του 2.

* "str(integer)".

* "repr(integer)".

* οποιαδήποτε άλλη μετατροπή συμβολοσειράς στη βάση 10, για παράδειγμα
  "f"{integer}"", ""{}".format(integer)", ή "b"%d" % integer".

Οι περιορισμοί δεν ισχύουν για συναρτήσεις με γραμμικό αλγόριθμο:

* "int(string, base)" με βάση 2, 4, 8, 16, ή 32.

* "int.from_bytes()" και "int.to_bytes()".

* "hex()", "oct()", "bin()".

* Format Specification Mini-Language για δεκαεξαδικούς, οκταδικούς και
  δυαδικούς αριθμούς.

* "str" σε "float".

* "str" σε "decimal.Decimal".


Διαμόρφωση ορίου
----------------

Πριν από την εκκίνηση της Python, μπορείτε να χρησιμοποιήσετε μια
μεταβλητή περιβάλλοντος ή ένα δείκτη γραμμής εντολών διερμηνέα για να
διαμορφώσετε το όριο:

* "PYTHONINTMAXSTRDIGITS", π.χ. "PYTHONINTMAXSTRDIGITS=640 python3"
  για να ορίσετε το όριο σε 640 ή "PYTHONINTMAXSTRDIGITS=0 python3"
  για να απενεργοποιήσετε τον περιορισμό.

* "-X int_max_str_digits", π.χ. "python3 -X int_max_str_digits=640"

* Το "sys.flags.int_max_str_digits" περιέχει την τιμή
  "PYTHONINTMAXSTRDIGITS" ή "-X int_max_str_digits". Εάν και η επιλογή
  env var και η επιλογή  "-X" είναι καθορισμένη, η επιλογή "-X" έχει
  προτεραιότητα. Μια τιμή *-1* υποδεικνύει ότι και τα δύο δεν
  ορίστηκαν, επομένως χρησιμοποιήθηκε μια τιμή
  "sys.int_info.default_max_str_digits" κατά την προετοιμασία.

Από τον κώδικα, μπορείτε να επιθεωρήσετε το τρέχον όριο και να ορίσετε
ένα νέο χρησιμοποιώντας αυτά τα "sys" APIs:

* Οι "sys.get_int_max_str_digits()" και "sys.set_int_max_str_digits()"
  είναι ένας getter και setter για το όριο σε όλο τον διερμηνέα. Οι
  δευτερεύοντες διερμηνείς έχουν το δικό τους όριο.

Πληροφορίες σχετικά με την προεπιλογή και το ελάχιστο μπορούν να
βρεθούν στο "sys.int_info":

* Το "sys.int_info.default_max_str_digits" είναι το  μεταγλωττισμένο
  προεπιλεγμένο όριο.

* Το "sys.int_info.str_digits_check_threshold" είναι η χαμηλότερη
  αποδεκτή τιμή για το όριο (εκτός από το 0 που το απενεργοποιεί).

Added in version 3.11.

Προσοχή:

  Ο ορισμός ενός χαμηλού ορίου *μπορεί* να οδηγήσει σε προβλήματα. Αν
  και σπάνιος, υπάρχει κώδικας που περιέχει ακέραιες σταθερές σε
  δεκαδικό αριθμό στην πηγή τους που υπερβαίνουν το ελάχιστο όριο.
  Συνέπεια της ρύθμισης του ορίου είναι ότι ο πηγαίος κώδικας Python
  που περιέχει δεκαδικούς ακέραιους αριθμούς μεγαλύτερους από το όριο
  θα αντιμετωπίσει σφάλμα κατά την ανάλυση, συνήθως κατά την εκκίνηση
  ή την ώρα της εισαγωγής ή ακόμα και κατά την εγκατάσταση - ανά πάσα
  στιγμή είναι ενημερωμένο ".pyc" δεν υπάρχει ήδη για τον κώδικα. Μια
  λύση για τον πηγαίο που περιέχει τόσο μεγάλες σταθερές είναι να τις
  μετατρέψετε σε δεκαεξαδική μορφή "0x" καθώς δεν έχει όριο.Δοκιμάστε
  σχολαστικά την εφαρμογή σας εάν χρησιμοποιείτε χαμηλό όριο.
  Βεβαιωθείτε ότι οι δοκιμές σας εκτελούνται με το όριο που έχει
  οριστεί νωρίς μέσω του περιβάλλοντος ή του δείκτη, ώστε να ισχύει
  κατά την εκκίνηση και ακόμη και κατά τη διάρκεια οποιουδήποτε
  βήματος εγκατάστασης που μπορεί να καλέσει την Python για να
  μεταγλωττίσει εκ των προτέρων το ".py" πηγαίο σε αρχεία ".pyc".


Προτεινόμενη διαμόρφωση
-----------------------

Το προεπιλεγμένο "sys.int_info.default_max_str_digits" αναμένεται να
είναι λογικό για τις περισσότερες εφαρμογές. Εάν η εφαρμογή σας
απαιτεί διαφορετικό όριο, ορίστε το από το κύριο σημείο εισόδου σας
χρησιμοποιώντας τον συμβατό με τον κώδικα της έκδοσης Python, καθώς
αυτά τα API προστέθηκαν στην ενημερωμένη έκδοση κώδικα ασφαλείας σε
εκδόσεις πριν από την 3.12.

Παράδειγμα:

   >>> import sys
   >>> if hasattr(sys, "set_int_max_str_digits"):
   ...     upper_bound = 68000
   ...     lower_bound = 4004
   ...     current_limit = sys.get_int_max_str_digits()
   ...     if current_limit == 0 or current_limit > upper_bound:
   ...         sys.set_int_max_str_digits(upper_bound)
   ...     elif current_limit < lower_bound:
   ...         sys.set_int_max_str_digits(lower_bound)

Εάν πρέπει να το απενεργοποιήσετε εντελώς, ορίστε το σε "0".

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

[1] Πρόσθετε πληροφορίες σχετικά με αυτές τις ειδικές μεθόδους
    μπορείτε να βρείτε στο Εγχειρίδιο Αναφοράς Python (Βασική
    προσαρμογή).

[2] Σαν συνέπεια, η λίστα "[1, 2]" θεωρείται ίση με "[1.0, 2.0]", και
    ομοίως για πλειάδες (tuples).

[3] Πρέπει να έχουν, αφού ο parser δεν μπορεί να ξεχωρίσει τον τύπο
    των τελεστών.

[4] Οι χαρακτήρες με πεζά είναι αυτοί με την ιδιότητα γενικής
    κατηγορίας να είναι ένας από τους "Lu" (Γράμμα, κεφαλαίο), "Ll"
    (Γράμμα, πεζά), ή "Lt" (Γράμμα, κεφαλαία).

[5] Για να μορφοποιήσετε μόνο μια πλειάδα (tuple) θα πρέπει επομένως
    να παρέχετε μια πλειάδα singleton της οποίας το μόνο στοιχείο
    είναι η πλειάδα που πρόκειται να μορφοποιηθεί.
