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

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

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

abs(number, /)

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

aiter(async_iterable, /)

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

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

  Added in version 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, /)
awaitable anext(async_iterator, default, /)

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

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

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

  Added in version 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(integer, /)

  Convert an integer number to a binary string prefixed with «0b». The result is a valid Python expression. If integer 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(object=False, /)

  Επιστρέφετε μια δυαδική τιμή, π.χ. μία από τις τιμές `True` ή `False`. Το όρισμα μετατρέπεται χρησιμοποιώντας την τυπική truth testing procedure. Εάν το όρισμα είναι ψευδές ή παραλειφθεί, αυτό επιστρέφει `False``∙ διαφορετικά, επιστρέφει ``True`. Η κλάση `bool` είναι μια υποκλάση της `int` (βλ. Αριμθητικοί Τύποι — int, float, complex). Δεν μπορεί να γίνει περαιτέρω υποκλάση. Οι μόνες περιπτώσεις είναι `False` και `True` (βλ. Τύπος Boolean - :class`bool`).

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

breakpoint(*args, **kws)

  Αυτή η συνάρτηση μας μεταφέρει στο πρόγραμμα εντοπισμού σφαλμάτων στην τοποθεσία της κλήσης. Συγκεκριμένα, καλεί το `sys.breakpointhook()`, περνώντας απευθείας τα `args` και `kws`. Από προεπιλογή, το `sys.breakpointhook()` καλεί την `pdb.set_trace()` χωρίς να περιμένει ορίσματα. Σε αυτήν την περίπτωση, είναι καθαρά μια βολική συνάρτηση, επομένως δεν χρειάζεται να εισάγετε ρητά το `pdb` ή να πληκτρολογήσετε τόσο πολύ κώδικα. Ωστόσο η `sys.breakpointhook()` μπορεί να ρυθμιστεί σε κάποια άλλη συνάρτηση και το `breakpoint()` θα το καλέσει αυτόματα, επιτρέποντας σας να πέσετε στο πρόγραμμα εντοπισμού σφαλμάτων της επιλογής σας. Εάν η `sys.breakpointhook()` δεν είναι προσβάσιμη, αυτή η συνάρτηση θα κάνει raise το `RuntimeError`.

  Από προεπιλογή, η συμπεριφορά της `breakpoint()` μπορεί να αλλάξει με την μεταβλητή περιβάλλοντος `PYTHONBREAKPOINT`. Βλ. την `sys.breakpointhook()` για λεπτομέρειες χρήσης.

  Λάβετε υπόψη ότι αυτό δεν είναι εγγυημένο εάν η `sys.breakpointhook()` έχει αντικατασταθεί.

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

  Added in version 3.7.

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

  Επιστρέφετε ένας νέος πίνακας από 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=b'')
class bytes(source, encoding, errors='strict')

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

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

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

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

callable(object, /)

  Επιστρέφει `True` εάν το όρισμα object εμφανίζεται ως callable, και `False` εάν όχι. Εάν αυτό επιστρέψει `True`, είναι ακόμα πιθανό μια κλήση να αποτύχει, αλλά εάν είναι `False`, η κλήση του object δεν θα πετύχει ποτέ. Σημειώστε ότι οι κλάσεις μπορούν να κληθούν (η κλήση μιας κλάσης επιστρέφει ένα νέο instance). Τα instances μπορούν να κληθούν αν η κλάση τους έχει τη μέθοδο `__call__()`.

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

chr(codepoint, /)

  Return the string representing a character with the specified Unicode code point. For example, `chr(97)` returns the string `'a'`, while `chr(8364)` returns the string `'€'`. This is the inverse of `ord()`.

  The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). `ValueError` will be raised if it is outside that range.

@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: Οι μέθοδοι κλάσης κληρονομούν πλέον τα χαρακτηριστικά της μεθόδους (`__module__`, `__name__`, `__qualname__`, `__doc__` and `__annotations__`) και έχουν ένα νέο χαρακτηριστικό `__wrapped__`.

  Deprecated since version 3.11, removed in version 3.13: Οι μέθοδοι κλάσης δεν μπορούν πλέον να κάνουν wrap άλλους descriptors όπως `property()`.

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.

  Added in version 3.8: `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` μπορεί τώρα να μεταβιβαστεί σε σημαίες για να ενεργοποιηθεί η υποστήριξη για `await`, `async for`, και `async with`.

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

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

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

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

  Αν το όρισμα είναι συμβολοσειρά, πρέπει να περιέχει είτε ένα πραγματικό μέρος (στην ίδια μορφή όπως για το `float()`) είτε ένα φανταστικό μέρος (στην ίδια μορφή αλλά με επίθημα `'j'` ή `'J'`) ή και πραγματικά και φανταστικά μέρη (το πρόσημο του φανταστικού τμήματος είναι υποχρεωτικό σε αυτήν την περίπτωση). Η συμβολοσειρά μπορεί προαιρετικά να περιβάλλεται από κενά διαστήματα και τις στρογγυλές παρενθέσεις `'('` και `')'` οι οποίες αγνοούνται. Η συμβολοσειρά δεν πρέπει να περιέχει κενό διάστημα μεταξύ των `'+'`, `'-'` του επιθέματος `'j'` ή `'J'` και του δεκαδικού αριθμού. Για παράδειγμα, το `complex('1+2j')` είναι εντάξει, αλλά το `complex('1 + 2j')` κάνει raise μια `ValueError`. Πιο συγκεκριμένα, η είσοδος πρέπει να συμμορφώνεται με τον κανόνας παραγωγής `complexvalue` στην ακόλουθη γραμματική, αφού αφαιρεθούν οι παρενθέσεις και οι χαρακτήρες του κενών διαστημάτων στο τέλος:

      complexvalue: floatvalue |
                    floatvalue ("j" | "J") |
                    floatvalue sign absfloatvalue ("j" | "J")

  Εάν το όρισμα είναι αριθμός, ο κατασκευαστής χρησιμεύει ως αριθμητική μετατροπή όπως `int` και `float`. Για ένα γενικό αντικείμενο Python `x`, το `complex(x)` εκχωρεί στο `x.__complex__()`. Εάν το `__complex__()` δεν έχει οριστεί, τότε επιστρέφει στο `__float__()`. Εάν το `__float__()` δεν έχει οριστεί τότε επιστρέφει στο `__index__()`.

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

  Δείτε επίσης την `complex.from_number()` που δέχεται μόνο ένα αριθμητικό όρισμα.

  Εάν παραληφθούν όλα τα ορίσματα, επιστρέφει `0j`

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

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

  Άλλαξε στην έκδοση 3.8: Επιστρέφει πίσω στη `__index__()` εάν η `__complex__()` και η `__float__()` δεν ορίζονται.

  Αποσύρθηκε στην έκδοση 3.14: Η διαβίβαση ενός μιγαδικού αριθμού ως το real ή imag όρισμα έχει πλέον καταργηθεί∙ θα πρέπει να διαβιβάζεται μόνο ως ένα μοναδικό όρισμα θέσης.

delattr(object, name, /)

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

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

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

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

dir()
dir(object, /)

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

  Εάν το αντικείμενο έχει μία μέθοδο με το όνομα `__dir__()`, αυτή η μέθοδος θα καλείται και πρέπει να επιστρέψει μια λίστα από χαρακτηριστικά. Αυτό επιτρέπει τα αντικείμενα που υλοποιούν μια εξατομικευμένη συνάρτηση `__getattr__()` or `__getattribute__()` για την προσαρμογή του τρόπου με τον οποίο η `dir()` αναφέρει τα χαρακτηριστικά.

  Εάν το αντικείμενο δεν παρέχει την `__dir__()`, η συνάρτηση προσπαθεί να συλλέξει πληροφορίες από το χαρακτηριστικό `__dict__` του αντικειμένου, εάν έχει οριστεί, και από το αντικείμενο του τύπου του. Η λίστα που παράγεται ως αποτέλεσμα δεν είναι απαραίτητα πλήρης και μπορεί να είναι ανακριβής όταν το αντικείμενο έχει εξατομικευμένη `__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, /)

  Λαμβάνει δύο (μη μιγαδικούς) αριθμούς ως ορίσματα και επιστρέφει ένα ζεύγος αριθμών που αποτελείται από το πηλίκο και το υπόλοιπο τους όταν χρησιμοποιείται σε διαίρεση ακεραίου αριθμού. Με μεικτούς τύπους τελεστών, ισχύουν οι κανόνες για δυαδικούς τελεστές αριθμητικής. Για ακέραιους αριθμούς, το αποτέλεσμα είναι το ίδιο με `(a // b, a % b)`. Για αριθμούς κινητής υποδιαστολής το αποτέλεσμα είναι `(q, a % b)`, όπου το q είναι συνήθως `math.floor(a / b)` αλλά μπορεί να είναι μικρότερο κατά 1. Σε κάθε περίπτωση, το `q * b + a % b` είναι πολύ κοντά στο a, αν το `a % b` δεν είναι μηδενικό, έχει το ίδιο πρόσημο όπως το b, και `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(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(source, /, globals=None, locals=None)
  Παράμετροι:

    - source (`str` | code object) – Μια έκφραση Python.

    - globals (`dict` | `None`) – Το καθολικό namespace (προεπιλογή: `None`).

    - locals (mapping | `None`) – Το τοπικό namespace (προεπιλογή: `None`).

  Επιστρέφει:

    Το αποτέλεσμα της αξιολογούμενης έκφρασης

  κάνει raise:

    Τα συντακτικά σφάλματα αναφέρονται ως εξαιρέσεις

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

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

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

  Παράδειγμα:

      >>> 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` με το αντικείμενο κώδικα ως όρισμα. Μπορεί επίσης να εμφανιστούν συμβάντα μεταγλώττισης κώδικα.

  Άλλαξε στην έκδοση 3.13: Τα ορίσματα globals και locals υποστηρίζονται πλέον και ως ορίσματα λέξεων-κλειδιών.

  Άλλαξε στην έκδοση 3.13: Η σημασιολογία του προεπιλεγμένου ονόματος χώρου locals έχει τροποποιηθεί, όπως περιγράφεται για την ενσωματωμένη συνάρτηση `locals()`.

exec(source, /, globals=None, locals=None, *, closure=None)

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

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

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

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

  Σημείωση

  Όταν η `exec` λαμβάνει δύο ξεχωριστά αντικείμενα ως globals και locals, ο κώδικας εκτελείται σαν να ήταν ενσωματωμένος σε ορισμό κλάσης. Αυτό σημαίνει ότι συναρτήσεις και κλάσεις που ορίζονται στον εκτελούμενο κώδικα δεν θα έχουν πρόσβαση σε μεταβλητές που έχουν οριστεί στο ανώτερο επίπεδο (καθώς αυτές οι «ανωτέρου επιπέδου» μεταβλητές θεωρούνται ως μεταβλητές κλάσης, όπως συμβαίνει μέσα σε έναν ορισμό κλάσης).

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

  Το όρισμα closure καθορίζει ένα clossure–μια πλειάδα από cellvars. Είναι έγκυρο μόνο όταν το object είναι ένα αντικείμενο κώδικα που περιέχει free (closure) variables. Το μήκος της πλειάδας πρέπει να ταιριάζει ακριβώς με το μήκος το χαρακτηριστικό `co_freevars` του αντικειμένου κώδικα.

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

  Σημείωση

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

  Σημείωση

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

  Άλλαξε στην έκδοση 3.11: Προστέθηκε η παράμετρος closure.

  Άλλαξε στην έκδοση 3.13: Τα ορίσματα globals και locals υποστηρίζονται πλέον και ως ορίσματα λέξεων-κλειδιών.

  Άλλαξε στην έκδοση 3.13: Η σημασιολογία του προεπιλεγμένου ονόματος χώρου locals έχει τροποποιηθεί, όπως περιγράφεται για την ενσωματωμένη συνάρτηση `locals()`.

filter(function, iterable, /)

  Δημιουργεί έναν iterator από εκείνα τα στοιχεία του iterable για τα οποία η function είναι αληθής. Το iterable μπορεί να είναι είτε μια ακολουθία, ένα container που υποστηρίζει iteration, ή ένας iterator. Εάν η function είναι `None`, η συνάρτηση ταυτότητας υποτίθεται, δηλαδή, όλα τα στοιχεία του iterable που είναι ψευδή αφαιρούνται.

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

  Βλ. `itertools.filterfalse()` για τη συμπληρωματική συνάρτηση που επιστρέφει στοιχεία του iterable για τα οποία η function είναι ψευδής.

class float(number=0.0, /)
class float(string, /)

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

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

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

  Εάν το όρισμα είναι συμβολοσειρά (string), θα πρέπει να περιέχει έναν δεκαδικό αριθμό, προαιρετικά πριν από ένα σύμβολο και προαιρετικά ενσωματωμένο σε κενό διάστημα. Το προαιρετικό πρόσημο μπορεί να είναι `'+'` ή `'-'``∙ ένα σύμβολο ``'+'` δεν έχει καμία επίδραση στην τιμή που παράγεται. Το όρισμα μπορεί επίσης να είναι μια συμβολοσειρά που αντιπροσωπεύει ένα NaN (not-a-number), ή θετικό η αρνητικό άπειρο. Πιο συγκεκριμένα, η είσοδος πρέπει να συμμορφώνεται με τον κανόνα παραγωγής `floatvalue` στην ακόλουθη γραμματική, αφού αφαιρεθούν οι χαρακτήρες κενού διαστήματος που έπονται και προηγούνται:

      sign:          "+" | "-"
      infinity:      "Infinity" | "inf"
      nan:           "nan"
      digit:         <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart:     digit (["_"] digit)*
      number:        [digitpart] "." digitpart | digitpart ["."]
      exponent:      ("e" | "E") [sign] digitpart
      floatnumber:   number [exponent]
      absfloatvalue: floatnumber | infinity | nan
      floatvalue:    [sign] absfloatvalue

  Τα πεζά/κεφαλαία δεν είναι σημαντικά, επομένως, για παράδειγμα, «inf», «Inf», «INFINITY», και «iNfINity» είναι όλες αποδεκτές ορθογραφίες για το θετικό άπειρο.

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

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

  Δείτε επίσης τη `float.from_number()` που δέχεται μόνο αριθμητικό όρισμα.

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

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

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

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

  Άλλαξε στην έκδοση 3.8: Επιστρέφει στο `__index__()` εάν το `__float__()` δεν έχει οριστεί.

format(value, format_spec='', /)

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

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

  Μια κλήση στο `format(value, format_spec)` μεταφράζεται σε `type(value).__format__(value, format_spec)` το οποίο παρακάμπτει το instance του λεξικού κατά την αναζήτηση της τιμής της μεθόδου `__format__()`. Μια εξαίρεση `TypeError` γίνεται raise εάν η αναζήτηση της μεθόδου φτάσει στο `object` και το format_spec δεν είναι κενό ή εάν είτε το format_spec είτε η τιμή επιστροφής δεν είναι συμβολοσειρές.

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

  Σημείωση

  Για αντικείμενα με προσαρμοσμένες μεθόδους `__hash__()`, σημειώστε ότι το `hash()` περικόπτει την τιμή επιστροφής με βάση το πλάτος bit του υπολογιστή.

help()
help(request)

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

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

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

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

hex(integer, /)

  Convert an integer number to a lowercase hexadecimal string prefixed with «0x». If integer 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()`.

  Αυτό είναι η διεύθυνση του αντικειμένου στην μνήμη.

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

input()
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(number=0, /)
class int(string, /, base=10)

  Επιστέφει έναν αριθμό κινητής υποδιαστολής που κατασκευάστηκε από έναν αριθμό ή μια συμβολοσειρά, ή επιστρέφει `0` εάν δεν δίνεται κάποιο όρισμα.

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

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

  Εάν το όρισμα ορίζει `__int__()`, `int(x)` επιστρέφει `x.__int__()`. Εάν το όρισμα ορίζει `__index__()`, επιστρέφει `x.__index__()`. Για αριθμούς κινητής υποδιαστολής, αυτό περικόπτεται προς το μηδέν.

  Εάν το όρισμα δεν είναι αριθμός ή εάν δίνεται base, τότε πρέπει να είναι μια συμβολοσειρά , `bytes`, ή `bytearray` που αντιπροσωπεύει έναν ακέραιο αριθμό στην ρίζα base. Προαιρετικά, η συμβολοσειρά μπορεί να προηγείται από `+` ή `-` (χωρίς κενό ενδιάμεσο), να έχει αρχικά μηδενικά, να περιβάλλεται από κενό διάστημα και να έχει μονές υπογραμμίσεις διάσπαρτες μεταξύ των ψηφίων.

  Μια συμβολοσειρά (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: Η πρώτη παράμετρος είναι πλέον μόνο θέσεως.

  Άλλαξε στην έκδοση 3.8: Επιστρέφει πίσω στη `__index__()` αν η `__int__()` δεν έχει οριστεί.

  Άλλαξε στην έκδοση 3.11: Οι είσοδοι συμβολοσειράς και οι αναπαραστάσεις συμβολοσειρών `int` μπορούν να περιοριστούν για να αποφευχθούν επιθέσεις άρνησης υπηρεσίας. Μια `ValueError` γίνεται raise όταν γίνεται υπέρβαση του ορίου κατά τη μετατροπή μιας συμβολοσειράς σε μια `int` ή κατά τη μετατροπή ενός `int` σε μια συμβολοσειρά θα υπερβεί το όριο. Δείτε την τεκμηρίωση integer string conversion length limitation.

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

isinstance(object, classinfo, /)

  Επιστρέφει `True` εάν το όρισμα object είναι ένα instance του ορίσματος classinfo , ή μιας (άμεσης, έμμεσης ή virtual) υποκλάσης αυτού. Εάν το object δεν είναι ένα αντικείμενο του δεδομένου τύπου, η συνάρτηση θα επιστρέφει πάντα `False`. Εάν το classinfo είναι μια πλειάδα τύπου αντικειμένων (ή αναδρομικά, άλλες τέτοιες πλειάδες) ή μια Τύπος Ένωσης πολλαπλών τύπων, επιστρέφει `True` εάν το object είναι ένα instance οποιουδήποτε από τους τύπους. Εάν το classinfo δεν είναι ένα τύπος ή μια πλειάδα τύπων και τέτοιες πλειάδες, γίνεται raise μια εξαίρεση `TypeError`. Η `TypeError` δεν μπορεί να γίνει raise για μη έγκυρο τύπο, εάν ένας προηγούμενος έλεγχος είναι επιτυχής.

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

issubclass(class, classinfo, /)

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

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

iter(iterable, /)
iter(callable, sentinel, /)

  Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, the single argument 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 the first argument must be a callable object. The iterator created in this case will call callable 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(object, /)

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

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

class list(iterable=(), /)

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

locals()

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

  Στο επίπεδο module, καθώς και όταν χρησιμοποιείται η `exec()` ή η `eval()` με έναν μόνο χώρο ονομάτων, αυτή η συνάρτηση επιστρέφει τον ίδιο χώρο ονομάτων με τη `globals()`.

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

  Όταν χρησιμοποιείται η `exec()` ή η `eval()` με ξεχωριστά local και global ορίσματα, επιστρέφει στον τοπικό χώρο ονομάτων που περάστηκε στην κλήση της συνάρτησης.

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

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

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

  Καλώντας την `locals()` ως μέρος μιας έκφρασης γεννήτριας είναι ισοδύναμη με την κλήση της μέσα σε μια εμφωλευμένη συνάρτηση γεννήτριας.

  Άλλαξε στην έκδοση 3.12: Η συμπεριφορά της `locals()` μέσα σε μια έκφραση σύμπτυξης έχει ενημερωθεί όπως περιγράφεται στην PEP 709.

  Άλλαξε στην έκδοση 3.13: Στο πλαίσιο της PEP 667, τα σημασιολογικά χαρακτηριστικά της τροποποίησης των αντικειμένων αντιστοιχίσεων που επιστρέφονται από αυτήν τη συνάρτηση έχουν πλέον οριστεί. Η συμπεριφορά σε optimized scopes είναι πλέον όπως περιγράφεται παραπάνω. Πέραν του ότι πλέον είναι ορισμένη, η συμπεριφορά σε άλλα πεδία παραμένει αμετάβλητη σε σχέση με προηγούμενες εκδόσεις.

map(function, iterable, /, *iterables, strict=False)

  Επιστρέφει έναν iterator που εφαρμόζει function σε κάθε στοιχείο του iterable, δίνοντας τα αποτελέσματα. Εάν περάσουν επιπλέον ορίσματα iterables, η function πρέπει να λάβει τόσα ορίσματα και να εφαρμόζεται στα στοιχεία από όλα τα iterables παράλληλα. Με πολλαπλούς iterables, ο iterator σταματά όταν εξαντληθεί ο συντομότερος iterable. Εάν το strict είναι `True` και μία από τα iterables εξαντληθεί πριν από τις άλλες, γίνεται raise μια `ValueError`. Για περιπτώσεις όπου οι είσοδοι συνάρτησης είναι ήδη διατεταγμένες σε πλειάδες ορισμάτων, βλέπε `itertools.starmap()`.

  Άλλαξε στην έκδοση 3.14: Προστέθηκε η παράμετρος strict.

max(iterable, /, *, key=None)
max(iterable, /, *, default, key=None)
max(arg1, arg2, /, *args, key=None)

  Επιστρέφει το μεγαλύτερο στοιχείο σε ένα 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: Προστέθηκε η παράμετρος μόνο λέξης-κλειδί default.

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

class memoryview(object)

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

min(iterable, /, *, key=None)
min(iterable, /, *, default, key=None)
min(arg1, arg2, /, *args, key=None)

  Επιστρέφει το μικρότερο στοιχείο σε έναν 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: Προστέθηκε η παράμετρος μόνο λέξης-κλειδί default.

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

next(iterator, /)
next(iterator, default, /)

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

class object

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

  Σημείωση

  Τα στιγμιότυπα `object` δεν έχουν χαρακτηριστικά `__dict__`, επομένως δεν μπορείτε να εκχωρήσετε αυθαίρετα χαρακτηριστικά σε ένα στιγμιότυπο του `object`.

oct(integer, /)

  Convert an integer number to an octal string prefixed with «0o». The result is a valid Python expression. If integer 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 είναι μια προαιρετική συμβολοσειρά που καθορίζει τη λειτουργία στην οποία ανοίγει το αρχείο. Από προεπιλογή είναι `'r'` που σημαίνει ανοιχτό για ανάγνωση σε λειτουργία κειμένου. Άλλες κοινές τιμές είναι `'w'` για εγγραφή (περικοπή του αρχείου εάν υπάρχει ήδη), `'x'` για αποκλειστική δημιουργία και `'a'` για προσθήκη (κάτι που σε μερικά συστήματα Unix, σημαίνει ότι όλες οι εγγραφές προσαρτώνται στο τέλος του αρχείου ανεξάρτητα από την τρέχουσα θέση αναζήτησης). Στη λειτουργία κειμένου, εάν δεν έχει καθοριστεί το encoding, η κωδικοποίηση που χρησιμοποιείται εξαρτάται από την πλατφόρμα: `locale.getencoding()` καλείται για να ληφθεί η τρέχουσα κωδικοποίηση τοπικών ρυθμίσεων. (Για την ανάγνωση και την εγγραφή ακατέργαστων bytes χρησιμοποιείται δυαδική λειτουργία και αφήνουν το encoding απροσδιόριστο.) Οι διαθέσιμες λειτουργίες είναι:

  Χαρακτήρας | Έννοια
  --- | ---
  `'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 έχουν πρώτα αποκωδικοποιηθεί χρησιμοποιώντας μια εξαρτώμενη από πλατφόρμα κωδικοποίηση ή χρήση της καθορισμένης κωδικοποίησης εάν δίνεται.

  Σημείωση

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

  To buffering είναι ένας προαιρετικός ακέραιος που χρησιμοποιείται για το ορισμό της πολιτικής αποθήκευσης στην προσωρινή μνήμη. Περνάει το 0 για να απενεργοποιήσετε την προσωρινή μνήμη (επιτρέπεται μόνο σε δυαδική λειτουργία), το 1 για να επιλέξετε προσωρινή αποθήκευση γραμμής (μπορεί να χρησιμοποιηθεί μόνο όταν γράφετε σε λειτουργία κειμένου) και έναν ακέραιο > 1 για να υποδείξει το μέγεθος σε byte μιας προσωρινής μνήμης τμημάτων σταθερού μεγέθους. Λάβετε υπόψη ότι ο καθορισμός ενός μεγέθους buffer με αυτόν τον τρόπο ισχύει για I/O με δυαδική προσωρινή μνήμη, αλλά το `TextIOWrapper` (δηλαδή, τα αρχεία που ανοίγουν με `mode='r+'`) θα έχουνε άλλη αποθήκευση. Για να απενεργοποιήσετε την προσωρινή αποθήκευση στο `TextIOWrapper`, εξετάστε το ενδεχόμενο να χρησιμοποιήσετε μια `write_through` σημαία για `io.TextIOWrapper.reconfigure()`. Όταν δεν δίνεται όρισμα buffering, η προεπιλεγμένη πολιτική προσωρινής αποθήκευσης λειτουργεί ως εξής:

  - Τα δυαδικά αρχεία αποθηκεύονται στην προσωρινή μνήμη σε κομμάτια σταθερού μεγέθους∙ το μέγεθος του buffer είναι `max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)` όταν το μέγεθος μπλοκ της συσκευής είναι διαθέσιμο. Στα περισσότερα συστήματα, το buffer θα έχει συνήθως μήκος 128 kilobytes.

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

  Το encoding είναι το όνομα της κωδικοποίησης που χρησιμοποιείται για την αποκωδικοποίηση ή την κωδικοποίηση του αρχείου. Θα πρέπει να χρησιμοποιείται μόνο σε λειτουργία κειμένου. Η προεπιλεγμένη κωδικοποίηση εξαρτάται από την πλατφόρμα (οτιδήποτε επιστρέφει η `locale.getencoding()`), αλλά οποιοδήποτε text encoding που υποστηρίζεται από την Python. Δείτε το module `codecs` για τη λίστα των υποστηριζόμενων κωδικοποιήσεων.

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

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

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

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

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

  - Το `'xmlcharrefreplace'` υποστηρίζεται μόνο κατά την εγγραφή σε αρχείο. Οι χαρακτήρες που δεν υποστηρίζονται από την κωδικοποίηση αντικαθίστανται με την κατάλληλη αναφορά χαρακτήρων XML `&#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`.

  Κάνει raise ένα auditing event `open` με ορίσματα `path`, `mode`, `flags`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Άλλαξε στην έκδοση 3.11: Η λειτουργία `'U'` έχει αφαιρεθεί.

ord(character, /)

  Return the ordinal value of a character.

  If the argument is a one-character string, return the Unicode code point of that character. For example, `ord('a')` returns the integer `97` and `ord('€')` (Euro sign) returns `8364`. This is the inverse of `chr()`.

  If the argument is a `bytes` or `bytearray` object of length 1, return its single byte value. For example, `ord(b'a')` returns the integer `97`.

pow(base, exp, mod=None)

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

  When arguments are builtin 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`. Whereas, for a negative base of type `int` or `float` with an integral exponent, a float result is delivered. For example, `pow(-9, 2.0)` returns `81.0`.

  Για τους τελεστές της `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

  Ο decorator `@property` μετατρέπει την μέθοδο `voltage()` σε «getter» για ένα χαρακτηριστικό μόνο για ανάγνωση με το ίδιο όνομα, και ορίζει τη συμβολοσειρά εγγράφων για voltage σε «Get the current voltage.»

  @getter
  @setter
  @deleter

    Ένα αντικείμενο ιδιότητας έχει μεθόδους `getter`, `setter`, και `deleter` που μπορούν να χρησιμοποιηθούν ως διακοσμητές που δημιουργούν ένα αντίγραφο της ιδιότητας με την αντίστοιχη συνάρτηση accessor που έχει οριστεί στον decorator. Αυτό εξηγείται καλύτερα με ένα παράδειγμα:

        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 των αντικειμένων ιδιότητας είναι πλέον εγγράψιμες.

  __name__

    Χαρακτηριστικό που περιέχει το όνομα της ιδιότητας. Το όνομα της ιδιότητας μπορεί να αλλάξει κατά την εκτέλεση.

    Added in version 3.13.

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

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

repr(object, /)

  Επιστρέφει μια συμβολοσειρά που περιέχει μια εκτυπώσιμη αναπαράσταση ενός αντικειμένου. Για πολλούς τύπους, αυτή η συνάρτηση κάνει μια προσπάθεια να επιστρέψει μια συμβολοσειρά που θα απέδιδε ένα αντικείμενο με την ίδια τιμή όταν μεταβιβαζόταν στο `eval()` ∙ διαφορετικά, η αναπαράσταση είναι μια συμβολοσειρά που περικλείεται σε αγκύλες που περιέχει το όνομα του τύπου του αντικειμένου μαζί με πρόσθετες πληροφορίες που συχνά περιλαμβάνουν το όνομα και τη διεύθυνση του αντικειμένου. Μια κλάση μπορεί να ελέγξει τι επιστρέφει αυτή η συνάρτηση για τις οντότητες της ορίζοντας μια μέθοδο `__repr__()`. Εάν η `sys.displayhook()` δεν είναι προσβάσιμη, αυτή η συνάρτηση θα κάνει raise το `RuntimeError`.

  Αυτή η κλάση έχει μια προσαρμοσμένη αναπαράσταση που μπορεί να αξιολογηθεί:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(object, /)

  Return a reverse iterator. The argument 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=None)

  Επιστρέφει τον 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. Δείτε το Αριθμητική Κινητής Υποδιαστολής: Ζητήματα και Περιορισμοί για περισσότερες πληροφορίες.

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 όπως ορίζεται στο Names (identifiers and keywords) , εκτός εάν το αντικείμενο επιλέξει να το επιβάλει αυτό, για παράδειγμα σε ένα προσαρμοσμένο `__getattribute__()` ή μέσω `__slots__`. Ένα χαρακτηριστικό του οποίου το όνομα δεν είναι αναγνωριστικό δεν θα είναι προσβάσιμο χρησιμοποιώντας τη σημειογραφία, αλλά είναι προσβάσιμο μέσω του `getattr()` κ.λπ..

  Σημείωση

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

class slice(stop, /)
class slice(start, stop, step=None, /)

  Επιστρέφετε ένα αντικείμενο slice που αντιπροσωπεύει το σύνολο των δεικτών που καθορίζονται από το `range(start, stop, step)`. Τα ορίσματα start και step είναι από προεπιλογή `None`.

  Τα αντικείμενα τμημάτων έχουν χαρακτηριστικά δεδομένων μόνο για ανάγνωση `start`, `stop`, και `step` τα οποία απλώς επιστρέφουν τις τιμές του ορίσματος (ή την προεπιλογή τους). Δεν έχουνε άλλη ρητή λειτουργικότητα∙ ωστόσο, χρησιμοποιούνται από το NumPy και άλλα πακέτα τρίτων.

  start
  stop
  step

  Τα αντικείμενα slice δημιουργούνται επίσης όταν χρησιμοποιείται εκτεταμένη σύνταξη ευρετηρίου. Για παράδειγμα: `a[start:stop:step]` ή `a[start:stop, i]`. Δείτε τη `itertools.islice()` για μια εναλλακτική έκδοση που επιστρέφει ένα iterator.

  Άλλαξε στην έκδοση 3.12: Τα αντικείμενα slice είναι πλέον hashable (με την προϋπόθεση `start`, `stop`, και `step` μπορούν να κατακερματιστούν).

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 Techniques.

@staticmethod

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

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

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

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

  Μια στατική μέθοδος μπορεί να κληθεί είτε στην κλάση (όπως `C.f()`) είτε σε ένα instance (όπως `C().f()`). Επιπλέον, η στατική μέθοδος descriptor μπορεί επίσης να κληθεί, επομένως μπορεί να χρησιμοποιηθεί στον ορισμός της κλάσης (όπως `f()`).

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

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

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

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

  Άλλαξε στην έκδοση 3.10: Οι στατικές μέθοδοι κληρονομούν πλέον τα χαρακτηριστικά της μεθόδου (`__module__`, `__name__`, `__qualname__`, `__doc__` και `__annotations__`),, έχουν ένα νέο χαρακτηριστικό `__wrapped__`, και μπορούν πλέον να καλούνται ως κανονικές λειτουργίες.

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

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

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

sum(iterable, /, start=0)

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

  Για ορισμένες περιπτώσεις χρήσης, υπάρχουν καλές εναλλακτικές λύσεις για το `sum()`. Ο προτιμώμενος, γρήγορος τρόπος για να συνδέσετε μια ακολουθία συμβολοσειρών είναι καλώντας `''.join(sequence)`. Για να προσθέσετε τιμές κινητής υποδιαστολής με εκτεταμένη ακρίβεια, δείτε `math.fsum()`. Για να συνδυάσετε μια σειρά iterable, σκεφτείτε να χρησιμοποιήσετε το `itertools.chain()`.

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

  Άλλαξε στην έκδοση 3.12: Η άθροιση των floats άλλαξε σε έναν αλγόριθμο που δίνει μεγαλύτερη ακρίβεια και καλύτερη αντιμεταθετικότητα στις περισσότερες κατασκευές.

  Άλλαξε στην έκδοση 3.14: Προστέθηκε εξειδίκευση για άθροιση συμπλεγμάτων, χρησιμοποιώντας τον ίδιο αλγόριθμο όπως για την άθροιση των float.

class super
class super(type, object_or_type=None, /)

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

  Το object_or_type καθορίζει το method resolution order που θα αναζητηθεί. Η αναζήτηση ξεκινά από την κλάση αμέσως μετά τον type.

  Για παράδειγμα, εάν `__mro__` του object_or_type είναι `D -> B -> C -> A -> object` και η τιμή του type είναι `B`, τότε η `super()` αναζητά `C -> A -> object`.

  Το χαρακτηριστικό `__mro__` της κλάσης που αντιστοιχεί σε λίστες του object_or_type παραθέτει τη σειρά αναζήτησης ανάλυσης μεθόδου που χρησιμοποιείται και από τις `getattr()` και `super()`. Το χαρακτηριστικό είναι δυναμικό και μπορεί να αλλάξει κάθε φορά που ενημερώνεται η ιεραρχία κληρονομικότητας.

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

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

  Υπάρχουν δύο τυπικές περιπτώσεις χρήσης για το 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 σε μια κλάση γονέα ή αδελφού.

  Λάβετε υπόψη ότι το `super()` υλοποιείται ως μέρος της διαδικασίας δέσμευσης για ρητές αναζητήσεις χαρακτηριστικών με κουκκίδες όπως `super().__getitem__(name)`. Το κάνει εφαρμόζοντας τη δικιά του μέθοδο `__getattribute__()` για αναζήτηση κλάσεων με προβλέψιμη σειρά που υποστηρίζει πολλαπλή κληρονομικότητα. Συνεπώς, η `super()` δεν έχει οριστεί για σιωπηρές αναζητήσεις που χρησιμοποιούν δηλώσεις ή τελεστές όπως `super()[name]`.

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

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

  Άλλαξε στην έκδοση 3.14: Τα αντικείμενα `super` είναι πλέον `pickleable` και `copyable`.

class tuple(iterable=(), /)

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

class type(object, /)
class type(name, bases, dict, /, **kwargs)

  Με ένα όρισμα, επιστρέψτε τον τύπο ενός object. Η τιμή που επιστρέφεται είναι ένα αντικείμενο τύπου και γενικά το ίδιο αντικείμενο με αυτό που επιστρέφεται από το `object.__class__`.

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

  Με τρία ορίσματα, επιστρέφει ένα αντικείμενο νέου τύπου. Αυτή είναι ουσιαστικά μια δυναμική μορφή της δήλωσης `class`. Η συμβολοσειρά name είναι το όνομα της κλάσης και γίνεται το χαρακτηριστικό `__name__`. Η πλειάδα bases περιέχει τις βασικές κλάσεις και γίνεται το χαρακτηριστικό `__bases__` ∙ αν είναι κενό, προστίθεται το `object`, η τελική βάση όλων των κλάσεων. Το λεξικό dict περιέχει ορισμούς χαρακτηριστικών και μεθόδων για το σώμα της κλάσης∙ μπορεί να αντιγραφεί ή να προσαρμοστεί πριν γίνει το χαρακτηριστικό `__dict__`. Οι ακόλουθες δύο προτάσεις δημιουργούν πανομοιότυπα αντικείμενα `type`

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

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

  - Τεκμηρίωση για χαρακτηριστικά και μεθόδους σε κλάσεις.

  - Τύποι Αντικειμένων

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

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

  Άλλαξε στην έκδοση 3.6: Οι υποκλάσης της `type` που δεν αντικαθιστούν το `type.__new__` δεν μπορούν πλέον να χρησιμοποιούν τη φόρμα ενός επιχειρήματος για να λάβουν τον τύπο ενός αντικειμένου.

vars()
vars(object, /)

  Επιστρέφει το χαρακτηριστικό `__dict__` για ένα module, κλάση, στιγμιότυπο, ή οποιοδήποτε άλλο αντικείμενο με ένα χαρακτηριστικό `__dict__`.

  Αντικείμενα όπως modules και instances έχουν ένα χαρακτηριστικό `__dict__` με δυνατότητα ενημέρωσης∙ ωστόσο, άλλα αντικείμενα μπορεί να έχουν περιορισμούς εγγραφής στα χαρακτηριστικά τους `__dict__` (για παράδειγμα, οι κλάσεις χρησιμοποιούν ένα `types.MappingProxyType` για την αποτροπή άμεσων ενημερώσεων λεξικού).

  Χωρίς ένα όρισμα, `vars()` συμπεριφέρεται όπως `locals()`.

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

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

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.