collections.abc.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-05-10 10:19+0300\n"
"PO-Revision-Date: 2025-05-02 23:52+0200\n"
"Last-Translator: Marios Giannopoulos <mariosgian_2002@yahoo.gr>\n"
"Language-Team: PyGreece <organizers@pygreece.org>\n"
"Language: el\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: library/collections.abc.rst:2
msgid ":mod:`!collections.abc` --- Abstract Base Classes for Containers"
msgstr ":mod:`!collections.abc` --- Αφηρημένες Βασικές Κλάσεις για Containers"

#: library/collections.abc.rst:10
msgid "Formerly, this module was part of the :mod:`collections` module."
msgstr "Παλαιότερα, αυτό το module ήταν μέρος του :mod:`collections` module."

#: library/collections.abc.rst:13
msgid "**Source code:** :source:`Lib/_collections_abc.py`"
msgstr "**Πηγαίος κώδικας:** :source:`Lib/_collections_abc.py`"

#: library/collections.abc.rst:23
msgid ""
"This module provides :term:`abstract base classes <abstract base class>` "
"that can be used to test whether a class provides a particular interface; "
"for example, whether it is :term:`hashable` or whether it is a :term:"
"`mapping`."
msgstr ""
"Αυτό το module παρέχει :term:`αφηρημένες βασικές κλάσεις <abstract base "
"class>` που μπορούν να χρησιμοποιηθούν για να ελεγχθεί εάν μια κλάση παρέχει "
"μια συγκεκριμένη διεπαφή· για παράδειγμα, εάν είναι :term:`hashable` ή εάν "
"είναι :term:`mapping`."

#: library/collections.abc.rst:27
msgid ""
"An :func:`issubclass` or :func:`isinstance` test for an interface works in "
"one of three ways."
msgstr ""
"Ένας έλεγχος :func:`issubclass` ή :func:`isinstance` για μια διεπαφή "
"λειτουργεί με έναν από τρεις τρόπους."

#: library/collections.abc.rst:30
msgid ""
"A newly written class can inherit directly from one of the abstract base "
"classes.  The class must supply the required abstract methods.  The "
"remaining mixin methods come from inheritance and can be overridden if "
"desired.  Other methods may be added as needed:"
msgstr ""
"Μια νέα γραμμένη κλάση μπορεί να κληρονομήσει άμεσα από τις αφηρημένες "
"βασικές κλάσεις. Η κλάση πρέπει να παρέχει τις απαιτούμενες αφηρημένες "
"μεθόδους. Οι υπόλοιπες μέθοδοι mixin προέρχονται από την κληρονομικότητα και "
"μπορούν να παρακαμφθούν αν χρειάζεται. Άλλες μέθοδοι μπορούν να προστεθούν "
"όταν είναι αναγκαίο:"

#: library/collections.abc.rst:35
msgid ""
"class C(Sequence):                      # Direct inheritance\n"
"    def __init__(self): ...             # Extra method not required by the "
"ABC\n"
"    def __getitem__(self, index):  ...  # Required abstract method\n"
"    def __len__(self):  ...             # Required abstract method\n"
"    def count(self, value): ...         # Optionally override a mixin method"
msgstr ""
"class C(Sequence):                      # Direct inheritance\n"
"    def __init__(self): ...             # Extra method not required by the "
"ABC\n"
"    def __getitem__(self, index):  ...  # Required abstract method\n"
"    def __len__(self):  ...             # Required abstract method\n"
"    def count(self, value): ...         # Optionally override a mixin method"

#: library/collections.abc.rst:43
msgid ""
">>> issubclass(C, Sequence)\n"
"True\n"
">>> isinstance(C(), Sequence)\n"
"True"
msgstr ""
">>> issubclass(C, Sequence)\n"
"True\n"
">>> isinstance(C(), Sequence)\n"
"True"

#: library/collections.abc.rst:50
msgid ""
"Existing classes and built-in classes can be registered as \"virtual "
"subclasses\" of the ABCs.  Those classes should define the full API "
"including all of the abstract methods and all of the mixin methods. This "
"lets users rely on :func:`issubclass` or :func:`isinstance` tests to "
"determine whether the full interface is supported.  The exception to this "
"rule is for methods that are automatically inferred from the rest of the API:"
msgstr ""
"Υπάρχουσες κλάσεις και ενσωματωμένες κλάσεις μπορούν να καταχωρηθούν ως "
"\"εικονικές υποκλάσεις\" των ABCs. Αυτές οι κλάσεις θα πρέπει να ορίζουν το "
"πλήρες API, συμπεριλαμβανομένων όλων των αφηρημένων μεθόδων και όλων των "
"μεθόδων mixin. Αυτό επιτρέπει στους χρήστες να βασίζονται στους ελέγχους :"
"func:`issubclass` ή :func:`isinstance` για να καθορίσουν εάν υποστηρίζεται η "
"πλήρης διεπαφή. Η εξαίρεση σε αυτό τον κανόνα είναι για τις μεθόδους που "
"προσδιορίζονται αυτόματα από το υπόλοιπο API:"

#: library/collections.abc.rst:58
msgid ""
"class D:                                 # No inheritance\n"
"    def __init__(self): ...              # Extra method not required by the "
"ABC\n"
"    def __getitem__(self, index):  ...   # Abstract method\n"
"    def __len__(self):  ...              # Abstract method\n"
"    def count(self, value): ...          # Mixin method\n"
"    def index(self, value): ...          # Mixin method\n"
"\n"
"Sequence.register(D)                     # Register instead of inherit"
msgstr ""
"class D:                                 # No inheritance\n"
"    def __init__(self): ...              # Extra method not required by the "
"ABC\n"
"    def __getitem__(self, index):  ...   # Abstract method\n"
"    def __len__(self):  ...              # Abstract method\n"
"    def count(self, value): ...          # Mixin method\n"
"    def index(self, value): ...          # Mixin method\n"
"\n"
"Sequence.register(D)                     # Register instead of inherit"

#: library/collections.abc.rst:69
msgid ""
">>> issubclass(D, Sequence)\n"
"True\n"
">>> isinstance(D(), Sequence)\n"
"True"
msgstr ""
">>> issubclass(D, Sequence)\n"
"True\n"
">>> isinstance(D(), Sequence)\n"
"True"

#: library/collections.abc.rst:76
msgid ""
"In this example, class :class:`!D` does not need to define ``__contains__``, "
"``__iter__``, and ``__reversed__`` because the :ref:`in-operator "
"<comparisons>`, the :term:`iteration <iterable>` logic, and the :func:"
"`reversed` function automatically fall back to using ``__getitem__`` and "
"``__len__``."
msgstr ""
"Σε αυτό το παράδειγμα, η κλάση :class:`!D` δεν χρειάζεται να ορίσει τις "
"μεθόδους ``__contains__``, ``__iter__``, και ``__reversed__`` επειδή ο "
"τελεστής :ref:`in-operator <comparisons>`, η λογική :term:`iteration "
"<iterable>`, και η συνάρτηση :func:`reversed` χρησιμοποιούν αυτόματα τις "
"μεθόδους ``__getitem__`` και ``__len__``."

#: library/collections.abc.rst:82
msgid ""
"Some simple interfaces are directly recognizable by the presence of the "
"required methods (unless those methods have been set to :const:`None`):"
msgstr ""
"Ορισμένες απλές διεπαφές είναι άμεσα αναγνωρίσιμες από την παρουσία των "
"απαιτούμενων μεθόδων (εκτός αν αυτές οι μέθοδοι έχουν οριστεί σε :const:"
"`None`):"

#: library/collections.abc.rst:85
msgid ""
"class E:\n"
"    def __iter__(self): ...\n"
"    def __next__(self): ..."
msgstr ""
"class E:\n"
"    def __iter__(self): ...\n"
"    def __next__(self): ..."

#: library/collections.abc.rst:91
msgid ""
">>> issubclass(E, Iterable)\n"
"True\n"
">>> isinstance(E(), Iterable)\n"
"True"
msgstr ""
">>> issubclass(E, Iterable)\n"
"True\n"
">>> isinstance(E(), Iterable)\n"
"True"

#: library/collections.abc.rst:98
msgid ""
"Complex interfaces do not support this last technique because an interface "
"is more than just the presence of method names.  Interfaces specify "
"semantics and relationships between methods that cannot be inferred solely "
"from the presence of specific method names.  For example, knowing that a "
"class supplies ``__getitem__``, ``__len__``, and ``__iter__`` is "
"insufficient for distinguishing a :class:`Sequence` from a :class:`Mapping`."
msgstr ""
"Οι σύνθετες διεπαφές δεν υποστηρίζουν αυτή την τελευταία τεχνική επειδή μια "
"διεπαφή είναι κάτι περισσότερο από την παρουσία ονομάτων μεθόδων. Οι "
"διεπαφές καθορίζουν τη σημασιολογία και τις σχέσεις μεταξύ των μεθόδων που "
"δεν μπορούν να συναχθούν αποκλειστικά από την παρουσία συγκεκριμένων "
"ονομάτων μεθόδων. Για παράδειγμα, η γνώση ότι μια κλάση παρέχει τις μεθόδους "
"``__getitem__``, ``__len__`` και ``__iter__`` δεν είναι επαρκής για να "
"διακρίνει μια κλάση :class:`Sequence` από μια κλάση :class:`Mapping`."

#: library/collections.abc.rst:106
msgid ""
"These abstract classes now support ``[]``. See :ref:`types-genericalias` "
"and :pep:`585`."
msgstr ""
"Αυτές οι αφηρημένες κλάσεις υποστηρίζουν πλέον ``[]``. Δείτε :ref:`types-"
"genericalias` και :pep:`585`."

#: library/collections.abc.rst:113
msgid "Collections Abstract Base Classes"
msgstr "Αφηρημένες Βασικές Κλάσεις Συλλογών"

#: library/collections.abc.rst:115
msgid ""
"The collections module offers the following :term:`ABCs <abstract base "
"class>`:"
msgstr ""
"Το collections module προσφέρει τις εξής :term:`ABCs <abstract base class>`:"

#: library/collections.abc.rst:120
msgid "ABC"
msgstr "ABC"

#: library/collections.abc.rst:120
msgid "Inherits from"
msgstr "Κληρονομεί από"

#: library/collections.abc.rst:120
msgid "Abstract Methods"
msgstr "Αφηρημένες Μέθοδοι"

#: library/collections.abc.rst:120
msgid "Mixin Methods"
msgstr "Mixin Μέθοδοι"

#: library/collections.abc.rst:122
msgid ":class:`Container` [1]_"
msgstr ":class:`Container` [1]_"

#: library/collections.abc.rst:122
msgid "``__contains__``"
msgstr "``__contains__``"

#: library/collections.abc.rst:123
msgid ":class:`Hashable` [1]_"
msgstr ":class:`Hashable` [1]_"

#: library/collections.abc.rst:123
msgid "``__hash__``"
msgstr "``__hash__``"

#: library/collections.abc.rst:124
msgid ":class:`Iterable` [1]_ [2]_"
msgstr ":class:`Iterable` [1]_ [2]_"

#: library/collections.abc.rst:124 library/collections.abc.rst:125
msgid "``__iter__``"
msgstr "``__iter__``"

#: library/collections.abc.rst:125
msgid ":class:`Iterator` [1]_"
msgstr ":class:`Iterator` [1]_"

#: library/collections.abc.rst:125 library/collections.abc.rst:126
msgid ":class:`Iterable`"
msgstr ":class:`Iterable`"

#: library/collections.abc.rst:125
msgid "``__next__``"
msgstr "``__next__``"

#: library/collections.abc.rst:126
msgid ":class:`Reversible` [1]_"
msgstr ":class:`Reversible` [1]_"

#: library/collections.abc.rst:126
msgid "``__reversed__``"
msgstr "``__reversed__``"

#: library/collections.abc.rst:127
msgid ":class:`Generator`  [1]_"
msgstr ":class:`Generator`  [1]_"

#: library/collections.abc.rst:127
msgid ":class:`Iterator`"
msgstr ":class:`Iterator`"

#: library/collections.abc.rst:127 library/collections.abc.rst:173
msgid "``send``, ``throw``"
msgstr "``send``, ``throw``"

#: library/collections.abc.rst:127
msgid "``close``, ``__iter__``, ``__next__``"
msgstr "``close``, ``__iter__``, ``__next__``"

#: library/collections.abc.rst:128
msgid ":class:`Sized`  [1]_"
msgstr ":class:`Sized`  [1]_"

#: library/collections.abc.rst:128
msgid "``__len__``"
msgstr "``__len__``"

#: library/collections.abc.rst:129
msgid ":class:`Callable`  [1]_"
msgstr ":class:`Callable`  [1]_"

#: library/collections.abc.rst:129
msgid "``__call__``"
msgstr "``__call__``"

#: library/collections.abc.rst:130
msgid ":class:`Collection`  [1]_"
msgstr ":class:`Collection`  [1]_"

#: library/collections.abc.rst:130
msgid ":class:`Sized`, :class:`Iterable`, :class:`Container`"
msgstr ":class:`Sized`, :class:`Iterable`, :class:`Container`"

#: library/collections.abc.rst:130 library/collections.abc.rst:143
msgid "``__contains__``, ``__iter__``, ``__len__``"
msgstr "``__contains__``, ``__iter__``, ``__len__``"

#: library/collections.abc.rst:134 library/collections.abc.rst:137
msgid ":class:`Sequence`"
msgstr ":class:`Sequence`"

#: library/collections.abc.rst:134
msgid ":class:`Reversible`, :class:`Collection`"
msgstr ":class:`Reversible`, :class:`Collection`"

#: library/collections.abc.rst:134
msgid "``__getitem__``, ``__len__``"
msgstr "``__getitem__``, ``__len__``"

#: library/collections.abc.rst:134
msgid ""
"``__contains__``, ``__iter__``, ``__reversed__``, ``index``, and ``count``"
msgstr ""
"``__contains__``, ``__iter__``, ``__reversed__``, ``index``, and ``count``"

#: library/collections.abc.rst:137
msgid ":class:`MutableSequence`"
msgstr ":class:`MutableSequence`"

#: library/collections.abc.rst:137
msgid ""
"``__getitem__``, ``__setitem__``, ``__delitem__``, ``__len__``, ``insert``"
msgstr ""
"``__getitem__``, ``__setitem__``, ``__delitem__``, ``__len__``, ``insert``"

#: library/collections.abc.rst:137
msgid ""
"Inherited :class:`Sequence` methods and ``append``, ``clear``, ``reverse``, "
"``extend``, ``pop``, ``remove``, and ``__iadd__``"
msgstr ""
"Κληρονομημένες :class:`Sequence` μέθοδοι και ``append``, ``clear``, "
"``reverse``, ``extend``, ``pop``, ``remove``, and ``__iadd__``"

#: library/collections.abc.rst:143 library/collections.abc.rst:148
msgid ":class:`Set`"
msgstr ":class:`Set`"

#: library/collections.abc.rst:143 library/collections.abc.rst:154
msgid ":class:`Collection`"
msgstr ":class:`Collection`"

#: library/collections.abc.rst:143
msgid ""
"``__le__``, ``__lt__``, ``__eq__``, ``__ne__``, ``__gt__``, ``__ge__``, "
"``__and__``, ``__or__``, ``__sub__``, ``__rsub__``, ``__xor__``, "
"``__rxor__`` and ``isdisjoint``"
msgstr ""
"``__le__``, ``__lt__``, ``__eq__``, ``__ne__``, ``__gt__``, ``__ge__``, "
"``__and__``, ``__or__``, ``__sub__``, ``__rsub__``, ``__xor__``, "
"``__rxor__`` και ``isdisjoint``"

#: library/collections.abc.rst:148
msgid ":class:`MutableSet`"
msgstr ":class:`MutableSet`"

#: library/collections.abc.rst:148
msgid "``__contains__``, ``__iter__``, ``__len__``, ``add``, ``discard``"
msgstr "``__contains__``, ``__iter__``, ``__len__``, ``add``, ``discard``"

#: library/collections.abc.rst:148
msgid ""
"Inherited :class:`Set` methods and ``clear``, ``pop``, ``remove``, "
"``__ior__``, ``__iand__``, ``__ixor__``, and ``__isub__``"
msgstr ""
"Κληρονομημένες :class:`Set` μέθοδοι και ``clear``, ``pop``, ``remove``, "
"``__ior__``, ``__iand__``, ``__ixor__``, και ``__isub__``"

#: library/collections.abc.rst:154 library/collections.abc.rst:158
msgid ":class:`Mapping`"
msgstr ":class:`Mapping`"

#: library/collections.abc.rst:154
msgid "``__getitem__``, ``__iter__``, ``__len__``"
msgstr "``__getitem__``, ``__iter__``, ``__len__``"

#: library/collections.abc.rst:154
msgid ""
"``__contains__``, ``keys``, ``items``, ``values``, ``get``, ``__eq__``, and "
"``__ne__``"
msgstr ""
"``__contains__``, ``keys``, ``items``, ``values``, ``get``, ``__eq__``, και "
"``__ne__``"

#: library/collections.abc.rst:158
msgid ":class:`MutableMapping`"
msgstr ":class:`MutableMapping`"

#: library/collections.abc.rst:158
msgid ""
"``__getitem__``, ``__setitem__``, ``__delitem__``, ``__iter__``, ``__len__``"
msgstr ""
"``__getitem__``, ``__setitem__``, ``__delitem__``, ``__iter__``, ``__len__``"

#: library/collections.abc.rst:158
msgid ""
"Inherited :class:`Mapping` methods and ``pop``, ``popitem``, ``clear``, "
"``update``, and ``setdefault``"
msgstr ""
"Κληρονομημένες :class:`Mapping` μέθοδοι και ``pop``, ``popitem``, ``clear``, "
"``update``, και ``setdefault``"

#: library/collections.abc.rst:165
msgid ":class:`MappingView`"
msgstr ":class:`MappingView`"

#: library/collections.abc.rst:165
msgid ":class:`Sized`"
msgstr ":class:`Sized`"

#: library/collections.abc.rst:165
msgid "``__init__``, ``__len__`` and ``__repr__``"
msgstr "``__init__``, ``__len__`` and ``__repr__``"

#: library/collections.abc.rst:166
msgid ":class:`ItemsView`"
msgstr ":class:`ItemsView`"

#: library/collections.abc.rst:166 library/collections.abc.rst:168
msgid ":class:`MappingView`, :class:`Set`"
msgstr ":class:`MappingView`, :class:`Set`"

#: library/collections.abc.rst:166 library/collections.abc.rst:168
#: library/collections.abc.rst:170
msgid "``__contains__``, ``__iter__``"
msgstr "``__contains__``, ``__iter__``"

#: library/collections.abc.rst:168
msgid ":class:`KeysView`"
msgstr ":class:`KeysView`"

#: library/collections.abc.rst:170
msgid ":class:`ValuesView`"
msgstr ":class:`ValuesView`"

#: library/collections.abc.rst:170
msgid ":class:`MappingView`, :class:`Collection`"
msgstr ":class:`MappingView`, :class:`Collection`"

#: library/collections.abc.rst:172
msgid ":class:`Awaitable` [1]_"
msgstr ":class:`Awaitable` [1]_"

#: library/collections.abc.rst:172
msgid "``__await__``"
msgstr "``__await__``"

#: library/collections.abc.rst:173
msgid ":class:`Coroutine` [1]_"
msgstr ":class:`Coroutine` [1]_"

#: library/collections.abc.rst:173
msgid ":class:`Awaitable`"
msgstr ":class:`Awaitable`"

#: library/collections.abc.rst:173
msgid "``close``"
msgstr "``close``"

#: library/collections.abc.rst:174
msgid ":class:`AsyncIterable` [1]_"
msgstr ":class:`AsyncIterable` [1]_"

#: library/collections.abc.rst:174 library/collections.abc.rst:175
msgid "``__aiter__``"
msgstr "``__aiter__``"

#: library/collections.abc.rst:175
msgid ":class:`AsyncIterator` [1]_"
msgstr ":class:`AsyncIterator` [1]_"

#: library/collections.abc.rst:175
msgid ":class:`AsyncIterable`"
msgstr ":class:`AsyncIterable`"

#: library/collections.abc.rst:175
msgid "``__anext__``"
msgstr "``__anext__``"

#: library/collections.abc.rst:176
msgid ":class:`AsyncGenerator` [1]_"
msgstr ":class:`AsyncGenerator` [1]_"

#: library/collections.abc.rst:176
msgid ":class:`AsyncIterator`"
msgstr ":class:`AsyncIterator`"

#: library/collections.abc.rst:176
msgid "``asend``, ``athrow``"
msgstr "``asend``, ``athrow``"

#: library/collections.abc.rst:176
msgid "``aclose``, ``__aiter__``, ``__anext__``"
msgstr "``aclose``, ``__aiter__``, ``__anext__``"

#: library/collections.abc.rst:177
msgid ":class:`Buffer` [1]_"
msgstr ":class:`Buffer` [1]_"

#: library/collections.abc.rst:177
msgid "``__buffer__``"
msgstr "``__buffer__``"

#: library/collections.abc.rst:182
msgid "Footnotes"
msgstr "Υποσημειώσεις"

#: library/collections.abc.rst:183
msgid ""
"These ABCs override :meth:`~abc.ABCMeta.__subclasshook__` to support testing "
"an interface by verifying the required methods are present and have not been "
"set to :const:`None`.  This only works for simple interfaces.  More complex "
"interfaces require registration or direct subclassing."
msgstr ""
"Αυτές οι ABCs παρακάμπτουν την μέθοδο :meth:`~abc.ABCMeta.__subclasshook__` "
"για να υποστηρίξουν τον έλεγχο μιας διεπαφής μέσω της επαλήθευσης της "
"παρουσίας των απαιτούμενων μεθόδων και του ότι δεν έχουν ρυθμιστεί σε :const:"
"`None`. Αυτό λειτουργεί μόνο για απλές διεπαφές. Πιο σύνθετες διεπαφές "
"απαιτούν εγγραφή ή άμεση υποκλάση."

#: library/collections.abc.rst:189
msgid ""
"Checking ``isinstance(obj, Iterable)`` detects classes that are registered "
"as :class:`Iterable` or that have an :meth:`~container.__iter__` method, but "
"it does not detect classes that iterate with the :meth:`~object.__getitem__` "
"method.  The only reliable way to determine whether an object is :term:"
"`iterable` is to call ``iter(obj)``."
msgstr ""
"Ο έλεγχος ``isinstance(obj, Iterable)`` εντοπίζει κλάσεις που είναι "
"καταχωρημένες ως :class:`Iterable` ή που έχουν την μέθοδο :meth:`~container."
"__iter__`, αλλά δεν εντοπίζει τις κλάσεις που πραγματοποιούν επανάληψη με τη "
"μέθοδο :meth:`~object.__getitem__`. Ο μόνος αξιόπιστος τρόπος για να "
"προσδιοριστεί αν ένα αντικείμενο είναι :term:`iterable` είναι να καλέσετε "
"``iter(obj)``."

#: library/collections.abc.rst:197
msgid "Collections Abstract Base Classes -- Detailed Descriptions"
msgstr "Αφηρημένες Βασικές Κλάσεις Συλλογών -- Αναλυτικές Περιγραφές"

#: library/collections.abc.rst:202
msgid "ABC for classes that provide the :meth:`~object.__contains__` method."
msgstr "ABC για κλάσεις που παρέχουν την μέθοδο :meth:`~object.__contains__`."

#: library/collections.abc.rst:206
msgid "ABC for classes that provide the :meth:`~object.__hash__` method."
msgstr "ABC για κλάσεις που παρέχουν την μέθοδο :meth:`~object.__hash__`."

#: library/collections.abc.rst:210
msgid "ABC for classes that provide the :meth:`~object.__len__` method."
msgstr "ABC για κλάσεις που παρέχουν την μέθοδο :meth:`~object.__len__`."

#: library/collections.abc.rst:214
msgid "ABC for classes that provide the :meth:`~object.__call__` method."
msgstr "ABC για κλάσεις που παρέχουν την μέθοδο :meth:`~object.__call__`."

#: library/collections.abc.rst:216
msgid ""
"See :ref:`annotating-callables` for details on how to use :class:`!Callable` "
"in type annotations."
msgstr ""
"Ανατρέξτε στο :ref:`annotating-callables` για λεπτομέρειες σχετικά με τον "
"τρόπο χρήσης του :class:`!Callable` σε τύπους annotations."

#: library/collections.abc.rst:221
msgid "ABC for classes that provide the :meth:`~container.__iter__` method."
msgstr "ABC για κλάσεις που παρέχουν την μέθοδο :meth:`~container.__iter__`."

#: library/collections.abc.rst:223
msgid ""
"Checking ``isinstance(obj, Iterable)`` detects classes that are registered "
"as :class:`Iterable` or that have an :meth:`~container.__iter__` method, but "
"it does not detect classes that iterate with the :meth:`~object.__getitem__` "
"method. The only reliable way to determine whether an object is :term:"
"`iterable` is to call ``iter(obj)``."
msgstr ""
"Ο έλεγχος ``isinstance(obj, Iterable)`` εντοπίζει κλάσεις που είναι "
"καταχωρημένες ως :class:`Iterable` ή που διαθέτουν τη μέθοδο :meth:"
"`~container.__iter__`, αλλά δεν εντοπίζει κλάσεις που πραγματοποιούν "
"επανάληψη με τη μέθοδο :meth:`~object.__getitem__`. Ο μόνος αξιόπιστος "
"τρόπος για να προσδιοριστεί αν ένα αντικείμενο είναι :term:`iterable` είναι "
"να κληθεί ``iter(obj)``."

#: library/collections.abc.rst:232
msgid "ABC for sized iterable container classes."
msgstr "ABC για τις κλάσεις επαναλαμβανόμενων container με μέγεθος."

#: library/collections.abc.rst:238
msgid ""
"ABC for classes that provide the :meth:`~iterator.__iter__` and :meth:"
"`~iterator.__next__` methods.  See also the definition of :term:`iterator`."
msgstr ""
"ABC για κλάσεις που παρέχουν τις μεθόδους :meth:`~iterator.__iter__` και :"
"meth:`~iterator.__next__`. Δείτε επίσης τον ορισμό του :term:`iterator`."

#: library/collections.abc.rst:244
msgid ""
"ABC for iterable classes that also provide the :meth:`~object.__reversed__` "
"method."
msgstr ""
"ABC για τις επαναλαμβανόμενες κλάσεις που παρέχουν επίσης τη μέθοδο :meth:"
"`~object.__reversed__`."

#: library/collections.abc.rst:251
msgid ""
"ABC for :term:`generator` classes that implement the protocol defined in :"
"pep:`342` that extends :term:`iterators <iterator>` with the :meth:"
"`~generator.send`, :meth:`~generator.throw` and :meth:`~generator.close` "
"methods."
msgstr ""
"ABC για τις κλάσεις :term:`generator` που υλοποιούν το πρωτόκολλο που "
"ορίζεται στο :pep:`342` το οποίο επεκτείνει τους :term:`iterators "
"<iterator>` με τις μεθόδους :meth:`~generator.send`, :meth:`~generator."
"throw` και :meth:`~generator.close`."

#: library/collections.abc.rst:256
msgid ""
"See :ref:`annotating-generators-and-coroutines` for details on using :class:"
"`!Generator` in type annotations."
msgstr ""
"Δείτε. :ref:`annotating-generators-and-coroutines` για λεπτομέρειες σχετικά "
"με τη χρήση του :class:`!Generator` σε τύπους annotations."

#: library/collections.abc.rst:264
msgid "ABCs for read-only and mutable :term:`sequences <sequence>`."
msgstr ""
"ABCs μόνο για ανάγνωση (read-only) και mutable :term:`sequences <sequence>`."

#: library/collections.abc.rst:266
msgid ""
"Implementation note: Some of the mixin methods, such as :meth:`~container."
"__iter__`, :meth:`~object.__reversed__` and :meth:`index`, make repeated "
"calls to the underlying :meth:`~object.__getitem__` method. Consequently, "
"if :meth:`~object.__getitem__` is implemented with constant access speed, "
"the mixin methods will have linear performance; however, if the underlying "
"method is linear (as it would be with a linked list), the mixins will have "
"quadratic performance and will likely need to be overridden."
msgstr ""
"Σημείωση υλοποίησης: Μερικές από τις μεθόδους mixin, όπως :meth:`~container."
"__iter__`, :meth:`~object.__reversed__` και :meth:`index`, κάνουν "
"επανειλημμένες κλήσεις στην μέθοδο :meth:`~object.__getitem__`. Ως "
"αποτέλεσμα, αν η :meth:`~object.__getitem__` είναι υλοποιημένη με σταθερή "
"ταχύτητα πρόσβασης, οι μέθοδοι mixin θα έχουν γραμμική απόδοση. Ωστόσο, αν η "
"υποκείμενη μέθοδος είναι γραμμική (όπως θα ήταν με μια συνδεδεμένη λίστα), "
"οι mixins θα έχουν τετραγωνική απόδοση και πιθανώς θα χρειαστεί να "
"αντικατασταθούν."

#: library/collections.abc.rst:275
msgid "The index() method added support for *stop* and *start* arguments."
msgstr ""
"Η μέθοδος index() πρόσθεσε υποστήριξη για τα ορίσματα *stop* και *start*."

#: library/collections.abc.rst:282
msgid "ABCs for read-only and mutable :ref:`sets <types-set>`."
msgstr ""
"ABCs μόνο για ανάγνωση (read-only) και mutable :ref:`sets <types-set>`."

#: library/collections.abc.rst:287
msgid "ABCs for read-only and mutable :term:`mappings <mapping>`."
msgstr ""
"ABCs μόνο για ανάγνωση (read-only) και mutable :term:`mappings <mapping>`."

#: library/collections.abc.rst:294
msgid ""
"ABCs for mapping, items, keys, and values :term:`views <dictionary view>`."
msgstr ""
"ABCs για αντιστοιχήσεις, στοιχεία, κλειδιά και τιμές :term:`views "
"<dictionary view>`."

#: library/collections.abc.rst:298
msgid ""
"ABC for :term:`awaitable` objects, which can be used in :keyword:`await` "
"expressions.  Custom implementations must provide the :meth:`~object."
"__await__` method."
msgstr ""
"ABC για αντικείμενα :term:`awaitable`, που μπορούν να χρησιμοποιηθούν σε "
"εκφράσεις :keyword:`await`. Οι προσαρμοσμένες υλοποιήσεις πρέπει να παρέχουν "
"τη μέθοδο :meth:`~object.__await__`."

#: library/collections.abc.rst:302
msgid ""
":term:`Coroutine <coroutine>` objects and instances of the :class:"
"`~collections.abc.Coroutine` ABC are all instances of this ABC."
msgstr ""
"Τα αντικείμενα :term:`Coroutine <coroutine>` και τα στιγμιότυπα της κλάσης :"
"class:`~collections.abc.Coroutine` είναι όλα παραδείγματα αυτής της ABC."

#: library/collections.abc.rst:306
msgid ""
"In CPython, generator-based coroutines (:term:`generators <generator>` "
"decorated with :func:`@types.coroutine <types.coroutine>`) are *awaitables*, "
"even though they do not have an :meth:`~object.__await__` method. Using "
"``isinstance(gencoro, Awaitable)`` for them will return ``False``. Use :func:"
"`inspect.isawaitable` to detect them."
msgstr ""
"Στην CPython, οι generator-based coroutines (:term:`generators <generator>` "
"που είναι decorated με :func:`@types.coroutine <types.coroutine>`) είναι "
"*awaitables*, αν και δεν διαθέτουν μέθοδο :meth:`~object.__await__`. Η χρήση "
"της ``isinstance(gencoro, Awaitable)`` γι' αυτές θα επιστρέψει ``False``. "
"Χρησιμοποιείτε τη συνάρτηση :func:`inspect.isawaitable` για να τις "
"εντοπίσετε."

#: library/collections.abc.rst:316
msgid ""
"ABC for :term:`coroutine` compatible classes.  These implement the following "
"methods, defined in :ref:`coroutine-objects`: :meth:`~coroutine.send`, :meth:"
"`~coroutine.throw`, and :meth:`~coroutine.close`.  Custom implementations "
"must also implement :meth:`~object.__await__`.  All :class:`Coroutine` "
"instances are also instances of :class:`Awaitable`."
msgstr ""
"ABC για κλάσεις συμβατές με το :term:`coroutine`. Αυτές υλοποιούν τις εξής "
"μεθόδους, οι οποίες ορίζονται στο :ref:`coroutine-objects`: :meth:"
"`~coroutine.send`, :meth:`~coroutine.throw`, και :meth:`~coroutine.close`. "
"Οι προσαρμοσμένες υλοποιήσεις πρέπει επίσης να υλοποιούν τη μέθοδο :meth:"
"`~object.__await__`. Όλα τα :class:`Coroutine` στιγμιότυπα είναι επίσης "
"στιγμιότυπα της κλάσης :class:`Awaitable`."

#: library/collections.abc.rst:324
msgid ""
"In CPython, generator-based coroutines (:term:`generators <generator>` "
"decorated with :func:`@types.coroutine <types.coroutine>`) are *awaitables*, "
"even though they do not have an :meth:`~object.__await__` method. Using "
"``isinstance(gencoro, Coroutine)`` for them will return ``False``. Use :func:"
"`inspect.isawaitable` to detect them."
msgstr ""
"Στην CPython, οι generator-based coroutines (:term:`generators <generator>` "
"που είναι διακοσμημένες με :func:`@types.coroutine <types.coroutine>`) είναι "
"*awaitables*, αν και δεν έχουν τη μέθοδο :meth:`~object.__await__`. Η χρήση "
"της ``isinstance (gencoro, Coroutine)`` γι' αυτές θα επιστρέψει ``False``. "
"Χρησιμοποιείται η συνάρτηση :func:`inspect.isawaitable` για να εντοπιστούν."

#: library/collections.abc.rst:330
msgid ""
"See :ref:`annotating-generators-and-coroutines` for details on using :class:"
"`!Coroutine` in type annotations. The variance and order of type parameters "
"correspond to those of :class:`Generator`."
msgstr ""
"Βλ. :ref:`annotating-generators-and-coroutines` για λεπτομέρειες σχετικά με "
"τη χρήση της :class:`!Coroutine` σε σχολιασμούς τύπου. Η διακύμανση και η "
"σειρά των παραμέτρων τύπου αντιστοιχούν σε εκείνες της :class:`Generator`."

#: library/collections.abc.rst:339
msgid ""
"ABC for classes that provide an ``__aiter__`` method.  See also the "
"definition of :term:`asynchronous iterable`."
msgstr ""
"ABC για κλάσεις που παρέχουν μια μέθοδο ``__aiter__``. Δείτε επίσης τον "
"ορισμό του :term:`asynchronous iterable`."

#: library/collections.abc.rst:346
msgid ""
"ABC for classes that provide ``__aiter__`` and ``__anext__`` methods.  See "
"also the definition of :term:`asynchronous iterator`."
msgstr ""
"ABC για κλάσεις που παρέχουν τις μεθόδους ``__aiter__`` και ``__anext__``. "
"Δείτε επίσης τον ορισμό του :term:`asynchronous iterator`."

#: library/collections.abc.rst:353
msgid ""
"ABC for :term:`asynchronous generator` classes that implement the protocol "
"defined in :pep:`525` and :pep:`492`."
msgstr ""
"ABC για κλάσεις :term:`asynchronous generator` που υλοποιούν το πρωτόκολλο "
"που ορίζεται στο :pep:`525` και :pep:`492`."

#: library/collections.abc.rst:356
msgid ""
"See :ref:`annotating-generators-and-coroutines` for details on using :class:"
"`!AsyncGenerator` in type annotations."
msgstr ""
"Δείτε :ref:`annotating-generators-and-coroutines` για λεπτομέρειες σχετικά "
"με τη χρήση του :class:`!AsyncGenerator` σε σχολιασμούς τύπου."

#: library/collections.abc.rst:363
msgid ""
"ABC for classes that provide the :meth:`~object.__buffer__` method, "
"implementing the :ref:`buffer protocol <bufferobjects>`. See :pep:`688`."
msgstr ""
"ABC για κλάσεις που παρέχουν τη μέθοδο :meth:`~object.__buffer__`, "
"υλοποιώντας το :ref:`buffer protocol <bufferobjects>`. Δείτε το :pep:`688`."

#: library/collections.abc.rst:369
msgid "Examples and Recipes"
msgstr "Παραδείγματα και Συνταγές"

#: library/collections.abc.rst:371
msgid ""
"ABCs allow us to ask classes or instances if they provide particular "
"functionality, for example::"
msgstr ""
"Οι ABCs επιτρέπουν να ρωτήσουμε τις κλάσεις ή τα αντικείμενα αν παρέχουν "
"συγκεκριμένη λειτουργικότητα, για παράδειγμα::"

#: library/collections.abc.rst:374
msgid ""
"size = None\n"
"if isinstance(myvar, collections.abc.Sized):\n"
"    size = len(myvar)"
msgstr ""
"size = None\n"
"if isinstance(myvar, collections.abc.Sized):\n"
"    size = len(myvar)"

#: library/collections.abc.rst:378
msgid ""
"Several of the ABCs are also useful as mixins that make it easier to develop "
"classes supporting container APIs.  For example, to write a class supporting "
"the full :class:`Set` API, it is only necessary to supply the three "
"underlying abstract methods: :meth:`~object.__contains__`, :meth:`~container."
"__iter__`, and :meth:`~object.__len__`. The ABC supplies the remaining "
"methods such as :meth:`!__and__` and :meth:`~frozenset.isdisjoint`::"
msgstr ""
"Μερικές από τις ABCs είναι επίσης χρήσιμες ως mixins που διευκολύνουν την "
"ανάπτυξη κλάσεων που υποστηρίζουν τα APIs των container. Για παράδειγμα, για "
"να γράψετε μια κλάση που υποστηρίζει το πλήρες API του :class:`Set`, αρκεί "
"να παρέχετε τις τρεις υποκείμενες αφηρημένες μεθόδους: :meth:`~object."
"__contains__`, :meth:`~container.__iter__`, και :meth:`~object.__len__`. Η "
"ABC παρέχει τις υπόλοιπες μεθόδους, όπως :meth:`!__and__` και :meth:"
"`~frozenset.isdisjoint`::"

#: library/collections.abc.rst:385
msgid ""
"class ListBasedSet(collections.abc.Set):\n"
"    ''' Alternate set implementation favoring space over speed\n"
"        and not requiring the set elements to be hashable. '''\n"
"    def __init__(self, iterable):\n"
"        self.elements = lst = []\n"
"        for value in iterable:\n"
"            if value not in lst:\n"
"                lst.append(value)\n"
"\n"
"    def __iter__(self):\n"
"        return iter(self.elements)\n"
"\n"
"    def __contains__(self, value):\n"
"        return value in self.elements\n"
"\n"
"    def __len__(self):\n"
"        return len(self.elements)\n"
"\n"
"s1 = ListBasedSet('abcdef')\n"
"s2 = ListBasedSet('defghi')\n"
"overlap = s1 & s2            # The __and__() method is supported "
"automatically"
msgstr ""
"class ListBasedSet(collections.abc.Set):\n"
"    ''' Alternate set implementation favoring space over speed\n"
"        and not requiring the set elements to be hashable. '''\n"
"    def __init__(self, iterable):\n"
"        self.elements = lst = []\n"
"        for value in iterable:\n"
"            if value not in lst:\n"
"                lst.append(value)\n"
"\n"
"    def __iter__(self):\n"
"        return iter(self.elements)\n"
"\n"
"    def __contains__(self, value):\n"
"        return value in self.elements\n"
"\n"
"    def __len__(self):\n"
"        return len(self.elements)\n"
"\n"
"s1 = ListBasedSet('abcdef')\n"
"s2 = ListBasedSet('defghi')\n"
"overlap = s1 & s2            # The __and__() method is supported "
"automatically"

#: library/collections.abc.rst:407
msgid "Notes on using :class:`Set` and :class:`MutableSet` as a mixin:"
msgstr ""
"Σημειώσεις για τη χρήση των :class:`Set` και :class:`MutableSet` ως mixin:"

#: library/collections.abc.rst:410
msgid ""
"Since some set operations create new sets, the default mixin methods need a "
"way to create new instances from an :term:`iterable`. The class constructor "
"is assumed to have a signature in the form ``ClassName(iterable)``. That "
"assumption is factored-out to an internal :class:`classmethod` called :meth:"
"`!_from_iterable` which calls ``cls(iterable)`` to produce a new set. If "
"the :class:`Set` mixin is being used in a class with a different constructor "
"signature, you will need to override :meth:`!_from_iterable` with a "
"classmethod or regular method that can construct new instances from an "
"iterable argument."
msgstr ""
"Δεδομένου ότι ορισμένες λειτουργίες συνόλων δημιουργούν νέα σύνολα, οι "
"προεπιλεγμένες μέθοδοι mixin χρειάζονται έναν τρόπο δημιουργίας νέων "
"αντικειμένων από ένα :term:`iterable`. Υποτίθεται ότι ο κατασκευαστής της "
"κλάσης έχει μια υπογραφή της μορφής ``ClassName(iterable)``. Αυτή η υπόθεση "
"είναι αποσυνδεδεμένη σε μια εσωτερική :class:`classmethod` που ονομάζεται :"
"meth:`!_from_iterable`, η οποία καλεί το ``cls(iterable)`` για να "
"δημιουργήσει ένα νέο σύνολο. Εάν το mixin :class:`Set` χρησιμοποιείται σε "
"μια κλάση με διαφορετική υπογραφή κατασκευαστή, θα χρειαστεί να "
"αντικαταστήσετε την :meth:`!_from_iterable` με μια μέθοδο κλάσης ή κανονική "
"μέθοδο που μπορεί να δημιουργήσει νέα αντικείμενα από ένα όρισμα iterable."

#: library/collections.abc.rst:421
msgid ""
"To override the comparisons (presumably for speed, as the semantics are "
"fixed), redefine :meth:`~object.__le__` and :meth:`~object.__ge__`, then the "
"other operations will automatically follow suit."
msgstr ""
"Για να παρακάμψετε τις συγκρίσεις (πιθανότατα για λόγους απόδοσης, καθώς η "
"σημασιολογία είναι καθορισμένη), ορίστε ξανά τις μεθόδους :meth:`~object."
"__le__`, και :meth:`~object.__ge__`, και οι άλλες λειτουργίες θα "
"ακολουθήσουν αυτόματα."

#: library/collections.abc.rst:427
msgid ""
"The :class:`Set` mixin provides a :meth:`!_hash` method to compute a hash "
"value for the set; however, :meth:`~object.__hash__` is not defined because "
"not all sets are :term:`hashable` or immutable.  To add set hashability "
"using mixins, inherit from both :meth:`Set` and :meth:`Hashable`, then "
"define ``__hash__ = Set._hash``."
msgstr ""
"Το mixin :class:`Set` παρέχει τη μέθοδο meth:`!_hash` για να υπολογίσει μια "
"τιμή κατακερματισμού για το σύνολο. Ωστόσο, η μέθοδος :meth:`~object."
"__hash__` δεν είναι ορισμένη, επειδή δεν είναι όλα τα σύνολα :term:"
"`hashable` ή αμετάβλητα. Για να προσθέσετε hashability σε ένα σύνολο "
"χρησιμοποιώντας mixins, κληρονομήστε τόσο από τις κλάσεις :meth:`Set` όσο "
"και :meth:`Hashable`, και στη συνέχεια ορίστε ``__hash__ = Set._hash``."

#: library/collections.abc.rst:435
msgid ""
"`OrderedSet recipe <https://code.activestate.com/recipes/576694/>`_ for an "
"example built on :class:`MutableSet`."
msgstr ""
"Συνταγή `OrderedSet <https://code.activestate.com/recipes/576694/>`_ για ένα "
"παράδειγμα που βασίζεται στην κλάση :class:`MutableSet`."

#: library/collections.abc.rst:438
msgid "For more about ABCs, see the :mod:`abc` module and :pep:`3119`."
msgstr ""
"Για περισσότερα σχετικά με τις ABCs, δείτε το :mod:`abc` module και το :pep:"
"`3119`."

#~ msgid ":class:`ByteString`"
#~ msgstr ":class:`ByteString`"

#~ msgid "Inherited :class:`Sequence` methods"
#~ msgstr "Κληρονομημένες :class:`Sequence` μέθοδοι"

#~ msgid ""
#~ "The :class:`ByteString` ABC has been deprecated. For use in typing, "
#~ "prefer a union, like ``bytes | bytearray``, or :class:`collections.abc."
#~ "Buffer`. For use as an ABC, prefer :class:`Sequence` or :class:"
#~ "`collections.abc.Buffer`."
#~ msgstr ""
#~ "Η ABC :class:`ByteString` έχει αποσυρθεί. Για χρήση στην δακτυλογράφηση, "
#~ "προτιμάται ένωση, όπως ``bytes | bytearray``, ή :class:`collections.abc."
#~ "Buffer`. Για χρήση ως ABC, προτιμάται :class:`Sequence` ή :class:"
#~ "`collections.abc.Buffer`."