Ενσωματωμένες (Built-in) Συναρτήσεις
************************************

O interpreter της Python έχει έναν αριθμό από συναρτήσεις και τύπους
ενσωματωμένους (built-in) σε αυτόν, που είναι πάντα διαθέσιμα.
Παρατίθενται εδώ με αλφαβητική σειρά.

+---------------------------+-------------------------+-------------------------+---------------------------+
| Ενσωματωμένες (Built-in) Συναρτήσεις                                                                      |
|===========================|=========================|=========================|===========================|
| **A** "abs()" "aiter()"   | **E** "enumerate()"     | **L** "len()" "list()"  | **R** "range()" "repr()"  |
| "all()" "any()" "anext()" | "eval()" "exec()"       | "locals()"  **M**       | "reversed()" "round()"    |
| "ascii()"  **B** "bin()"  | **F** "filter()"        | "map()" "max()"         | **S** "set()" "setattr()" |
| "bool()" "breakpoint()"   | "float()" "format()"    | "memoryview()" "min()"  | "slice()" "sorted()"      |
| "bytearray()" "bytes()"   | "frozenset()"  **G**    | **N** "next()"  **O**   | "staticmethod()" "str()"  |
| **C** "callable()"        | "getattr()" "globals()" | "object()" "oct()"      | "sum()" "super()"  **T**  |
| "chr()" "classmethod()"   | **H** "hasattr()"       | "open()" "ord()"  **P** | "tuple()" "type()"  **V** |
| "compile()" "complex()"   | "hash()" "help()"       | "pow()" "print()"       | "vars()"  **Z** "zip()"   |
| **D** "delattr()"         | "hex()"  **I** "id()"   | "property()"            | **_** "__import__()"      |
| "dict()" "dir()"          | "input()" "int()"       |                         |                           |
| "divmod()"                | "isinstance()"          |                         |                           |
|                           | "issubclass()" "iter()" |                         |                           |
+---------------------------+-------------------------+-------------------------+---------------------------+

abs(x)

   Return the absolute value of a number.  The argument may be an
   integer, a floating point number, or an object implementing
   "__abs__()". If the argument is a complex number, its magnitude is
   returned.

aiter(async_iterable)

   Επιστρέφεται ένας *asynchronous iterator* για ένα *asynchronous
   iterable*. Ισοδυναμεί με την κλήση του "x.__aiter__()".

   Σημείωση: Σε αντίθεση με το "iter()", το "aiter()" δεν έχει
   παραλλαγή 2 ορισμάτων.

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

all(iterable)

   Επιστρέφει "True" εάν όλα τα στοιχεία του *iterable* είναι true (ή
   εάν το iterable είναι κενό).  Ισοδυναμεί με:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

awaitable anext(async_iterator[, default])

   Όταν αναμένεται, επιστρέφεται το επόμενο στοιχείο από το
   *asynchronous iterator*, ή *default* (προεπιλογή) εάν δίνεται και ο
   iterator έχει εξαντληθεί.

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

   Αυτό καλεί την μέθοδο "__anext__()" του *async_iterator*,
   επιστρέφοντας ένα *awaitable*. Αναμένοντας αυτό, επιστρέφει την
   επόμενη τιμή του iterator. Αν δίνεται το *default* (προεπιλογή),
   αυτό επιστρέφεται εάν ο iterator έχει εξαντληθεί, αλλιώς γίνεται
   raise ένα "StopAsyncIteration".

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

any(iterable)

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

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

ascii(object)

   Όπως η "repr()", επιστρέφει μια συμβολοσειρά που περιέχει μια
   εκτυπώσιμη απεικόνιση ενός αντικειμένου, αλλά αναιρεί τους μη-ASCII
   χαρακτήρες στη συμβολοσειρά που επιστρέφεται από το "repr()"
   χρησιμοποιώντας "\x", "\u", ή "\U" αποδράσεις.  Αυτό παράγει μια
   συμβολοσειρά παρόμοια με αυτή που επιστρέφεται από την "repr()"
   στην Python 2.

bin(x)

   Convert an integer number to a binary string prefixed with "0b".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. Some examples:

   >>> bin(3)
   '0b11'
   >>> bin(-10)
   '-0b1010'

   Εάν το πρόθεμα "0b" είναι επιθυμητό ή όχι, μπορείτε να
   χρησιμοποιήσετε έναν από τους παρακάτω τρόπους.

   >>> format(14, '#b'), format(14, 'b')
   ('0b1110', '1110')
   >>> f'{14:#b}', f'{14:b}'
   ('0b1110', '1110')

   Δείτε επίσης τη "format()" για περισσότερες πληροφορίες.

class bool([x])

   Return a Boolean value, i.e. one of "True" or "False".  *x* is
   converted using the standard truth testing procedure.  If *x* is
   false or omitted, this returns "False"; otherwise, it returns
   "True".  The "bool" class is a subclass of "int" (see Αριμθητικοί
   Τύποι --- int, float, complex). It cannot be subclassed further.
   Its only instances are "False" and "True" (see Boolean Values).

   Άλλαξε στην έκδοση 3.7: *x* is now a positional-only parameter.

breakpoint(*args, **kws)

   This function drops you into the debugger at the call site.
   Specifically, it calls "sys.breakpointhook()", passing "args" and
   "kws" straight through.  By default, "sys.breakpointhook()" calls
   "pdb.set_trace()" expecting no arguments.  In this case, it is
   purely a convenience function so you don't have to explicitly
   import "pdb" or type as much code to enter the debugger.  However,
   "sys.breakpointhook()" can be set to some other function and
   "breakpoint()" will automatically call that, allowing you to drop
   into the debugger of choice. If "sys.breakpointhook()" is not
   accessible, this function will raise "RuntimeError".

   Εγείρει ένα auditing event "builtins.breakpoint" με όρισμα
   "breakpointhook".

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

class bytearray([source[, encoding[, errors]]])

   Επιστρέφετε ένας νέος πίνακας από bytes.  Η κλάση "bytearray" είναι
   μια μεταβλητή ακολουθία ακεραίων στο εύρος 0 <= x < 256.  Έχει τις
   περισσότερες από τις συνήθεις μεθόδους μεταβλητών ακολουθιών, που
   περιγράφονται στο Τύποι Μεταβλητών Ακολουθιών (Sequences), καθώς
   και τις περισσότερες μεθόδους που έχει ο τύπος "bytes", δείτε
   Λειτουργίες Bytes και Bytearray.

   Η προαιρετική παράμετρος *source* μπορεί να χρησιμοποιηθεί για την
   αρχικοποίηση του πίνακα με μερικούς διαφορετικούς τρόπους:

   * Εάν είναι *string*, πρέπει επίσης να δώσετε τις παραμέτρους
     *encoding* (και προαιρετικά, *errors*)∙ η "bytearray()" στη
     συνέχεια μετατρέπει τη συμβολοσειρά σε byte χρησιμοποιώντας
     "str.encode()".

   * Εάν είναι *integer*, ο πίνακας θα έχει αυτό το μέγεθος και θα
     αρχικοποιηθεί με null bytes.

   * Εάν είναι αντικείμενο που συμμορφώνεται με το buffer interface,
     θα χρησιμοποιηθεί μια προσωρινή μνήμη μόνο για ανάγνωση του
     αντικείμενου για την προετοιμασία του πίνακα με τα bytes.

   * Εάν είναι *iterable*, πρέπει να είναι ένας iterable ακεραίων στο
     εύρος "0 <= x < 256", οι οποίοι χρησιμοποιούνται ως αρχικά
     περιεχόμενα του πίνακα.

   Χωρίς όρισμα δημιουργείται ένας πίνακας μεγέθους 0.

   Βλ. επίσης Τύποι δυαδικής ακολουθίας --- bytes, bytearray,
   memoryview και Αντικείμενα Bytearray.

class bytes([source[, encoding[, errors]]])

   Επιστρέφεται ένα νέο αντικείμενο "bytes", που είναι μια αμετάβλητη
   ακολουθία ακεραίων στο εύρος "0 <= x < 256".  Η "bytes" είναι μια
   αμετάβλητη έκδοση του "bytearray" -- έχει τις ίδιες μεθόδους χωρίς
   μετάλλαξη και την ίδια συμπεριφορά ευρετηριοποίησης και τεμαχισμού.

   Συνεπώς, τα ορίσματα του constructor ερμηνεύονται ως "bytearray()".

   Τα αντικείμενα bytes μπορούν επίσης να δημιουργηθούν με literals,
   βλέπε String and Bytes literals.

   Βλέπε επίσης Τύποι δυαδικής ακολουθίας --- bytes, bytearray,
   memoryview, Αντικείμενα Bytes, και Λειτουργίες Bytes και Bytearray.

callable(object)

   Return "True" if the *object* argument appears callable, "False" if
   not.  If this returns "True", it is still possible that a call
   fails, but if it is "False", calling *object* will never succeed.
   Note that classes are callable (calling a class returns a new
   instance); instances are callable if their class has a "__call__()"
   method.

   Νέο στην έκδοση 3.2: Αυτή η συνάρτηση πρώτα αφαιρέθηκε στην Python
   3.0 και στη συνέχεια επανήλθε στην Python 3.2.

chr(i)

   Επιστρέφει τη συμβολοσειρά που αντιπροσωπεύει έναν χαρακτήρα του
   οποίου ο κωδικός σημείου Unicode είναι ο ακέραιος *i*.  Για
   παράδειγμα, "chr(97)" επιστρέφει τη συμβολοσειρά "'a'", ενώ το
   "chr(8364)" επιστρέφει τη συμβολοσειρά "'€'". Αυτό είναι το
   αντίστροφο του "ord()".

   Το έγκυρο εύρος για το όρισμα είναι από 0 έως 1,114,111 (0x10FFFF
   στη βάση 16).  Το "ValueError" θα γίνει raise εάν το *i* είναι
   εκτός αυτού του εύρους.

@classmethod

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

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

      class C:
          @classmethod
          def f(cls, arg1, arg2): ...

   Η φόρμα "@classmethod" είναι μια συνάρτηση *decorator* -- βλέπε
   Function definitions για λεπτομέρειες.

   Μια μέθοδος κλάσης μπορεί να κληθεί είτε στην κλάση (όπως "C.f()")
   είτε σε ένα instance (όπως "C().f()").  Το instance αγνοείται εκτός
   από την κλάση της. Εάν μια μέθοδος κλάσης καλείται για μια
   παραγόμενη κλάση, το αντικείμενο παραγόμενης κλάσης μεταβιβάζεται
   ως το υπονοούμενο πρώτο όρισμα.

   Οι μέθοδοι κλάσης διαφέρουν από τις στατικές μεθόδους C++ ή Java.
   Αν θέλετε, ανατρέξτε στο "staticmethod()" σε αυτήν την ενότητα. Για
   περισσότερες πληροφορίες σχετικά με τις μεθόδους κλάσης, ανατρέξτε
   στο The standard type hierarchy.

   Άλλαξε στην έκδοση 3.9: Οι μέθοδοι κλάσης μπορούν πλέον να
   αναδιπλώσουν άλλους *descriptors* όπως η "property()".

   Άλλαξε στην έκδοση 3.10: Class methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__") and have a new "__wrapped__" attribute.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)

   Μεταγλωττίστε το *source* σε έναν κώδικα ή αντικείμενο AST.  Τα
   αντικείμενα κώδικα μπορούν να εκτελεστούν από "exec()" ή "eval()".
   Η *source* μπορεί να είναι είτε μια κανονική συμβολοσειρά, μια
   συμβολοσειρά byte ή μια συμβολοσειρά AST αντικείμενου.  Ανατρέξτε
   στην τεκμηρίωση του module "ast" για πληροφορίες σχετικά με τον
   τρόπο εργασίας με αντικείμενα AST.

   Το όρισμα *filename* θα πρέπει να δίνει το αρχείο από το οποίο
   διαβάζεται ο κώδικας∙ να περάσει κάποια αναγνωρίσιμη τιμή εάν δεν
   διαβαστεί από ένα αρχείο (χρησιμοποιείται συνήθως "'<string>'").

   Το όρισμα *mode* καθορίζει το είδος του κώδικα που πρέπει να
   μεταγλωττιστεί∙ μπορεί να είναι "'exec'" εάν η *source* αποτελείται
   από μια ακολουθία δηλώσεων, "'eval'" εάν αποτελείται από μία μόνο
   έκφραση, ή "'single'" εάν αποτελείται από μία μόνο διαδραστική
   πρόταση (στην τελευταία περίπτωση, θα εκτυπωθούν δηλώσεις έκφρασης
   που αξιολογούνται σε κάτι διαφορετικό από "None").

   Τα προαιρετικά ορίσματα *flags* και *dont_inherit* ελέγχουν ποιες
   compiler options θα πρέπει να ενεργοποιηθούν και ποιες future
   features θα πρέπει να επιτρέπονται. Εάν δεν υπάρχει καμία (ή και οι
   δύο είναι μηδέν) ο κώδικας μεταγλωττίζεται με τα ίδια flags που
   επηρεάζουν τον κώδικα που καλεί "compile()". Εάν το όρισμα *flags*
   δίνεται και το *dont_inherit* δεν είναι (ή είναι μηδέν), τότε οι
   επιλογές του μεταγλωττιστή και οι μελλοντικές δηλώσεις που
   καθορίζονται από το όρισμα *flags* χρησιμοποιούνται ανεξάρτητα από
   αυτές που θα χρησιμοποιούνταν ούτως ή άλλως. Εάν το *dont_inherit*
   είναι ένα μη μηδενικός ακέραιος, τότε το όρισμα *flags* είναι αυτό
   -- οι σημαίες (μελλοντικές δυνατότητες και επιλογές μεταγλωττιστή)
   στον περιβάλλοντα κώδικα αγνοούνται.

   Οι επιλογές του μεταγλωττιστή και οι μελλοντικές εντολές
   καθορίζονται από bits που μπορούν να συνδυαστούν κατά bit ORed μαζί
   για να καθορίσουν πολλές επιλογές. Το πεδίο bit που απαιτείται για
   το καθορισμό ενός δεδομένου μελλοντικού χαρακτηριστικού μπορεί να
   βρεθεί ως το χαρακτηριστικό "compiler_flag" στο "_Feature" instance
   του module "__future__". Compiler flags μπορούν να βρεθούν στο
   module "ast", με το πρόθεμα "PyCF_".

   Το όρισμα *optimize* καθορίζει το επίπεδο βελτιστοποίησης του
   μεταγλωττιστή∙ η προεπιλεγμένη τιμή "-1" επιλέγει το επίπεδο
   βελτιστοποίησης του διερμηνέα όπως δίνεται από τις επιλογές "-O".
   Τα ρητά επίπεδα είναι "0" (χωρίς βελτιστοποίηση∙ το "__debug__"
   είναι αληθές), "1" (οι ισχυρισμοί καταργήθηκαν, το "__debug__"
   είναι ψευδές) ή "2" (οι συμβολοσειρές εγγραφών καταργήθηκαν
   επίσης).

   Αυτή η συνάρτηση κάνει raise "SyntaxError" εάν ο μεταγλωττισμένος
   κώδικας είναι άκυρος, και το "ValueError" εάν ο κώδικας
   περιλαμβάνει null bytes.

   Εάν θέλετε να αναλύσετε τον κώδικα Python στην αναπαράσταση του
   AST, δείτε το "ast.parse()".

   Κάνει raise ένα auditing event "compile" με ορίσματα "source" και
   "filename". Αυτό το συμβάν μπορεί επίσης να προκύψει από έμμεση
   μεταγλώττιση.

   Σημείωση:

     Κατά τη μεταγλώττιση μιας συμβολοσειράς με κωδικό πολλαπλών
     γραμμών στη λειτουργία "'single'" ή "'eval'", η είσοδος πρέπει να
     τερματίζεται με τουλάχιστον έναν χαρακτήρα νέας γραμμής.  Αυτό
     γίνεται για να διευκολυνθεί ο εντοπισμός μη ολοκληρωμένων και
     ολοκληρωμένων δηλώσεων στο module "code".

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

     Είναι δυνατό να καταρρεύσει ο interpreter της Python με μια
     αρκετά μεγάλη/σύνθετη συμβολοσειρά κατά τη μεταγλώττιση σε ένα
     αντικείμενο AST λόγω περιορισμών βάθους στοίβας στον
     μεταγλωττιστή AST της Python.

   Άλλαξε στην έκδοση 3.2: Επιτρέπεται η χρήση νέων γραμμών Windows
   και Mac.  Επίσης, η εισαγωγή στη λειτουργία "'exec'" δεν χρειάζεται
   πλέον να τελειώνει σε νέα γραμμή.  Προστέθηκε η παράμετρος
   *optimize*.

   Άλλαξε στην έκδοση 3.5: Προηγουμένως, το "TypeError" έγινε raise
   όταν null bytes συναντήθηκαν στο *source*.

   Νέο στην έκδοση 3.8: "ast.PyCF_ALLOW_TOP_LEVEL_AWAIT" μπορεί τώρα
   να μεταβιβαστεί σε σημαίες για να ενεργοποιηθεί η υποστήριξη για
   "await", "async for", και "async with".

class complex([real[, imag]])

   Return a complex number with the value *real* + *imag**1j or
   convert a string or number to a complex number.  If the first
   parameter is a string, it will be interpreted as a complex number
   and the function must be called without a second parameter.  The
   second parameter can never be a string. Each argument may be any
   numeric type (including complex).  If *imag* is omitted, it
   defaults to zero and the constructor serves as a numeric conversion
   like "int" and "float".  If both arguments are omitted, returns
   "0j".

   For a general Python object "x", "complex(x)" delegates to
   "x.__complex__()".  If "__complex__()" is not defined then it falls
   back to "__float__()".  If "__float__()" is not defined then it
   falls back to "__index__()".

   Σημείωση:

     When converting from a string, the string must not contain
     whitespace around the central "+" or "-" operator.  For example,
     "complex('1+2j')" is fine, but "complex('1 + 2j')" raises
     "ValueError".

   Ο μιγαδικός τύπος περιγράφεται στο Αριμθητικοί Τύποι --- int,
   float, complex.

   Άλλαξε στην έκδοση 3.6: Επιτρέπεται η ομαδοποίηση ψηφίων με κάτω
   παύλες όπως στα literals του κώδικα.

   Άλλαξε στην έκδοση 3.8: Falls back to "__index__()" if
   "__complex__()" and "__float__()" are not defined.

delattr(object, name)

   Αυτό είναι σχετικό της "setattr()".  Τα ορίσματα είναι ένα
   αντικείμενο και μια συμβολοσειρά.  Η συμβολοσειρά πρέπει να είναι
   το όνομα ενός από τα χαρακτηριστικά του αντικειμένου.  Η συνάρτηση
   διαγράφει το επώνυμο χαρακτηριστικό, υπό την προϋπόθεση ότι το
   αντικείμενο το επιτρέπει. Για παράδειγμα, το "delattr(x, 'foobar')"
   είναι ισοδύναμο με το "del x.foobar". Το *name* δεν χρειάζεται να
   είναι αναγνωριστικό της Python (δείτε "setattr()").

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

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

   Για άλλα containers, δείτε τις ενσωματωμένες κλάσεις "list", "set",
   και "tuple", καθώς και το module "collections".

dir([object])

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

   If the object has a method named "__dir__()", this method will be
   called and must return the list of attributes. This allows objects
   that implement a custom "__getattr__()" or "__getattribute__()"
   function to customize the way "dir()" reports their attributes.

   If the object does not provide "__dir__()", the function tries its
   best to gather information from the object's "__dict__" attribute,
   if defined, and from its type object.  The resulting list is not
   necessarily complete and may be inaccurate when the object has a
   custom "__getattr__()".

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

   * Εάν το αντικείμενο είναι module τύπου αντικειμένου, η λίστα
     περιέχει τα ονόματα των χαρακτηριστικών του module.

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

   * Εναλλακτικά, η λίστα περιέχει τα ονόματα των χαρακτηριστικών του
     αντικειμένου, τα ονόματα των χαρακτηριστικών της κλάσης, και
     αναδρομικά τα χαρακτηριστικά της κλάσης βάσεως της κλάσης.

   Η παραγόμενη λίστα είναι ταξινομημένη αλφαβητικά.  Για παράδειγμα:

   >>> import struct
   >>> dir()   # show the names in the module namespace  
   ['__builtins__', '__name__', 'struct']
   >>> dir(struct)   # show the names in the struct module 
   ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
    '__initializing__', '__loader__', '__name__', '__package__',
    '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
    'unpack', 'unpack_from']
   >>> class Shape:
   ...     def __dir__(self):
   ...         return ['area', 'perimeter', 'location']
   >>> s = Shape()
   >>> dir(s)
   ['area', 'location', 'perimeter']

   Σημείωση:

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

divmod(a, b)

   Take two (non-complex) numbers as arguments and return a pair of
   numbers consisting of their quotient and remainder when using
   integer division.  With mixed operand types, the rules for binary
   arithmetic operators apply.  For integers, the result is the same
   as "(a // b, a % b)". For floating point numbers the result is "(q,
   a % b)", where *q* is usually "math.floor(a / b)" but may be 1 less
   than that.  In any case "q * b + a % b" is very close to *a*, if "a
   % b" is non-zero it has the same sign as *b*, and "0 <= abs(a % b)
   < abs(b)".

enumerate(iterable, start=0)

   Επιστρέφει ένα αντικείμενο απαρίθμησης.  Το *iterable* πρέπει να
   είναι μια ακολουθία, ένα *iterator*, ή κάποιο άλλο αντικείμενο που
   υποστηρίζει το iteration. Η μέθοδος "__next__()" του iterator που
   επιστρέφεται από το "enumerate()" επιστρέφει μια πλειάδα (tuple)
   που περιέχει μια καταμέτρηση (από το *start* που είναι με
   προεπιλογή στο 0) και τις τιμές που λαμβάνονται από την επανάληψη
   πάνω στο *iterable*.

   >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
   >>> list(enumerate(seasons))
   [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
   >>> list(enumerate(seasons, start=1))
   [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

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

      def enumerate(sequence, start=0):
          n = start
          for elem in sequence:
              yield n, elem
              n += 1

eval(expression[, globals[, locals]])

   The arguments are a string and optional globals and locals.  If
   provided, *globals* must be a dictionary.  If provided, *locals*
   can be any mapping object.

   Το όρισμα *expression* αναλύεται και αξιολογείται ως μια έκφραση
   της Python (από τεχνικής άποψης, μια λίστα συνθηκών)
   χρησιμοποιώντας τα λεξικά (dictionaries) *globals* και *locals* ως
   global και local namespace.  Εάν το λεξικό *globals* υπάρχει και
   δεν περιέχει μια τιμή για το κλειδί "__builtins__", μια αναφορά στο
   λεξικό του ενσωματωμένου module "builtins" εισάγεται κάτω από αυτό
   το κλειδί πριν αναλυθεί το *expression*.  Με αυτόν τον τρόπο
   μπορείτε να ελέγξετε ποια από τα ενσωματωμένα στοιχεία είναι
   διαθέσιμα για τον εκτελέσιμο κώδικα, εισάγοντας το δικό σας λεξικό
   "__builtins__" στο *globals* πριν διαβαστεί στη "eval()".  Εάν το
   λεξικό *locals* παραλειφθεί, ορίζεται από προεπιλογή στο λεξικό
   *globals*.  Εάν παραληφθούν και τα δύο λεξικά, η έκφραση εκτελείται
   με τα *globals* και *locals* στο περιβάλλον όπου καλείται η
   "eval()".  Σημείωση, το *eval()* δεν έχει πρόσβαση στο *nested
   scopes* (μη τοπικά) στο περιβάλλον που περικλείει.

   The return value is the result of the evaluated expression. Syntax
   errors are reported as exceptions.  Example:

   >>> x = 1
   >>> eval('x+1')
   2

   Αυτή η συνάρτηση μπορεί επίσης να χρησιμοποιηθεί για την εκτέλεση
   αυθαίρετων αντικειμένων κώδικα (όπως αυτά που δημιουργούνται από
   την "compile()").  Σε αυτή την περίπτωση, μεταβιβάζει ένα
   αντικείμενο κώδικα αντί για μια συμβολοσειρά.  Εάν το αντικείμενο
   κώδικα έχει μεταγλωττιστεί με "'exec'" ως το όρισμα *mode*, η
   επιστρεφόμενη τιμή του "eval()"'s θα είναι "None".

   Συμβουλές: η δυναμική εκτέλεση εντολών υποστηρίζεται από την
   συνάρτηση "exec()".  Οι συναρτήσεις "globals()" και "locals()"
   επιστρέφουν το τρέχον global και local λεξικό, αντίστοιχα, το οποίο
   μπορεί να είναι χρήσιμο για μεταβίβαση γύρω από τη χρήση από τις
   "eval()" ή "exec()".

   Εάν η δεδομένη πηγή είναι μια συμβολοσειρά, τότε αφαιρούνται τα
   κενά και τα tabs που προηγούνται ή έπονται.

   Βλ. τη "ast.literal_eval()" για μια συνάρτηση που μπορεί με
   ασφάλεια να αξιολογήσει τις συμβολοσειρές με εκφράσεις που
   περιέχουν μόνο literals.

   Κάνει raise ένα auditing event "exec" με το αντικείμενο κώδικα ως
   όρισμα. Μπορεί επίσης να εμφανιστούν συμβάντα μεταγλώττισης κώδικα.

exec(object[, globals[, locals]])

   Αυτή η συνάρτηση υποστηρίζει δυναμική εκτέλεση κώδικα Python. Το
   *object* πρέπει να είναι είτε μια συμβολοσειρά (string) είτε ένα
   αντικείμενο κώδικα.  Εάν είναι μια συμβολοσειρά, η συμβολοσειρά
   αναλύεται ως μια σουίτα δηλώσεων Python που στη συνέχεια εκτελείται
   (εκτός εάν παρουσιαστεί σφάλμα σύνταξης). [1] Εάν πρόκειται για ένα
   αντικείμενο κώδικα, απλά εκτελείται.  Σε όλες τις περιπτώσεις, ο
   κώδικας που εκτελείται αναμένεται να είναι έγκυρος ως είσοδος
   αρχείου (δείτε την ενότητα File input στο Εγχειρίδιο Αναφοράς).
   Λάβετε υπόψη ότι οι εντολές "nonlocal", "yield",  και "return" δεν
   μπορούν να χρησιμοποιηθούν εκτός των ορισμών συναρτήσεων, ακόμη και
   στο πλαίσιο του κώδικα που διαβιβάζεται στη "exec()". Η
   επιστρεφόμενη τιμή είναι "None".

   In all cases, if the optional parts are omitted, the code is
   executed in the current scope.  If only *globals* is provided, it
   must be a dictionary (and not a subclass of dictionary), which will
   be used for both the global and the local variables.  If *globals*
   and *locals* are given, they are used for the global and local
   variables, respectively.  If provided, *locals* can be any mapping
   object.  Remember that at the module level, globals and locals are
   the same dictionary. If exec gets two separate objects as *globals*
   and *locals*, the code will be executed as if it were embedded in a
   class definition.

   Εάν το λεξικό *globals* δεν περιέχει τιμή για το κλειδί
   "__builtins__", μια αναφορά στο λεξικό του ενσωματωμένου module
   "builtins" εισάγεται κάτω από αυτό το κλειδί.  Με αυτόν τον τρόπο
   μπορεί να ελέγξετε τι ενσωματωμένα (built-ins) είναι διαθέσιμα στον
   εκτελέσιμο κώδικα εισάγοντας το δικό σας "__builtins__" λεξικό στο
   *globals* πριν το διαβάσετε στο "exec()".

   Κάνει raise ένα auditing event "exec" με το αντικείμενο κώδικα ως
   όρισμα. Μπορεί επίσης να εμφανιστούν συμβάντα μεταγλώττισης κώδικα.

   Σημείωση:

     Οι ενσωματωμένες συναρτήσεις "globals()" και "locals()"
     επιστρέφουν το τρέχον global και local λεξικό, αντίστοιχα, που
     μπορεί να είναι χρήσιμο για χρήση ως δεύτερο και τρίτο όρισμα στο
     "exec()".

   Σημείωση:

     Το προεπιλεγμένο *locals* ενεργεί όπως περιγράφεται για τη
     συνάρτηση "locals()" παρακάτω: δεν πρέπει να επιχειρήσετε
     τροποποιήσεις στο προεπιλεγμένο *locals* λεξικό. Περνάει ένα ρητό
     *locals* λεξικό εάν θέλετε να δείτε τα αποτελέσματα του κώδικα
     στο *locals* με την επιστροφή της συνάρτησης "exec()".

filter(function, iterable)

   Construct an iterator from those elements of *iterable* for which
   *function* returns true.  *iterable* may be either a sequence, a
   container which supports iteration, or an iterator.  If *function*
   is "None", the identity function is assumed, that is, all elements
   of *iterable* that are false are removed.

   Λάβετε υπόψη ότι το "filter(function, iterable)" είναι ισοδύναμο με
   την έκφραση της γεννήτριας "(item for item in iterable if
   function(item))" εάν η συνάρτηση δεν είναι "None" και "(item for
   item in iterable if item)" εάν η συνάρτηση είναι "None".

   See "itertools.filterfalse()" for the complementary function that
   returns elements of *iterable* for which *function* returns false.

class float([x])

   Return a floating point number constructed from a number or string
   *x*.

   If the argument is a string, it should contain a decimal number,
   optionally preceded by a sign, and optionally embedded in
   whitespace.  The optional sign may be "'+'" or "'-'"; a "'+'" sign
   has no effect on the value produced.  The argument may also be a
   string representing a NaN (not-a-number), or positive or negative
   infinity.  More precisely, the input must conform to the
   "floatvalue" production rule in the following grammar, after
   leading and trailing whitespace characters are removed:

      sign        ::= "+" | "-"
      infinity    ::= "Infinity" | "inf"
      nan         ::= "nan"
      digitpart   ::= digit (["_"] digit)*
      number      ::= [digitpart] "." digitpart | digitpart ["."]
      exponent    ::= ("e" | "E") ["+" | "-"] digitpart
      floatnumber ::= number [exponent]
      floatvalue  ::= [sign] (floatnumber | infinity | nan)

   Here "digit" is a Unicode decimal digit (character in the Unicode
   general category "Nd"). Case is not significant, so, for example,
   "inf", "Inf", "INFINITY", and "iNfINity" are all acceptable
   spellings for positive infinity.

   Otherwise, if the argument is an integer or a floating point
   number, a floating point number with the same value (within
   Python's floating point precision) is returned.  If the argument is
   outside the range of a Python float, an "OverflowError" will be
   raised.

   For a general Python object "x", "float(x)" delegates to
   "x.__float__()".  If "__float__()" is not defined then it falls
   back to "__index__()".

   Εάν δεν δοθεί όρισμα, επιστρέφεται το "0.0".

   Examples:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

   Ο τύπος float περιγράφεται στο Αριμθητικοί Τύποι --- int, float,
   complex.

   Άλλαξε στην έκδοση 3.6: Επιτρέπεται η ομαδοποίηση ψηφίων με κάτω
   παύλες όπως στα literals του κώδικα.

   Άλλαξε στην έκδοση 3.7: *x* is now a positional-only parameter.

   Άλλαξε στην έκδοση 3.8: Falls back to "__index__()" if
   "__float__()" is not defined.

format(value[, format_spec])

   Μετατρέπει ένα *value* σε μια αναπαράσταση "formatted", όπως
   ελέγχεται από το *format_spec*.  Η ερμηνεία του *format_spec* θα
   εξαρτηθεί από τον τύπο του ορίσματος *value* ∙ ωστόσο υπάρχει μια
   τυπική σύνταξη μορφοποίησης που χρησιμοποιείται από τους
   περισσότερους ενσωματωμένους τύπους: Format Specification Mini-
   Language.

   Η προεπιλεγμένη *format_spec* είναι μια κενή συμβολοσειρά που
   συνήθως δίνει το ίδιο αποτέλεσμα με την κλήση του "str(value)".

   A call to "format(value, format_spec)" is translated to
   "type(value).__format__(value, format_spec)" which bypasses the
   instance dictionary when searching for the value's "__format__()"
   method.  A "TypeError" exception is raised if the method search
   reaches "object" and the *format_spec* is non-empty, or if either
   the *format_spec* or the return value are not strings.

   Άλλαξε στην έκδοση 3.4: Το "object().__format__(format_spec)" κάνει
   raise το "TypeError" εάν το *format_spec* δεν είναι κενή
   συμβολοσειρά.

class frozenset([iterable])

   Επιστρέφει ένα νέο αντικείμενο "frozenset", προαιρετικά με στοιχεία
   που λαμβάνονται από το *iterable*.  Το "frozenset" είναι μια
   ενσωματωμένη κλάση.  Δείτε το "frozenset" και το Τύποι Συνόλου
   (Set) --- set, frozenset για τεκμηρίωση αυτής της κλάσης.

   Για άλλα containers, ανατρέξτε στις ενσωματωμένες κλάσεις "set",
   "list", "tuple", και "dict", καθώς και το module "collections".

getattr(object, name[, default])

   Επιστρέφει την τιμή του ονομασμένου χαρακτηριστικού του *object*
   Το *name* πρέπει να είναι μια συμβολοσειρά. Εάν η συμβολοσειρά
   είναι το όνομα ενός από τα χαρακτηριστικά του αντικειμένου, το
   αποτέλεσμα είναι η τιμή αυτού του χαρακτηριστικού.  Για παράδειγμα,
   "getattr(x, 'foobar')" είναι ισοδύναμο με το "x.foobar".  Εάν το
   χαρακτηριστικό γνώρισμα δεν υπάρχει, το *default* επιστρέφεται εάν
   παρέχεται, διαφορετικά γίνεται raise το "AttributeError".  Το
   *name* δεν χρειάζεται να είναι αναγνωριστικό Python (δείτε
   "setattr()").

   Σημείωση:

     Δεδομένου ότι το private name mangling συμβαίνει κατά τη στιγμή
     της μεταγλώττισης, πρέπει κανείς να παραμορφώνει χειροκίνητα το
     όνομα ενός ιδιωτικού χαρακτηριστικού (χαρακτηριστικά με δύο
     κορυφαίες υπογραμμίσεις) για να ανακτήσει με "getattr()".

globals()

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

hasattr(object, name)

   Τα ορίσματα είναι ένα αντικείμενο και μια συμβολοσειρά (string).
   Το αποτέλεσμα είναι "True" εάν η συμβολοσειρά είναι το όνομα ενός
   από τα χαρακτηριστικά του αντικειμένου, "False" εάν όχι. (Αυτό
   υλοποιείται καλώντας το "getattr(object, name)" και να δούμε αν
   γίνεται raise ένα "AttributeError" ή όχι.)

hash(object)

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

   Σημείωση:

     For objects with custom "__hash__()" methods, note that "hash()"
     truncates the return value based on the bit width of the host
     machine. See "__hash__()" for details.

help([object])

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

   Λάβετε υπόψη ότι εάν εμφανίζεται μια κάθετος (/) στη λίστα
   παραμέτρων μιας συνάρτησης κατά την κλήση "help()", σημαίνει ότι οι
   παράμετροι πριν από την κάθετο είναι μόνο θέσης. Για περισσότερες
   πληροφορίες, βλέπε the FAQ entry on positional-only parameters.

   Αυτή η συνάρτηση προστίθεται στον ενσωματωμένο χώρο ονομάτων από το
   module "site".

   Άλλαξε στην έκδοση 3.4: Οι αλλαγές σε "pydoc" και "inspect"
   σημαίνουν ότι οι αναφερόμενες υπογραφές για callables είναι πλέον
   πιο ολοκληρωμένες και συνεπείς.

hex(x)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer. Some
   examples:

   >>> hex(255)
   '0xff'
   >>> hex(-42)
   '-0x2a'

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

   >>> '%#x' % 255, '%x' % 255, '%X' % 255
   ('0xff', 'ff', 'FF')
   >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
   ('0xff', 'ff', 'FF')
   >>> f'{255:#x}', f'{255:x}', f'{255:X}'
   ('0xff', 'ff', 'FF')

   Δείτε επίσης τη "format()" για περισσότερες πληροφορίες.

   Δείτε επίσης τη "int()" για τη μετατροπή μιας δεκαεξαδικής
   συμβολοσειράς σε ακέραιο χρησιμοποιώντας μια βάση του 16.

   Σημείωση:

     Για να αποκτήσετε μια αναπαράσταση δεκαεξαδικής συμβολοσειράς για
     ένα float, χρησιμοποιήστε τη μέθοδο "float.hex()".

id(object)

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

   **Λεπτομέρεια υλοποίησης CPython:** Αυτό είναι η διεύθυνση του
   αντικειμένου στην μνήμη.

   Εγείρει ένα auditing event "builtins.id" με όρισμα "id".

input([prompt])

   Εάν υπάρχει το όρισμα *prompt*, γράφεται στην τυπική έξοδο χωρίς
   μια νέα γραμμή μετάδοσης.  Στη συνέχεια, η συνάρτηση διαβάζει μια
   γραμμή από την είσοδο, τη μετατρέπει σε μια συμβολοσειρά (με την
   αφαίρεση μιας νέας γραμμής) και την επιστρέφει.  Όταν διαβάζεται το
   EOF, γίνεται raise η "EOFError".  Παράδειγμα:

      >>> s = input('--> ')  
      --> Monty Python's Flying Circus
      >>> s  
      "Monty Python's Flying Circus"

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

   Κάνει raise  ένα auditing event "builtins.input" με όρισμα "prompt"
   προτού διαβάσει την είσοδο

   Κάνει raise  ένα auditing event "builtins.input/result" με το
   αποτέλεσμα μετά την επιτυχή ανάγνωση των δεδομένων.

class int([x])
class int(x, base=10)

   Return an integer object constructed from a number or string *x*,
   or return "0" if no arguments are given.  If *x* defines
   "__int__()", "int(x)" returns "x.__int__()".  If *x* defines
   "__index__()", it returns "x.__index__()".  If *x* defines
   "__trunc__()", it returns "x.__trunc__()". For floating point
   numbers, this truncates towards zero.

   If *x* is not a number or if *base* is given, then *x* must be a
   string, "bytes", or "bytearray" instance representing an integer in
   radix *base*.  Optionally, the string can be preceded by "+" or "-"
   (with no space in between), have leading zeros, be surrounded by
   whitespace, and have single underscores interspersed between
   digits.

   Μια συμβολοσειρά (string) ακέραιου αριθμού βάσης n περιέχει ψηφία,
   καθένα από τα οποία αντιπροσωπεύει μια τιμή από το 0 έως το n-1. Οι
   τιμές 0--9 μπορούν να αναπαρασταθούν με οποιοδήποτε δεκαδικό ψηφίο
   Unicode. Οι τιμές 10--35 μπορούν να αναπαρασταθούν με "a" ως το "z"
   (ή "A" ως το "Z"). Η προεπιλεγμένη *base* είναι 10. Οι
   επιτρεπόμενες βάσεις είναι 0 και 2--36. Οι συμβολοσειρές βάσης -2,
   -8 και -16 μπορούν προαιρετικά να έχουν το πρόθεμα "0b"/"0B",
   "0o"/"0O", ή "0x"/"0X", όπως και με ακέραιους αριθμούς στον κώδικα.
   Για την βάση 0, η συμβολοσειρά ερμηνεύεται με παρόμοιο τρόπο με
   έναν integer literal in code, στο ότι η πραγματική βάση είναι 2, 8,
   10 ή 16 όπως προσδιορίζεται από το πρόθεμα. Η βάση 0 δεν επιτρέπει
   επίσης τα μηδενικά στην αρχή : "int('010', 0)" δεν είναι εφικτό,
   ενώ το "int('010')" και "int('010', 8)" είναι.

   Ο ακέραιος τύπος περιγράφεται στο Αριμθητικοί Τύποι --- int, float,
   complex.

   Άλλαξε στην έκδοση 3.4: Εάν το *base* δεν είναι ένα instance της
   "int" και το *base* αντικείμενο έχει μια μέθοδο "base.__index__",
   αυτή η μέθοδος καλείται για να αποκτήσει τον ακέραιο της βάσης.
   Προηγούμενες εκδόσεις χρησιμοποιούσαν την "base.__int__" αντί της
   "base.__index__".

   Άλλαξε στην έκδοση 3.6: Επιτρέπεται η ομαδοποίηση ψηφίων με κάτω
   παύλες όπως στα literals του κώδικα.

   Άλλαξε στην έκδοση 3.7: *x* is now a positional-only parameter.

   Άλλαξε στην έκδοση 3.8: Falls back to "__index__()" if "__int__()"
   is not defined.

   Άλλαξε στην έκδοση 3.10.7: "int" string inputs and string
   representations can be limited to help avoid denial of service
   attacks. A "ValueError" is raised when the limit is exceeded while
   converting a string *x* to an "int" or when converting an "int"
   into a string would exceed the limit. See the integer string
   conversion length limitation documentation.

isinstance(object, classinfo)

   Return "True" if the *object* argument is an instance of the
   *classinfo* argument, or of a (direct, indirect, or *virtual*)
   subclass thereof.  If *object* is not an object of the given type,
   the function always returns "False". If *classinfo* is a tuple of
   type objects (or recursively, other such tuples) or a Τύπος Ένωσης
   of multiple types, return "True" if *object* is an instance of any
   of the types. If *classinfo* is not a type or tuple of types and
   such tuples, a "TypeError" exception is raised.

   Άλλαξε στην έκδοση 3.10: Το *classinfo* μπορεί να είναι ένα Τύπος
   Ένωσης.

issubclass(class, classinfo)

   Επιστρέφει "True" εάν η *class* είναι μια υποκλάση (άμεση, έμμεση,
   ή *virtual*) του *classinfo*.  Μια κλάση θεωρείται υποκλάση του
   εαυτού της. Το *classinfo* μπορεί να είναι μια πλειάδα (tuple)
   αντικειμένων κλάσης (ή αναδρομικά, άλλες τέτοιες πλειάδες) ή μια
   Τύπος Ένωσης, οπότε επιστρέφετε "True" εάν η *class* είναι υποκλάση
   οποιασδήποτε καταχώρισης στο *classinfo*.  Σε οποιαδήποτε άλλη
   περίπτωση, γίνεται raise μια εξαίρεση "TypeError".

   Άλλαξε στην έκδοση 3.10: Το *classinfo* μπορεί να είναι ένα Τύπος
   Ένωσης.

iter(object[, sentinel])

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, *object* must be a collection object
   which supports the *iterable* protocol (the "__iter__()" method),
   or it must support the sequence protocol (the "__getitem__()"
   method with integer arguments starting at "0").  If it does not
   support either of those protocols, "TypeError" is raised. If the
   second argument, *sentinel*, is given, then *object* must be a
   callable object.  The iterator created in this case will call
   *object* with no arguments for each call to its "__next__()"
   method; if the value returned is equal to *sentinel*,
   "StopIteration" will be raised, otherwise the value will be
   returned.

   Δείτε επίσης Τύποι Iterator.

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

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(s)

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

   **Λεπτομέρεια υλοποίησης CPython:** Το "len" κάνει raise μια
   "OverflowError" σε μήκη τα οποία είναι μεγαλύτερα από
   "sys.maxsize", όπως "range(2 ** 100)".

class list([iterable])

   Αντί να είναι συνάρτηση, το "list" είναι στην πραγματικότητα ένας
   μεταβλητός τύπος ακολουθίας, όπως τεκμηριώνεται στα Λίστες και
   Τύποι Ακολουθίας (Sequence) --- list, tuple, range.

locals()

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

   Σημείωση:

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

map(function, iterable, ...)

   Return an iterator that applies *function* to every item of
   *iterable*, yielding the results.  If additional *iterable*
   arguments are passed, *function* must take that many arguments and
   is applied to the items from all iterables in parallel.  With
   multiple iterables, the iterator stops when the shortest iterable
   is exhausted.  For cases where the function inputs are already
   arranged into argument tuples, see "itertools.starmap()".

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

   Επιστρέφει το μεγαλύτερο στοιχείο σε ένα iterable ή το μεγαλύτερο
   από δύο ή περισσότερα ορίσματα.

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

   Υπάρχουν δύο προαιρετικά ορίσματα τύπου λέξη-κλειδί. Το όρισμα
   *key* καθορίζει μια συνάρτηση ταξινόμησης ενός ορίσματος όπως αυτή
   χρησιμοποιείται για το "list.sort()". Το όρισμα *default* καθορίζει
   ένα αντικείμενο που θα επιστρέψει εάν το iterable που παρέχεται
   είναι κενό. Εάν το iterable είναι κενό και το *default* δεν
   παρέχεται, γίνεται raise μια "ValueError".

   Εάν πολλά στοιχεία είναι μέγιστα, η συνάρτηση επιστρέφει το πρώτο
   που συναντήθηκε.  Αυτό είναι σύμφωνο με άλλα εργαλεία διατήρησης
   σταθερότητας ταξινόμησης όπως "sorted(iterable, key=keyfunc,
   reverse=True)[0]" και "heapq.nlargest(1, iterable, key=keyfunc)".

   Νέο στην έκδοση 3.4: The *default* keyword-only argument.

   Άλλαξε στην έκδοση 3.8: Το *key* μπορεί να είναι "None".

class memoryview(object)

   Επιστρέφει ένα αντικείμενο "memory view" που δημιουργήθηκε από το
   συγκεκριμένο όρισμα.  Βλέπε Όψεις Μνήμης για περισσότερες
   λεπτομέρειες.

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

   Επιστρέφει το μικρότερο στοιχείο σε έναν iterable ή το μικρότερο
   από δύο ή περισσότερα ορίσματα.

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

   Υπάρχουν δύο προαιρετικά ορίσματα τύπου λέξη-κλειδί. Το όρισμα
   *key* καθορίζει μια συνάρτηση ταξινόμησης ενός ορίσματος όπως αυτή
   χρησιμοποιείται για το "list.sort()". Το όρισμα *default* καθορίζει
   ένα αντικείμενο που θα επιστρέψει εάν το iterable που παρέχεται
   είναι κενό. Εάν το iterable είναι κενό και το *default* δεν
   παρέχεται, γίνεται raise μια "ValueError".

   Εάν πολλά στοιχεία είναι ελάχιστα, η συνάρτηση επιστρέφει το πρώτο
   που συναντήθηκε.  Αυτό είναι σύμφωνο με άλλα εργαλεία διατήρησης
   σταθερότητας ταξινόμησης, όπως "sorted(iterable, key=keyfunc)[0]"
   και "heapq.nsmallest(1, iterable, key=keyfunc)".

   Νέο στην έκδοση 3.4: The *default* keyword-only argument.

   Άλλαξε στην έκδοση 3.8: Το *key* μπορεί να είναι "None".

next(iterator[, default])

   Ανάκτηση του επόμενου στοιχείο από το *iterator* καλώντας τη μέθοδο
   "__next__()".  Εάν δοθεί *default*, επιστρέφεται εάν ο iterator
   έχει εξαντληθεί, διαφορετικά γίνεται raise μια "StopIteration".

class object

   Return a new featureless object.  "object" is a base for all
   classes. It has methods that are common to all instances of Python
   classes.  This function does not accept any arguments.

   Σημείωση:

     "object" does *not* have a "__dict__", so you can't assign
     arbitrary attributes to an instance of the "object" class.

oct(x)

   Convert an integer number to an octal string prefixed with "0o".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. For example:

   >>> oct(8)
   '0o10'
   >>> oct(-56)
   '-0o70'

   Εάν θέλετε να μετατρέψετε έναν ακέραιο αριθμό σε οκταδική
   συμβολοσειρά είτε με το πρόθεμα "0o" είτε όχι, μπορείτε να
   χρησιμοποιήσετε έναν από τους παρακάτω τρόπους.

   >>> '%#o' % 10, '%o' % 10
   ('0o12', '12')
   >>> format(10, '#o'), format(10, 'o')
   ('0o12', '12')
   >>> f'{10:#o}', f'{10:o}'
   ('0o12', '12')

   Δείτε επίσης τη "format()" για περισσότερες πληροφορίες.

open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   Ανοίγει το *file* και επιστρέφει ένα αντίστοιχο *file object*. Εάν
   το αρχείο δεν μπορεί να ανοίξει, γίνεται raise μια "OSError". Δείτε
   το Ανάγνωση και Εγγραφή Αρχείων για περισσότερα παραδείγματα χρήσης
   αυτής της συνάρτησης.

   Το *αρχείο* είναι ένα *path-like object* που δίνει το όνομα
   διαδρομής (απόλυτο ή σε σχέση με τον τρέχοντα κατάλογο εργασίας)
   του αρχείου που θα ανοίξει ή ένας ακέραιος περιγραφέας αρχείου του
   αρχείου που πρόκειται να αναδιπλωθεί.  (Εάν δίνεται ένας
   περιγραφέας αρχείου, κλείνει όταν το επιστρεφόμενο αντικείμενο I/O
   είναι κλειστό εκτός εάν *closefd* έχει οριστεί ως "False".)

   *mode* is an optional string that specifies the mode in which the
   file is opened.  It defaults to "'r'" which means open for reading
   in text mode. Other common values are "'w'" for writing (truncating
   the file if it already exists), "'x'" for exclusive creation, and
   "'a'" for appending (which on *some* Unix systems, means that *all*
   writes append to the end of the file regardless of the current seek
   position).  In text mode, if *encoding* is not specified the
   encoding used is platform-dependent:
   "locale.getpreferredencoding(False)" is called to get the current
   locale encoding. (For reading and writing raw bytes use binary mode
   and leave *encoding* unspecified.)  The available modes are:

   +-----------+-----------------------------------------------------------------+
   | Χαρακτήρ  | Έννοια                                                          |
   | ας        |                                                                 |
   |===========|=================================================================|
   | "'r'"     | άνοιγμα για ανάγνωση (default)                                  |
   +-----------+-----------------------------------------------------------------+
   | "'w'"     | άνοιγμα για εγγραφή, περικόπτοντας πρώτα το αρχείο              |
   +-----------+-----------------------------------------------------------------+
   | "'x'"     | άνοιγμα για αποκλειστική δημιουργία, αποτυγχάνοντας εάν το      |
   |           | αρχείο υπάρχει ήδη                                              |
   +-----------+-----------------------------------------------------------------+
   | "'a'"     | άνοιγμα για εγγραφή, προσαρτάται στο τέλος του αρχείου εάν      |
   |           | υπάρχει                                                         |
   +-----------+-----------------------------------------------------------------+
   | "'b'"     | δυαδική (binary) λειτουργία                                     |
   +-----------+-----------------------------------------------------------------+
   | "'t'"     | λειτουργία κειμένου (default)                                   |
   +-----------+-----------------------------------------------------------------+
   | "'+'"     | άνοιγμα για ενημέρωση (ανάγνωση και εγγραφή)                    |
   +-----------+-----------------------------------------------------------------+

   Η προεπιλεγμένη λειτουργία είναι "'r'" (ανοίγει για ανάγνωση
   κειμένου, συνώνυμο του "'rt'"). Οι λειτουργίες "'w+'" και "'w+b'"
   ανοίγει και περικόβει το αρχείο.  Οι λειτουργίες "'r+'" and "'r+b'"
   ανοίγουν το αρχείο χωρίς περικοπή.

   Όπως αναφέρεται στο Overview, η Python κάνει διάκριση μεταξύ
   δυαδικού και κειμένου I/O.  Τα αρχεία που ανοίγουν σε δυαδική
   λειτουργία (συμπεριλαμβανομένου του "'b'" στο όρισμα *mode*)
   επιστρέφουν τα περιεχόμενα ως "bytes" αντικείμενα χωρίς
   αποκωδικοποίηση.  Στη λειτουργία κειμένου (η προεπιλογή, ή όταν το
   "'t'" περιλαμβάνεται στο όρισμα *mode*), τα περιεχόμενα του αρχείου
   επιστρέφονται ως "str", τα bytes έχουν πρώτα αποκωδικοποιηθεί
   χρησιμοποιώντας μια εξαρτώμενη από πλατφόρμα κωδικοποίηση ή χρήση
   της καθορισμένης *κωδικοποίησης* εάν δίνεται.

   There is an additional mode character permitted, "'U'", which no
   longer has any effect, and is considered deprecated. It previously
   enabled *universal newlines* in text mode, which became the default
   behavior in Python 3.0. Refer to the documentation of the newline
   parameter for further details.

   Σημείωση:

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

   *buffering* is an optional integer used to set the buffering
   policy.  Pass 0 to switch buffering off (only allowed in binary
   mode), 1 to select line buffering (only usable in text mode), and
   an integer > 1 to indicate the size in bytes of a fixed-size chunk
   buffer. Note that specifying a buffer size this way applies for
   binary buffered I/O, but "TextIOWrapper" (i.e., files opened with
   "mode='r+'") would have another buffering. To disable buffering in
   "TextIOWrapper", consider using the "write_through" flag for
   "io.TextIOWrapper.reconfigure()". When no *buffering* argument is
   given, the default buffering policy works as follows:

   * Binary files are buffered in fixed-size chunks; the size of the
     buffer is chosen using a heuristic trying to determine the
     underlying device's "block size" and falling back on
     "io.DEFAULT_BUFFER_SIZE".  On many systems, the buffer will
     typically be 4096 or 8192 bytes long.

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

   *encoding* is the name of the encoding used to decode or encode the
   file. This should only be used in text mode.  The default encoding
   is platform dependent (whatever "locale.getpreferredencoding()"
   returns), but any *text encoding* supported by Python can be used.
   See the "codecs" module for the list of supported encodings.

   Το *errors* είναι μια προαιρετική συμβολοσειρά που καθορίζει τον
   τρόπο χειρισμού των σφαλμάτων κωδικοποίησης και
   αποκωδικοποίησης-αυτό δεν μπορεί να χρησιμοποιηθεί σε δυαδική
   λειτουργία. Διατίθεται μια ποικιλία τυπικών εργαλείων χειρισμού
   σφαλμάτων (παρατίθενται στην ενότητα Error Handlers), αν και
   οποιοδήποτε όνομα χειρισμού σφαλμάτων έχει καταχωρηθεί με το
   "codecs.register_error()" είναι επίσης έγκυρο.  Τα τυπικά ονόματα
   περιλαμβάνουν:

   * Το "'strict'" κάνει raise μια εξαίρεση "ValueError" εάν υπάρχει
     σφάλμα κωδικοποίησης.  Η προεπιλεγμένη τιμή του "None" έχει το
     ίδιο αποτέλεσμα.

   * Το "'ignore'" αγνοεί τα σφάλματα.  Σημειώστε ότι η παράβλεψη
     σφαλμάτων κωδικοποίησης μπορεί να οδηγήσει σε απώλεια δεδομένων.

   * Το "'replace'" προκαλεί την εισαγωγή ενός δείκτη αντικατάστασης
     (όπως "'?'") όταν υπάρχουν δεδομένα με λανθασμένη μορφή.

   * Το "'surrogateescape'" θα αντιπροσωπεύει τυχόν λανθασμένα bytes
     ως μονάδες χαμηλού υποκατάστατου κωδικού που κυμαίνονται από
     U+DC80 έως U+DCFF. Αυτές οι μονάδες υποκατάστατου κωδικού θα
     μετατραπούν στη συνέχεια στα ίδια bytes όταν ο χειριστής
     σφαλμάτων "surrogateescape" χρησιμοποιείται κατά την εγγραφή
     δεδομένων.  Αυτό είναι χρήσιμο για την επεξεργασία αρχείων σε
     άγνωστη κωδικοποίηση.

   * "'xmlcharrefreplace'" is only supported when writing to a file.
     Characters not supported by the encoding are replaced with the
     appropriate XML character reference "&#nnn;".

   * Το "'backslashreplace'" αντικαθιστά δεδομένα με λανθασμένη μορφή
     από τις ακολουθίες διαφυγής με ανάστροφης καθέτου Python.

   * Το "'namereplace'" (υποστηρίζεται επίσης μόνο κατά τη σύνταξη)
     αντικαθιστά τους μη υποστηριζόμενους χαρακτήρες με ακολουθίες
     διαφυγής "\N{...}".

   Το *newline* καθορίζει τον τρόπο ανάλυσης χαρακτήρων νέας γραμμής
   από τη ροή. Μπορεί να είναι και "None", "''", "'\n'", "'\r'", και
   "'\r\n'".  Λειτουργεί ως εξής:

   * Κατά την ανάγνωση εισόδου από την ροή, εάν το *newline* είναι
     "None", η καθολική λειτουργία νέων γραμμών είναι ενεργοποιημένη.
     Οι γραμμές στην είσοδο μπορούν να τελειώνουν σε "'\n'", "'\r'", ή
     "'\r\n'", και αυτά μεταφράζονται σε "'\n'" πριν επιστραφούν στον
     καλούντα.  Εάν είναι "''", η καθολική λειτουργία νέων γραμμών
     είναι ενεργοποιημένη, αλλά οι καταλήξεις γραμμών επιστρέφονται
     στον καλούντα αμετάφραστα.  Εάν έχει κάποια από τις άλλες νόμιμες
     τιμές, οι γραμμές εισόδου τερματίζονται μόνο από τη δεδομένη
     συμβολοσειρά και η κατάληξη γραμμής επιστρέφεται στον καλούντα
     αμετάφραστη.

   * Κατά την εγγραφή εξόδου στη ροή, εάν το *newline* είναι "None",
     τυχόν χαρακτήρες "'\n'" μεταφράζονται στο διαχωριστικό
     προεπιλεγμένων γραμμών του συστήματος, "os.linesep".  Εάν το
     *newline* είναι "''" ή "'\n'", δεν πραγματοποιείται μετάφραση εάν
     το *newline* είναι οποιαδήποτε από τις άλλες νόμιμες τιμές,
     γράφονται οποιοιδήποτε χαρακτήρες "'\n'" μεταφράζονται στη
     δεδομένη συμβολοσειρά.

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

   Ένα προσαρμοσμένο πρόγραμμα ανοίγματος μπορεί να χρησιμοποιηθεί
   μεταβιβάζοντας ένα callable ως *opener*. Ο υποκείμενος περιγραφέας
   αρχείου για το αντικείμενο αρχείου λαμβάνεται στη συνέχεια καλώντας
   το *opener* με (*file*, *flags*).  Το *opener* πρέπει να επιστρέψει
   ένα περιγραφέα ανοιχτού αρχείου (περνώντας "os.open" ως *opener*
   έχει ως αποτέλεσμα λειτουργικότητας παρόμοια με το να περάσουμε το
   "None").

   Το νέο δημιουργημένο αρχείο είναι non-inheritable.

   Το παρακάτω παράδειγμα χρησιμοποιεί την παράμετρο dir_fd της
   συνάρτησης "os.open()" για να ανοίξει ένα αρχείο σε σχέση με έναν
   δεδομένο κατάλογο:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('This will be written to somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # don't leak a file descriptor

   Ο τύπος του *file object* που επιστρέφεται από τη συνάρτηση
   "open()" εξαρτάται από τη λειτουργία.  Όταν το "open()"
   χρησιμοποιείται για το άνοιγμα ενός αρχείου σε λειτουργία κειμένου
   ("'w'", "'r'", "'wt'", "'rt'", κ.λπ.), επιστρέφει μια υποκλάση του
   "io.TextIOBase" (specifically "io.TextIOWrapper").  Όταν
   χρησιμοποιείται για το άνοιγμα ενός αρχείου σε δυαδική λειτουργία
   με προσωρινή αποθήκευση, η κλάση που επιστρέφεται είναι μια
   υποκλάση του "io.BufferedIOBase".  Η ακριβής κλάση ποικίλλει: σε
   λειτουργία δυαδικής ανάγνωσης, επιστρέφει ένα "io.BufferedReader" ∙
   σε δυαδικές καταστάσεις εγγραφής και δυαδικής προσθήκης, επιστρέφει
   ένα "io.BufferedWriter", και στη λειτουργία ανάγνωσης/εγγραφής,
   επιστρέφει ένα "io.BufferedRandom".  Όταν η προσωρινή αποθήκευση
   είναι απενεργοποιημένη, επιστρέφεται, η ακατέργαστη ροή , μια
   υποκλάση "io.RawIOBase", "io.FileIO".

   Δείτε επίσης τις ενότητες διαχείρισης αρχείων, όπως "fileinput",
   "io" (όπου ορίζεται η "open()"), "os", "os.path", "tempfile", και
   "shutil".

   Raises an auditing event "open" with arguments "file", "mode",
   "flags".

   Τα ορίσματα "mode" και "flags" μπορεί να έχουν τροποποιηθεί ή να
   έχουν συναχθεί από την αρχική κλήση.

      Άλλαξε στην έκδοση 3.3:

      * Προστέθηκε η παράμετρος *opener*.

      * Προστέθηκε η λειτουργία "'x'".

      * Το "IOError" γινόταν raise παλιά, τώρα είναι ψευδώνυμο του
        "OSError".

      * Το "FileExistsError" γίνεται raise τώρα εάν το αρχείο που
        ανοίγει σε λειτουργία αποκλειστικής δημιουργίας ("'x'")
        υπάρχει ήδη.

      Άλλαξε στην έκδοση 3.4:

      * Το αρχείο είναι πλέον μη κληρονομικό.

   Deprecated since version 3.4, removed in version 3.10: The "'U'"
   mode.

      Άλλαξε στην έκδοση 3.5:

      * Εάν η κλήση συστήματος διακοπεί και ο χειριστής σήματος δεν
        κάνει raise μια εξαίρεση, η συνάρτηση επαναλαμβάνει τώρα την
        κλήση συστήματος αντί να κάνει raise μια εξαίρεση
        "InterruptedError" (δείτε το **PEP 475** για το σκεπτικό).

      * Προστέθηκε το πρόγραμμα χειρισμού σφαλμάτων "'namereplace'".

      Άλλαξε στην έκδοση 3.6:

      * Προστέθηκε υποστήριξη για την αποδοχή αντικειμένων που
        υλοποιούν "os.PathLike".

      * Στα Windows, το άνοιγμα μιας προσωρινής μνήμης κονσόλας μπορεί
        να επιστρέψει μια υποκλάση του "io.RawIOBase" εκτός από το
        "io.FileIO".

ord(c)

   Δεδομένου μιας συμβολοσειράς που αντιπροσωπεύει έναν χαρακτήρα
   Unicode, επιστρέφει έναν ακέραιο που αντιπροσωπεύει το σημείο
   κωδικού Unicode αυτού του χαρακτήρα.  Για παράδειγμα, το "ord('a')"
   επιστρέφει τον ακέραιο αριθμό "97" και "ord('€')" (σύμβολο του
   ευρώ) επιστρέφει "8364".  Αυτό είναι το αντίστροφο του "chr()".

pow(base, exp[, mod])

   Επιστρέφει *base* στην δύναμη *exp*∙ εάν υπάρχει το *mod*,
   επιστρέφει *base* στην δύναμη *exp*, modulo *mod* (υπολογίζεται πιο
   αποτελεσματικά από το "pow(base, exp) % mod"). Η φόρμα δύο
   ορισμάτων "pow(base, exp)" ισοδυναμεί με τη χρήση του τελεστή
   δύναμης: "base**exp".

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For
   "int" operands, the result has the same type as the operands (after
   coercion) unless the second argument is negative; in that case, all
   arguments are converted to float and a float result is delivered.
   For example, "pow(10, 2)" returns "100", but "pow(10, -2)" returns
   "0.01".  For a negative base of type "int" or "float" and a non-
   integral exponent, a complex result is delivered.  For example,
   "pow(-9, 0.5)" returns a value close to "3j".

   Για τους τελεστές της "int" *base* και *exp*, εάν υπάρχει *mod*, το
   *mod* πρέπει επίσης να είναι ακεραίου τύπου και το *mod* πρέπει να
   είναι μη μηδενικό. Εάν υπάρχει *mod* και το *exp* είναι αρνητικό,
   το *base* πρέπει να είναι σχετικά πρώτο στο *mod*. Σε αυτήν την
   περίπτωση , επιστρέφεται το "pow(inv_base, -exp, mod)", όπου το
   *inv_base* είναι αντίστροφο του *base* modulo *mod*.

   Ακολουθεί ένα παράδειγμα υπολογισμού ενός αντίστροφου για το "38"
   modulo "97":

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

   Άλλαξε στην έκδοση 3.8: Για του τελεστές "int", η μορφή τριών
   ορισμών του "pow" επιτρέπει τώρα το δεύτερο όρισμα να είναι
   αρνητικό, επιτρέποντας τον υπολογισμό των αρθρωτών αντίστροφων.

   Άλλαξε στην έκδοση 3.8: Επιτρέπονται ορίσματα keyword.  Παλαιότερα,
   υποστηρίζονταν μόνο ορίσματα θέσης.

print(*objects, sep=' ', end='\n', file=None, flush=False)

   Εκτυπώνει *objects* στην ροή κειμένου *file*, χωρισμένα με *sep*
   και ακολουθούμενα από *end*. Τα *sep*, *end*, *file*, και *flush*,
   εάν υπάρχουν, πρέπει να δίνονται ως ορίσματα keyword.

   Όλα τα μη keyword ορίσματα μετατρέπονται σε συμβολοσειρές όπως
   κάνει η "str()" και γράφονται στη ροή, χωρισμένα με *sep* και
   ακολουθούνται από *end*.  Και τα δύο *sep* και *end* πρέπει να
   είναι συμβολοσειρές∙ μπορεί επίσης να είναι "None", που σημαίνει
   ότι θα χρησιμοποιηθούν οι προεπιλεγμένες τιμές.  Εάν δεν δίνονται
   *αντικείμενα*, η "print()" θα γράψει απλά *end*.

   Το όρισμα *file* πρέπει να είναι αντικείμενο με μια μέθοδο
   "write(string)``∙ εάν δεν υπάρχει ή είναι ``None", θα
   χρησιμοποιηθεί το "sys.stdout".  Επειδή τα τυπωμένα ορίσματα
   μετατρέπονται σε συμβολοσειρές κειμένου, η "print()" δεν μπορεί να
   χρησιμοποιηθεί με αντικείμενα αρχείου δυαδικής λειτουργίας.  Για
   αυτά, χρησιμοποιούμε το "file.write(...)".

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

   Άλλαξε στην έκδοση 3.3: Προστέθηκε το όρισμα keyword *flush*.

class property(fget=None, fset=None, fdel=None, doc=None)

   Επιστρέφει ένα χαρακτηριστικό ιδιότητας.

   Το *fget* είναι μια συνάρτηση για τη λήψη μιας τιμής
   χαρακτηριστικού.  Το *fset* είναι μια συνάρτηση για τον ορισμό μιας
   τιμής χαρακτηριστικού. Το *fdel* είναι μια συνάρτηση για τη
   διαγραφή μιας τιμής χαρακτηριστικού.  Και το *doc* δημιουργεί μια
   συμβολοσειρά εγγράφων για το χαρακτηριστικό.

   Μια τυπική χρήση είναι ο ορισμός ενός διαχειριζόμενου
   χαρακτηριστικού "x":

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "I'm the 'x' property.")

   Εάν το *c* είναι ένα instance του *C*, το "c.x" θα καλέσει τον
   λήπτη, το "c.x = value` θα καλέσει τον ρυθμιστή, και το ``del c.x"
   τον διαγραφέα.

   Εάν δίνεται, το *doc* θα είναι το docstring του χαρακτηριστικού
   ιδιότητας. Διαφορετικά , η ιδιότητα θα αντιγράψει τη συμβολοσειρά
   του *fget* (εάν υπάρχει).  Αυτό καθιστά δυνατή τη δημιουργία
   ιδιοτήτων μόνο για ανάγνωση, εύκολα χρησιμοποιώντας τη "property()"
   ως *decorator*:

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Get the current voltage."""
              return self._voltage

   The "@property" decorator turns the "voltage()" method into a
   "getter" for a read-only attribute with the same name, and it sets
   the docstring for *voltage* to "Get the current voltage."

   A property object has "getter", "setter", and "deleter" methods
   usable as decorators that create a copy of the property with the
   corresponding accessor function set to the decorated function.
   This is best explained with an example:

      class C:
          def __init__(self):
              self._x = None

          @property
          def x(self):
              """I'm the 'x' property."""
              return self._x

          @x.setter
          def x(self, value):
              self._x = value

          @x.deleter
          def x(self):
              del self._x

   Αυτός ο κώδικας είναι ακριβώς ισοδύναμος με το πρώτο παράδειγμα.
   Φροντίστε να δώσετε στις πρόσθετες συναρτήσεις το ίδιο όνομα με την
   αρχική ιδιότητα ("x" σε αυτήν την περίπτωση.)

   Το επιστρεφόμενο αντικείμενο ιδιότητας έχει επίσης τα
   χαρακτηριστικά "fget", "fset", και "fdel" που αντιστοιχούν στα
   ορίσματα του κατασκευαστή.

   Άλλαξε στην έκδοση 3.5: Τα *docstrings* των αντικειμένων ιδιότητας
   είναι πλέον εγγράψιμες.

class range(stop)
class range(start, stop[, step])

   Αντί να είναι συνάρτηση, το "range" είναι στην πραγματικότητα ένας
   αμετάβλητος τύπος ακολουθίας, όπως τεκμηριώνεται στα Εύρη (Ranges)
   και Τύποι Ακολουθίας (Sequence) --- list, tuple, range.

repr(object)

   Return a string containing a printable representation of an object.
   For many types, this function makes an attempt to return a string
   that would yield an object with the same value when passed to
   "eval()"; otherwise, the representation is a string enclosed in
   angle brackets that contains the name of the type of the object
   together with additional information often including the name and
   address of the object.  A class can control what this function
   returns for its instances by defining a "__repr__()" method. If
   "sys.displayhook()" is not accessible, this function will raise
   "RuntimeError".

reversed(seq)

   Return a reverse *iterator*.  *seq* must be an object which has a
   "__reversed__()" method or supports the sequence protocol (the
   "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "0").

round(number[, ndigits])

   Επιστρέφει τον *number* στρογγυλοποιημένο σε *ndigits* ακρίβεια
   μετά την υποδιαστολή.  Εάν το *ndigits* παραληφθεί ή είναι "None",
   επιστρέφει τον πλησιέστερο ακέραιο αριθμό στην είσοδό του.

   Για του ενσωματωμένους τύπους που υποστηρίζουν τη "round()", οι
   τιμές στρογγυλοποιούνται στο πλησιέστερο πολλαπλάσιο του 10 στην
   δύναμη μείον *ndigits*∙ εάν δύο πολλαπλάσια είναι εξίσου κοντά, η
   στρογγυλοποίηση γίνεται προς την άρτια επιλογή (έτσι, για
   παράδειγμα, τόσο το ``round(0.5)`` και ``round(-0.5)`` είναι ``0``,
   και ``round(1.5)`` είναι ``2``).  Οποιαδήποτε ακέραια τιμή είναι
   έγκυρη για *ndigits* (θετική, μηδενική, ή αρνητική).  Η
   επιστρεφόμενη τιμή είναι ακέραιος εάν το *ndigits* παραλειφθεί ή
   είναι "None". Διαφορετικά, η τιμή επιστροφής έχει τον ίδιο τύπο με
   το *number*.

   Για ένα γενικό αντικείμενο Python "number", "round" εκχωρεί στο
   "number.__round__".

   Σημείωση:

     Η συμπεριφορά του "round()" για floats μπορεί να είναι
     εκπληκτική: για παράδειγμα, το "round(2.675, 2)" δίνει "2.67"
     αντί για το αναμενόμενο "2.68". Αυτό δεν είναι bug: είναι
     αποτέλεσμα του γεγονότος ότι τα περισσότερα δεκαδικά κλάσματα δεν
     μπορούν να αναπαρασταθούν ακριβώς ως float.  Δείτε το Floating
     Point Arithmetic:  Issues and Limitations για περισσότερες
     πληροφορίες.

class set([iterable])

   Επιστρέφει ένα νέο αντικείμενο "set", προαιρετικά με στοιχεία που
   λαμβάνονται από το *iterable*.  Το "set" είναι μια ενσωματωμένη
   κλάση.  Δείτε "set" και Τύποι Συνόλου (Set) --- set, frozenset για
   τεκμηρίωση αυτής της κλάσης.

   Για άλλα containers, δείτε τις ενσωματωμένες κλάσεις "frozenset",
   "list", "tuple", και "dict", καθώς και το module "collections".

setattr(object, name, value)

   Αυτό είναι το αντίστοιχο τους "getattr()".  Τα ορίσματα είναι ένα
   αντικείμενο, μια συμβολοσειρά και μια αυθαίρετη τιμή.  Η
   συμβολοσειρά μπορεί να ονομάσει ένα υπάρχον χαρακτηριστικό ή ένα
   νέο χαρακτηριστικό. Η συνάρτηση εκχωρεί την τιμή στο
   χαρακτηριστικό, με την προϋπόθεση ότι το αντικείμενο το επιτρέπει.
   Για παράδειγμα "setattr(x, 'foobar', 123)" ισοδυναμεί με το
   "x.foobar = 123".

   Το *name* δεν χρειάζεται να είναι αναγνωριστικό Python όπως
   ορίζεται στο Identifiers and keywords , εκτός εάν το αντικείμενο
   επιλέξει να το επιβάλει αυτό, για παράδειγμα σε ένα προσαρμοσμένο
   "__getattribute__()" ή μέσω "__slots__". Ένα χαρακτηριστικό του
   οποίου το όνομα δεν είναι αναγνωριστικό δεν θα είναι προσβάσιμο
   χρησιμοποιώντας τη σημειογραφία, αλλά είναι προσβάσιμο μέσω του
   "getattr()" κ.λπ..

   Σημείωση:

     Δεδομένου ότι το private name mangling συμβαίνει κατά τη στιγμή
     της μεταγλώττισης, πρέπει κανείς να παραμορφώσει με μη αυτόματο
     τρόπο το όνομα ενός ιδιωτικού χαρακτηριστικού (χαρακτηριστικά με
     δύο προπορευόμενες κάτω παύλες) για να το ορίσει με "setattr()".

class slice(stop)
class slice(start, stop[, step])

   Return a *slice* object representing the set of indices specified
   by "range(start, stop, step)".  The *start* and *step* arguments
   default to "None".  Slice objects have read-only data attributes
   "start", "stop", and "step" which merely return the argument values
   (or their default).  They have no other explicit functionality;
   however, they are used by NumPy and other third-party packages.
   Slice objects are also generated when extended indexing syntax is
   used.  For example: "a[start:stop:step]" or "a[start:stop, i]".
   See "itertools.islice()" for an alternate version that returns an
   iterator.

sorted(iterable, /, *, key=None, reverse=False)

   Επιστρέφει μια νέα ταξινομημένη λίστα από τα στοιχεία στο
   *iterable*.

   Έχει δύο προαιρετικά ορίσματα που πρέπει να καθοριστούν ως ορίσματα
   λέξεων-κλειδιών.

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

   Το *reverse* είναι μια δυαδική τιμή.  Εάν οριστεί σε "True", τότε
   τα στοιχεία της λίστας ταξινομούνται σαν να είχε αντιστραφεί κάθε
   σύγκριση.

   Χρησιμοποιήστε το "functools.cmp_to_key()" για να μετατρέψετε μια
   συνάρτηση *cmp* παλιού τύπου σε συνάρτηση *key*.

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

   Ο αλγόριθμος ταξινόμησης χρησιμοποιεί μόνο συγκρίσεις "<" μεταξύ
   στοιχείων.  Ενώ ο ορισμός μιας μεθόδου "__lt__()" αρκεί για την
   ταξινόμηση, το **PEP 8** συνιστά και τις έξι rich comparisons που
   θα εφαρμοστούν.  Αυτό θα βοηθήσει στην αποφυγή σφαλμάτων κατά τη
   χρήση των ίδιων δεδομένων με άλλα εργαλεία διάταξης, όπως "max()"
   που βασίζονται σε διαφορετική υποκείμενη μέθοδο.  Η υλοποίηση και
   των έξι συγκρίσεων βοηθά επίσης στην αποφυγή σύγχυσης για
   συγκρίσεις μικτού τύπου που μπορούν να καλέσουν την ανακλώμενη
   μέθοδο "__gt__()".

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

@staticmethod

   Μετατροπή μιας μεθόδου σε στατική μέθοδο.

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

      class C:
          @staticmethod
          def f(arg1, arg2, ...): ...

   Η φόρμα "@staticmethod" είναι μια συνάρτηση *decorator* -- δείτε
   Function definitions για λεπτομέρειες.

   A static method can be called either on the class (such as "C.f()")
   or on an instance (such as "C().f()"). Moreover, they can be called
   as regular functions (such as "f()").

   Οι στατικές μέθοδοι στην Python είναι παρόμοιες με αυτές που
   βρίσκονται στην Java ή στη C++. Επίσης, ανατρέξτε στη
   "classmethod()" για μια παραλλαγή που είναι χρήσιμη για τη
   δημιουργία εναλλακτικών κατασκευαστών κλάσεων.

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

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

   Για περισσότερες πληροφορίες σχετικά με τις στατικές μεθόδους,
   δείτε το The standard type hierarchy.

   Άλλαξε στην έκδοση 3.10: Static methods now inherit the method
   attributes ("__module__", "__name__", "__qualname__", "__doc__" and
   "__annotations__"), have a new "__wrapped__" attribute, and are now
   callable as regular functions.

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

   Επιστρέφει μια έκδοση "str" του *object*.  Δείτε "str()" για
   λεπτομέρειες.

   Το "str" είναι η ενσωματωμένη συμβολοσειρά *class*.  Για γενικές
   πληροφορίες σχετικά με τις συμβολοσειρές, ανατρέξτε Τύπος
   Ακολουθίας (Sequence) Κειμένου --- str.

sum(iterable, /, start=0)

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

   For some use cases, there are good alternatives to "sum()". The
   preferred, fast way to concatenate a sequence of strings is by
   calling "''.join(sequence)".  To add floating point values with
   extended precision, see "math.fsum()".  To concatenate a series of
   iterables, consider using "itertools.chain()".

   Άλλαξε στην έκδοση 3.8: Η παράμετρος *start* μπορεί να καθοριστεί
   ως όρισμα keyword.

class super([type[, object-or-type]])

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

   The *object-or-type* determines the *method resolution order* to be
   searched.  The search starts from the class right after the *type*.

   For example, if "__mro__" of *object-or-type* is "D -> B -> C -> A
   -> object" and the value of *type* is "B", then "super()" searches
   "C -> A -> object".

   The "__mro__" attribute of the *object-or-type* lists the method
   resolution search order used by both "getattr()" and "super()".
   The attribute is dynamic and can change whenever the inheritance
   hierarchy is updated.

   Εάν το δεύτερο όρισμα παραλειφθεί, το υπεραντικείμενο που
   επιστράφηκε δεν είναι δεσμευμένο.  Εάν το δεύτερο όρισμα είναι
   αντικείμενο, "isinstance(obj, type)" πρέπει να είναι αληθές.  Εάν
   το δεύτερο όρισμα είναι ένας τύπος, το "issubclass(type2, type)"
   πρέπει να είναι αληθές (αυτό είναι χρήσιμο για μεθόδους κλάσης).

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

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

   Και για τις δύο περιπτώσεις χρήσης, μια τυπική κλήση υπερκλάσης
   μοιάζει με αυτό:

      class C(B):
          def method(self, arg):
              super().method(arg)    # This does the same thing as:
                                     # super(C, self).method(arg)

   Εκτός από τις αναζητήσεις μεθόδων, το "super()" λειτουργεί επίσης
   για αναζητήσεις χαρακτηριστικών.  Μια πιθανή περίπτωση χρήσης για
   αυτό είναι η κλήση *descriptors* σε μια κλάση γονέα ή αδελφού.

   Note that "super()" is implemented as part of the binding process
   for explicit dotted attribute lookups such as
   "super().__getitem__(name)". It does so by implementing its own
   "__getattribute__()" method for searching classes in a predictable
   order that supports cooperative multiple inheritance. Accordingly,
   "super()" is undefined for implicit lookups using statements or
   operators such as "super()[name]".

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

   Για πρακτικές προτάσεις σχετικά με το πώς να σχεδιάσετε
   συνεργατικές τάξεις χρησιμοποιώντας το "super()", ανατρέξτε οδηγός
   χρήσης super().

class tuple([iterable])

   Αντί να είναι συνάρτηση, το "tuple" είναι στην πραγματικότητα ένα
   αμετάβλητος τύπος ακολουθίας, όπως τεκμηριώνεται στα Πλειάδες
   (Tuples) και Τύποι Ακολουθίας (Sequence) --- list, tuple, range.

class type(object)
class type(name, bases, dict, **kwds)

   With one argument, return the type of an *object*.  The return
   value is a type object and generally the same object as returned by
   "object.__class__".

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

   With three arguments, return a new type object.  This is
   essentially a dynamic form of the "class" statement. The *name*
   string is the class name and becomes the "__name__" attribute. The
   *bases* tuple contains the base classes and becomes the "__bases__"
   attribute; if empty, "object", the ultimate base of all classes, is
   added.  The *dict* dictionary contains attribute and method
   definitions for the class body; it may be copied or wrapped before
   becoming the "__dict__" attribute. The following two statements
   create identical "type" objects:

   >>> class X:
   ...     a = 1
   ...
   >>> X = type('X', (), dict(a=1))

   See also Τύποι Αντικειμένων.

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

   Δείτε επίσης Customizing class creation.

   Άλλαξε στην έκδοση 3.6: Subclasses of "type" which don't override
   "type.__new__" may no longer use the one-argument form to get the
   type of an object.

vars([object])

   Return the "__dict__" attribute for a module, class, instance, or
   any other object with a "__dict__" attribute.

   Objects such as modules and instances have an updateable "__dict__"
   attribute; however, other objects may have write restrictions on
   their "__dict__" attributes (for example, classes use a
   "types.MappingProxyType" to prevent direct dictionary updates).

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

   Μια εξαίρεση "TypeError" γίνεται raise εάν ένα αντικείμενο έχει
   καθοριστεί αλλά δεν έχει ένα χαρακτηριστικό "__dict__" (για
   παράδειγμα, εάν η κλάση του ορίζει το "__slots__" χαρακτηριστικό).

zip(*iterables, strict=False)

   Επανάληψη σε πολλούς iterables παράλληλα, δημιουργώντας πλειάδες με
   ένα αντικείμενο από το καθένα.

   Παράδειγμα:

      >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
      ...     print(item)
      ...
      (1, 'sugar')
      (2, 'spice')
      (3, 'everything nice')

   Πιο τυπικά: η "zip()" επιστρέφει έναν iterator πλειάδων, όπου η
   *i*-η πλειάδα περιέχει το *i*-ο στοιχείο από κάθε ένα από τους
   επαναλήψιμους ορισμάτων.

   Ένας άλλος τρόπος για να σκεφτείτε τη "zip()" είναι ότι μετατρέπει
   τις γραμμές σε στήλες, και τις στήλες σε γραμμές.  Αυτό είναι
   παρόμοιο με μεταφορά μιας μήτρας.

   Το "zip()" είναι τεμπέλης: Τα στοιχεία δεν θα υποβληθούν σε
   επεξεργασία μέχρι να επαναληφθεί ο iterable, π.χ. με έναν βρόχο
   "for" ή με αναδίπλωση σε μια "list".

   Ένα πράγμα που πρέπει να λάβετε υπόψη είναι ότι τα iterables που
   μεταβιβάστηκαν στη "zip()" θα μπορούσαν να έχουνε διαφορετικά μήκη∙
   μερικές φορές από το σχεδιασμό και μερικές φορές λόγω ενός
   σφάλματος στον κώδικα που προετοίμασε αυτά τα iterables.  Η Python
   προσφέρει τρεις διαφορετικές προσεγγίσεις για την αντιμετώπιση
   αυτού του ζητήματος:

   * Από default, η "zip()" σταματά όταν εξαντληθεί ο συντομότερος
     iterable. Αυτό θα αγνοήσει τα υπόλοιπα στοιχεία στους
     μεγαλύτερους iterables, κόβοντας το αποτέλεσμα στο μήκος του
     συντομότερου iterable:

        >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
        [(0, 'fee'), (1, 'fi'), (2, 'fo')]

   * Η "zip()" χρησιμοποιείται συχνά σε περιπτώσεις όπου τα iterables
     υποτίθεται ότι έχουν ίσο μήκος.  Σε τέτοιες περιπτώσεις,
     συνίσταται η χρήση της επιλογής "strict=True". Η έξοδος είναι
     ίδια με την κανονική "zip()":

        >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
        [('a', 1), ('b', 2), ('c', 3)]

     Σε αντίθεση με την προεπιλεγμένη συμπεριφορά, γίνεται raise ένα
     "ValueError" εάν ένα iterable εξαντληθεί πριν από τα άλλα:

     >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):  
     ...     print(item)
     ...
     (0, 'fee')
     (1, 'fi')
     (2, 'fo')
     Traceback (most recent call last):
       ...
     ValueError: zip() argument 2 is longer than argument 1

     Χωρίς το όρισμα "strict=True", κάθε σφάλμα που οδηγεί σε
     επαναλαμβανόμενα μήκη διαφορετικού μήκους θα τεθεί σε σίγαση,
     πιθανώς να εμφανίζεται ως δυσεύρετο σφάλμα σε άλλο μέρος του
     προγράμματος.

   * Οι μικρότεροι iterables μπορούν να συμπληρωθούν σε μια σταθερή
     τιμή ώστε όλα τα iterables να έχουνε το ίδιο μήκος.  Αυτό γίνεται
     από το "itertools.zip_longest()".

   Περιπτώσεις άκρων: Με ένα μόνο επαναληπτικό όρισμα, η "zip()"
   επιστρέφει έναν iterator 1-πλειάδων.  Χωρίς ορίσματα, επιστρέφει
   έναν κενό iterator.

   Συμβουλές και κόλπα:

   * Η σειρά αξιολόγησης από αριστερά προς τα δεξιά των iterables
     είναι εγγυημένη. Αυτό καθιστά δυνατό ένα ιδίωμα για την
     ομαδοποίηση μιας σειράς δεδομένων σε ομάδες n-μήκους
     χρησιμοποιώντας "zip(*[iter(s)]*n, strict=True)".  Αυτό
     επαναλαμβάνει τις *ίδιες* επαναλήψεις "n" φορές έτσι ώστε κάθε
     πλειάδα εξόδου να έχει το αποτέλεσμα των κλήσεων "n" προς τον
     επαναλήπτη. Αυτό έχει ως αποτέλεσμα τη διαίρεση της εισόδου σε
     κομμάτια μήκους.

   * Η "zip()" σε συνδυασμό με τον τελεστή "*" μπορεί να
     χρησιμοποιηθεί για την αποσυμπίεση μιας λίστας:

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

   Άλλαξε στην έκδοση 3.10: Προστέθηκε το όρισμα  "strict".

__import__(name, globals=None, locals=None, fromlist=(), level=0)

   Σημείωση:

     Αυτή είναι μια προηγμένη συνάρτηση που δεν χρειάζεται στον
     καθημερινό προγραμματισμό της Python, σε αντίθεση με το
     "importlib.import_module()".

   Αυτή η συνάρτηση καλείται από τη δήλωση "import".  Μπορεί να
   αντικατασταθεί (με εισαγωγή του module "builtins" και αντιστοίχιση
   σε "builtins.__import__") προκειμένου να αλλάξει η σημασιολογία της
   δήλωσης "import", αλλά αυτό αποθαρρύνεται **σθεναρά**, καθώς είναι
   συνήθως απλούστερο να χρησιμοποιήσετε τα άγκιστρα εισαγωγής (δείτε
   **PEP 302**) για την επίτευξη των ίδιων στόχων και δεν προκαλεί
   προβλήματα με τον κώδικα που προϋποθέτει την χρήση της
   προεπιλεγμένης υλοποίησης εισαγωγής.  Η άμεση χρήση του
   "__import__()" επίσης αποθαρρύνεται υπέρ του
   "importlib.import_module()".

   Η συνάρτηση εισάγει το module *name*, χρησιμοποιώντας πιθανώς τα
   δεδομένα *globals* και *locals* για να καθορίσει τον τρόπο
   ερμηνείας του ονόματος σε ένα πλαίσιο πακέτου. Η *fromlist* δίνει
   τα ονόματα των αντικειμένων ή των υπομονάδων που θα πρέπει να
   εισαχθούν από το module που δίνεται από το *name*.  Η τυπική
   υλοποίηση δεν χρησιμοποιεί καθόλου το όρισμα *locals* και
   χρησιμοποιεί τα *globals* της μόνο για να προσδιορίσει το πλαίσιο
   του πακέτου της δήλωσης "import".

   Το *level* καθορίζει εάν θα χρησιμοποιηθούν απόλυτες ή σχετικές
   εισαγωγές. Το "0" (η προεπιλογή) σημαίνει μόνο απόλυτες εισαγωγές.
   Οι θετικές τιμές για το *level* υποδεικνύουν τον αριθμό των γονικών
   καταλόγων προς αναζήτηση σε σχέση με τον κατάλογο του module που
   καλεί την "__import__()" (δείτε το **PEP 328** για λεπτομέρειες).

   Όταν η μεταβλητή *name* είναι της μορφής "package.module",
   κανονικά, επιστρέφεται το πακέτο ανωτάτου επιπέδου (το όνομα μέχρι
   την πρώτη κουκκίδα), *όχι* το module που ονομάζεται *name*.
   Ωστόσο, όταν δίνεται ένα μη κενό όρισμα *fromlist*, επιστρέφεται το
   module με το όνομα *name*.

   Για παράδειγμα, η δήλωση "import spam" καταλήγει σε bytecode που
   μοιάζει με τον ακόλουθο κώδικα:

      spam = __import__('spam', globals(), locals(), [], 0)

   Η δήλωση "import spam.ham" καταλήγει σε αυτήν την κλήση:

      spam = __import__('spam.ham', globals(), locals(), [], 0)

   Σημειώστε πως το "__import__()" επιστρέφει το ανωτάτου επιπέδου
   module εδώ, επειδή αυτό είναι το αντικείμενο που συνδέεται με ένα
   όνομα με τη δήλωση "import".

   Από την άλλη πλευρά, η δήλωση "from spam.ham import eggs, sausage
   as saus" καταλήγει σε

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

   Εδώ, το module "spam.ham" επιστρέφεται από τη "__import__()".  Από
   αυτό το αντικείμενο, τα ονόματα προς εισαγωγή ανακτώνται και
   εκχωρούνται στα αντίστοιχα ονόματά τους.

   Εάν θέλετε απλώς να εισάγετε ένα module (ενδεχομένως μέσα σε ένα
   πακέτο) με το όνομα, χρησιμοποιήστε το "importlib.import_module()".

   Άλλαξε στην έκδοση 3.3: Αρνητικές τιμές για το *level* δεν
   υποστηρίζονται πλέον (το οποίο επίσης αλλάζει την προεπιλεγμένη
   τιμή σε 0).

   Άλλαξε στην έκδοση 3.9: Όταν χρησιμοποιούνται επιλογές της γραμμής
   εντολών "-E" ή "-I", τότε η μεταβλητή περιβάλλοντος "PYTHONCASEOK"
   δεν λαμβάνεται υπόψιν.

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

[1] Λάβετε υπόψη ότι ο αναλυτής δέχεται μόνο τη σύμβαση τέλους γραμμής
    τύπου Unix. Εάν διαβάζετε τον κώδικα από ένα αρχείο βεβαιωθείτε
    ότι χρησιμοποιείτε την λειτουργία μετατροπής νέας γραμμής για την
    μετατροπή νέων γραμμών σε στυλ Windows ή Mac.
