errors.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-02-17 21:03+0100\n"
"PO-Revision-Date: 2024-09-20 11:30+0300\n"
"Last-Translator: Panagiotis Skias <panagiotis.skias@gmail.com>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: el\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 3.5\n"

#: tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Σφάλματα και Εξαιρέσεις"

#: tutorial/errors.rst:7
msgid ""
"Until now error messages haven't been more than mentioned, but if you have "
"tried out the examples you have probably seen some.  There are (at least) "
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr ""
"Μέχρι τώρα τα μηνύματα σφαλμάτων (error messages) δεν ήταν περισσότερα από "
"όσα αναφέρθηκαν, αλλά αν έχετε δοκιμάσει τα παραδείγματα, πιθανότατα έχετε "
"δει μερικά.  Υπάρχουν (τουλάχιστον) δύο διαφορετικά είδη σφαλμάτων: *syntax "
"errors* (συντακτικά σφάλματα) και *exceptions* (εξαιρέσεις)."

#: tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Syntax Errors (Συντακτικά Σφάλματα)"

#: tutorial/errors.rst:17
msgid ""
"Syntax errors, also known as parsing errors, are perhaps the most common "
"kind of complaint you get while you are still learning Python::"
msgstr ""
"Τα syntax errors, γνωστά και ως parsing errors, είναι ίσως το πιο "
"συνηθισμένο είδος παραπόνου που λαμβάνετε ενώ εξακολουθείτε να μαθαίνετε "
"Python::"

#: tutorial/errors.rst:20
msgid ""
">>> while True print('Hello world')\n"
"  File \"<stdin>\", line 1\n"
"    while True print('Hello world')\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> while True print('Hello world')\n"
"  File \"<stdin>\", line 1\n"
"    while True print('Hello world')\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

#: tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays little arrows pointing at "
"the token in the line where the error was detected.  The error may be caused "
"by the absence of a token *before* the indicated token.  In the example, the "
"error is detected at the function :func:`print`, since a colon (``':'``) is "
"missing before it.  File name and line number are printed so you know where "
"to look in case the input came from a script."
msgstr ""
"Ο αναλυτής επαναλαμβάνει την παραβατική γραμμή και εμφανίζει ένα μικρό "
"'βέλος' που δείχνει το διακριτικό στη γραμμή που εντοπίστηκε το σφάλμα.  Το "
"σφάλμα μπορεί να προκληθεί από την απουσία διακριτικού *πριν* από το "
"υποδεικνυόμενο διακριτικό.  Στο παράδειγμα, το σφάλμα ανιχνεύεται στην "
"συνάρτηση :func:`print`, καθώς λείπει μια άνω κάτω τελεία (``':'``) πριν από "
"αυτήν.  Το όνομα του αρχείου και ο αριθμός γραμμής εκτυπώνονται, ώστε να "
"γνωρίζετε πού να ψάξετε σε περίπτωση που η είσοδος προήλθε από ένα script."

#: tutorial/errors.rst:37
msgid "Exceptions"
msgstr "Exceptions (Εξαιρέσεις)"

#: tutorial/errors.rst:39
msgid ""
"Even if a statement or expression is syntactically correct, it may cause an "
"error when an attempt is made to execute it. Errors detected during "
"execution are called *exceptions* and are not unconditionally fatal: you "
"will soon learn how to handle them in Python programs.  Most exceptions are "
"not handled by programs, however, and result in error messages as shown "
"here::"
msgstr ""
"Ακόμη και αν μια πρόταση ή μια έκφραση είναι συντακτικά σωστή, μπορεί να "
"προκαλέσει σφάλμα όταν γίνεται προσπάθεια εκτέλεσης της. Τα σφάλματα που "
"εντοπίζονται κατά την εκτέλεση ονομάζονται *εξαιρέσεις* και δεν είναι άνευ "
"όρων μοιραία (fatal): σύντομα θα μάθετε πως να τα χειρίζεστε σε προγράμματα "
"Python.  Ωστόσο, οι περισσότερες εξαιρέσεις δεν αντιμετωπίζονται από "
"προγράμματα και οδηγούν σε μηνύματα σφάλματος όπως φαίνεται εδώ::"

#: tutorial/errors.rst:45
msgid ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: can only concatenate str (not \"int\") to str"
msgstr ""
">>> 10 * (1/0)\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ZeroDivisionError: division by zero\n"
">>> 4 + spam*3\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'spam' is not defined\n"
">>> '2' + 2\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: can only concatenate str (not \"int\") to str"

#: tutorial/errors.rst:58
msgid ""
"The last line of the error message indicates what happened. Exceptions come "
"in different types, and the type is printed as part of the message: the "
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
"`TypeError`. The string printed as the exception type is the name of the "
"built-in exception that occurred.  This is true for all built-in exceptions, "
"but need not be true for user-defined exceptions (although it is a useful "
"convention). Standard exception names are built-in identifiers (not reserved "
"keywords)."
msgstr ""
"Η τελευταία γραμμή του μηνύματος σφάλματος υποδεικνύει τι συνέβη. Οι "
"εξαιρέσεις υπάρχουν σε διαφορετικούς τύπους και ο τύπος εκτυπώνεται ως μέρος "
"του μηνύματος: οι τύποι στο παράδειγμα είναι :exc:`ZeroDivisionError`, :exc:"
"`NameError` και :exc:`TypeError`. Η συμβολοσειρά που εκτυπώνεται ως τύπος "
"εξαίρεσης είναι όνομα της ενσωματωμένης εξαίρεσης που προέκυψε.  Αυτό ισχύει "
"για όλες τις ενσωματωμένες (built-in) εξαιρέσεις, αλλά δεν χρειάζεται να "
"ισχύει για εξαιρέσεις που ορίζονται από το χρήστη (αν και είναι μια χρήσιμη "
"σύμβαση). Οι standard εξαιρέσεις είναι ενσωματωμένα (built-in) αναγνωριστικά "
"(όχι δεσμευμένες λέξεις-κλειδιά)."

#: tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what "
"caused it."
msgstr ""
"Η υπόλοιπη γραμμή παρέχει λεπτομέρειες με βάση τον τύπο της εξαίρεσης και το "
"τι την προκάλεσε."

#: tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception occurred, in the form of a stack traceback. In general it contains "
"a stack traceback listing source lines; however, it will not display lines "
"read from standard input."
msgstr ""
"Το προηγούμενο μέρος του μηνύματος σφάλματος εμφανίζει το περιβάλλον όπου "
"συνέβη η εξαίρεση, με τη μορφή ανίχνευσης στοίβας. Γενικά περιέχει μια "
"στοίβα ανίχνευσης γραμμών πηγής∙ ωστόσο, δεν θα εμφανίζει γραμμές που "
"διαβάζονται από standard είσοδο."

#: tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
"Το :ref:`bltin-exceptions` παραθέτει τις ενσωματωμένες εξαιρέσεις και τις "
"έννοιές τους."

#: tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Διαχείριση Εξαιρέσεων"

#: tutorial/errors.rst:82
msgid ""
"It is possible to write programs that handle selected exceptions. Look at "
"the following example, which asks the user for input until a valid integer "
"has been entered, but allows the user to interrupt the program (using :kbd:"
"`Control-C` or whatever the operating system supports); note that a user-"
"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
"exception. ::"
msgstr ""
"Είναι δυνατό να γραφτεί κώδικας που χειρίζεται επιλεγμένες εξαιρέσεις. "
"Κοιτάξτε το ακόλουθο παράδειγμα, το οποίο ζητά από τον χρήστη να εισάγει "
"έναν έγκυρο ακέραιο αριθμό, αλλά επιτρέπει στον χρήστη να διακόψει το "
"πρόγραμμα (χρησιμοποιώντας :kbd:`Control-C` ή ό,τι υποστηρίζει το "
"λειτουργικό σύστημα)· σημειώστε ότι μια διακοπή που δημιουργείται από τον "
"χρήστη σηματοδοτείται κάνοντας raise την εξαίρεση :exc:"
"`KeyboardInterrupt`. ::"

#: tutorial/errors.rst:88
msgid ""
">>> while True:\n"
"...     try:\n"
"...         x = int(input(\"Please enter a number: \"))\n"
"...         break\n"
"...     except ValueError:\n"
"...         print(\"Oops!  That was no valid number.  Try again...\")\n"
"..."
msgstr ""
">>> while True:\n"
"...     try:\n"
"...         x = int(input(\"Please enter a number: \"))\n"
"...         break\n"
"...     except ValueError:\n"
"...         print(\"Oops!  That was no valid number.  Try again...\")\n"
"..."

#: tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "Η δήλωση :keyword:`try` λειτουργεί ως εξής."

#: tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
"keyword:`except` keywords) is executed."
msgstr ""
"Πρώτον, εκτελείται η *try clause* (η πρόταση(εις) μεταξύ των λέξεων-"
"κλειδιών :keyword:`try` and :keyword:`except`)."

#: tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the :"
"keyword:`try` statement is finished."
msgstr ""
"Εάν δεν προκύψει εξαίρεση, η *except clause* παραλείπεται και η εκτέλεση της "
"πρότασης :keyword:`try` ολοκληρώνεται."

#: tutorial/errors.rst:104
msgid ""
"If an exception occurs during execution of the :keyword:`try` clause, the "
"rest of the clause is skipped.  Then, if its type matches the exception "
"named after the :keyword:`except` keyword, the *except clause* is executed, "
"and then execution continues after the try/except block."
msgstr ""
"Εάν παρουσιαστεί μια εξαίρεση κατά την εκτέλεση της πρότασης :keyword:`try`, "
"η υπόλοιπη πρόταση παραλείπεται.  Στη συνέχεια, εάν ο τύπος της ταιριάζει με "
"την εξαίρεση που ονομάζεται από τη λέξη-κλειδί :keyword:`except`, η *except "
"clause* εκτελείται, και στη συνέχεια η εκτέλεση συνεχίζεται μετά το μπλοκ "
"try/except."

#: tutorial/errors.rst:109
msgid ""
"If an exception occurs which does not match the exception named in the "
"*except clause*, it is passed on to outer :keyword:`try` statements; if no "
"handler is found, it is an *unhandled exception* and execution stops with an "
"error message."
msgstr ""
"Εάν προκύψει μια εξαίρεση που δεν ταιριάζει με την εξαίρεση που αναφέρεται "
"στην *except clause*, μεταβιβάζεται σε εξωτερικές εντολές :keyword:`try` · "
"εάν δεν βρεθεί κανένας χειριστής, είναι μια *unhandled exception* και η "
"εκτέλεση σταματά με μήνυμα σφάλματος."

#: tutorial/errors.rst:113
msgid ""
"A :keyword:`try` statement may have more than one *except clause*, to "
"specify handlers for different exceptions.  At most one handler will be "
"executed. Handlers only handle exceptions that occur in the corresponding "
"*try clause*, not in other handlers of the same :keyword:`!try` statement.  "
"An *except clause* may name multiple exceptions as a parenthesized tuple, "
"for example::"
msgstr ""
"Μια πρόταση :keyword:`try` μπορεί να έχει περισσότερες από μία *except "
"clause*, για να καθορίσει χειριστές για διαφορετικές εξαιρέσεις.  Το πολύ "
"ένας χειριστής θα εκτελεστεί. Οι χειριστές χειρίζονται μόνο εξαιρέσεις που "
"εμφανίζονται στην αντίστοιχη *try clause*, όχι σε άλλους χειριστές της ίδιας "
"πρότασης :keyword:`!try`.  Μια *except clause* μπορεί να ονομάσει πολλαπλές "
"εξαιρέσεις ως πλειάδα (tuple) σε παρένθεση, για παράδειγμα::"

#: tutorial/errors.rst:119
msgid ""
"... except (RuntimeError, TypeError, NameError):\n"
"...     pass"
msgstr ""
"... except (RuntimeError, TypeError, NameError):\n"
"...     pass"

#: tutorial/errors.rst:122
msgid ""
"A class in an :keyword:`except` clause matches exceptions which are "
"instances of the class itself or one of its derived classes (but not the "
"other way around --- an *except clause* listing a derived class does not "
"match instances of its base classes). For example, the following code will "
"print B, C, D in that order::"
msgstr ""
"Μια κλάση σε μια πρόταση :keyword:`except` ταιριάζει με εξαιρέσεις που είναι "
"στιγμιότυπα της ίδιας της κλάσης ή μιας από τις παραγόμενες κλάσεις της "
"(αλλά όχι το αντίστροφο --- μια *except clause* που παραθέτει μια παράγωγη "
"κλάση δεν ταιριάζει με τις παρουσίες των βασικών της κλάσεων). Για "
"παράδειγμα, ο ακόλουθος κώδικας θα εκτυπώσει τα B, C, D με αυτή τη σειρά::"

#: tutorial/errors.rst:127
msgid ""
"class B(Exception):\n"
"    pass\n"
"\n"
"class C(B):\n"
"    pass\n"
"\n"
"class D(C):\n"
"    pass\n"
"\n"
"for cls in [B, C, D]:\n"
"    try:\n"
"        raise cls()\n"
"    except D:\n"
"        print(\"D\")\n"
"    except C:\n"
"        print(\"C\")\n"
"    except B:\n"
"        print(\"B\")"
msgstr ""
"class B(Exception):\n"
"    pass\n"
"\n"
"class C(B):\n"
"    pass\n"
"\n"
"class D(C):\n"
"    pass\n"
"\n"
"for cls in [B, C, D]:\n"
"    try:\n"
"        raise cls()\n"
"    except D:\n"
"        print(\"D\")\n"
"    except C:\n"
"        print(\"C\")\n"
"    except B:\n"
"        print(\"B\")"

#: tutorial/errors.rst:146
msgid ""
"Note that if the *except clauses* were reversed (with ``except B`` first), "
"it would have printed B, B, B --- the first matching *except clause* is "
"triggered."
msgstr ""
"Σημειώστε ότι εάν οι *except clauses* είχαν αντιστραφεί (με το ``except B`` "
"πρώτα), θα είχε εκτυπωθεί B, B, B --- ενεργοποιείται η πρώτη αντιστοίχιση "
"*except clause*."

#: tutorial/errors.rst:149
msgid ""
"When an exception occurs, it may have associated values, also known as the "
"exception's *arguments*. The presence and types of the arguments depend on "
"the exception type."
msgstr ""
"Όταν προκύπτει μια εξαίρεση, μπορεί να έχει συσχετισμένες τιμές, γνωστές και "
"ως *ορίσματα* της εξαίρεσης. Η παρουσία και οι τύποι των ορισμάτων "
"εξαρτώνται από τον τύπο εξαίρεσης."

#: tutorial/errors.rst:153
msgid ""
"The *except clause* may specify a variable after the exception name.  The "
"variable is bound to the exception instance which typically has an ``args`` "
"attribute that stores the arguments. For convenience, builtin exception "
"types define :meth:`~object.__str__` to print all the arguments without "
"explicitly accessing ``.args``.  ::"
msgstr ""
"Το *except clause* μπορεί να καθορίσει μια μεταβλητή μετά το όνομα της "
"εξαίρεσης.  Η μεταβλητή συνδέεται με το στιγμιότυπο της εξαίρεσης η οποία "
"συνήθως έχει ένα χαρακτηριστικό ``args`` που αποθηκεύει τα ορίσματα. Για "
"ευκολία, οι ενσωματωμένοι (builtin) τύποι εξαίρεσης ορίζουν :meth:`~object."
"__str__` για να εκτυπώσετε όλα τα ορίσματα χωρίς ρητή πρόσβαση στο ``."
"args``.  ::"

#: tutorial/errors.rst:159
msgid ""
">>> try:\n"
"...     raise Exception('spam', 'eggs')\n"
"... except Exception as inst:\n"
"...     print(type(inst))    # the exception type\n"
"...     print(inst.args)     # arguments stored in .args\n"
"...     print(inst)          # __str__ allows args to be printed directly,\n"
"...                          # but may be overridden in exception "
"subclasses\n"
"...     x, y = inst.args     # unpack args\n"
"...     print('x =', x)\n"
"...     print('y =', y)\n"
"...\n"
"<class 'Exception'>\n"
"('spam', 'eggs')\n"
"('spam', 'eggs')\n"
"x = spam\n"
"y = eggs"
msgstr ""
">>> try:\n"
"...     raise Exception('spam', 'eggs')\n"
"... except Exception as inst:\n"
"...     print(type(inst))    # the exception type\n"
"...     print(inst.args)     # arguments stored in .args\n"
"...     print(inst)          # __str__ allows args to be printed directly,\n"
"...                          # but may be overridden in exception "
"subclasses\n"
"...     x, y = inst.args     # unpack args\n"
"...     print('x =', x)\n"
"...     print('y =', y)\n"
"...\n"
"<class 'Exception'>\n"
"('spam', 'eggs')\n"
"('spam', 'eggs')\n"
"x = spam\n"
"y = eggs"

#: tutorial/errors.rst:176
msgid ""
"The exception's :meth:`~object.__str__` output is printed as the last part "
"('detail') of the message for unhandled exceptions."
msgstr ""
"Η έξοδος της εξαίρεσης :meth:`~object.__str__` εκτυπώνεται ως το τελευταίο "
"μέρος ('λεπτομέρεια') του μηνύματος για μη χειριζόμενες εξαιρέσεις."

#: tutorial/errors.rst:179
msgid ""
":exc:`BaseException` is the common base class of all exceptions. One of its "
"subclasses, :exc:`Exception`, is the base class of all the non-fatal "
"exceptions. Exceptions which are not subclasses of :exc:`Exception` are not "
"typically handled, because they are used to indicate that the program should "
"terminate. They include :exc:`SystemExit` which is raised by :meth:`sys."
"exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to "
"interrupt the program."
msgstr ""
"Η :exc:`BaseException` είναι η κοινή βασική κλάση όλων των εξαιρέσεων. Μια "
"από τις υποκατηγορίες της, :exc:`Exception`, είναι η βασική κλάση όλων των "
"μη μοιραίων εξαιρέσεων. Εξαιρέσεις που δεν είναι υποκλάσεις του :exc:"
"`Exception` δεν αντιμετωπίζονται συνήθως, επειδή χρησιμοποιούνται για να "
"υποδείξουν ότι το πρόγραμμα πρέπει να τερματιστεί. Περιλαμβάνουν το :exc:"
"`SystemExit` το οποίο αυξάνεται από το :meth:`sys.exit` και το :exc:"
"`KeyboardInterrupt` το οποίο γίνεται raise όταν ο χρήστης επιθυμεί να "
"διακόψει την εκτέλεση του προγράμματος."

#: tutorial/errors.rst:187
msgid ""
":exc:`Exception` can be used as a wildcard that catches (almost) everything. "
"However, it is good practice to be as specific as possible with the types of "
"exceptions that we intend to handle, and to allow any unexpected exceptions "
"to propagate on."
msgstr ""
"Η :exc:`Exception` μπορεί να χρησιμοποιηθεί ως μπαλαντέρ που πιάνει (σχεδόν) "
"τα πάντα. Ωστόσο, είναι καλή πρακτική να είμαστε όσο το δυνατόν πιο "
"συγκεκριμένοι με τους τύπους εξαιρέσεων που σκοπεύουμε να χειριστούμε και να "
"επιτρέπουμε τυχόν απροσδόκητες εξαιρέσεις που εξαπλώνονται."

#: tutorial/errors.rst:192
msgid ""
"The most common pattern for handling :exc:`Exception` is to print or log the "
"exception and then re-raise it (allowing a caller to handle the exception as "
"well)::"
msgstr ""
"Το πιο κοινό μοτίβο για το χειρισμό :exc:`Exception` είναι να εκτυπώσετε ή "
"να καταγράψετε την εξαίρεση και στη συνέχεια να την επαναφέρετε "
"(επιτρέποντας σε έναν καλούντα να χειριστεί και την εξαίρεση)::"

#: tutorial/errors.rst:196
msgid ""
"import sys\n"
"\n"
"try:\n"
"    f = open('myfile.txt')\n"
"    s = f.readline()\n"
"    i = int(s.strip())\n"
"except OSError as err:\n"
"    print(\"OS error:\", err)\n"
"except ValueError:\n"
"    print(\"Could not convert data to an integer.\")\n"
"except Exception as err:\n"
"    print(f\"Unexpected {err=}, {type(err)=}\")\n"
"    raise"
msgstr ""
"import sys\n"
"\n"
"try:\n"
"    f = open('myfile.txt')\n"
"    s = f.readline()\n"
"    i = int(s.strip())\n"
"except OSError as err:\n"
"    print(\"OS error:\", err)\n"
"except ValueError:\n"
"    print(\"Could not convert data to an integer.\")\n"
"except Exception as err:\n"
"    print(f\"Unexpected {err=}, {type(err)=}\")\n"
"    raise"

#: tutorial/errors.rst:210
msgid ""
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
"clause*, which, when present, must follow all *except clauses*.  It is "
"useful for code that must be executed if the *try clause* does not raise an "
"exception. For example::"
msgstr ""
"Η πρόταση :keyword:`try` ... :keyword:`except` έχει ένα προαιρετικό *else "
"clause*, το οποίο, όταν υπάρχει, πρέπει να ακολουθεί όλες τις *except "
"clauses*.  Είναι χρήσιμο για κώδικα που πρέπει να εκτελεστεί εάν το *try "
"clause* δεν κάνει raise μια εξαίρεση. Για παράδειγμα::"

#: tutorial/errors.rst:215
msgid ""
"for arg in sys.argv[1:]:\n"
"    try:\n"
"        f = open(arg, 'r')\n"
"    except OSError:\n"
"        print('cannot open', arg)\n"
"    else:\n"
"        print(arg, 'has', len(f.readlines()), 'lines')\n"
"        f.close()"
msgstr ""
"for arg in sys.argv[1:]:\n"
"    try:\n"
"        f = open(arg, 'r')\n"
"    except OSError:\n"
"        print('cannot open', arg)\n"
"    else:\n"
"        print(arg, 'has', len(f.readlines()), 'lines')\n"
"        f.close()"

#: tutorial/errors.rst:224
msgid ""
"The use of the :keyword:`!else` clause is better than adding additional code "
"to the :keyword:`try` clause because it avoids accidentally catching an "
"exception that wasn't raised by the code being protected by the :keyword:`!"
"try` ... :keyword:`!except` statement."
msgstr ""
"Η χρήση της πρότασης :keyword:`!else` είναι καλύτερη από την προσθήκη "
"πρόσθετου κώδικα στην πρόταση :keyword:`try`, επειδή αποφεύγει την κατά "
"λάθος σύλληψη μιας εξαίρεσης που δεν προέκυψε από τον κώδικα που "
"προστατεύεται από την πρόταση :keyword:`!try` ... :keyword:`!except`."

#: tutorial/errors.rst:229
msgid ""
"Exception handlers do not handle only exceptions that occur immediately in "
"the *try clause*, but also those that occur inside functions that are called "
"(even indirectly) in the *try clause*. For example::"
msgstr ""
"Οι χειριστές εξαιρέσεων δεν χειρίζονται μόνο τις εξαιρέσεις που εμφανίζονται "
"αμέσως στη *try clause*, αλλά και εκείνες που εμφανίζονται μέσα σε "
"συναρτήσεις που καλούνται (ακόμη και έμμεσα) στην *try clause*. Για "
"παράδειγμα::"

#: tutorial/errors.rst:233
msgid ""
">>> def this_fails():\n"
"...     x = 1/0\n"
"...\n"
">>> try:\n"
"...     this_fails()\n"
"... except ZeroDivisionError as err:\n"
"...     print('Handling run-time error:', err)\n"
"...\n"
"Handling run-time error: division by zero"
msgstr ""
">>> def this_fails():\n"
"...     x = 1/0\n"
"...\n"
">>> try:\n"
"...     this_fails()\n"
"... except ZeroDivisionError as err:\n"
"...     print('Handling run-time error:', err)\n"
"...\n"
"Handling run-time error: division by zero"

#: tutorial/errors.rst:247
msgid "Raising Exceptions"
msgstr "Raising Εξαιρέσεων"

#: tutorial/errors.rst:249
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"Η δήλωση :keyword:`raise` επιτρέπει στον προγραμματιστή να αναγκάσει να "
"εμφανιστεί μια καθορισμένη εξαίρεση. Για  παράδειγμα::"

#: tutorial/errors.rst:252
msgid ""
">>> raise NameError('HiThere')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: HiThere"
msgstr ""
">>> raise NameError('HiThere')\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: HiThere"

#: tutorial/errors.rst:257
msgid ""
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
"This must be either an exception instance or an exception class (a class "
"that derives from :class:`BaseException`, such as :exc:`Exception` or one of "
"its subclasses).  If an exception class is passed, it will be implicitly "
"instantiated by calling its constructor with no arguments::"
msgstr ""
"Το μοναδικό όρισμα στο :keyword:`raise` υποδεικνύει την εξαίρεση που πρέπει "
"να γίνει raise. Αυτή πρέπει να είναι είτε μια παρουσία εξαίρεσης ή μια "
"εξαίρεση κλάση (μια κλάση που προέρχεται από :class:`BaseException`, όπως :"
"exc:`Exception` ή μία από τις υποκλάσεις της). Εάν περάσει μια κλάση "
"εξαίρεσης, θα δημιουργηθεί σιωπηρά καλώντας τον constructor της χωρίς "
"ορίσματα::"

#: tutorial/errors.rst:263
msgid "raise ValueError  # shorthand for 'raise ValueError()'"
msgstr "κάνει raise ένα ValueError # συντομογραφία για το 'raise ValueError()'"

#: tutorial/errors.rst:265
msgid ""
"If you need to determine whether an exception was raised but don't intend to "
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
"raise the exception::"
msgstr ""
"Εάν πρέπει να προσδιορίσετε εάν έχει εγγραφεί μια εξαίρεση, αλλά δεν "
"σκοπεύετε να τη χειριστείτε, μια απλούστερη μορφή της δήλωσης :keyword:"
"`raise` σας επιτρέπει να κάνετε ξανά raise την εξαίρεση::"

#: tutorial/errors.rst:269
msgid ""
">>> try:\n"
"...     raise NameError('HiThere')\n"
"... except NameError:\n"
"...     print('An exception flew by!')\n"
"...     raise\n"
"...\n"
"An exception flew by!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"NameError: HiThere"
msgstr ""
">>> try:\n"
"...     raise NameError('HiThere')\n"
"... except NameError:\n"
"...     print('An exception flew by!')\n"
"...     raise\n"
"...\n"
"An exception flew by!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"NameError: HiThere"

#: tutorial/errors.rst:284
msgid "Exception Chaining"
msgstr "Αλυσιδωτές Εξαιρέσεις"

#: tutorial/errors.rst:286
msgid ""
"If an unhandled exception occurs inside an :keyword:`except` section, it "
"will have the exception being handled attached to it and included in the "
"error message::"
msgstr ""
"Εάν παρουσιαστεί μια μη χειριζόμενη (unhandled) εξαίρεση μέσα σε μια "
"ενότητα :keyword:`except`, θα επισυνάψει την εξαίρεση που θα χειριστεί και "
"θα συμπεριληφθεί στο μήνυμα σφάλματος::"

#: tutorial/errors.rst:290
msgid ""
">>> try:\n"
"...     open(\"database.sqlite\")\n"
"... except OSError:\n"
"...     raise RuntimeError(\"unable to handle error\")\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n"
"\n"
"During handling of the above exception, another exception occurred:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"RuntimeError: unable to handle error"
msgstr ""
">>> try:\n"
"...     open(\"database.sqlite\")\n"
"... except OSError:\n"
"...     raise RuntimeError(\"unable to handle error\")\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n"
"\n"
"During handling of the above exception, another exception occurred:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"RuntimeError: unable to handle error"

#: tutorial/errors.rst:305
msgid ""
"To indicate that an exception is a direct consequence of another, the :"
"keyword:`raise` statement allows an optional :keyword:`from<raise>` clause::"
msgstr ""
"Για να υποδείξετε ότι μια εξαίρεση είναι άμεση συνέπεια μιας άλλης, η "
"πρόταση :keyword:`raise` επιτρέπει μια προαιρετική πρόταση :keyword:"
"`from<raise>`::"

#: tutorial/errors.rst:308
msgid ""
"# exc must be exception instance or None.\n"
"raise RuntimeError from exc"
msgstr ""
"# Το exc πρέπει να είναι παράδειγμα εξαίρεσης ή None.\n"
"κάνει raise το RuntimeError από exc"

#: tutorial/errors.rst:311
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr ""
"Αυτό μπορεί να είναι χρήσιμο όταν μετασχηματίζεται εξαιρέσεις. Για "
"παράδειγμα::"

#: tutorial/errors.rst:313
msgid ""
">>> def func():\n"
"...     raise ConnectionError\n"
"...\n"
">>> try:\n"
"...     func()\n"
"... except ConnectionError as exc:\n"
"...     raise RuntimeError('Failed to open database') from exc\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"  File \"<stdin>\", line 2, in func\n"
"ConnectionError\n"
"\n"
"The above exception was the direct cause of the following exception:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"RuntimeError: Failed to open database"
msgstr ""
">>> def func():\n"
"...     raise ConnectionError\n"
"...\n"
">>> try:\n"
"...     func()\n"
"... except ConnectionError as exc:\n"
"...     raise RuntimeError('Failed to open database') from exc\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"  File \"<stdin>\", line 2, in func\n"
"ConnectionError\n"
"\n"
"The above exception was the direct cause of the following exception:\n"
"\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"RuntimeError: Failed to open database"

#: tutorial/errors.rst:332
msgid ""
"It also allows disabling automatic exception chaining using the ``from "
"None`` idiom::"
msgstr ""
"Επιτρέπει επίσης την απενεργοποίηση της αυτόματης αλυσίδας εξαιρέσεων "
"χρησιμοποιώντας ``from None`` idiom::"

#: tutorial/errors.rst:335
msgid ""
">>> try:\n"
"...     open('database.sqlite')\n"
"... except OSError:\n"
"...     raise RuntimeError from None\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"RuntimeError"
msgstr ""
">>> try:\n"
"...     open('database.sqlite')\n"
"... except OSError:\n"
"...     raise RuntimeError from None\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 4, in <module>\n"
"RuntimeError"

#: tutorial/errors.rst:344
msgid ""
"For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr ""
"Για περισσότερες πληροφορίες σχετικά με την μηχανική αλυσίδων, δείτε :ref:"
"`bltin-exceptions`."

#: tutorial/errors.rst:350
msgid "User-defined Exceptions"
msgstr "Εξαιρέσεις που καθορίζονται από το χρήστη"

#: tutorial/errors.rst:352
msgid ""
"Programs may name their own exceptions by creating a new exception class "
"(see :ref:`tut-classes` for more about Python classes).  Exceptions should "
"typically be derived from the :exc:`Exception` class, either directly or "
"indirectly."
msgstr ""
"Τα  προγράμματα μπορούν να ονομάσουν τις δικές τους εξαιρέσεις δημιουργώντας "
"μια νέα κλάση εξαιρέσεων (δείτε :ref:`tut-classes` για περισσότερα σχετικά "
"με τις κλάσεις Python).  Οι εξαιρέσεις θα πρέπει συνήθως να προέρχονται από "
"την κλάση :exc:`Exception`, είτε άμεσα είτε έμμεσα."

#: tutorial/errors.rst:356
msgid ""
"Exception classes can be defined which do anything any other class can do, "
"but are usually kept simple, often only offering a number of attributes that "
"allow information about the error to be extracted by handlers for the "
"exception."
msgstr ""
"Μπορούν να οριστούν κλάσεις εξαίρεσης που κάνουν οτιδήποτε μπορεί να κάνει "
"οποιαδήποτε άλλη κλάση, αλλά συνήθως διατηρούνται απλές, συχνά προσφέρουν "
"μόνο έναν αριθμό χαρακτηριστικών που επιτρέπουν την εξαγωγή πληροφοριών "
"σχετικά με το σφάλμα από τους χειριστές για την εξαίρεση."

#: tutorial/errors.rst:360
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the "
"naming of the standard exceptions."
msgstr ""
"Οι περισσότερες εξαιρέσεις ορίζονται με ονόματα που τελειώνουν σε \"Error\", "
"παρόμοια με την ονομασία των τυπικών εξαιρέσεων."

#: tutorial/errors.rst:363
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define."
msgstr ""
"Πολλά standard modules ορίζουν τις δικές τους εξαιρέσεις για την αναφορά "
"σφαλμάτων που μπορεί να προκύψουν σε συναρτήσεις που ορίζουν."

#: tutorial/errors.rst:370
msgid "Defining Clean-up Actions"
msgstr "Καθορισμός ενεργειών καθαρισμού"

#: tutorial/errors.rst:372
msgid ""
"The :keyword:`try` statement has another optional clause which is intended "
"to define clean-up actions that must be executed under all circumstances.  "
"For example::"
msgstr ""
"Η δήλωση :keyword:`try` έχει μια άλλη προαιρετική πρόταση που προορίζεται να "
"ορίσει ενέργειες καθαρισμού που πρέπει να εκτελεστούν υπό οποιεσδήποτε "
"συνθήκες.  Για παράδειγμα::"

#: tutorial/errors.rst:376
msgid ""
">>> try:\n"
"...     raise KeyboardInterrupt\n"
"... finally:\n"
"...     print('Goodbye, world!')\n"
"...\n"
"Goodbye, world!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"KeyboardInterrupt"
msgstr ""
">>> try:\n"
"...     raise KeyboardInterrupt\n"
"... finally:\n"
"...     print('Goodbye, world!')\n"
"...\n"
"Goodbye, world!\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"KeyboardInterrupt"

#: tutorial/errors.rst:386
msgid ""
"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "
"will execute as the last task before the :keyword:`try` statement completes. "
"The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "
"statement produces an exception. The following points discuss more complex "
"cases when an exception occurs:"
msgstr ""
"Εάν υπάρχει μια πρόταση :keyword:`finally`, η πρόταση :keyword:`!finally` θα "
"εκτελεστεί ως η τελευταία εργασία πριν από την ολοκλήρωση της πρότασης :"
"keyword:`try`. Η πρόταση :keyword:`!finally` εκτελείται είτε όχι η πρόταση :"
"keyword:`!try` παράγει μια εξαίρεση. Τα ακόλουθα σημεία συζητούν πιο "
"περίπλοκες περιπτώσεις όταν εμφανίζεται μια εξαίρεση:"

#: tutorial/errors.rst:392
msgid ""
"If an exception occurs during execution of the :keyword:`!try` clause, the "
"exception may be handled by an :keyword:`except` clause. If the exception is "
"not handled by an :keyword:`!except` clause, the exception is re-raised "
"after the :keyword:`!finally` clause has been executed."
msgstr ""
"Εάν παρουσιαστεί μια εξαίρεση κατά την εκτέλεση της πρότασης :keyword:`!"
"try`, η εξαίρεση μπορεί να αντιμετωπιστεί από μια πρόταση :keyword:`except`, "
"Εάν η εξαίρεση δεν αντιμετωπίζεται από μια πρόταση :keyword:`!except`, η "
"εξαίρεση γίνεται ξανά raise μετά την εκτέλεση της πρότασης :keyword:`!"
"finally`."

#: tutorial/errors.rst:398
msgid ""
"An exception could occur during execution of an :keyword:`!except` or :"
"keyword:`!else` clause. Again, the exception is re-raised after the :keyword:"
"`!finally` clause has been executed."
msgstr ""
"Μια εξαίρεση θα μπορούσε να προκύψει κατά την εκτέλεση μιας πρότασης :"
"keyword:`!except` ή :keyword:`!else`. Και πάλι, η εξαίρεση τίθεται ξανά μετά "
"την εκτέλεση της πρότασης :keyword:`!finally`."

#: tutorial/errors.rst:402
msgid ""
"If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, exceptions are not re-raised."
msgstr ""
"Εάν η πρόταση :keyword:`!finally` εκτελέσει μια πρόταση :keyword:`break`, :"
"keyword:`continue` ή :keyword:`return`, οι εξαιρέσεις δεν αυξάνονται εκ νέου."

#: tutorial/errors.rst:406
msgid ""
"If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, the :keyword:`!finally` clause "
"will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :"
"keyword:`!return` statement's execution."
msgstr ""
"Εάν η πρόταση :keyword:`!try` φτάσει σε μια δήλωση :keyword:`break`, :"
"keyword:`continue` ή :keyword:`return`, η πρόταση :keyword:`!finally` θα "
"εκτελεστεί ακριβώς πριν από τα :keyword:`!break`, :keyword:`!continue` or :"
"keyword:`!return` της εκτέλεσης της δήλωσης."

#: tutorial/errors.rst:412
msgid ""
"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the "
"returned value will be the one from the :keyword:`!finally` clause's :"
"keyword:`!return` statement, not the value from the :keyword:`!try` "
"clause's :keyword:`!return` statement."
msgstr ""
"Εάν μια πρόταση :keyword:`!finally` περιλαμβάνει μια δήλωση :keyword:`!"
"return`, η τιμή που επιστρέφεται θα είναι αυτή από την πρόταση :keyword:`!"
"finally` της δήλωσης της :keyword:`!return`, και όχι η τιμή από τη δήλωση :"
"keyword:`!try` της πρότασης :keyword:`!return`."

#: tutorial/errors.rst:418
msgid "For example::"
msgstr "Για παράδειγμα::"

#: tutorial/errors.rst:420
msgid ""
">>> def bool_return():\n"
"...     try:\n"
"...         return True\n"
"...     finally:\n"
"...         return False\n"
"...\n"
">>> bool_return()\n"
"False"
msgstr ""
">>> def bool_return():\n"
"...     try:\n"
"...         return True\n"
"...     finally:\n"
"...         return False\n"
"...\n"
">>> bool_return()\n"
"False"

#: tutorial/errors.rst:429
msgid "A more complicated example::"
msgstr "Ένα πιο περίπλοκο παράδειγμα::"

#: tutorial/errors.rst:431
msgid ""
">>> def divide(x, y):\n"
"...     try:\n"
"...         result = x / y\n"
"...     except ZeroDivisionError:\n"
"...         print(\"division by zero!\")\n"
"...     else:\n"
"...         print(\"result is\", result)\n"
"...     finally:\n"
"...         print(\"executing finally clause\")\n"
"...\n"
">>> divide(2, 1)\n"
"result is 2.0\n"
"executing finally clause\n"
">>> divide(2, 0)\n"
"division by zero!\n"
"executing finally clause\n"
">>> divide(\"2\", \"1\")\n"
"executing finally clause\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"<stdin>\", line 3, in divide\n"
"TypeError: unsupported operand type(s) for /: 'str' and 'str'"
msgstr ""
">>> def divide(x, y):\n"
"...     try:\n"
"...         result = x / y\n"
"...     except ZeroDivisionError:\n"
"...         print(\"division by zero!\")\n"
"...     else:\n"
"...         print(\"result is\", result)\n"
"...     finally:\n"
"...         print(\"executing finally clause\")\n"
"...\n"
">>> divide(2, 1)\n"
"result is 2.0\n"
"executing finally clause\n"
">>> divide(2, 0)\n"
"division by zero!\n"
"executing finally clause\n"
">>> divide(\"2\", \"1\")\n"
"executing finally clause\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"  File \"<stdin>\", line 3, in divide\n"
"TypeError: unsupported operand type(s) for /: 'str' and 'str'"

#: tutorial/errors.rst:454
msgid ""
"As you can see, the :keyword:`finally` clause is executed in any event.  "
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
"keyword:`except` clause and therefore re-raised after the :keyword:`!"
"finally` clause has been executed."
msgstr ""
"Όπως μπορείτε να δείτε, η πρόταση :keyword:`finally` εκτελείται σε "
"οποιαδήποτε περίπτωση.  Το :exc:`TypeError` που δημιουργείται με τη διαίρεση "
"δύο συμβολοσειρών δεν χειρίζεται από την πρόταση :keyword:`except` και "
"επομένως γίνεται ξανά raise μετά την εκτέλεση του όρου :keyword:`!finally`."

#: tutorial/errors.rst:459
msgid ""
"In real world applications, the :keyword:`finally` clause is useful for "
"releasing external resources (such as files or network connections), "
"regardless of whether the use of the resource was successful."
msgstr ""
"Στις εφαρμογές του πραγματικού κόσμου, η πρόταση :keyword:`finally` είναι "
"χρήσιμη για την απελευθέρωση εξωτερικών πόρων (όπως αρχεία ή συνδέσεις "
"δικτύου), ανεξάρτητα από το εάν η χρήση του πόρου ήταν επιτυχής."

#: tutorial/errors.rst:467
msgid "Predefined Clean-up Actions"
msgstr "Προκαθορισμένες ενέργειες καθαρισμού"

#: tutorial/errors.rst:469
msgid ""
"Some objects define standard clean-up actions to be undertaken when the "
"object is no longer needed, regardless of whether or not the operation using "
"the object succeeded or failed. Look at the following example, which tries "
"to open a file and print its contents to the screen. ::"
msgstr ""
"Μερικά αντικείμενα ορίζουν τις τυπικές ενέργειες καθαρισμού που πρέπει να "
"αναλαμβάνονται όταν το αντικείμενο δεν χρειάζεται πλέον, ανεξάρτητα από το "
"εάν η λειτουργία που χρησιμοποιεί το αντικείμενο πέτυχε ή απέτυχε. Κοιτάξτε "
"το ακόλουθο αντικείμενο, το οποίο προσπαθεί να ανοίξει ένα αρχείο και να "
"εκτυπώσει τα περιεχόμενα του στην οθόνη. ::"

#: tutorial/errors.rst:474
msgid ""
"for line in open(\"myfile.txt\"):\n"
"    print(line, end=\"\")"
msgstr ""
"for line in open(\"myfile.txt\"):\n"
"    print(line, end=\"\")"

#: tutorial/errors.rst:477
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after this part of the code has finished "
"executing. This is not an issue in simple scripts, but can be a problem for "
"larger applications. The :keyword:`with` statement allows objects like files "
"to be used in a way that ensures they are always cleaned up promptly and "
"correctly. ::"
msgstr ""
"Το πρόβλημα με αυτόν τον κώδικα είναι ότι αφήνει το αρχείο ανοιχτό για "
"απροσδιόριστο χρονικό διάστημα μετά την ολοκλήρωση της εκτέλεσης αυτού του "
"τμήματος του κώδικα. Αυτό δεν είναι πρόβλημα σε απλά σενάρια, αλλά μπορεί να "
"είναι πρόβλημα για μεγαλύτερες εφαρμογές. Η δήλωση :keyword:`with` επιτρέπει "
"σε αντικείμενα όπως αρχεία να χρησιμοποιούνται με τρόπο που διασφαλίζει ότι "
"καθαρίζονται πάντα άμεσα και σωστά. ::"

#: tutorial/errors.rst:483
msgid ""
"with open(\"myfile.txt\") as f:\n"
"    for line in f:\n"
"        print(line, end=\"\")"
msgstr ""
"with open(\"myfile.txt\") as f:\n"
"    for line in f:\n"
"        print(line, end=\"\")"

#: tutorial/errors.rst:487
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Objects which, like "
"files, provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""
"Μετά την εκτέλεση της πρότασης, το αρχείο *f* είναι πάντα κλειστό, ακόμα και "
"αν παρουσιάστηκε πρόβλημα κατά την επεξεργασία των γραμμών. Τα αντικείμενα "
"που, όπως τα αρχεία παρέχουν προκαθορισμένες ενέργειες καθαρισμού θα το "
"υποδεικνύουν στην τεκμηρίωση τους."

#: tutorial/errors.rst:495
msgid "Raising and Handling Multiple Unrelated Exceptions"
msgstr "Raising και Χειρισμός Πολλαπλών Άσχετων Εξαιρέσεων"

#: tutorial/errors.rst:497
msgid ""
"There are situations where it is necessary to report several exceptions that "
"have occurred. This is often the case in concurrency frameworks, when "
"several tasks may have failed in parallel, but there are also other use "
"cases where it is desirable to continue execution and collect multiple "
"errors rather than raise the first exception."
msgstr ""
"Υπάρχουν περιπτώσεις όπου είναι απαραίτητο να αναφερθούν πολλές εξαιρέσεις "
"που έχουν συμβεί. Αυτό συμβαίνει συχνά σε πλαίσια ταυτόχρονης χρήσης, όταν "
"πολλές εργασίες μπορεί να έχουνε αποτύχει παράλληλα, αλλά υπάρχουν και άλλες "
"περιπτώσεις χρήσης όπου είναι επιθυμητό να συνεχιστεί η εκτέλεση και η "
"συλλογή πολλαπλών σφαλμάτων αντί να κάνει raise την πρώτη εξαίρεση."

#: tutorial/errors.rst:503
msgid ""
"The builtin :exc:`ExceptionGroup` wraps a list of exception instances so "
"that they can be raised together. It is an exception itself, so it can be "
"caught like any other exception. ::"
msgstr ""
"Η ενσωματωμένη (builtin) :exc:`ExceptionGroup` αναδιπλώνει μια λίστα με "
"παρουσίες εξαιρέσεων ώστε να μπορούν να αυξηθούν μαζί. Είναι μια εξαίρεση "
"από μόνη της, επομένως μπορεί να συλληφθεί όπως κάθε άλλη εξαίρεση. ::"

#: tutorial/errors.rst:507
msgid ""
">>> def f():\n"
"...     excs = [OSError('error 1'), SystemError('error 2')]\n"
"...     raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |   File \"<stdin>\", line 3, in f\n"
"  | ExceptionGroup: there were problems\n"
"  +-+---------------- 1 ----------------\n"
"    | OSError: error 1\n"
"    +---------------- 2 ----------------\n"
"    | SystemError: error 2\n"
"    +------------------------------------\n"
">>> try:\n"
"...     f()\n"
"... except Exception as e:\n"
"...     print(f'caught {type(e)}: e')\n"
"...\n"
"caught <class 'ExceptionGroup'>: e\n"
">>>"
msgstr ""
">>> def f():\n"
"...     excs = [OSError('error 1'), SystemError('error 2')]\n"
"...     raise ExceptionGroup('there were problems', excs)\n"
"...\n"
">>> f()\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  |   File \"<stdin>\", line 3, in f\n"
"  | ExceptionGroup: there were problems\n"
"  +-+---------------- 1 ----------------\n"
"    | OSError: error 1\n"
"    +---------------- 2 ----------------\n"
"    | SystemError: error 2\n"
"    +------------------------------------\n"
">>> try:\n"
"...     f()\n"
"... except Exception as e:\n"
"...     print(f'caught {type(e)}: e')\n"
"...\n"
"caught <class 'ExceptionGroup'>: e\n"
">>>"

#: tutorial/errors.rst:529
msgid ""
"By using ``except*`` instead of ``except``, we can selectively handle only "
"the exceptions in the group that match a certain type. In the following "
"example, which shows a nested exception group, each ``except*`` clause "
"extracts from the group exceptions of a certain type while letting all other "
"exceptions propagate to other clauses and eventually to be reraised. ::"
msgstr ""
"Χρησιμοποιώντας ``except*`` αντί για ``except``, μπορούμε επιλεκτικά να "
"χειριστούμε μόνο τις εξαιρέσεις στην ομάδα που αντιστοιχούν σε έναν "
"συγκεκριμένο τύπο. Στο παρακάτω παράδειγμα, το οποίο δείχνει μια ένθετη "
"ομάδα εξαιρέσεων, κάθε πρόταση ``except*`` εξάγει από τις εξαιρέσεις της "
"ομάδας ενός συγκεκριμένου τύπου, ενώ αφήνει όλες τις άλλες εξαιρέσεις να "
"διαδοθούν σε άλλες προτάσεις και τελικά να ξαναγίνουν raise. ::"

#: tutorial/errors.rst:536
msgid ""
">>> def f():\n"
"...     raise ExceptionGroup(\n"
"...         \"group1\",\n"
"...         [\n"
"...             OSError(1),\n"
"...             SystemError(2),\n"
"...             ExceptionGroup(\n"
"...                 \"group2\",\n"
"...                 [\n"
"...                     OSError(3),\n"
"...                     RecursionError(4)\n"
"...                 ]\n"
"...             )\n"
"...         ]\n"
"...     )\n"
"...\n"
">>> try:\n"
"...     f()\n"
"... except* OSError as e:\n"
"...     print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"...     print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 2, in <module>\n"
"  |   File \"<stdin>\", line 2, in f\n"
"  | ExceptionGroup: group1\n"
"  +-+---------------- 1 ----------------\n"
"    | ExceptionGroup: group2\n"
"    +-+---------------- 1 ----------------\n"
"      | RecursionError: 4\n"
"      +------------------------------------\n"
">>>"
msgstr ""
">>> def f():\n"
"...     raise ExceptionGroup(\n"
"...         \"group1\",\n"
"...         [\n"
"...             OSError(1),\n"
"...             SystemError(2),\n"
"...             ExceptionGroup(\n"
"...                 \"group2\",\n"
"...                 [\n"
"...                     OSError(3),\n"
"...                     RecursionError(4)\n"
"...                 ]\n"
"...             )\n"
"...         ]\n"
"...     )\n"
"...\n"
">>> try:\n"
"...     f()\n"
"... except* OSError as e:\n"
"...     print(\"There were OSErrors\")\n"
"... except* SystemError as e:\n"
"...     print(\"There were SystemErrors\")\n"
"...\n"
"There were OSErrors\n"
"There were SystemErrors\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 2, in <module>\n"
"  |   File \"<stdin>\", line 2, in f\n"
"  | ExceptionGroup: group1\n"
"  +-+---------------- 1 ----------------\n"
"    | ExceptionGroup: group2\n"
"    +-+---------------- 1 ----------------\n"
"      | RecursionError: 4\n"
"      +------------------------------------\n"
">>>"

#: tutorial/errors.rst:572
msgid ""
"Note that the exceptions nested in an exception group must be instances, not "
"types. This is because in practice the exceptions would typically be ones "
"that have already been raised and caught by the program, along the following "
"pattern::"
msgstr ""
"Λάβετε υπόψη ότι οι εξαιρέσεις που είναι ένθετες σε μια ομάδα εξαιρέσεων "
"πρέπει να είναι στιγμιότυπα, όχι τύποι. Αυτό συμβαίνει επειδή στην πράξη οι "
"εξαιρέσεις θα ήταν συνήθως αυτές που έχουν ήδη αναφερθεί και καταγραφεί από "
"το πρόγραμμα, σύμφωνα με το ακόλουθο μοτίβο::"

#: tutorial/errors.rst:577
msgid ""
">>> excs = []\n"
"... for test in tests:\n"
"...     try:\n"
"...         test.run()\n"
"...     except Exception as e:\n"
"...         excs.append(e)\n"
"...\n"
">>> if excs:\n"
"...    raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."
msgstr ""
">>> excs = []\n"
"... for test in tests:\n"
"...     try:\n"
"...         test.run()\n"
"...     except Exception as e:\n"
"...         excs.append(e)\n"
"...\n"
">>> if excs:\n"
"...    raise ExceptionGroup(\"Test Failures\", excs)\n"
"..."

#: tutorial/errors.rst:592
msgid "Enriching Exceptions with Notes"
msgstr "Εμπλουτίζοντας τις Εξαιρέσεις με Σημειώσεις"

#: tutorial/errors.rst:594
msgid ""
"When an exception is created in order to be raised, it is usually "
"initialized with information that describes the error that has occurred. "
"There are cases where it is useful to add information after the exception "
"was caught. For this purpose, exceptions have a method ``add_note(note)`` "
"that accepts a string and adds it to the exception's notes list. The "
"standard traceback rendering includes all notes, in the order they were "
"added, after the exception. ::"
msgstr ""
"Όταν δημιουργείται μια εξαίρεση προκειμένου να γίνει raise, συνήθως "
"αρχικοποιείται με πληροφορίες που περιγράφουν το σφάλμα που έχει προκύψει. "
"Υπάρχουν περιπτώσεις όπου είναι χρήσιμο να προστεθούν πληροφορίες μετά την "
"σύλληψη της εξαίρεσης. Για το σκοπό αυτό, οι εξαιρέσεις έχουνε μια μέθοδο "
"``add_note(note)`` που δέχεται μια συμβολοσειρά και την προσθέτει στη λίστα "
"σημειώσεων της εξαίρεσης. Η standard απόδοση παρακολούθησης περιλαμβάνει "
"όλες τις σημειώσεις, με τη σειρά που προστέθηκα, μετά την εξαίρεση. ::"

#: tutorial/errors.rst:601
msgid ""
">>> try:\n"
"...     raise TypeError('bad type')\n"
"... except Exception as e:\n"
"...     e.add_note('Add some information')\n"
"...     e.add_note('Add some more information')\n"
"...     raise\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"
msgstr ""
">>> try:\n"
"...     raise TypeError('bad type')\n"
"... except Exception as e:\n"
"...     e.add_note('Add some information')\n"
"...     e.add_note('Add some more information')\n"
"...     raise\n"
"...\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 2, in <module>\n"
"TypeError: bad type\n"
"Add some information\n"
"Add some more information\n"
">>>"

#: tutorial/errors.rst:615
msgid ""
"For example, when collecting exceptions into an exception group, we may want "
"to add context information for the individual errors. In the following each "
"exception in the group has a note indicating when this error has occurred. ::"
msgstr ""
"Για παράδειγμα, όταν συλλέγουμε εξαιρέσεις σε μια ομάδα εξαιρέσεων, μπορεί "
"να θέλουμε να προσθέσουμε πληροφορίες περιβάλλοντος για τα μεμονωμένα "
"σφάλματα. Στην συνέχεια κάθε εξαίρεση στην ομάδα έχει μια σημείωση που "
"υποδεικνύει πότε έχει συμβεί αυτό το σφάλμα. ::"

#: tutorial/errors.rst:619
msgid ""
">>> def f():\n"
"...     raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"...     try:\n"
"...         f()\n"
"...     except Exception as e:\n"
"...         e.add_note(f'Happened in Iteration {i+1}')\n"
"...         excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 1\n"
"    +---------------- 2 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 2\n"
"    +---------------- 3 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 3\n"
"    +------------------------------------\n"
">>>"
msgstr ""
">>> def f():\n"
"...     raise OSError('operation failed')\n"
"...\n"
">>> excs = []\n"
">>> for i in range(3):\n"
"...     try:\n"
"...         f()\n"
"...     except Exception as e:\n"
"...         e.add_note(f'Happened in Iteration {i+1}')\n"
"...         excs.append(e)\n"
"...\n"
">>> raise ExceptionGroup('We have some problems', excs)\n"
"  + Exception Group Traceback (most recent call last):\n"
"  |   File \"<stdin>\", line 1, in <module>\n"
"  | ExceptionGroup: We have some problems (3 sub-exceptions)\n"
"  +-+---------------- 1 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 1\n"
"    +---------------- 2 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 2\n"
"    +---------------- 3 ----------------\n"
"    | Traceback (most recent call last):\n"
"    |   File \"<stdin>\", line 3, in <module>\n"
"    |   File \"<stdin>\", line 2, in f\n"
"    | OSError: operation failed\n"
"    | Happened in Iteration 3\n"
"    +------------------------------------\n"
">>>"