"datetime" --- Βασικοί τύποι ημερομηνίας και ώρας
*************************************************

**Πηγαίος κώδικας:** Lib/datetime.py

======================================================================

Το module "datetime" παρέχει κλάσεις για την επεξεργασία ημερομηνιών
και ωρών.

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

Πρακτική συμβουλή:

  Μετάβαση στους κωδικούς μορφοποίησης.

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

  Module "calendar"
     Γενικές συναρτήσεις που σχετίζονται με το ημερολόγιο.

  Module "time"
     Πρόσβαση και μετατροπές χρόνου.

  Module "zoneinfo"
     Συγκεκριμένες ζώνες ώρας που αντιπροσωπεύουν τη βάση δεδομένων
     ζωνών ώρας IANA.

  Πακέτο dateutil
     Βιβλιοθήκη τρίτου μέρους με επεκτείνουσα υποστήριξη ζωνών ώρας
     και ανάλυσης.

  Πακέτο DateType
     Third-party library that introduces distinct static types to for
     example, allow *static type checkers* to differentiate between
     naive and aware datetimes.


Aware and naive objects
=======================

Τα αντικείμενα ημερομηνίας και ώρας μπορούν να κατηγοριοποιηθούν ως
"ενήμερα" ή "αδαή" ανάλογα με το αν περιλαμβάνουν ή όχι πληροφορίες
ζώνης ώρας.

Με επαρκή γνώση των εφαρμοστέων αλγοριθμικών και πολιτικών ρυθμίσεων
χρόνου, όπως πληροφορίες ζώνης ώρας και θερινής ώρας, ένα **ενήμερο**
αντικείμενο μπορεί να εντοπίσει τη θέση του σε σχέση με άλλα ενήμερα
αντικείμενα. Ένα ενήμερο αντικείμενο αντιπροσωπεύει μια συγκεκριμένη
στιγμή στο χρόνο που δεν υπόκειται σε ερμηνεία. [1]

Ένα **αδαές** αντικείμενο δεν περιέχει αρκετές πληροφορίες για να
εντοπίσει με σαφήνεια τον εαυτό του σε σχέση με άλλα αντικείμενα
ημερομηνίας/ώρας. Το αν ένα αδαές αντικείμενο αντιπροσωπεύει
Συντονισμένη Παγκόσμια Ώρα (UTC), τοπική ώρα, ή ώρα σε κάποια άλλη
ζώνη ώρας εξαρτάται αποκλειστικά από το πρόγραμμα, όπως ακριβώς
εξαρτάται από το πρόγραμμα εάν ένας συγκεκριμένος αριθμός
αντιπροσωπεύει μέτρα, μίλια ή μάζα. Τα αδαή αντικείμενα είναι εύκολο
να κατανοηθούν και να χρησιμοποιηθούν, με κόστος την αγνόηση ορισμένων
πτυχών της πραγματικότητας.

For applications requiring aware objects, "datetime" and "time"
objects have an optional time zone information attribute, "tzinfo",
that can be set to an instance of a subclass of the abstract "tzinfo"
class. These "tzinfo" objects capture information about the offset
from UTC time, the time zone name, and whether daylight saving time is
in effect.

Μόνο μία συγκεκριμένη κλάση "tzinfo", η κλάση "timezone", παρέχεται
από το "datetime" module. Η κλάση "timezone" μπορεί να αντιπροσωπεύει
απλές ζώνες ώρας με σταθερές αποκλίσεις από την UTC, όπως η ίδια η UTC
ή οι ζώνες ώρας EST και EDT της Βόρειας Αμερικής. Η υποστήριξη ζωνών
ώρας σε βαθύτερα επίπεδα λεπτομέρειας είναι ευθύνη της εφαρμογής. Οι
κανόνες για την προσαρμογή του χρόνου σε όλο τον κόσμο είναι
περισσότερο πολιτικοί παρά λογικοί, αλλάζουν συχνά και δεν υπάρχει
πρότυπο κατάλληλο για κάθε εφαρμογή εκτός από την UTC.


Σταθερές
========

Το "datetime" module εξάγει τις παρακάτω σταθερές:

datetime.MINYEAR

   Ο μικρότερος αριθμός έτους που επιτρέπεται σε ένα αντικείμενο
   "date" ή "datetime". Το "MINYEAR" είναι 1.

datetime.MAXYEAR

   Ο μεγαλύτερος αριθμός έτους που επιτρέπεται σε ένα αντικείμενο
   "date" ή "datetime". Το "MAXYEAR" είναι 9999.

datetime.UTC

   Ψευδώνυμο για το μοναδικό αντικείμενο ζώνης ώρας UTC
   "datetime.timezone.utc".

   Added in version 3.11.


Available types
===============

class datetime.date

   Μια ιδανική αδαής ημερομηνία, υποθέτοντας ότι το τρέχον Γρηγοριανό
   ημερολόγιο ήταν πάντα σε ισχύ και θα είναι πάντα σε ισχύ.
   Χαρακτηριστικά: "year", "month" και "day".

class datetime.time

   Μια ιδανική ώρα, ανεξάρτητη από οποιαδήποτε συγκεκριμένη ημέρα,
   υποθέτοντας ότι κάθε ημέρα έχει ακριβώς 24*60*60 δευτερόλεπτα. (Δεν
   υπάρχει έννοια "δευτερόλεπτα διακοπής" εδώ.) Χαρακτηριστικά:
   "hour", "minute", "second", "microsecond", και "tzinfo".

class datetime.datetime

   Μια συνδυασμένη ημερομηνία και ώρα. Χαρακτηριστικά: "year",
   "month", "day", "hour", "minute", "second", "microsecond", και
   "tzinfo".

class datetime.timedelta

   Μια διάρκεια που εκφράζει τη διαφορά μεταξύ δύο στιγμιοτύπων
   "datetime" ή "date" με ακρίβεια μικροδευτερολέπτου.

class datetime.tzinfo

   Μια αφηρημένη κλάση βάσης για αντικείμενα πληροφοριών ζώνης ώρας.
   Αυτά χρησιμοποιούνται από τις κλάσεις "datetime" και "time" για να
   παρέχουν μια προσαρμόσιμη έννοια προσαρμογής χρόνου (για
   παράδειγμα, για να ληφθούν υπόψη η ζώνη ώρας και/ή η θερινή ώρα).

class datetime.timezone

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

   Added in version 3.2.

Αντικείμενα αυτών των τύπων είναι αμετάβλητα.

Subclass relationships:

   [εικόνα: timedelta, tzinfo, time, and date inherit from object;
   timezone inherits from tzinfo; and datetime inherits from
   date.][εικόνα]


Common properties
-----------------

Οι "date", "datetime", "time" και "timezone" τύποι έχουν κάποια κοινά
χαρακτηριστικά:

* Αντικείμενα αυτών των τύπων είναι αμετάβλητα.

* Αντικείμενα αυτών των τύπων είναι *hashable*, πράγμα που σημαίνει
  ότι μπορούν να χρησιμοποιηθούν ως κλειδιά λεξικού.

* Αντικείμενα αυτών των τύπων υποστηρίζουν αποδοτικό pickling μέσω του
  module "pickle".


Determining if an object is aware or naive
------------------------------------------

Αντικείμενα της κλάσης "date" είναι πάντα αδαή.

Ένα αντικείμενο της "time" ή "datetime" μπορεί να είναι ενήμερο ή
αδαές.

Ένα αντικείμενα της κλάσης "datetime" "d" είναι ενήμερο αν ισχύουν και
τα δύο παρακάτω:

1. το "d.tzinfo" δεν είναι "None"

2. το "d.tzinfo.utcoffset(d)" δεν επιστρέφει "None"

Διαφορετικά, το "d" είναι αδαές.

Ένα αντικείμενο "time" "t" είναι ενήμερο αν ισχύουν και τα δύο
παρακάτω:

1. το "t.tzinfo" δεν είναι "None"

2. το "t.tzinfo.utcoffset(None)" δεν επιστρέφει "None".

Διαφορετικά, το "t" είναι αδαές.

Ο διαχωρισμός μεταξύ ενήμερων και αδαών δεν ισχύει για τα αντικείμενα
"timedelta".


"timedelta" objects
===================

Ένα αντικείμενο "timedelta" αντιπροσωπεύει μια διάρκεια, τη διαφορά
μεταξύ δύο στιγμιοτύπων "datetime" ή "date".

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

   Όλα τα ορίσματα είναι προαιρετικά και με προεπιλογή 0. Τα ορίσματα
   μπορεί να είναι ακέραιοι ή αριθμοί κινητής υποδιαστολής, και μπορεί
   να είναι θετικά ή αρνητικά.

   Μόνο τα *days*, *seconds* και *microseconds* αποθηκεύονται
   εσωτερικά. Τα ορίσματα μετατρέπονται σε αυτές τις μονάδες:

   * Ένα χιλιοστό του δευτερολέπτου μετατρέπεται σε 1000
     μικροδευτερόλεπτα.

   * Ένα λεπτό μετατρέπεται σε 60 δευτερόλεπτα.

   * Μια ώρα μετατρέπεται σε 3600 δευτερόλεπτα.

   * Μια εβδομάδα μετατρέπεται σε 7 ημέρες.

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

   * "0 <= microseconds < 1000000"

   * "0 <= seconds < 3600*24" (ο αριθμός των δευτερολέπτων σε μια
     μέρα)

   * "-999999999 <= days <= 999999999"

   Το παρακάτω παράδειγμα δείχνει πώς οποιαδήποτε ορίσματα εκτός από
   τα *days*, *seconds* και *microseconds* "συγχωνεύονται" και
   κανονικοποιούνται σε αυτά τα τρία τελικά γνωρίσματα:

      >>> import datetime as dt
      >>> delta = dt.timedelta(
      ...     days=50,
      ...     seconds=27,
      ...     microseconds=10,
      ...     milliseconds=29000,
      ...     minutes=5,
      ...     hours=8,
      ...     weeks=2
      ... )
      >>> # Only days, seconds, and microseconds remain
      >>> delta
      datetime.timedelta(days=64, seconds=29156, microseconds=10)

   Πρακτική συμβουλή:

     "import datetime as dt" instead of "import datetime" or "from
     datetime import datetime" to avoid confusion between the module
     and the class. See How I Import Python’s datetime Module.

   Εάν κάποιο από τα ορίσματα είναι αριθμός κινητής υποδιαστολής και
   υπάρχουν δεκαδικά μικροδευτερόλεπτα, τα δεκαδικά μικροδευτερόλεπτα
   που απομένουν από όλα τα ορίσματα συνδυάζονται και το άθροισμά τους
   στρογγυλοποιείται στο πλησιέστερο μικροδευτερόλεπτο χρησιμοποιώντας
   τον κανόνα σπασίματος ισοπαλίας (round-half-to-even). Εάν κανένα
   από τα ορίσματα δεν είναι αριθμός κινητής υποδιαστολής, οι πράξεις
   μετατροπής και κανονικοποίησης είναι ακριβείς (δεν χάνεται
   πληροφορία).

   Εάν η κανονικοποιημένη τιμή των ημερών βρίσκεται εκτός του
   καθορισμένου εύρους, γίνεται raise η "OverflowError".

   Σημειώστε ότι η κανονικοποίηση των αρνητικών τιμών μπορεί να είναι
   απροσδόκητη στην αρχή. Για παράδειγμα:

      >>> import datetime as dt
      >>> d = dt.timedelta(microseconds=-1)
      >>> (d.days, d.seconds, d.microseconds)
      (-1, 86399, 999999)

   Δεδομένου ότι η συμβολοσειρά αναπαράστασης των αντικειμένων
   "timedelta" μπορεί να είναι μπερδευτική, χρησιμοποιήστε την
   παρακάτω συνταγή για να παραγάγετε μια πιο αναγνώσιμη μορφή:

      >>> def pretty_timedelta(td):
      ...     if td.days >= 0:
      ...         return str(td)
      ...     return f'-({-td!s})'
      ...
      >>> d = timedelta(hours=-1)
      >>> str(d)  # not human-friendly
      '-1 day, 23:00:00'
      >>> pretty_timedelta(d)
      '-(1:00:00)'

Χαρακτηριστικά Κλάσης:

timedelta.min

   Το πιο αρνητικό αντικείμενο της "timedelta",
   "timedelta(-999999999)".

timedelta.max

   Το πιο θετικό αντικείμενο της "timedelta",
   "timedelta(days=999999999, hours=23, minutes=59, seconds=59,
   microseconds=999999)".

timedelta.resolution

   Η μικρότερη δυνατή διαφορά μεταξύ μη ίσων αντικειμένων "timedelta",
   "timedelta(microseconds=1)".

Σημειώστε ότι, λόγω της κανονικοποίησης, το "timedelta.max``είναι
μεγαλύτερο από το ``-timedelta.min". Το "-timedelta.max" δεν μπορεί να
αναπαρασταθεί ως ένα αντικείμενο "timedelta".

Χαρακτηριστικά στιγμιοτύπου (μόνο για ανάγνωση):

timedelta.days

   Μεταξύ -999,999,999 και 999,999,999 συμπεριλαμβανομένου.

timedelta.seconds

   Μεταξύ 0 και 86,399 συμπεριλαμβανομένου.

   Προσοχή:

     Είναι ένα σχετικά συνηθισμένο σφάλμα ο κώδικας να χρησιμοποιεί
     κατά λάθος αυτό το χαρακτηριστικό, όταν στην πραγματικότητα
     προορίζεται να πάρει την τιμή της "total_seconds()":

        >>> import datetime as dt
        >>> duration = dt.timedelta(seconds=11235813)
        >>> duration.days, duration.seconds
        (130, 3813)
        >>> duration.total_seconds()
        11235813.0

timedelta.microseconds

   Μεταξύ 0 και 999,999 συμπεριλαμβανομένου.

Υποστηριζόμενες πράξεις:

+----------------------------------+-------------------------------------------------+
| Πράξη                            | Αποτέλεσμα                                      |
|==================================|=================================================|
| "t1 = t2 + t3"                   | Το άθροισμα των "t2" και "t3". Στη συνέχεια το  |
|                                  | "t1 - t2 == t3" και το "t1 - t3 == t2" είναι    |
|                                  | αληθή. (1)                                      |
+----------------------------------+-------------------------------------------------+
| "t1 = t2 - t3"                   | Η διαφορά του "t2" και "t3". Στη συνέχεια το    |
|                                  | "t1 == t2 - t3" και "t2 == t1 + t3" είναι       |
|                                  | αληθή. (1)(6)                                   |
+----------------------------------+-------------------------------------------------+
| "t1 = t2 * i or t1 = i * t2"     | Πολλαπλασιασμός του διαστήματος με έναν         |
|                                  | ακέραιο. Στη συνέχεια το "t1 // i == t2" είναι  |
|                                  | αληθή, εφόσον "i != 0".                         |
+----------------------------------+-------------------------------------------------+
|                                  | Γενικά, το "t1  * i == t1 * (i-1) + t1" είναι   |
|                                  | αληθές. (1)                                     |
+----------------------------------+-------------------------------------------------+
| "t1 = t2 * f or t1 = f * t2"     | Πολλαπλασιασμός του διαστήματος με έναν αριθμό  |
|                                  | κινητής υποδιαστολής. Το αποτέλεσμα             |
|                                  | στρογγυλοποιείται στο πλησιέστερο πολλαπλάσιο   |
|                                  | της timedelta.resolution χρησιμοποιώντας τον    |
|                                  | κανόνα σπασίματος ισοπαλίας "round-half-to-     |
|                                  | even".                                          |
+----------------------------------+-------------------------------------------------+
| "f = t2 / t3"                    | Διαίρεση (3) της συνολικής διάρκειας "t2" με τη |
|                                  | μονάδα διαστήματος "t3". Επιστρέφει ένα "float" |
|                                  | αντικείμενο.                                    |
+----------------------------------+-------------------------------------------------+
| "t1 = t2 / f or t1 = t2 / i"     | Διαίρεση του διαστήματος με έναν αριθμό κινητής |
|                                  | υποδιαστολής ή έναν ακέραιο. Το αποτέλεσμα θα   |
|                                  | στρογγυλοποιηθεί στο πλησιέστερο πολλαπλάσιο    |
|                                  | της timedelta.resolution χρησιμοποιώντας τον    |
|                                  | κανόνα σπασίματος ισοπαλίας "round-half-to-     |
|                                  | even".                                          |
+----------------------------------+-------------------------------------------------+
| "t1 = t2 // i" or "t1 = t2 //    | Η ακέραια διαίρεση υπολογίζεται και το υπόλοιπο |
| t3"                              | (εάν υπάρχει) παραλείπεται. Στην δεύτερη        |
|                                  | περίπτωση, ένα ακέραιος επιστρέφεται. (3)       |
+----------------------------------+-------------------------------------------------+
| "t1 = t2 % t3"                   | Το υπόλοιπο υπολογίζεται ως ένα "timedelta"     |
|                                  | αντικείμενο. (3)                                |
+----------------------------------+-------------------------------------------------+
| "q, r = divmod(t1, t2)"          | Υπολογίζει το πηλίκο και το υπόλοιπο: "q = t1   |
|                                  | // t2" (3) και "r = t1 % t2". Το "q" είναι ένας |
|                                  | ακέραιος και το "r" είναι ένα "timedelta"       |
|                                  | αντικείμενο.                                    |
+----------------------------------+-------------------------------------------------+
| "+t1"                            | Επιστρέφει ένα "timedelta" αντικείμενο με την   |
|                                  | ίδια τιμή. (2)                                  |
+----------------------------------+-------------------------------------------------+
| "-t1"                            | Ισοδύναμο με "timedelta(-t1.days, -t1.seconds,  |
|                                  | -t1.microseconds)", και με "t1 * -1". (1)(4)    |
+----------------------------------+-------------------------------------------------+
| "abs(t)"                         | Ισοδύναμο με "+t" όταν "t.days >= 0" και με     |
|                                  | "-t" όταν "t.days < 0". (2)                     |
+----------------------------------+-------------------------------------------------+
| "str(t)"                         | Επιστρέφει μια συμβολοσειρά στη μορφή "[D       |
|                                  | day[s], ][H]H:MM:SS[.UUUUUU]", όπου το D είναι  |
|                                  | αρνητικό για αρνητικό "t". (5)                  |
+----------------------------------+-------------------------------------------------+
| "repr(t)"                        | Επιστρέφει μια συμβολοσειρά αναπαράστασης του   |
|                                  | "timedelta" αντικειμένου ως μια κλήση           |
|                                  | κατασκευαστή με κανονικές τιμές                 |
|                                  | χαρακτηριστικών.                                |
+----------------------------------+-------------------------------------------------+

Σημειώσεις:

1. Αυτό είναι ακριβές αλλά μπορεί να υπερχειλίσει.

2. Αυτό είναι ακριβές και δεν μπορεί να υπερχειλίσει.

3. Η διαίρεση με το μηδέν κάνει raise "ZeroDivisionError".

4. Το "-timedelta.max" δεν μπορεί να αναπαρασταθεί ως ένα "timedelta"
   αντικείμενο.

5. Οι αναπαραστάσεις συμβολοσειράς "timedelta" αντικειμένων είναι
   κανονικοποιημένες παρόμοια με την εσωτερική τους αναπαράσταση. Αυτό
   οδηγεί κάπως σε ασυνήθη αποτελέσματα για αρνητικά timedeltas. Για
   παράδειγμα:

      >>> timedelta(hours=-5)
      datetime.timedelta(days=-1, seconds=68400)
      >>> print(_)
      -1 day, 19:00:00

6. Η έκφραση "t2 - t3" θα είναι συνέχεια ίση με την έκφραση "t2 +
   (-t3)" εκτός όταν το t3 είναι ίσο με "timedelta.max" ∙ σε αυτή τη
   περίπτωση το πρώτο θα παράγει ένα αποτέλεσμα ενώ το δεύτερο θα
   υπερχειλίσει.

Εκτός από τις παραπάνω λειτουργίες, τα αντικείμενα "timedelta"
υποστηρίζουν ορισμένες προσθέσεις και αφαιρέσεις με αντικείμενα "date"
και "datetime" (δείτε παρακάτω).

Άλλαξε στην έκδοση 3.2: Floor division and true division of a
"timedelta" object by another "timedelta" object are now supported, as
are remainder operations and the "divmod()" function. True division
and multiplication of a "timedelta" object by a "float" object are now
supported.

Τα αντικείμενα "timedelta" υποστηρίζουν συγκρίσεις ισότητας και
διάταξης.

Σε Boolean συμφραζόμενα, ένα αντικείμενο "timedelta" θεωρείται αληθές
μόνο αν δεν είναι ίσο με "timedelta(0)".

Μέθοδοι στιγμιοτύπου:

timedelta.total_seconds()

   Return the total number of seconds contained in the duration.
   Equivalent to "td / timedelta(seconds=1)". For interval units other
   than seconds, use the division form directly (for example, "td /
   timedelta(microseconds=1)").

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

   Added in version 3.2.


Examples of usage: "timedelta"
------------------------------

Ένα επιπλέον παράδειγμα κανονικοποίησης:

   >>> # Components of another_year add up to exactly 365 days
   >>> import datetime as dt
   >>> year = dt.timedelta(days=365)
   >>> another_year = dt.timedelta(weeks=40, days=84, hours=23,
   ...                             minutes=50, seconds=600)
   >>> year == another_year
   True
   >>> year.total_seconds()
   31536000.0

Παραδείγματα αριθμητικών πράξεων με "timedelta":

   >>> import datetime as dt
   >>> year = dt.timedelta(days=365)
   >>> ten_years = 10 * year
   >>> ten_years
   datetime.timedelta(days=3650)
   >>> ten_years.days // 365
   10
   >>> nine_years = ten_years - year
   >>> nine_years
   datetime.timedelta(days=3285)
   >>> three_years = nine_years // 3
   >>> three_years, three_years.days // 365
   (datetime.timedelta(days=1095), 3)


"date" objects
==============

Ένα αντικείμενο "date" αναπαριστά μια ημερομηνία (έτος, μήνα και
ημέρα) σε ένα ιδεατό ημερολόγιο, το τρέχον Γρηγοριανό ημερολόγιο
επεκτεταμένο επ' αόριστον και προς τις δύο κατευθύνσεις.

Η 1η Ιανουαρίου του 1ου έτους ονομάζεται ημέρα 1, η 2α Ιανουαρίου του
1ου έτους ονομάζεται ημέρα 2, και ούτω καθεξής. [2]

class datetime.date(year, month, day)

   Όλα τα ορίσματα είναι υποχρεωτικά. Τα ορίσματα πρέπει να είναι
   ακέραιοι αριθμοί, στα παρακάτω εύρη:

   * "MINYEAR <= year <= MAXYEAR"

   * "1 <= month <= 12"

   * "1 <= day <= number of days in the given month and year"

   Εάν ένα όρισμα εκτός αυτών των ευρών δοθεί, γίνεται raise
   "ValueError".

Άλλοι κατασκευαστές, όλες οι μέθοδοι της κλάσης:

classmethod date.today()

   Επιστρέφει την τρέχουσα τοπική ημερομηνία.

   Αυτό είναι ισοδύναμο με "date.fromtimestamp(time.time())".

classmethod date.fromtimestamp(timestamp)

   Return the local date corresponding to the POSIX *timestamp*, such
   as is returned by "time.time()".

   Αυτό μπορεί να κάνει raise "OverflowError", εάν το timestamp είναι
   εκτός του εύρους τιμών που υποστηρίζει η συνάρτηση "localtime()"
   της πλατφόρμας C, καθώς και "OSError" σε περίπτωση αποτυχίας της
   "localtime()". Είναι κοινό αυτό να περιορίζεται σε έτη από το 1970
   έως το 2038. Σημειώστε ότι σε μη POSIX συστήματα που περιλαμβάνουν
   δευτερόλεπτα διαλείμματος στην έννοια τους για ένα timestamp, τα
   δευτερόλεπτα διαλείμματος αγνοούνται από την "fromtimestamp()".

   Άλλαξε στην έκδοση 3.3: Κάνει raise "OverflowError" αντί για
   "ValueError" εάν το timestamp είναι εκτός του εύρους τιμών που
   υποστηρίζει η συνάρτηση "localtime()" της πλατφόρμας C. Κάνει raise
   "OSError" αντί για "ValueError" σε περίπτωση αποτυχίας της
   "localtime()".

   Άλλαξε στην έκδοση 3.15: Accepts any real number as *timestamp*,
   not only integer or float.

classmethod date.fromordinal(ordinal)

   Return the date corresponding to the proleptic Gregorian *ordinal*,
   where January 1 of year 1 has ordinal 1.

   Γίνεται raise η "ValueError" εκτός εάν "1 <= ordinal <=
   date.max.toordinal()". Για οποιαδήποτε ημέρα "d",
   "date.fromordinal(d.toordinal()) == d".

classmethod date.fromisoformat(date_string)

   Επιστρέφει ένα αντικείμενο "date" που αντιστοιχεί σε ένα
   *date_string* δοσμένο σε οποιαδήποτε έγκυρη μορφή ISO 8601, με τις
   εξής εξαιρέσεις:

   1. Οι ημερομηνίες μειωμένης ακρίβειας δεν υποστηρίζονται προς το
      παρόν ("YYYY-MM", "YYYY").

   2. Οι εκτεταμένες αναπαραστάσεις ημερομηνίας δεν υποστηρίζονται
      προς το παρόν ("±YYYYYY-MM-DD").

   3. Οι διατακτικές ημερομηνίες δεν υποστηρίζονται προς το παρόν
      ("YYYY-OOO").

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

      >>> import datetime as dt
      >>> dt.date.fromisoformat('2019-12-04')
      datetime.date(2019, 12, 4)
      >>> dt.date.fromisoformat('20191204')
      datetime.date(2019, 12, 4)
      >>> dt.date.fromisoformat('2021-W01-1')
      datetime.date(2021, 1, 4)

   Added in version 3.7.

   Άλλαξε στην έκδοση 3.11: Προηγουμένως, αυτή η μέθοδος υποστήριζε
   μόνο τη μορφή "YYYY-MM-DD".

classmethod date.fromisocalendar(year, week, day)

   Return a "date" corresponding to the ISO calendar date specified by
   *year*, *week* and *day*. This is the inverse of the function
   "date.isocalendar()".

   Added in version 3.8.

classmethod date.strptime(date_string, format)

   Επιστρέφει ένα αντικείμενο "date" που αντιστοιχεί σε *date_string*,
   αναλυμένο σύμφωνα με το *format*. Αυτό είναι ισοδύναμο με:

      date(*(time.strptime(date_string, format)[0:3]))

   Η "ValueError" γίνεται raise εάν το date_string και το format δεν
   μπορούν να αναλυθούν από την "time.strptime()" ή εάν επιστρέφει μια
   τιμή που δεν είναι τουλάχιστον μια πλειάδα χρόνου. Δείτε επίσης τα
   strftime() and strptime() behavior και "date.fromisoformat()".

   Σημείωση:

     If *format* specifies a day of month ("%d") without a year,
     "ValueError" is raised.  This is to avoid a quadrennial leap year
     bug in code seeking to parse only a month and day as the default
     year used in absence of one in the format is not a leap year. The
     workaround is to always include a year in your *format*.  If
     parsing *date_string* values that do not have a year, explicitly
     add a year that is a leap year before parsing:

        >>> import datetime as dt
        >>> date_string = "02/29"
        >>> when = dt.date.strptime(f"{date_string};1984", "%m/%d;%Y")  # Avoids leap year bug.
        >>> when.strftime("%B %d")
        'February 29'

   Added in version 3.14.

Χαρακτηριστικά Κλάσης:

date.min

   Το νωρίτερο αναπαραστάσιμο έτος, "date(MINYEAR, 1, 1)".

date.max

   Το πιο πρόσφατο αναπαραστάσιμο έτος, "date(MAXYEAR, 12, 31)".

date.resolution

   Η μικρότερη δυνατή διαφορά μεταξύ μη-ίσων αντικειμένων ημέρας,
   "timedelta(days=1)".

Χαρακτηριστικά στιγμιοτύπου (μόνο για ανάγνωση):

date.year

   Μεταξύ "MINYEAR" και "MAXYEAR" συμπεριλαμβανομένων.

date.month

   Μεταξύ 1 και 12 συμπεριλαμβανομένων.

date.day

   Μεταξύ 1 και του αριθμού των ημερών στον δεδομένο μήνα του
   δεδομένου έτους.

Υποστηριζόμενες πράξεις:

+---------------------------------+------------------------------------------------+
| Πράξη                           | Αποτέλεσμα                                     |
|=================================|================================================|
| "date2 = date1 + timedelta"     | Το "date2" θα είναι "timedelta.days" ημέρες    |
|                                 | μετά το "date1". (1)                           |
+---------------------------------+------------------------------------------------+
| "date2 = date1 - timedelta"     | Υπολογίζει το "date2" έτσι ώστε "date2 +       |
|                                 | timedelta == date1". (2)                       |
+---------------------------------+------------------------------------------------+
| "timedelta = date1 - date2"     | (3)                                            |
+---------------------------------+------------------------------------------------+
| "date1 == date2" "date1 !=      | Σύγκριση ισότητας. (4)                         |
| date2"                          |                                                |
+---------------------------------+------------------------------------------------+
| "date1 < date2" "date1 > date2" | Σύγκριση σειράς. (5)                           |
| "date1 <= date2" "date1 >=      |                                                |
| date2"                          |                                                |
+---------------------------------+------------------------------------------------+

Σημειώσεις:

1. Το *date2* μετακινείται προς τα εμπρός στο χρόνο εάν
   "timedelta.days > 0", ή προς τα πίσω εάν "timedelta.days < 0".
   Έπειτα "date2 - date1 == timedelta.days". Τα "timedelta.seconds"
   και "timedelta.microseconds" αγνοούνται. Η "OverflowError" γίνεται
   raise εάν το "date2.year" θα ήταν μικρότερο από "MINYEAR" ή
   μεγαλύτερο από "MAXYEAR".

2. τα "timedelta.seconds" και "timedelta.microseconds" αγνοούνται.

3. Αυτό είναι ακριβές και δεν μπορεί να υπερχειλίσει. Τα
   "timedelta.seconds" και "timedelta.microseconds" είναι 0, και
   "date2 + timedelta == date1" μετά.

4. Τα "date" αντικείμενα είναι ίσα εάν αναπαριστούν την ίδια
   ημερομηνία.

   Τα "date" αντικείμενα που δεν είναι επίσης "datetime" στιγμιότυπα
   δεν είναι ποτέ ίσα με "datetime" αντικείμενα, ακόμη και αν
   αναπαριστούν την ίδια ημερομηνία.

5. Το *date1* θεωρείται μικρότερο από το *date2* όταν το *date1*
   προηγείται του *date2* στο χρόνο. Με άλλα λόγια, "date1 < date2" αν
   και μόνο αν "date1.toordinal() < date2.toordinal()".

   Order comparison between a "date" object that is not also a
   "datetime" instance and a "datetime" object raises "TypeError".

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

Στα Boolean περιεχόμενα, όλα τα αντικείμενα "date" θεωρούνται αληθή.

Μέθοδοι στιγμιοτύπου:

date.replace(year=self.year, month=self.month, day=self.day)

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

   Παράδειγμα:

      >>> import datetime as dt
      >>> d = dt.date(2002, 12, 31)
      >>> d.replace(day=26)
      datetime.date(2002, 12, 26)

   Η γενική συνάρτηση "copy.replace()" υποστηρίζει επίσης τα "date"
   αντικείμενα.

date.timetuple()

   Επιστρέφει μια "time.struct_time" όπως επιστρέφεται από την
   "time.localtime()".

   Οι ώρες, τα λεπτά και τα δευτερόλεπτα είναι 0, και το DST flag
   είναι -1.

   Το "d.timetuple()" είναι ισοδύναμο με:

      time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))

   όπου "yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1"
   είναι ο αριθμός της ημέρας εντός του τρέχοντος έτους ξεκινώντας από
   1 για την 1η Ιανουαρίου.

date.toordinal()

   Επιστρέφει το προληπτικό Γρηγοριανό αριθμό της ημερομηνίας, όπου η
   1η Ιανουαρίου του 1ου έτους έχει αριθμό 1. Για οποιοδήποτε
   αντικείμενο "date" "d", "date.fromordinal(d.toordinal()) == d".

date.weekday()

   Επιστρέφει την ημέρα του έτους ως έναν ακέραιο, όπου η Δευτέρα
   είναι 0 και η Κυριακή είναι 6. Για παράδειγμα, "date(2002, 12,
   4).weekday() == 2", ως Τετάρτη. Δείτε επίσης "isoweekday()".

date.isoweekday()

   Επιστρέφει την ημέρα της εβδομάδα ως έναν ακέραιο, όπου η Δευτέρα
   είναι 1 και η Κυριακή είναι 7. Για παράδειγμα, "date(2002, 12,
   4).isoweekday() == 3", μια Τετάρτη. Δείτε επίσης "weekday()",
   "isocalendar()".

date.isocalendar()

   Επιστρέφει ένα αντικείμενο *named tuple* με τρία στοιχεία "year",
   "week" και "weekday".

   Το ημερολόγιο ISO είναι μια ευρέως χρησιμοποιούμενη εκδοχή τους
   Γρηγοριανού ημερολογίου. [3]

   Το ISO έτος αποτελείται από 52 ή 53 πλήρες εβδομάδες, όπου μια
   εβδομάδα ξεκινάει από την ημέρα Δευτέρα και τελειώνει με την ημέρα
   Κυριακή. Η πρώτη εβδομάδα ενός ISO έτους είναι η πρώτη (Γρηγοριανή)
   ημερολογιακή εβδομάδα ενός έτους που περιλαμβάνει μια Πέμπτη. Αυτό
   καλείται εβδομάδα νούμερο 1, και το ISO έτος αυτής της Πέμπτης
   είναι ίδιο με το Γρηγοριανό έτος.

   Για παράδειγμα, το 2004 ξεκινά με Πέμπτη, συνεπώς η πρώτη εβδομάδα
   του ISO έτους 2004 ξεκινάει τη Δευτέρα 29 Δεκεμβρίου 2003, και
   τελειώνει την Κυριακή, 4 Ιανουαρίου 2004:

      >>> import datetime as dt
      >>> dt.date(2003, 12, 29).isocalendar()
      datetime.IsoCalendarDate(year=2004, week=1, weekday=1)
      >>> dt.date(2004, 1, 4).isocalendar()
      datetime.IsoCalendarDate(year=2004, week=1, weekday=7)

   Άλλαξε στην έκδοση 3.9: Το αποτέλεσμα άλλαξε από μια πλειάδα σε ένα
   *named tuple*.

date.isoformat()

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ημέρα σε μορφή ISO
   8601, "YYYY-MM-DD":

      >>> import datetime as dt
      >>> dt.date(2002, 12, 4).isoformat()
      '2002-12-04'

date.__str__()

   Για μια ημέρα "d", το "str(d)" είναι ισοδύναμο με "d.isoformat()".

date.ctime()

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ημέρα:

      >>> import datetime as dt
      >>> dt.date(2002, 12, 4).ctime()
      'Wed Dec  4 00:00:00 2002'

   Το "d.ctime()" είναι ισοδύναμο με:

      time.ctime(time.mktime(d.timetuple()))

   σε πλατφόρμες όπου η εγγενής C "ctime()" συνάρτηση (την οποία καλεί
   η "time.ctime()", αλλά την οποία δεν καλεί η "date.ctime()")
   συμμορφώνεται με το πρότυπο C.

date.strftime(format)

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ημερομηνία,
   ελεγχόμενη από μια ρητή συμβολοσειρά μορφοποίησης. Οι κωδικοί
   μορφοποίησης που αναφέρονται σε ώρες, λεπτά ή δευτερόλεπτα θα
   εμφανίζουν τιμές 0. Δείτε επίσης τα strftime() and strptime()
   behavior και "date.isoformat()".

date.__format__(format)

   Ίδιο με τη μέθοδο "date.strftime()". Αυτό επιτρέπει να ορίσετε μια
   συμβολοσειρά μορφοποίησης για ένα αντικείμενο "date" σε
   μορφοποιημένες συμβολοσειρές και κατά τη χρήση της "str.format()".
   Δείτε επίσης τα strftime() and strptime() behavior και
   "date.isoformat()".


Examples of usage: "date"
-------------------------

Παράδειγμα μέτρησης ημερών για ένα γεγονός:

   >>> import time
   >>> import datetime as dt
   >>> today = dt.date.today()
   >>> today
   datetime.date(2007, 12, 5)
   >>> today == dt.date.fromtimestamp(time.time())
   True
   >>> my_birthday = dt.date(today.year, 6, 24)
   >>> if my_birthday < today:
   ...     my_birthday = my_birthday.replace(year=today.year + 1)
   ...
   >>> my_birthday
   datetime.date(2008, 6, 24)
   >>> time_to_birthday = abs(my_birthday - today)
   >>> time_to_birthday.days
   202

Περισσότερα παραδείγματα χρήσης της "date":

   >>> import datetime as dt
   >>> d = dt.date.fromordinal(730920) # 730920th day after 1. 1. 0001
   >>> d
   datetime.date(2002, 3, 11)

   >>> # Methods related to formatting string output
   >>> d.isoformat()
   '2002-03-11'
   >>> d.strftime("%d/%m/%y")
   '11/03/02'
   >>> d.strftime("%A %d. %B %Y")
   'Monday 11. March 2002'
   >>> d.ctime()
   'Mon Mar 11 00:00:00 2002'
   >>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
   'The day is 11, the month is March.'

   >>> # Methods for extracting 'components' under different calendars
   >>> t = d.timetuple()
   >>> for i in t:
   ...     print(i)
   2002                # year
   3                   # month
   11                  # day
   0
   0
   0
   0                   # weekday (0 = Monday)
   70                  # 70th day in the year
   -1
   >>> ic = d.isocalendar()
   >>> for i in ic:
   ...     print(i)
   2002                # ISO year
   11                  # ISO week number
   1                   # ISO day number ( 1 = Monday )

   >>> # A date object is immutable; all operations produce a new object
   >>> d.replace(year=2005)
   datetime.date(2005, 3, 11)


"datetime" objects
==================

Ένα αντικείμενο "datetime" είναι ένα ενιαίο αντικείμενο που περιέχει
όλες τις πληροφορίες ενός αντικειμένου "date" και ενός αντικειμένου
"time".

Like a "date" object, "datetime" assumes the current Gregorian
calendar extended in both directions; like a "time" object, "datetime"
assumes there are exactly 3600*24 seconds in every day.

Κατασκευαστής:

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

   Τα ορίσματα *year*, *month* και *day* είναι υποχρεωτικά. Το
   *tzinfo* μπορεί να είναι "None", ή ένα στιγμιότυπο μιας υποκλάσης
   "tzinfo". Οι υπόλοιπες παράμετροι θα πρέπει να είναι ακέραιοι στα
   παρακάτω εύρη:

   * "MINYEAR <= year <= MAXYEAR",

   * "1 <= month <= 12",

   * "1 <= day <= number of days in the given month and year",

   * "0 <= hour < 24",

   * "0 <= minute < 60",

   * "0 <= second < 60",

   * "0 <= microsecond < 1000000",

   * "fold in [0, 1]".

   Εάν ένα όρισμα εκτός αυτών των ευρών δοθεί, γίνεται raise
   "ValueError".

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

Άλλοι κατασκευαστές, όλες οι μέθοδοι της κλάσης:

classmethod datetime.today()

   Επιστρέφει την τρέχουσα τοπική ημερομηνία και ώρα, με "tzinfo"
   "None".

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

      datetime.fromtimestamp(time.time())

   Δείτε επίσης "now()", "fromtimestamp()".

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

classmethod datetime.now(tz=None)

   Επιστρέφει την τρέχουσα τοπική ημερομηνία και ώρα.

   Εάν το προαιρετικό όρισμα *tz* είναι "None" ή δεν έχει οριστεί,
   είναι σαν τη μέθοδο "today()", αλλά, αν είναι δυνατόν, παρέχει
   μεγαλύτερη ακρίβεια από αυτή που μπορεί να ληφθεί μέσω ενός
   timestamp από την "time.time()" (για παράδειγμα, αυτό μπορεί να
   είναι δυνατό σε πλατφόρμες που παρέχουν τη συνάρτηση
   "gettimeofday()" της C).

   Εάν το *tz* δεν είναι "None", θα πρέπει να είναι ένα στιγμιότυπο
   της υποκλάσης "tzinfo" και η τρέχουσα ημερομηνία και ώρα θα
   μετατραπούν στην ζώνη ώρας του *tz*.

   Αυτή η συνάρτηση προτιμάται έναντι των "today()" και "utcnow()".

   Σημείωση:

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

classmethod datetime.utcnow()

   Επιστρέφει την τρέχουσα UTC ημερομηνία και ώρα, με το "tzinfo"
   "None".

   Αυτό είναι σαν τη "now()", αλλά επιστρέφει την τρέχουσα ημερομηνία
   και ώρα UTC, ως ένα απλό αντικείμενο "datetime". Μια ενημερωμένη
   τρέχουσα ημερομηνία/ ώρα UTC μπορεί να ληφθεί καλώντας το
   "datetime.now(timezone.utc)". Δείτε επίσης την "now()".

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

     Επειδή τα αδαή αντικείμενα "datetime" αντιμετωπίζονται από πολλές
     μεθόδους "datetime" ως τοπικές ώρες, προτιμάται η χρήση ενήμερων
     datetimes για την αναπαράσταση των χρόνων σε UTC. Ως εκ τούτου, ο
     συνιστώμενος τρόπος για να δημιουργήσετε ένα αντικείμενο που
     αναπαριστά την τρέχουσα ώρα σε UTC είναι καλώντας το
     "datetime.now(timezone.utc)".

   Αποσύρθηκε στην έκδοση 3.12: Χρησιμοποιήστε την "datetime.now()" με
   "UTC" καλύτερα.

classmethod datetime.fromtimestamp(timestamp, tz=None)

   Επιστρέφει την τοπική ημερομηνία και ώρα που αντιστοιχεί στη
   χρονική σήμανση POSIX, όπως αυτή που επιστρέφεται από την
   "time.time()". Εάν το προαιρετικό όρισμα *tz* είναι "None" ή δεν
   έχει καθοριστεί, η χρονική σήμανση μετατρέπεται στην τοπική
   ημερομηνία και ώρα της πλατφόρμας και το αντικείμενο "datetime" που
   επιστρέφεται είναι αδαές.

   Εάν το *tz* δεν είναι "None", πρέπει να είναι μια παρουσία μιας
   υποκλάσης "tzinfo" και η χρονική σήμανση μετατρέπεται στη ζώνη ώρας
   του *tz*.

   Η "fromtimestamp()" μπορεί να κάνει raise μια "OverflowError", εάν
   η χρονική σήμανση είναι εκτός του εύρους τιμών που υποστηρίζονται
   από τις συναρτήσεις "localtime()" ή "gmtime()" της πλατφόρμας C,
   και το σφάλμα "OSError" σε περίπτωση σφάλματος "localtime()" ή
   "gmtime()". Είναι σύνηθες αυτό να περιορίζεται στα έτη από το 1970
   έως το 2038. Σημειώστε ότι σε συστήματα εκτός POSIX που
   περιλαμβάνουν δευτερόλεπτα άλματος στην έννοια της χρονικής
   σήμανσης, τα δευτερόλεπτα άλματος αγνοούνται από τη
   "fromtimestamp()", και στη συνέχεια είναι πιθανό να υπάρχουν δύο
   χρονικές σημάνσεις που διαφέρουν κατά ένα δευτερόλεπτο και
   αποδίδουν πανομοιότυπα αντικείμενα "datetime". Αυτή η μέθοδος
   προτιμάται έναντι της "utcfromtimestamp()".

   Άλλαξε στην έκδοση 3.3: Κάνει raise την "OverflowError" αντί για τη
   "ValueError" εάν η χρονική σήμανση είναι εκτός του εύρους τιμών που
   υποστηρίζονται από τις συναρτήσεις "localtime()" ή "gmtime()" της
   πλατφόρμας C. Κάνει raise την "OSError" αντί για τη "ValueError" σε
   περίπτωση σφάλματος των "localtime()" ή "gmtime()".

   Άλλαξε στην έκδοση 3.6: Η "fromtimestamp()" ενδέχεται να επιστρέψει
   στιγμιότυπα με το "fold" ορισμένο σε 1.

   Άλλαξε στην έκδοση 3.15: Accepts any real number as *timestamp*,
   not only integer or float.

classmethod datetime.utcfromtimestamp(timestamp)

   Επιστρέφει το UTC "datetime" που αντιστοιχεί στο POSIX timestamp,
   με το "tzinfo" "None".  (Το αντικείμενο που προκύπτει είναι αδαές.)

   Αυτό μπορεί να κάνει raise μια "OverflowError", εάν το timestamp
   βρίσκεται εκτός του εύρους τιμών που υποστηρίζεται από τη συνάρτηση
   "gmtime()" της πλατφόρμας C, και "OSError" σε περίπτωση αποτυχίας
   της "gmtime()". Είναι σύνηθες αυτό να περιορίζεται σε έτη από το
   1970 έως το 2038.

   Για να λάβετε ένα ενήμερο αντικείμενο "datetime", καλέστε την
   "fromtimestamp()":

      datetime.fromtimestamp(timestamp, timezone.utc)

   Σε πλατφόρμες συμβατές με POSIX, είναι ισοδύναμο με την ακόλουθη
   έκφραση:

      datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)

   εκτός από το ότι ο δεύτερος τύπος υποστηρίζει πάντα το πλήρες εύρος
   ετών: από το "MINYEAR" έως και το "MAXYEAR".

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

     Επειδή τα αδαή αντικείμενα "datetime" αντιμετωπίζονται από πολλές
     μεθόδους της "datetime" ως τοπικές ώρες, προτιμάται η χρήση
     ενήμερων αντικειμένων datetime για την αναπαράσταση χρόνων σε
     UTC. Ως εκ τούτου, ο προτεινόμενος τρόπος για τη δημιουργία ενός
     αντικειμένου που αναπαριστά μια συγκεκριμένη χρονική σήμανση σε
     UTC είναι η κλήση της "datetime.fromtimestamp(timestamp,
     tz=timezone.utc)".

   Άλλαξε στην έκδοση 3.3: Κάνει raise "OverflowError" αντί της
   "ValueError" εάν το timestamp είναι εκτός του εύρους τιμών που
   υποστηρίζεται από τη συνάρτηση "gmtime()" της πλατφόρμας C. Κάνει
   raise "OSError" αντί της "ValueError" σε περίπτωση αποτυχίας της
   "gmtime()".

   Άλλαξε στην έκδοση 3.15: Accepts any real number as *timestamp*,
   not only integer or float.

   Αποσύρθηκε στην έκδοση 3.12: Χρησιμοποιεί εναλλακτικά τη
   "datetime.fromtimestamp()" με το "UTC".

classmethod datetime.fromordinal(ordinal)

   Επιστέφει τη "datetime" που αντιστοιχεί στον προληπτικό Γρηγοριανό
   ταξινομητή, όπου η 1η Ιανουαρίου του 1ου έτους έχει ταξινομητή 1. Η
   "ValueError" γίνεται raise εκτός εάν "1 <= ordinal <=
   datetime.max.toordinal()". Η ώρα, το λεπτό, το δευτερόλεπτο και το
   μικροδευτερόλεπτο του αποτελέσματος είναι όλα 0, και το "tzinfo"
   είναι "None".

classmethod datetime.combine(date, time, tzinfo=time.tzinfo)

   Return a new "datetime" object whose date components are equal to
   the given "date" object's, and whose time components are equal to
   the given "time" object's. If the *tzinfo* argument is provided,
   its value is used to set the "tzinfo" attribute of the result,
   otherwise the "tzinfo" attribute of the *time* argument is used.
   If the *date* argument is a "datetime" object, its time components
   and "tzinfo" attributes are ignored.

   Για οποιοδήποτε αντικείμενο "datetime" "d", "d ==
   datetime.combine(d.date(), d.time(), d.tzinfo)".

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

classmethod datetime.fromisoformat(date_string)

   Επιστρέφει μια "datetime" που αντιστοιχεί σε μια *date_string* σε
   οποιαδήποτε έγκυρη μορφή ISO 8601, με τις εξής εξαιρέσεις:

   1. Οι αποκλίσεις ζώνης ώρας μπορεί να έχουν κλασματικά
      δευτερόλεπτα.

   2. Ο διαχωριστής "T" μπορεί να αντικατασταθεί από οποιονδήποτε μόνο
      χαρακτήρα unicode.

   3. Οι κλασματικές ώρες και λεπτά δεν υποστηρίζονται.

   4. Οι ημερομηνίες μειωμένης ακρίβειας δεν υποστηρίζονται προς το
      παρόν ("YYYY-MM", "YYYY").

   5. Οι εκτεταμένες αναπαραστάσεις ημερομηνίας δεν υποστηρίζονται
      προς το παρόν ("±YYYYYY-MM-DD").

   6. Οι διατακτικές ημερομηνίες δεν υποστηρίζονται προς το παρόν
      ("YYYY-OOO").

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

      >>> import datetime as dt
      >>> dt.datetime.fromisoformat('2011-11-04')
      datetime.datetime(2011, 11, 4, 0, 0)
      >>> dt.datetime.fromisoformat('20111104')
      datetime.datetime(2011, 11, 4, 0, 0)
      >>> dt.datetime.fromisoformat('2011-11-04T00:05:23')
      datetime.datetime(2011, 11, 4, 0, 5, 23)
      >>> dt.datetime.fromisoformat('2011-11-04T00:05:23Z')
      datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)
      >>> dt.datetime.fromisoformat('20111104T000523')
      datetime.datetime(2011, 11, 4, 0, 5, 23)
      >>> dt.datetime.fromisoformat('2011-W01-2T00:05:23.283')
      datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)
      >>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283')
      datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
      >>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')
      datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
      >>> dt.datetime.fromisoformat('2011-11-04T00:05:23+04:00')
      datetime.datetime(2011, 11, 4, 0, 5, 23,
          tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

   Added in version 3.7.

   Άλλαξε στην έκδοση 3.11: Προηγουμένως, αυτή η μέθοδος υποστήριζε
   μόνο μορφές που μπορούσαν να εκδοθούν από τις μεθόδους
   "date.isoformat()" ή "datetime.isoformat()".

classmethod datetime.fromisocalendar(year, week, day)

   Return a "datetime" corresponding to the ISO calendar date
   specified by *year*, *week* and *day*. The non-date components of
   the datetime are populated with their normal default values. This
   is the inverse of the function "datetime.isocalendar()".

   Added in version 3.8.

classmethod datetime.strptime(date_string, format)

   Επιστρέφει μια "datetime" που αντιστοιχεί στο *date_string*,
   αναλυμένο σύμφωνα με το *format*.

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

      datetime(*(time.strptime(date_string, format)[0:6]))

   Η "ValueError" γίνεται raise εάν το date_string και το format δεν
   μπορούν να αναλυθούν από τη "time.strptime()" ή αν αυτή επιστρέψει
   μια τιμή που δεν είναι χρονική πλειάδα. Δείτε επίσης strftime() and
   strptime() behavior και "datetime.fromisoformat()".

   Άλλαξε στην έκδοση 3.15: If *format* specifies a day of month
   ("%d") without a year, "ValueError" is raised.  This is to avoid a
   quadrennial leap year bug in code seeking to parse only a month and
   day as the default year used in absence of one in the format is not
   a leap year. The workaround is to always include a year in your
   *format*.  If parsing *date_string* values that do not have a year,
   explicitly add a year that is a leap year before parsing:

      >>> import datetime as dt
      >>> date_string = "02/29"
      >>> when = dt.datetime.strptime(f"{date_string};1984", "%m/%d;%Y")  # Avoids leap year bug.
      >>> when.strftime("%B %d")
      'February 29'

Χαρακτηριστικά Κλάσης:

datetime.min

   Η νωρίτερη αναπαραστάσιμη τιμή "datetime", "datetime(MINYEAR, 1, 1,
   tzinfo=None)".

datetime.max

   Η τελευταία αναπαραστάσιμη τιμή "datetime", "datetime(MAXYEAR, 12,
   31, 23, 59, 59, 999999, tzinfo=None)".

datetime.resolution

   Η μικρότερη δυνατή διαφορά μεταξύ μη ίσων αντικειμένων "datetime"
   objects, "timedelta(microseconds=1)".

Χαρακτηριστικά στιγμιοτύπου (μόνο για ανάγνωση):

datetime.year

   Μεταξύ "MINYEAR" και "MAXYEAR" συμπεριλαμβανομένων.

datetime.month

   Μεταξύ 1 και 12 συμπεριλαμβανομένων.

datetime.day

   Μεταξύ 1 και του αριθμού των ημερών στον δεδομένο μήνα του
   δεδομένου έτους.

datetime.hour

   Στο "range(24)".

datetime.minute

   Στο "range(60)".

datetime.second

   Στο "range(60)".

datetime.microsecond

   Στο "range(1000000)".

datetime.tzinfo

   Το αντικείμενο που δόθηκε ως όρισμα *tzinfo* στον κατασκευαστή
   "datetime" ή "None" αν δεν δόθηκε κανένα.

datetime.fold

   Στο "[0, 1]". Χρησιμοποιείται για την αποσαφήνιση των τοπικών ωρών
   σε επαναλαμβανόμενο διάστημα. (Ένα επαναλαμβανόμενο διάστημα
   συμβαίνει όταν τα ρολόγια γυρίζουν πίσω στο τέλος της θερινής ώρας
   ή όταν οι αποκλίσεις UTC για την τρέχουσα ζώνη μειώνεται για
   πολιτικούς λόγους.) Οι τιμές 0 και 1 αντιπροσωπεύουν, αντίστοιχα,
   την πρώτη και τη δεύτερη από τις δύο χρονικές στιγμές με την ίδια
   αναπαράσταση τοπικής ώρας.

   Added in version 3.6.

Υποστηριζόμενες πράξεις:

+-----------------------------------------+----------------------------------+
| Πράξη                                   | Αποτέλεσμα                       |
|=========================================|==================================|
| "datetime2 = datetime1 + timedelta"     | (1)                              |
+-----------------------------------------+----------------------------------+
| "datetime2 = datetime1 - timedelta"     | (2)                              |
+-----------------------------------------+----------------------------------+
| "timedelta = datetime1 - datetime2"     | (3)                              |
+-----------------------------------------+----------------------------------+
| "datetime1 == datetime2" "datetime1 !=  | Σύγκριση ισότητας. (4)           |
| datetime2"                              |                                  |
+-----------------------------------------+----------------------------------+
| "datetime1 < datetime2" "datetime1 >    | Σύγκριση σειράς. (5)             |
| datetime2" "datetime1 <= datetime2"     |                                  |
| "datetime1 >= datetime2"                |                                  |
+-----------------------------------------+----------------------------------+

1. Το "datetime2" είναι μια διάρκεια του "timedelta" που αφαιρείται
   από το "datetime1", μετακινώντας το προς τα εμπρός στο χρόνο εάν
   "timedelta.days > 0", ή προς τα πίσω εάν "timedelta.days < 0". Το
   αποτέλεσμα έχει το ίδιο "tzinfo" με το εισαγόμενο datetime, και
   "datetime2 - datetime1 == timedelta" μετά. Η "OverflowError"
   γίνεται raise εάν το "datetime2.year" είναι μικρότερο από το
   "MINYEAR" ή μεγαλύτερο από το "MAXYEAR". Σημειώστε ότι δεν γίνονται
   προσαρμογές ζώνης ώρας ακόμη και αν το εισαγόμενο αντικείμενο είναι
   ενήμερο.

2. Υπολογίζει το "datetime2" έτσι ώστε "datetime2 + timedelta ==
   datetime1". Όπως και για την πρόσθεση, το αποτέλεσμα έχει το ίδιο
   "tzinfo" με το εισαγόμενο datetime, και δεν γίνονται προσαρμογές
   ζώνης ώρας ακόμη και αν το εισαγόμενο αντικείμενο είναι ενήμερο.

3. Subtraction of a "datetime" from a "datetime" is defined only if
   both operands are naive, or if both are aware. If one is aware and
   the other is naive, "TypeError" is raised.

   Εάν και οι δύο είναι αδαείς, ή και οι δύο είναι ενήμεροι και έχουν
   το ίδιο "tzinfo" attribute, τα "tzinfo" αγνοούνται, και το
   αποτέλεσμα είναι ένα αντικείμενο "timedelta" "t" τέτοιο ώστε
   "datetime2 + t == datetime1". Σε αυτή την περίπτωση δεν γίνονται
   προσαρμογές ζώνης ώρας.

   Εάν και οι δύο είναι ενήμεροι και έχουν διαφορετικά χαρακτηριστικά
   "tzinfo", "a-b" ενεργεί σαν να είχαν πρώτα μετατραπεί σε αδαή UTC
   datetimes. Το αποτέλεσμα είναι "(a.replace(tzinfo=None) -
   a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())" με την
   εξαίρεση η υλοποίηση δεν υπερχειλίζει ποτέ.

4. Τα αντικείμενα "datetime" είναι ίσα εάν αναπαριστούν την ίδια
   ημερομηνία και ώρα, λαμβάνοντας υπόψη τη ζώνη ώρας.

   Naive and aware "datetime" objects are never equal.

   If both comparands are aware, and have the same "tzinfo" attribute,
   the "tzinfo" and "fold" attributes are ignored and the base
   datetimes are compared. If both comparands are aware and have
   different "tzinfo" attributes, the comparison acts as comparands
   were first converted to UTC datetimes except that the
   implementation never overflows. "datetime" instances in a repeated
   interval are never equal to "datetime" instances in other time
   zone.

5. Το *datetime1* θεωρείται μικρότερο από το *datetime2* όταν το
   *datetime1* προηγείται από το *datetime2* στο χρόνο, λαμβάνοντας
   υπόψη τη ζώνη ώρας.

   Η σύγκριση διάταξης μεταξύ αδαών και ενήμερων αντικειμένων
   "datetime" κάνει raise "TypeError".

   Εάν και οι δύο συγκρινόμενοι είναι ενήμεροι, και έχουν το ίδιο
   χαρακτηριστικό "tzinfo", τα χαρακτηριστικά "tzinfo" και "fold"
   αγνοούνται και η βασική ημερομηνία συγκρίνεται. Εάν και οι δύο
   συγκρινόμενοι είναι ενήμεροι και έχουν διαφορετικά χαρακτηριστικά
   "tzinfo", η σύγκριση ενεργεί σαν να είχαν πρώτα μετατραπεί σε αδαή
   UTC datetimes με την εξαίρεση ότι η υλοποίηση δεν υπερχειλίζει
   ποτέ.

Άλλαξε στην έκδοση 3.3: Οι συγκρίσεις ισότητας μεταξύ ενήμερων και
αδαών αντικειμένων "datetime" δεν κάνουν raise "TypeError".

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

Μέθοδοι στιγμιοτύπου:

datetime.date()

   Επιστρέφει αντικείμενο "date" με το ίδιο έτος, μήνα και ημέρα.

datetime.time()

   Επιστρέφει αντικείμενο "time" με την ίδια ώρα, λεπτό, δευτερόλεπτο,
   μικροδευτερόλεπτο και παραμόρφωση του χρόνου. Το "tzinfo" είναι
   "None". Δείτε επίσης τη μέθοδο "timetz()".

   Άλλαξε στην έκδοση 3.6: Η τιμή παραμόρφωσης αντιγράφεται στο
   επιστρεφόμενο αντικείμενο "time".

datetime.timetz()

   Επιστρέφει αντικείμενο "time" με την ίδια ώρα, λεπτό, δευτερόλεπτο,
   μικροδευτερόλεπτο, παραμόρφωση του χρόνου και χαρακτηριστικά
   tzinfo. Δείτε επίσης τη μέθοδο "time()".

   Άλλαξε στην έκδοση 3.6: Η τιμή παραμόρφωσης αντιγράφεται στο
   επιστρεφόμενο αντικείμενο "time".

datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

   Επιστρέφει ένα νέο αντικείμενο "datetime" με τα ίδια
   χαρακτηριστικά, αλλά με τις καθορισμένες παραμέτρους ενημερωμένες.
   Σημειώστε ότι μπορεί να καθοριστεί "tzinfo=None" για να
   δημιουργήσει ένα αδαές datetime από ένα ενήμερο datetime χωρίς
   μετατροπή των ημερομηνιών και των χρονικών δεδομένων.

   Τα αντικείμενα "datetime" υποστηρίζονται επίσης από τη γενική
   συνάρτηση "copy.replace()".

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

datetime.astimezone(tz=None)

   Επιστρέφει ένα αντικείμενο "datetime" με νέο χαρακτηριστικό
   "tzinfo" *tz*, προσαρμόζοντας τα ημερολογιακά και χρονικά δεδομένα
   έτσι ώστε το αποτέλεσμα να είναι η ίδια ώρα UTC όπως *self*, αλλά
   στην τοπική ώρα του *tz*.

   Εάν παρέχεται, το *tz* πρέπει να είναι ένα αντικείμενο της
   υποκλάσης "tzinfo", και οι μέθοδοι "utcoffset()" και "dst()" δεν
   πρέπει να επιστρέφουν "None". Εάν το *self* είναι αδαές, θεωρείται
   ότι αναπαριστά την ώρα στην τοπική ζώνη ώρας του συστήματος.

   Εάν κληθεί χωρίς ορίσματα (ή με "tz=None") θεωρείται ότι η τοπική
   ζώνη ώρας του συστήματος είναι η στόχος ζώνη ώρας. Το
   χαρακτηριστικό ".tzinfo" του μετατραπέντος αντικειμένου datetime θα
   οριστεί σε ένα αντικείμενο της κλάσης "timezone" με το όνομα ζώνης
   και την απόκλιση που αποκτήθηκαν από το λειτουργικό σύστημα.

   Εάν "self.tzinfo" είναι *tz*, τότε "self.astimezone(tz)" είναι ίσο
   με το *self*: χωρίς προσαρμογή των ημερομηνιών ή των χρονικών
   δεδομένων. Διαφορετικά, το αποτέλεσμα είναι η τοπική ώρα στη ζώνη
   ώρας *tz*, αναπαριστώντας την ίδια ώρα UTC όπως το *self*: μετά τα
   "astz = dt.astimezone(tz)", "astz - astz.utcoffset()" θα έχουν τα
   ίδια ημερομηνιακά και χρονικά δεδομένα όπως το "dt -
   dt.utcoffset()".

   Εάν απλώς θέλετε να επισυνάψετε ένα αντικείμενο "timezone" *tz* σε
   ένα datetime *dt* χωρίς προσαρμογή των ημερομηνιών και των χρονικών
   δεδομένων, χρησιμοποιήστε "dt.replace(tzinfo=tz)". Εάν απλώς θέλετε
   να αφαιρέσετε το αντικείμενο "timezone" από ένα ενήμερο datetime
   *dt* χωρίς μετατροπή των ημερομηνιών και των χρονικών δεδομένων,
   χρησιμοποιήστε "dt.replace(tzinfo=None)".

   Σημειώστε ότι η προεπιλεγμένη μέθοδος "tzinfo.fromutc()" μπορεί να
   υπερκαλύπτεται σε μια υποκλάση "tzinfo" για να επηρεάσει το
   αποτέλεσμα που επιστρέφεται από τη μέθοδο "astimezone()". Αγνοώντας
   περιπτώσεις σφάλματος, η "astimezone()" λειτουργεί όπως:

      def astimezone(self, tz):
          if self.tzinfo is tz:
              return self
          # Convert self to UTC, and attach the new timezone object.
          utc = (self - self.utcoffset()).replace(tzinfo=tz)
          # Convert from UTC to tz's local time.
          return tz.fromutc(utc)

   Άλλαξε στην έκδοση 3.3: Το *tz* μπορεί τώρα να παραλειφθεί.

   Άλλαξε στην έκδοση 3.6: Η μέθοδος "astimezone()" μπορεί τώρα να
   κληθεί σε αδαή αντικείμενα που θεωρούνται ότι αναπαριστούν την
   τοπική ώρα του συστήματος.

datetime.utcoffset()

   Εάν το "tzinfo" είναι "None", επιστρέφει "None", αλλιώς επιστρέφει
   "self.tzinfo.utcoffset(self)" και κάνει raise μια εξαίρεση εάν το
   τελευταίο δεν επιστρέφει "None" ή ένα αντικείμενο "timedelta" με
   μέγεθος μικρότερο από μια ημέρα.

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

datetime.dst()

   Εάν το "tzinfo" είναι "None", επιστρέφει "None", αλλιώς επιστρέφει
   "self.tzinfo.dst(self)" και κάνει raise μια εξαίρεση εάν το
   τελευταίο δεν επιστρέφει "None" ή ένα αντικείμενο "timedelta" με
   μέγεθος μικρότερο από μια ημέρα.

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

datetime.tzname()

   Εάν το "tzinfo" είναι "None", επιστρέφει "None", αλλιώς επιστρέφει
   "self.tzinfo.tzname(self)", κάνει raise μια εξαίρεση εάν το
   τελευταίο δεν επιστρέφει "None" ή ένα αντικείμενο string,

datetime.timetuple()

   Επιστρέφει μια "time.struct_time" όπως επιστρέφεται από την
   "time.localtime()".

   Το "d.timetuple()" είναι ισοδύναμο με:

      time.struct_time((d.year, d.month, d.day,
                        d.hour, d.minute, d.second,
                        d.weekday(), yday, dst))

   όπου "yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1"
   είναι ο αριθμός της ημέρας μέσα στο τρέχον έτος ξεκινώντας από 1
   για την 1η Ιανουαρίου. Το χαρακτηριστικό "tm_isdst" του
   αποτελέσματος ορίζεται σύμφωνα με τη μέθοδο "dst()" : εάν "tzinfo"
   είναι "None" ή εάν η "dst()" επιστρέφει "None", τότε το "tm_isdst"
   ορίζεται σε "- 1"; αλλιώς, εάν η "dst()" επιστρέφει μια μη μηδενική
   τιμή, τότε "tm_isdst" ορίζεται σε 1; αλλιώς, το "tm_isdst" ορίζεται
   σε 0.

datetime.utctimetuple()

   Εάν το στιγμιότυπο "datetime" "d" είναι αδαές, αυτό είναι το ίδιο
   με το "d.timetuple()" εκτός αν το "tm_isdst" ορίζεται σε 0
   ανεξάρτητα από το τι επιστρέφει η "d.dst()". Η θερινή ώρα δεν
   ισχύει ποτέ για μια ώρα UTC.

   Εάν το "d" είναι ενήμερο, το "d" κανονικοποιείται σε ώρα UTC,
   αφαιρώντας το "d.utcoffset()", και μια "time.struct_time" για την
   κανονικοποιημένη ώρα επιστρέφεται. Το "tm_isdst" ορίζεται σε 0.
   Σημειώστε ότι μπορεί να γίνει raise μια "OverflowError" εάν το
   "d.year" ήταν "MINYEAR" ή "MAXYEAR" και η προσαρμογή UTC υπερβαίνει
   ένα όριο έτους.

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

     Επειδή τα αδαή αντικείμενα "datetime" αντιμετωπίζονται από πολλές
     μεθόδους "datetime" ως τοπικές ώρες, προτιμάται η χρήση ενήμερων
     datetimes για την αναπαράσταση ωρών σε UTC∙ ως αποτέλεσμα, η
     χρήση της "datetime.utctimetuple()" μπορεί να δώσει παραπλανητικά
     αποτελέσματα. Εάν έχετε ένα αδαές "datetime" που αναπαριστά την
     ώρα σε UTC, χρησιμοποιήστε
     "datetime.replace(tzinfo=timezone.utc)" για να το κάνετε ενήμερο,
     οπότε μπορείτε να χρησιμοποιήσετε τη μέθοδο
     "datetime.timetuple()".

datetime.toordinal()

   Επιστρέφει τον προληπτικό Γρηγοριανό αριθμό της ημερομηνίας. Το
   ίδιο με το "self.date().toordinal()".

datetime.timestamp()

   Επιστρέφει το χρονικό σήμα POSIX που αντιστοιχεί στο στιγμιότυπο
   "datetime". Η επιστρεφόμενη τιμή είναι ένα "float" παρόμοιο με αυτό
   που επιστρέφεται από τη συνάρτηση "time.time()".

   Naive "datetime" instances are assumed to represent local time and
   this method relies on platform C functions to perform the
   conversion. Since "datetime" supports a wider range of values than
   the platform C functions on many platforms, this method may raise
   "OverflowError" or "OSError" for times far in the past or far in
   the future.

   Για τα ενήμερα στιγμιότυπα "datetime", η επιστρεφόμενη τιμή
   υπολογίζεται ως:

      (dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()

   Σημείωση:

     Δεν υπάρχει μέθοδος για να αποκτήσετε το χρονικό σήμα POSIX
     απευθείας από ένα αδαές στιγμιότυπο "datetime" που αναπαριστά την
     ώρα σε UTC. Εάν η εφαρμογή σας χρησιμοποιεί αυτή τη σύμβαση και η
     ζώνη ώρας του συστήματός σας δεν είναι ρυθμισμένη σε UTC,
     μπορείτε να αποκτήσετε το χρονικό σήμα POSIX παρέχοντας
     "tzinfo=timezone.utc":

        timestamp = dt.replace(tzinfo=timezone.utc).timestamp()

     ή με τον υπολογισμό του χρονικού σήματος απευθείας:

        timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)

   Added in version 3.3.

   Άλλαξε στην έκδοση 3.6: Η μέθοδος "timestamp()" χρησιμοποιεί το
   χαρακτηριστικό "fold" για να διασαφηνίσει τις ώρες κατά τη διάρκεια
   ενός επαναλαμβανόμενου διαστήματος.

   Άλλαξε στην έκδοση 3.6: This method no longer relies on the
   platform C "mktime()" function to perform conversions.

datetime.weekday()

   Επιστρέφει την ημέρα της εβδομάδας ως ακέραιο, όπου η Δευτέρα είναι
   0 και η Κυριακή είναι 6. Το ίδιο με το "self.date().weekday()".
   Δείτε επίσης "isoweekday()".

datetime.isoweekday()

   Επιστρέφει την ημέρα της εβδομάδας ως ακέραιο, όπου η Δευτέρα είναι
   1 και η Κυριακή είναι 7. Το ίδιο με το "self.date().isoweekday()".
   Δείτε επίσης "weekday()", "isocalendar()".

datetime.isocalendar()

   Επιστρέφει ένα *named tuple* με τρία συστατικά: "year", "week" και
   "weekday". Το ίδιο με το "self.date().isocalendar()".

datetime.isoformat(sep='T', timespec='auto')

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ημερομηνία και ώρα
   σε μορφή ISO 8601:

   * "YYYY-MM-DDTHH:MM:SS.ffffff", εάν το "microsecond" δεν είναι 0

   * "YYYY-MM-DDTHH:MM:SS", εάν το "microsecond" είναι 0

   Εάν η "utcoffset()" δεν επιστρέψει "None", προστίθεται μια
   συμβολοσειρά που δίνει την απόκλιση UTC:

   * "YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]", εάν το
     "microsecond" δεν είναι 0

   * "YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]", εάν το "microsecond"
     είναι 0

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

      >>> import datetime as dt
      >>> dt.datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()
      '2019-05-18T15:17:08.132263'
      >>> dt.datetime(2019, 5, 18, 15, 17, tzinfo=dt.timezone.utc).isoformat()
      '2019-05-18T15:17:00+00:00'

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

      >>> import datetime as dt
      >>> class TZ(dt.tzinfo):
      ...     """A time zone with an arbitrary, constant -06:39 offset."""
      ...     def utcoffset(self, when):
      ...         return dt.timedelta(hours=-6, minutes=-39)
      ...
      >>> dt.datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
      '2002-12-25 00:00:00-06:39'
      >>> dt.datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()
      '2009-11-27T00:00:00.000100-06:39'

   Η προαιρετική παράμετρος *timespec* καθορίζει τον αριθμό των
   επιπλέον στοιχείων της ώρας που θα συμπεριληφθούν (η προεπιλογή
   είναι "'auto'"). Μπορεί να είναι ένα από τα εξής:

   * "'auto'": Το ίδιο με "'seconds'" εάν το "microsecond" είναι 0,
     διαφορετικά το ίδιο με "'microseconds'".

   * "'hours'": Συμπεριλαμβάνει την "hour" σε μορφή δύο ψηφίων "HH".

   * "'minutes'": Συμπεριλαμβάνει την "hour" και την "minute" σε μορφή
     "HH:MM".

   * "'seconds'": Συμπεριλαμβάνει την "hour", την "minute" και την
     "second" σε μορφή "HH:MM:SS".

   * "'milliseconds'": Συμπεριλαμβάνει πλήρη ώρα, αλλά κόβει το
     κλασματικό μέρος του δευτερολέπτου σε χιλιοστά του δευτερολέπτου.

   * "'microseconds'": Συμπεριλαμβάνει πλήρη ώρα σε μορφή
     "HH:MM:SS.ffffff".

   Σημείωση:

     Τα εξαιρούμενα στοιχεία ώρας κόβονται, δεν στρογγυλοποιούνται.

   Η "ValueError" θα γίνει raise σε μη έγκυρο όρισμα *timespec*:

      >>> import datetime as dt
      >>> dt.datetime.now().isoformat(timespec='minutes')
      '2002-12-25T00:00'
      >>> my_datetime = dt.datetime(2015, 1, 1, 12, 30, 59, 0)
      >>> my_datetime.isoformat(timespec='microseconds')
      '2015-01-01T12:30:59.000000'

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

datetime.__str__()

   Για ένα στιγμιότυπο "datetime" "d", το "str(d)" είναι ισοδύναμο με
   το "d.isoformat(' ')".

datetime.ctime()

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ημερομηνία και ώρα:

      >>> import datetime as dt
      >>> dt.datetime(2002, 12, 4, 20, 30, 40).ctime()
      'Wed Dec  4 20:30:40 2002'

   Η συμβολοσειρά εξόδου *δεν* θα περιλαμβάνει πληροφορίες ζώνης ώρας,
   ανεξάρτητα από το αν η είσοδος είναι ενήμερη ή αδαής.

   Το "d.ctime()" είναι ισοδύναμο με:

      time.ctime(time.mktime(d.timetuple()))

   σε πλατφόρμες όπου η εγγενής συνάρτηση "ctime()" της C (την οποία
   καλεί η "time.ctime()", αλλά την οποία δεν καλεί η
   "datetime.ctime()") συμμορφώνεται με το πρότυπο C.

datetime.strftime(format)

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ημερομηνία και ώρα,
   ελεγχόμενη από μια ρητή μορφή συμβολοσειράς. Δείτε επίσης
   strftime() and strptime() behavior και "datetime.isoformat()".

datetime.__format__(format)

   Παρόμοια με τη μέθοδο "datetime.strftime()". Αυτό καθιστά δυνατό
   τον καθορισμό μιας μορφής συμβολοσειράς για ένα αντικείμενο
   "datetime" σε formatted string literals και κατά τη χρήση της
   "str.format()". Δείτε επίσης strftime() and strptime() behavior και
   "datetime.isoformat()".


Examples of usage: "datetime"
-----------------------------

Παραδείγματα εργασίας με αντικείμενα "datetime":

   >>> import datetime as dt

   >>> # Using datetime.combine()
   >>> d = dt.date(2005, 7, 14)
   >>> t = dt.time(12, 30)
   >>> dt.datetime.combine(d, t)
   datetime.datetime(2005, 7, 14, 12, 30)

   >>> # Using datetime.now()
   >>> dt.datetime.now()
   datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
   >>> dt.datetime.now(dt.timezone.utc)
   datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone.utc)

   >>> # Using datetime.strptime()
   >>> my_datetime = dt.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
   >>> my_datetime
   datetime.datetime(2006, 11, 21, 16, 30)

   >>> # Using datetime.timetuple() to get tuple of all attributes
   >>> tt = my_datetime.timetuple()
   >>> for it in tt:
   ...     print(it)
   ...
   2006    # year
   11      # month
   21      # day
   16      # hour
   30      # minute
   0       # second
   1       # weekday (0 = Monday)
   325     # number of days since 1st January
   -1      # dst - method tzinfo.dst() returned None

   >>> # Date in ISO format
   >>> ic = my_datetime.isocalendar()
   >>> for it in ic:
   ...     print(it)
   ...
   2006    # ISO year
   47      # ISO week
   2       # ISO weekday

   >>> # Formatting a datetime
   >>> my_datetime.strftime("%A, %d. %B %Y %I:%M%p")
   'Tuesday, 21. November 2006 04:30PM'
   >>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(my_datetime, "day", "month", "time")
   'The day is 21, the month is November, the time is 04:30PM.'

Το παρακάτω παράδειγμα ορίζει μια υποκλάση "tzinfo" που λαμβάνει τις
πληροφορίες για ζώνη ώρας για την Καμπούλ, στο Αφγανιστάν, η οποία
χρησιμοποιούσε +4 UTC μέχρι το 1945 και στη συνέχεια +4:30 UTC από
τότε:

   import datetime as dt

   class KabulTz(dt.tzinfo):
       # Kabul used +4 until 1945, when they moved to +4:30
       UTC_MOVE_DATE = dt.datetime(1944, 12, 31, 20, tzinfo=dt.timezone.utc)

       def utcoffset(self, when):
           if when.year < 1945:
               return dt.timedelta(hours=4)
           elif (1945, 1, 1, 0, 0) <= when.timetuple()[:5] < (1945, 1, 1, 0, 30):
               # An ambiguous ("imaginary") half-hour range representing
               # a 'fold' in time due to the shift from +4 to +4:30.
               # If when falls in the imaginary range, use fold to decide how
               # to resolve. See PEP 495.
               return dt.timedelta(hours=4, minutes=(30 if when.fold else 0))
           else:
               return dt.timedelta(hours=4, minutes=30)

       def fromutc(self, when):
           # Follow same validations as in datetime.tzinfo
           if not isinstance(when, dt.datetime):
               raise TypeError("fromutc() requires a datetime argument")
           if when.tzinfo is not self:
               raise ValueError("when.tzinfo is not self")

           # A custom implementation is required for fromutc as
           # the input to this function is a datetime with utc values
           # but with a tzinfo set to self.
           # See datetime.astimezone or fromtimestamp.
           if when.replace(tzinfo=dt.timezone.utc) >= self.UTC_MOVE_DATE:
               return when + dt.timedelta(hours=4, minutes=30)
           else:
               return when + dt.timedelta(hours=4)

       def dst(self, when):
           # Kabul does not observe daylight saving time.
           return dt.timedelta(0)

       def tzname(self, when):
           if when >= self.UTC_MOVE_DATE:
               return "+04:30"
           return "+04"

Χρήση του "KabulTz" από το παραπάνω παράδειγμα:

   >>> tz1 = KabulTz()

   >>> # Datetime before the change
   >>> dt1 = dt.datetime(1900, 11, 21, 16, 30, tzinfo=tz1)
   >>> print(dt1.utcoffset())
   4:00:00

   >>> # Datetime after the change
   >>> dt2 = dt.datetime(2006, 6, 14, 13, 0, tzinfo=tz1)
   >>> print(dt2.utcoffset())
   4:30:00

   >>> # Convert datetime to another time zone
   >>> dt3 = dt2.astimezone(dt.timezone.utc)
   >>> dt3
   datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)
   >>> dt2
   datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())
   >>> dt2 == dt3
   True


"time" objects
==============

Ένα αντικείμενο "time" αναπαριστά μια (τοπική) ώρα της ημέρας,
ανεξάρτητη από οποιαδήποτε ημέρα, και υπόκειται σε προσαρμογή μέσω
ενός αντικειμένου "tzinfo".

class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

   Όλα τα ορίσματα είναι προαιρετικά. Το *tzinfo* μπορεί να είναι
   "None", ή ένα στιγμιότυπο μιας υποκλάσης "tzinfo". Τα υπόλοιπα
   ορίσματα πρέπει να είναι ακέραιοι στα ακόλουθα εύρη:

   * "0 <= hour < 24",

   * "0 <= minute < 60",

   * "0 <= second < 60",

   * "0 <= microsecond < 1000000",

   * "fold in [0, 1]".

   Εάν δοθεί ένα όρισμα εκτός αυτών των ευρών, γίνεται raise
   "ValueError". Όλες οι προεπιλογές είναι 0 εκτός από το *tzinfo*, το
   οποίο προεπιλέγεται σε "None".

Χαρακτηριστικά Κλάσης:

time.min

   Η πιο πρώιμη αναπαραστάσιμη "time", "time(0, 0, 0, 0)".

time.max

   Η πιο πρόσφατη αναπαραστάσιμη "time", "time(23, 59, 59, 999999)".

time.resolution

   Η μικρότερη δυνατή διαφορά μεταξύ μη ίσων αντικειμένων "time",
   "timedelta(microseconds=1)", αν και σημειώστε ότι η αριθμητική σε
   αντικείμενα "time" δεν υποστηρίζεται.

Χαρακτηριστικά στιγμιοτύπου (μόνο για ανάγνωση):

time.hour

   Στο "range(24)".

time.minute

   Στο "range(60)".

time.second

   Στο "range(60)".

time.microsecond

   Στο "range(1000000)".

time.tzinfo

   Το αντικείμενο που δόθηκε ως όρισμα tzinfo στον κατασκευαστή
   "time", ή "None" εάν δεν δόθηκε κανένα.

time.fold

   Στο "[0, 1]". Χρησιμοποιείται για την αποσαφήνιση των τοπικών ωρών
   σε επαναλαμβανόμενο διάστημα. (Ένα επαναλαμβανόμενο διάστημα
   συμβαίνει όταν τα ρολόγια γυρίζουν πίσω στο τέλος της θερινής ώρας
   ή όταν οι αποκλίσεις UTC για την τρέχουσα ζώνη μειώνεται για
   πολιτικούς λόγους.) Οι τιμές 0 και 1 αντιπροσωπεύουν, αντίστοιχα,
   την πρώτη και τη δεύτερη από τις δύο χρονικές στιγμές με την ίδια
   αναπαράσταση τοπικής ώρας.

   Added in version 3.6.

Τα αντικείμενα "time" υποστηρίζουν συγκρίσεις ισότητας και τάξης, όπου
το "a" θεωρείται μικρότερο από το "b" όταν το "a" προηγείται του "b"
στον χρόνο.

Αδαείς και ενήμερα αντικείμενα "time" δεν είναι ποτέ ίσα. Η σύγκριση
τάξης μεταξύ αδαών και ενήμερων αντικειμένων "time" προκαλεί
"TypeError".

Εάν και τα δύο συγκρινόμενα αντικείμενα είναι ενήμερα, και έχουν το
ίδιο χαρακτηριστικό "tzinfo", τα χαρακτηριστικά "tzinfo" και "fold"
αγνοούνται και η βάση των ωρών συγκρίνεται. Εάν και τα δύο
συγκρινόμενα αντικείμενα είναι ενήμερα και έχουν διαφορετικά
χαρακτηριστικά "tzinfo", τα συγκρινόμενα αντικείμενα προσαρμόζονται
πρώτα αφαιρώντας τις UTC μετατοπίσεις τους (που αποκτώνται από
"self.utcoffset()").

Άλλαξε στην έκδοση 3.3: Οι συγκρίσεις ισότητας μεταξύ ενήμερων και
αδαών στιγμιοτύπων "time" δεν κάνουν raise "TypeError".

Σε λογικά συμφραζόμενα, ένα αντικείμενο "time" θεωρείται πάντα αληθές.

Άλλαξε στην έκδοση 3.5: Before Python 3.5, a "time" object was
considered to be false if it represented midnight in UTC. This
behavior was considered obscure and error-prone and has been removed
in Python 3.5. See bpo-13936 for more information.

Άλλοι κατασκευαστές:

classmethod time.fromisoformat(time_string)

   Επιστρέφει μια "time" που αντιστοιχεί σε ένα *time_string* σε
   οποιαδήποτε έγκυρη μορφή ISO 8601, με τις ακόλουθες εξαιρέσεις:

   1. Οι αποκλίσεις ζώνης ώρας μπορεί να έχουν κλασματικά
      δευτερόλεπτα.

   2. Το αρχικό "T", που απαιτείται κανονικά σε περιπτώσεις όπου
      μπορεί να υπάρχει αμφιβολία μεταξύ μιας ημερομηνίας και μιας
      ώρας, δεν απαιτείται.

   3. Τα κλασματικά δευτερόλεπτα μπορούν να έχουν οποιονδήποτε αριθμό
      ψηφίων (οτιδήποτε πέρα από 6 θα κοπεί).

   4. Οι κλασματικές ώρες και λεπτά δεν υποστηρίζονται.

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

      >>> import datetime as dt
      >>> dt.time.fromisoformat('04:23:01')
      datetime.time(4, 23, 1)
      >>> dt.time.fromisoformat('T04:23:01')
      datetime.time(4, 23, 1)
      >>> dt.time.fromisoformat('T042301')
      datetime.time(4, 23, 1)
      >>> dt.time.fromisoformat('04:23:01.000384')
      datetime.time(4, 23, 1, 384)
      >>> dt.time.fromisoformat('04:23:01,000384')
      datetime.time(4, 23, 1, 384)
      >>> dt.time.fromisoformat('04:23:01+04:00')
      datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))
      >>> dt.time.fromisoformat('04:23:01Z')
      datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)
      >>> dt.time.fromisoformat('04:23:01+00:00')
      datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)

   Added in version 3.7.

   Άλλαξε στην έκδοση 3.11: Προηγουμένως, αυτή η μέθοδος υποστήριζε
   μόνο μορφές που θα μπορούσαν να εκδοθούν από τη "time.isoformat()".

classmethod time.strptime(date_string, format)

   Επιστρέφει μια "time" που αντιστοιχεί στο *date_string*, αναλυμένο
   σύμφωνα με το *format*.

   Εάν το *format* δεν περιλαμβάνει μικροδευτερόλεπτα ή πληροφορίες
   ζώνης ώρας, αυτό είναι ισοδύναμο με:

      time(*(time.strptime(date_string, format)[3:6]))

   Μια "ValueError" θα γίνει raise αν το *date_string* και το *format*
   δεν μπορούν να αναλυθούν από την "time.strptime()" ή αν επιστρέφει
   μια τιμή που δεν είναι τουλάχιστον μια πλειάδα ώρας. Δείτε επίσης
   strftime() and strptime() behavior και "time.fromisoformat()".

   Added in version 3.14.

Μέθοδοι στιγμιοτύπου:

time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

   Return a new "time" with the same values, but with specified
   parameters updated. Note that "tzinfo=None" can be specified to
   create a naive "time" from an aware "time", without conversion of
   the time data.

   Η "time" υποστηρίζεται επίσης από τη γενική συνάρτηση
   "copy.replace()".

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

time.isoformat(timespec='auto')

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ώρα σε μορφή ISO
   8601, μία από τις εξής:

   * "HH:MM:SS.ffffff", αν το "microsecond" δεν είναι 0

   * "HH:MM:SS", αν το "microsecond" είναι 0

   * "HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]", εάν η "utcoffset()" δεν
     επιστρέφει "None"

   * "HH:MM:SS+HH:MM[:SS[.ffffff]]", αν το "microsecond" είναι 0 και
     το "utcoffset()" δεν επιστρέφει "None"

   Η προαιρετική παράμετρος *timespec* καθορίζει τον αριθμό των
   επιπλέον στοιχείων της ώρας που θα συμπεριληφθούν (η προεπιλογή
   είναι "'auto'"). Μπορεί να είναι ένα από τα εξής:

   * "'auto'": Το ίδιο με "'seconds'" εάν το "microsecond" είναι 0,
     διαφορετικά το ίδιο με "'microseconds'".

   * "'hours'": Συμπεριλαμβάνει την "hour" σε μορφή δύο ψηφίων "HH".

   * "'minutes'": Συμπεριλαμβάνει την "hour" και την "minute" σε μορφή
     "HH:MM".

   * "'seconds'": Συμπεριλαμβάνει την "hour", την "minute" και την
     "second" σε μορφή "HH:MM:SS".

   * "'milliseconds'": Συμπεριλαμβάνει πλήρη ώρα, αλλά κόβει το
     κλασματικό μέρος του δευτερολέπτου σε χιλιοστά του δευτερολέπτου.

   * "'microseconds'": Συμπεριλαμβάνει πλήρη ώρα σε μορφή
     "HH:MM:SS.ffffff".

   Σημείωση:

     Τα εξαιρούμενα στοιχεία ώρας κόβονται, δεν στρογγυλοποιούνται.

   Μια "ValueError" θα γίνει raise για μια μη έγκυρη παράμετρο
   *timespec*.

   Παράδειγμα:

      >>> import datetime as dt
      >>> dt.time(hour=12, minute=34, second=56, microsecond=123456).isoformat(timespec='minutes')
      '12:34'
      >>> my_time = dt.time(hour=12, minute=34, second=56, microsecond=0)
      >>> my_time.isoformat(timespec='microseconds')
      '12:34:56.000000'
      >>> my_time.isoformat(timespec='auto')
      '12:34:56'

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

time.__str__()

   Για μια ώρα "t", το "str(t)" είναι ισοδύναμο με το "t.isoformat()".

time.strftime(format)

   Επιστρέφει μια συμβολοσειρά που αναπαριστά την ώρα, ελεγχόμενη από
   μια ρητή συμβολοσειρά μορφοποίησης. Δείτε επίσης strftime() and
   strptime() behavior και "time.isoformat()".

time.__format__(format)

   Ίδιο με την "time.strftime()". Αυτό καθιστά δυνατό τον ορισμό μιας
   συμβολοσειράς μορφοποίησης για ένα αντικείμενο "time" σε formatted
   string literals και κατά τη χρήση της μεθόδου "str.format()". Δείτε
   επίσης strftime() and strptime() behavior και "time.isoformat()".

time.utcoffset()

   Εάν το "tzinfo" είναι "None", επιστρέφει "None", διαφορετικά
   επιστρέφει "self.tzinfo.utcoffset(None)", και κάνει raise μια
   εξαίρεση εάν το τελευταίο δεν επιστρέφει "None" ή ένα αντικείμενο
   "timedelta" με μέγεθος μικρότερο από μια ημέρα.

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

time.dst()

   Εάν το "tzinfo" είναι "None", επιστρέφει "None", αλλιώς επιστρέφει
   "self.tzinfo.dst(None)", και κάνει raise μια εξαίρεση εάν το
   τελευταίο δεν επιστρέφει "None", ή ένα αντικείμενο "timedelta" με
   μέγεθος μικρότερο από μια ήμερα.

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

time.tzname()

   Εάν το "tzinfo" είναι "None", επιστρέφει "None", αλλιώς επιστρέφει
   "self.tzinfo.tzname(None)", ή κάνει raise μια εξαίρεση εάν το
   τελευταίο δεν επιστρέφει "None" ή ένα αντικείμενο συμβολοσειράς.


Examples of usage: "time"
-------------------------

Παραδείγματα εργασίας με ένα αντικείμενο "time":

   >>> import datetime as dt
   >>> class TZ1(dt.tzinfo):
   ...     def utcoffset(self, when):
   ...         return dt.timedelta(hours=1)
   ...     def dst(self, when):
   ...         return dt.timedelta(0)
   ...     def tzname(self, when):
   ...         return "+01:00"
   ...     def  __repr__(self):
   ...         return f"{self.__class__.__name__}()"
   ...
   >>> t = dt.time(12, 10, 30, tzinfo=TZ1())
   >>> t
   datetime.time(12, 10, 30, tzinfo=TZ1())
   >>> t.isoformat()
   '12:10:30+01:00'
   >>> t.dst()
   datetime.timedelta(0)
   >>> t.tzname()
   '+01:00'
   >>> t.strftime("%H:%M:%S %Z")
   '12:10:30 +01:00'
   >>> 'The {} is {:%H:%M}.'.format("time", t)
   'The time is 12:10.'


"tzinfo" objects
================

class datetime.tzinfo

   This is an *abstract base class*, meaning that this class should
   not be instantiated directly.  Define a subclass of "tzinfo" to
   capture information about a particular time zone.

   An instance of (a concrete subclass of) "tzinfo" can be passed to
   the constructors for "datetime" and "time" objects. The latter
   objects view their attributes as being in local time, and the
   "tzinfo" object supports methods revealing offset of local time
   from UTC, the name of the time zone, and DST offset, all relative
   to a date or time object passed to them.

   You need to derive a concrete subclass, and (at least) supply
   implementations of the standard "tzinfo" methods needed by the
   "datetime" methods you use. The "datetime" module provides
   "timezone", a simple concrete subclass of "tzinfo" which can
   represent time zones with fixed offset from UTC such as UTC itself
   or North American EST and EDT.

   Special requirement for pickling:  A "tzinfo" subclass must have an
   "__init__()" method that can be called with no arguments, otherwise
   it can be pickled but possibly not unpickled again. This is a
   technical requirement that may be relaxed in the future.

   Μια συγκεκριμένη υποκλάση της "tzinfo" μπορεί να χρειαστεί να
   υλοποιήσει τις παρακάτω μεθόδους. Το ποιες μέθοδοι ακριβώς
   χρειάζονται εξαρτάται από τις χρήσεις που γίνονται σε αντικείμενα
   "datetime" που είναι ενήμερα για τη ζώνη ώρας. Εάν έχετε
   αμφιβολίες, απλά υλοποιήστε τα όλα.

tzinfo.utcoffset(dt)

   Επιστρέφει την απόκλιση της τοπικής ώρας από το UTC, ως αντικείμενο
   "timedelta" που είναι θετικό ανατολικά του UTC. Εάν η τοπική ώρα
   είναι δυτικά του UTC, αυτό θα πρέπει να είναι αρνητικό.

   Αυτό αναπαριστά τη *συνολική* απόκλιση από το UTC. Για παράδειγμα,
   εάν ένα αντικείμενο "tzinfo" αναπαριστά τόσο τη ζώνη ώρας όσο και
   τις προσαρμογές DST, η "utcoffset()" θα πρέπει να επιστρέφει το
   άθροισμά τους. Εάν η απόκλιση UTC δεν είναι γνωστή, επιστρέψει
   "None". Διαφορετικά, η τιμή που επιστρέφεται πρέπει να είναι ένα
   αντικείμενο "timedelta" αυστηρά μεταξύ "-timedelta(hours=24)" και
   "timedelta(hours=24)" (η μεγέθυνση της απόκλισης πρέπει να είναι
   μικρότερη από μία ημέρα). Οι περισσότερες υλοποιήσεις της
   "utcoffset()" θα μοιάζουν με μία από τις παρακάτω δύο:

      return CONSTANT                 # fixed-offset class
      return CONSTANT + self.dst(dt)  # daylight-aware class

   Εάν η "utcoffset()" δεν επιστρέφει "None", τότε ούτε η "dst()" δεν
   θα πρέπει να επιστρέφει "None".

   Η προεπιλεγμένη υλοποίηση της "utcoffset()" κάνει raise
   "NotImplementedError".

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

tzinfo.dst(dt)

   Επιστρέφει την προσαρμογή της θερινής ώρας (DST), ως αντικείμενο
   "timedelta" ή "None" εάν οι πληροφορίες για τη θερινή ώρα δεν είναι
   γνωστές.

   Επιστρέφει "timedelta(0)" εάν το DST δεν είναι σε ισχύ. Εάν το DST
   είναι σε ισχύ, επιστρέφει την απόκλιση ως αντικείμενο "timedelta"
   (βλ. "utcoffset()" για λεπτομέρειες). Σημειώστε ότι η απόκλιση DST,
   εάν ισχύει, έχει ήδη προστεθεί στην απόκλιση UTC που επιστρέφεται
   από την "utcoffset()", επομένως δεν υπάρχει ανάγκη να
   συμβουλευτείτε την "dst()" εκτός αν σας ενδιαφέρει να αποκτήσετε
   πληροφορίες DST ξεχωριστά. Για παράδειγμα, η "datetime.timetuple()"
   καλεί τη μέθοδο "dst()" του χαρακτηριστικού "tzinfo" για να
   καθορίσει πώς θα πρέπει να ρυθμιστεί η σημαία "tm_isdst", και η
   "tzinfo.fromutc()" καλεί την "dst()" για να υπολογίσει για τις
   αλλαγές DST όταν διασχίζει ζώνες ώρας.

   Ένα στιγμιότυπο *tz* μιας υποκλάσης "tzinfo" που μοντελοποιεί τόσο
   τις κανονικές όσο και τις θερινές ώρες πρέπει να είναι συνεπές σε
   αυτό το σημείο:

   "tz.utcoffset(dt) - tz.dst(dt)"

   must return the same result for every "datetime" *dt* with
   "dt.tzinfo == tz". For sane "tzinfo" subclasses, this expression
   yields the time zone's "standard offset", which should not depend
   on the date or the time, but only on geographic location. The
   implementation of "datetime.astimezone()" relies on this, but
   cannot detect violations; it's the programmer's responsibility to
   ensure it. If a "tzinfo" subclass cannot guarantee this, it may be
   able to override the default implementation of "tzinfo.fromutc()"
   to work correctly with "astimezone()" regardless.

   Οι περισσότερες υλοποιήσεις της "dst()" θα μοιάζουν μάλλον με μία
   από αυτές τις δύο:

      import datetime as dt

      def dst(self, when):
          # a fixed-offset class:  doesn't account for DST
          return dt.timedelta(0)

   ή:

      import datetime as dt

      def dst(self, when):
          # Code to set dston and dstoff to the time zone's DST
          # transition times based on the input when.year, and expressed
          # in standard local time.

          if dston <= when.replace(tzinfo=None) < dstoff:
              return dt.timedelta(hours=1)
          else:
              return dt.timedelta(0)

   Η προεπιλεγμένη υλοποίηση της "dst()" κάνει raise
   "NotImplementedError".

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

tzinfo.tzname(dt)

   Return the time zone name corresponding to the "datetime" object
   *dt*, as a string. Nothing about string names is defined by the
   "datetime" module, and there's no requirement that it mean anything
   in particular. For example, ""GMT"", ""UTC"", ""-500"", ""-5:00"",
   ""EDT"", ""US/Eastern"", ""America/New York"" are all valid
   replies. Return "None" if a string name isn't known. Note that this
   is a method rather than a fixed string primarily because some
   "tzinfo" subclasses will wish to return different names depending
   on the specific value of *dt* passed, especially if the "tzinfo"
   class is accounting for daylight time.

   Η προεπιλεγμένη υλοποίηση της "tzname()" κάνει raise
   "NotImplementedError".

These methods are called by a "datetime" or "time" object, in response
to their methods of the same names. A "datetime" object passes itself
as the argument, and a "time" object passes "None" as the argument. A
"tzinfo" subclass's methods should therefore be prepared to accept a
*dt* argument of "None", or of class "datetime".

When "None" is passed, it's up to the class designer to decide the
best response. For example, returning "None" is appropriate if the
class wishes to say that time objects don't participate in the
"tzinfo" protocols. It may be more useful for "utcoffset(None)" to
return the standard UTC offset, as there is no other convention for
discovering the standard offset.

When a "datetime" object is passed in response to a "datetime" method,
"dt.tzinfo" is the same object as *self*. "tzinfo" methods can rely on
this, unless user code calls "tzinfo" methods directly. The intent is
that the "tzinfo" methods interpret *dt* as being in local time, and
not need worry about objects in other time zones.

Υπάρχει μια ακόμη μέθοδος "tzinfo" που μια υποκλάση μπορεί να θέλει να
την παρακάμψει:

tzinfo.fromutc(dt)

   Αυτό καλείται από την προεπιλεγμένη υλοποίηση της
   "datetime.astimezone()". Όταν καλείται από αυτήν, το "dt.tzinfo"
   είναι *self*, και τα δεδομένα ημερομηνίας και ώρας του *dt* πρέπει
   να θεωρούνται ότι εκφράζουν μια ώρα UTC. Ο σκοπός της "fromutc()"
   είναι να προσαρμόσει τα δεδομένα ημερομηνίας και ώρας,
   επιστρέφοντας ένα ισοδύναμο αντικείμενο ημερομηνίας και ώρας στην
   τοπική ώρα του *self*.

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

   Παραλείποντας τον κώδικα για περιπτώσεις σφαλμάτων, η προεπιλεγμένη
   υλοποίηση της "fromutc()" λειτουργεί ως εξής:

      import datetime as dt

      def fromutc(self, when):
          # raise ValueError error if when.tzinfo is not self
          dtoff = when.utcoffset()
          dtdst = when.dst()
          # raise ValueError if dtoff is None or dtdst is None
          delta = dtoff - dtdst  # this is self's standard offset
          if delta:
              when += delta   # convert to standard local time
              dtdst = when.dst()
              # raise ValueError if dtdst is None
          if dtdst:
              return when + dtdst
          else:
              return when

Στο παρακάτω αρχείο "tzinfo_examples.py" υπάρχουν μερικά παραδείγματα
κλάσεων "tzinfo":

   import datetime as dt

   # A class capturing the platform's idea of local time.
   # (May result in wrong values on historical times in
   #  timezones where UTC offset and/or the DST rules had
   #  changed in the past.)
   import time

   ZERO = dt.timedelta(0)
   HOUR = dt.timedelta(hours=1)
   SECOND = dt.timedelta(seconds=1)

   STDOFFSET = dt.timedelta(seconds=-time.timezone)
   if time.daylight:
       DSTOFFSET = dt.timedelta(seconds=-time.altzone)
   else:
       DSTOFFSET = STDOFFSET

   DSTDIFF = DSTOFFSET - STDOFFSET


   class LocalTimezone(dt.tzinfo):

       def fromutc(self, when):
           assert when.tzinfo is self
           stamp = (when - dt.datetime(1970, 1, 1, tzinfo=self)) // SECOND
           args = time.localtime(stamp)[:6]
           dst_diff = DSTDIFF // SECOND
           # Detect fold
           fold = (args == time.localtime(stamp - dst_diff))
           return dt.datetime(*args, microsecond=when.microsecond,
                              tzinfo=self, fold=fold)

       def utcoffset(self, when):
           if self._isdst(when):
               return DSTOFFSET
           else:
               return STDOFFSET

       def dst(self, when):
           if self._isdst(when):
               return DSTDIFF
           else:
               return ZERO

       def tzname(self, when):
           return time.tzname[self._isdst(when)]

       def _isdst(self, when):
           tt = (when.year, when.month, when.day,
                 when.hour, when.minute, when.second,
                 when.weekday(), 0, 0)
           stamp = time.mktime(tt)
           tt = time.localtime(stamp)
           return tt.tm_isdst > 0


   Local = LocalTimezone()


   # A complete implementation of current DST rules for major US time zones.

   def first_sunday_on_or_after(when):
       days_to_go = 6 - when.weekday()
       if days_to_go:
           when += dt.timedelta(days_to_go)
       return when


   # US DST Rules
   #
   # This is a simplified (i.e., wrong for a few cases) set of rules for US
   # DST start and end times. For a complete and up-to-date set of DST rules
   # and timezone definitions, visit the Olson Database (or try pytz):
   # http://www.twinsun.com/tz/tz-link.htm
   # https://sourceforge.net/projects/pytz/ (might not be up-to-date)
   #
   # In the US, since 2007, DST starts at 2am (standard time) on the second
   # Sunday in March, which is the first Sunday on or after Mar 8.
   DSTSTART_2007 = dt.datetime(1, 3, 8, 2)
   # and ends at 2am (DST time) on the first Sunday of Nov.
   DSTEND_2007 = dt.datetime(1, 11, 1, 2)
   # From 1987 to 2006, DST used to start at 2am (standard time) on the first
   # Sunday in April and to end at 2am (DST time) on the last
   # Sunday of October, which is the first Sunday on or after Oct 25.
   DSTSTART_1987_2006 = dt.datetime(1, 4, 1, 2)
   DSTEND_1987_2006 = dt.datetime(1, 10, 25, 2)
   # From 1967 to 1986, DST used to start at 2am (standard time) on the last
   # Sunday in April (the one on or after April 24) and to end at 2am (DST time)
   # on the last Sunday of October, which is the first Sunday
   # on or after Oct 25.
   DSTSTART_1967_1986 = dt.datetime(1, 4, 24, 2)
   DSTEND_1967_1986 = DSTEND_1987_2006


   def us_dst_range(year):
       # Find start and end times for US DST. For years before 1967, return
       # start = end for no DST.
       if 2006 < year:
           dststart, dstend = DSTSTART_2007, DSTEND_2007
       elif 1986 < year < 2007:
           dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
       elif 1966 < year < 1987:
           dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
       else:
           return (dt.datetime(year, 1, 1), ) * 2

       start = first_sunday_on_or_after(dststart.replace(year=year))
       end = first_sunday_on_or_after(dstend.replace(year=year))
       return start, end


   class USTimeZone(dt.tzinfo):

       def __init__(self, hours, reprname, stdname, dstname):
           self.stdoffset = dt.timedelta(hours=hours)
           self.reprname = reprname
           self.stdname = stdname
           self.dstname = dstname

       def __repr__(self):
           return self.reprname

       def tzname(self, when):
           if self.dst(when):
               return self.dstname
           else:
               return self.stdname

       def utcoffset(self, when):
           return self.stdoffset + self.dst(when)

       def dst(self, when):
           if when is None or when.tzinfo is None:
               # An exception may be sensible here, in one or both cases.
               # It depends on how you want to treat them.  The default
               # fromutc() implementation (called by the default astimezone()
               # implementation) passes a datetime with when.tzinfo is self.
               return ZERO
           assert when.tzinfo is self
           start, end = us_dst_range(when.year)
           # Can't compare naive to aware objects, so strip the timezone from
           # when first.
           when = when.replace(tzinfo=None)
           if start + HOUR <= when < end - HOUR:
               # DST is in effect.
               return HOUR
           if end - HOUR <= when < end:
               # Fold (an ambiguous hour): use when.fold to disambiguate.
               return ZERO if when.fold else HOUR
           if start <= when < start + HOUR:
               # Gap (a non-existent hour): reverse the fold rule.
               return HOUR if when.fold else ZERO
           # DST is off.
           return ZERO

       def fromutc(self, when):
           assert when.tzinfo is self
           start, end = us_dst_range(when.year)
           start = start.replace(tzinfo=self)
           end = end.replace(tzinfo=self)
           std_time = when + self.stdoffset
           dst_time = std_time + HOUR
           if end <= dst_time < end + HOUR:
               # Repeated hour
               return std_time.replace(fold=1)
           if std_time < start or dst_time >= end:
               # Standard time
               return std_time
           if start <= std_time < end - HOUR:
               # Daylight saving time
               return dst_time


   Eastern  = USTimeZone(-5, "Eastern",  "EST", "EDT")
   Central  = USTimeZone(-6, "Central",  "CST", "CDT")
   Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
   Pacific  = USTimeZone(-8, "Pacific",  "PST", "PDT")

Σημειώστε ότι υπάρχουν αναπόφευκτες λεπτές περιπτώσεις δύο φορές το
χρόνο σε μια υποκλάση "tzinfo" που λαμβάνει υπόψη τόσο την κανονική
όσο και τη θερινή ώρα, στα σημεία μετάβασης DST. Για να είμαστε
συγκεκριμένοι, σκεφτείτε την Ανατολική Ζώνη των ΗΠΑ (UTC -0500), όπου
η EDT ξεκινά το λεπτό μετά τις 1:59 (EST) τη δεύτερη Κυριακή του
Μαρτίου και τελειώνει το λεπτό μετά τις 1:59 (EDT) την πρώτη Κυριακή
του Νοεμβρίου:

     UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM
     EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM
     EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM

   start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM

     end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM

Όταν ξεκινάει το DST (η γραμμή "start"), το τοπικό ρολόι πηδάει από
1:59 σε 3:00. Μια τοπική ώρα της μορφής 2:MM δεν έχει νόημα σε αυτή
την ημέρα, έτσι η "astimezone(Eastern)" δεν θα επιστρέψει αποτέλεσμα
με "hour == 2" την ημέρα που ξεκινάει το DST. Για παράδειγμα, κατά τον
μετασχηματισμό Spring forward του 2016, παίρνουμε:

   >>> import datetime as dt
   >>> from tzinfo_examples import HOUR, Eastern
   >>> u0 = dt.datetime(2016, 3, 13, 5, tzinfo=dt.timezone.utc)
   >>> for i in range(4):
   ...     u = u0 + i*HOUR
   ...     t = u.astimezone(Eastern)
   ...     print(u.time(), 'UTC =', t.time(), t.tzname())
   ...
   05:00:00 UTC = 00:00:00 EST
   06:00:00 UTC = 01:00:00 EST
   07:00:00 UTC = 03:00:00 EDT
   08:00:00 UTC = 04:00:00 EDT

Όταν τελειώνει το DST (η γραμμή "end"), υπάρχει ένα δυνητικά χειρότερο
πρόβλημα: υπάρχει μια ώρα που δεν μπορεί να γραφτεί με σαφήνεια στην
τοπική ώρα: η τελευταία ώρα της θερινής ώρας. Στην Ανατολική ζώνη,
αυτές είναι οι ώρες της μορφής 5:MM UTC την ημέρα που τελειώνει η
θερινή ώρα. Το τοπικό ρολόι πηδάει από 1:59 (θερινή ώρα) πίσω σε 1:00
(κανονική ώρα) ξανά. Οι τοπικές ώρες της μορφής 1:MM είναι ασαφείς. Η
"astimezone()" μιμείται τη συμπεριφορά του τοπικού ρολογιού
χαρτογραφώντας δύο γειτονικές ώρες UTC στην ίδια τοπική ώρα τότε. Στο
παράδειγμα της Ανατολής, οι ώρες UTC της μορφής 5:MM και 6:MM
χαρτογραφούνται και οι δύο σε 1:MM όταν μετατραπούν σε Ανατολική, αλλά
οι προηγούμενες ώρες έχουν την ιδιότητα "fold" ρυθμισμένη σε 0 και οι
μεταγενέστερες ώρες έχουν ρυθμισμένη σε 1. Για παράδειγμα, κατά τη
μετάβαση Fall back του 2016, παίρνουμε:

   >>> import datetime as dt
   >>> from tzinfo_examples import HOUR, Eastern
   >>> u0 = dt.datetime(2016, 11, 6, 4, tzinfo=dt.timezone.utc)
   >>> for i in range(4):
   ...     u = u0 + i*HOUR
   ...     t = u.astimezone(Eastern)
   ...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)
   ...
   04:00:00 UTC = 00:00:00 EDT 0
   05:00:00 UTC = 01:00:00 EDT 0
   06:00:00 UTC = 01:00:00 EST 1
   07:00:00 UTC = 02:00:00 EST 0

Σημειώστε ότι τα στιγμιότυπα της "datetime" όπου διαφέρουν μόνο από
την τιμή του χαρακτηριστικού "fold" θεωρούνται ίσα στις συγκρίσεις.

Applications that can't bear wall-time ambiguities should explicitly
check the value of the "fold" attribute or avoid using hybrid "tzinfo"
subclasses; there are no ambiguities when using "timezone", or any
other fixed-offset "tzinfo" subclass (such as a class representing
only EST (fixed offset -5 hours), or only EDT (fixed offset -4
hours)).

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

     "zoneinfo"
        Το module "datetime" έχει μια βασική κλάση "timezone" (για τη
        διαχείριση αυθαίρετων σταθερών αποκλίσεων από το UTC) και το
        χαρακτηριστικό του "timezone.utc" (ένα στιγμιότυπο UTC της
        "timezone").

        Το "zoneinfo" φέρνει τη *βάση δεδομένων ζωνών ώρας IANA*
        (γνωστή και ως βάση δεδομένων Olson) στην Python, και η χρήση
        της συνιστάται.

  IANA time zone database
     Η Βάση Δεδομένων Ζωνών Ώρας (συχνά αποκαλείται tz, tzdata ή
     zoneinfo) περιέχει κώδικα και δεδομένα που αντιπροσωπεύουν την
     ιστορία της τοπικής ώρας για πολλές αντιπροσωπευτικές τοποθεσίες
     σε όλο τον κόσμο. Ενημερώνεται περιοδικά ώστε να αντικατοπτρίζει
     τις αλλαγές που γίνονται από πολιτικούς φορείς στα όρια των ζωνών
     ώρας, στις αποκλίσεις UTC και στους κανόνες θερινής ώρας.


"timezone" objects
==================

Η κλάση "timezone" είναι μια υποκλάση της "tzinfo", κάθε στιγμιότυπο
της οποίας αντιπροσωπεύει μια ζώνη ώρας που ορίζεται από μια σταθερή
μετατόπιση από το UTC.

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

class datetime.timezone(offset[, name])

   Το όρισμα *offset* πρέπει να καθοριστεί ως ένα αντικείμενο
   "timedelta" που αντιπροσωπεύει τη διαφορά μεταξύ της τοπικής ώρας
   και του UTC. Πρέπει να είναι αυστηρά μεταξύ "-timedelta(hours=24)"
   και "timedelta(hours=24)", διαφορετικά θα γίνει raise μια
   "ValueError".

   Το όρισμα *name* είναι προαιρετικό. Εάν καθοριστεί, πρέπει να είναι
   μια συμβολοσειρά που θα χρησιμοποιηθεί ως η τιμή που επιστρέφεται
   από τη μέθοδο "datetime.tzname()".

   Added in version 3.2.

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

timezone.utcoffset(dt)

   Επιστρέφει την σταθερή τιμή που καθορίστηκε κατά τη δημιουργία του
   στιγμιότυπου "timezone".

   Το όρισμα *dt* αγνοείται. Η επιστρεφόμενη τιμή είναι ένα
   στιγμιότυπο της "timedelta" που είναι ίσο με τη διαφορά μεταξύ της
   τοπικής ώρας και του UTC.

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

timezone.tzname(dt)

   Επιστρέφει την σταθερή τιμή που καθορίστηκε κατά τη δημιουργία του
   στιγμιότυπου "timezone".

   Εάν το *name* δεν παρέχεται στον κατασκευαστή, το όνομα που
   επιστρέφεται από "tzname(dt)" παράγεται από την τιμή του "offset"
   ως εξής. Εάν το *offset* είναι "timedelta(0)", το όνομα είναι
   "UTC", διαφορετικά είναι μια συμβολοσειρά στη μορφή "UTC±HH:MM",
   όπου ± είναι το πρόσημο του "offset", HH και MM είναι δύο ψηφία του
   "offset.hours" και "offset.minutes" αντίστοιχα.

   Άλλαξε στην έκδοση 3.6: Το όνομα που παράγεται από
   "offset=timedelta(0)" είναι τώρα απλώς "'UTC'", όχι "'UTC+00:00'".

timezone.dst(dt)

   Πάντα επιστρέφει "None".

timezone.fromutc(dt)

   Επιστρέφει "dt + offset". Το όρισμα *dt* πρέπει να είναι ένα
   συνειδητό στιγμιότυπο "datetime", με το "tzinfo" να έχει οριστεί σε
   "self".

Χαρακτηριστικά Κλάσης:

timezone.utc

   Η ζώνη ώρας UTC, "timezone(timedelta(0))".


"strftime()" and "strptime()" behavior
======================================

Τα αντικείμενα "date", "datetime" και "time" υποστηρίζουν όλα μια
μέθοδο "strftime(format)", για να δημιουργήσουν μια συμβολοσειρά που
αντιπροσωπεύει την ώρα υπό τον έλεγχο μιας ρητής μορφής συμβολοσειράς.

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

Ο παρακάτω πίνακας παρέχει μια γενική σύγκριση μεταξύ της "strftime()"
και της "strptime()":

+------------------+----------------------------------------------------------+--------------------------------------------------------------+
|                  | "strftime"                                               | "strptime"                                                   |
|==================|==========================================================|==============================================================|
| Χρήση            | Μετατροπή αντικειμένου σε συμβολοσειρά σύμφωνα με μια    | Ανάλυση μιας συμβολοσειράς σε ένα αντικείμενο δεδομένης      |
|                  | δεδομένη μορφή                                           | μορφής                                                       |
+------------------+----------------------------------------------------------+--------------------------------------------------------------+
| Τύπος μεθόδου    | Μέθοδος στιγμής                                          | Μέθοδος κλάσης                                               |
+------------------+----------------------------------------------------------+--------------------------------------------------------------+
| Υπογραφή         | "strftime(format)"                                       | "strptime(date_string, format)"                              |
+------------------+----------------------------------------------------------+--------------------------------------------------------------+


"strftime()" and "strptime()" format codes
------------------------------------------

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

   >>> import datetime as dt
   >>> dt.datetime.strptime('31/01/22 23:59:59.999999',
   ...                      '%d/%m/%y %H:%M:%S.%f')
   datetime.datetime(2022, 1, 31, 23, 59, 59, 999999)
   >>> _.strftime('%a %d %b %Y, %I:%M%p')
   'Mon 31 Jan 2022, 11:59PM'

The following is a list of all the format codes that the 2011 C
standard requires, and these work on all supported platforms.

+-------------+----------------------------------+--------------------------+---------+
| Οδηγία      | Σημασία                          | Παράδειγμα               | Σημειώ  |
|             |                                  |                          | σεις    |
|=============|==================================|==========================|=========|
| "%a"        | Ημέρα της εβδομάδας ως τοπική    | Sun, Mon, ..., Sat       | (1)     |
|             | συντομογραφία.                   | (en_US); So, Mo, ..., Sa |         |
|             |                                  | (de_DE)                  |         |
+-------------+----------------------------------+--------------------------+---------+
| "%A"        | Ημέρα της εβδομάδας ως τοπική    | Sunday, Monday, ...,     | (1)     |
|             | πλήρης ονομασία.                 | Saturday (en_US);        |         |
|             |                                  | Sonntag, Montag, ...,    |         |
|             |                                  | Samstag (de_DE)          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%b"        | Μήνας ως τοπική συντομογραφία.   | Jan, Feb, ..., Dec       | (1)     |
|             |                                  | (en_US); Jan, Feb, ...,  |         |
|             |                                  | Dez (de_DE)              |         |
+-------------+----------------------------------+--------------------------+---------+
| "%B"        | Μήνας ως τοπική πλήρης ονομασία. | January, February, ...,  | (1)     |
|             |                                  | December (en_US);        |         |
|             |                                  | Januar, Februar, ...,    |         |
|             |                                  | Dezember (de_DE)         |         |
+-------------+----------------------------------+--------------------------+---------+
| "%c"        | Το τοπικά κατάλληλο για την      | Tue Aug 16 21:30:00 1988 | (1)     |
|             | αναπαράσταση ημερομηνίας και     | (en_US); Di 16 Aug       |         |
|             | ώρας.                            | 21:30:00 1988 (de_DE)    |         |
+-------------+----------------------------------+--------------------------+---------+
| "%C"        | The year divided by 100 and      | 01, 02, ..., 99          | (0)     |
|             | truncated to an integer as a     |                          |         |
|             | zero-padded decimal number.      |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%d"        | Ημέρα του μήνα ως                | 01, 02, ..., 31          | (9),    |
|             | μηδενικά-γεμισμένο δεκαδικό      |                          | (10)    |
|             | νούμερο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%D"        | Equivalent to "%m/%d/%y".        | 11/28/25                 | (9)     |
+-------------+----------------------------------+--------------------------+---------+
| "%e"        | The day of the month as a space- | ␣1, ␣2, ..., 31          | (10)    |
|             | padded decimal number.           |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%F"        | Equivalent to "%Y-%m-%d", the    | 2025-10-11, 1001-12-30   |         |
|             | ISO 8601 format.                 |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%g"        | Last 2 digits of ISO 8601 year   | 00, 01, ..., 99          | (0)     |
|             | representing the year that       |                          |         |
|             | contains the greater part of the |                          |         |
|             | ISO week ("%V").                 |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%G"        | ISO 8601 έτος με αιώνα που       | 0001, 0002, ..., 2013,   | (8)     |
|             | αντιπροσωπεύει το έτος που       | 2014, ..., 9998, 9999    |         |
|             | περιέχει το μεγαλύτερο μέρος της |                          |         |
|             | ISO εβδομάδας ("%V").            |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%h"        | Equivalent to "%b".              | See "%b".                | (0)     |
+-------------+----------------------------------+--------------------------+---------+
| "%H"        | Ώρα (24-ωρο ρολόι) ως            | 00, 01, ..., 23          | (9)     |
|             | μηδενικά-γεμισμένο δεκαδικό      |                          |         |
|             | νούμερο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%I"        | Η ώρα (σε μορφή 12-ωρού) ως      | 01, 02, ..., 12          | (9)     |
|             | μηδενικά-γεμισμένο δεκαδικό      |                          |         |
|             | νούμερο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%j"        | Ημέρα του έτους ως               | 001, 002, ..., 366       | (9)     |
|             | μηδενικά-γεμισμένο δεκαδικό      |                          |         |
|             | νούμερο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%m"        | Μήνας ως μηδενικά-γεμισμένο      | 01, 02, ..., 12          | (9)     |
|             | δεκαδικό νούμερο.                |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%M"        | Λεπτό ως μηδενικά-γεμισμένο      | 00, 01, ..., 59          | (9)     |
|             | δεκαδικό νούμερο.                |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%n"        | The newline character ("'\n'").  | "\n"                     |         |
|             | For "strptime()", zero or more   |                          |         |
|             | whitespace.                      |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%p"        | Τοπικά ισοδύναμο είτε του AM     | AM, PM (en_US); am, pm   | (1),    |
|             | είτε του PM.                     | (de_DE)                  | (3)     |
+-------------+----------------------------------+--------------------------+---------+
| "%r"        | Locale's 12-hour clock time.     | 12:00:00 AM              | (1),    |
|             |                                  |                          | (0)     |
+-------------+----------------------------------+--------------------------+---------+
| "%R"        | Equivalent to "%H:%M".           | 10:01                    |         |
+-------------+----------------------------------+--------------------------+---------+
| "%S"        | Δευτερόλεπτο ως                  | 00, 01, ..., 59          | (4),    |
|             | μηδενικά-γεμισμένο δεκαδικό      |                          | (9)     |
|             | νούμερο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%t"        | The tab character ("'\t'"). For  | "\t"                     |         |
|             | "strptime()", zero or more       |                          |         |
|             | whitespace.                      |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%T"        | ISO 8601 time format, equivalent | 10:01:59                 |         |
|             | to "%H:%M:%S".                   |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%u"        | ISO 8601 ημέρα της εβδομάδας ως  | 1, 2, ..., 7             |         |
|             | δεκαδικό νούμερο όπου 1 είναι η  |                          |         |
|             | Δευτέρα.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%U"        | Αριθμός εβδομάδας του έτους      | 00, 01, ..., 53          | (7),    |
|             | (Κυριακή ως την πρώτη ημέρα της  |                          | (9)     |
|             | εβδομάδας) ως μηδενικά-γεμισμένο |                          |         |
|             | δεκαδικό νούμερο. Όλες οι ημέρες |                          |         |
|             | σε ένα νέο έτος που προηγούνται  |                          |         |
|             | της πρώτης Κυριακής θεωρούνται   |                          |         |
|             | ότι είναι στην εβδομάδα 0.       |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%V"        | ISO 8601 βδομάδα ως δεκαδικό     | 01, 02, ..., 53          | (8),    |
|             | νούμερο με τη Δευτέρα ως την     |                          | (9)     |
|             | πρώτη μέρα της εβδομάδας. Η      |                          |         |
|             | εβδομάδα 01 είναι η εβδομάδα που |                          |         |
|             | περιέχει την 4η Ιανουαρίου.      |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%w"        | Η ημέρα της εβδομάδας ως         | 0, 1, ..., 6             |         |
|             | δεκαδικός αριθμός, όπου 0 είναι  |                          |         |
|             | η Κυριακή και 6 είναι το         |                          |         |
|             | Σάββατο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%W"        | Αριθμός εβδομάδας του έτους      | 00, 01, ..., 53          | (7),    |
|             | (Δευτέρα ως την πρώτη ημέρα της  |                          | (9)     |
|             | εβδομάδας) ως μηδενικά-γεμισμένο |                          |         |
|             | δεκαδικό νούμερο. Όλες οι ημέρες |                          |         |
|             | σε ένα νέο έτος που προηγούνται  |                          |         |
|             | της πρώτης Δευτέρας θεωρούνται   |                          |         |
|             | ότι είναι στην εβδομάδα 0.       |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%x"        | Το τοπικά κατάλληλο για την      | 08/16/88 (None);         | (1)     |
|             | αναπαράσταση ημερομηνίας.        | 08/16/1988 (en_US);      |         |
|             |                                  | 16.08.1988 (de_DE)       |         |
+-------------+----------------------------------+--------------------------+---------+
| "%X"        | Το τοπικά κατάλληλο για την      | 21:30:00 (en_US);        | (1)     |
|             | αναπαράσταση ώρας.               | 21:30:00 (de_DE)         |         |
+-------------+----------------------------------+--------------------------+---------+
| "%y"        | Έτος χωρίς αιώνα ως              | 00, 01, ..., 99          | (9)     |
|             | μηδενικά-γεμισμένο δεκαδικό      |                          |         |
|             | νούμερο.                         |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%Y"        | Έτος με αιώνα ως δεκαδικός       | 0001, 0002, ..., 2013,   | (2)     |
|             | αριθμός.                         | 2014, ..., 9998, 9999    |         |
+-------------+----------------------------------+--------------------------+---------+
| "%z"        | Διαφορά UTC σε μορφή             | (empty), +0000, -0400,   | (6)     |
|             | "±HHMM[SS[.ffffff]]" (κενή       | +1030, +063415,          |         |
|             | συμβολοσειρά αν το αντικείμενο   | -030712.345216           |         |
|             | είναι αδαές).                    |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%Z"        | Όνομα ζώνης ώρας (κενή           | (κενό), UTC, GMT         | (6)     |
|             | συμβολοσειρά αν το αντικείμενο   |                          |         |
|             | είναι αδαές).                    |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%%"        | Ένας literal χαρακτήρας "'%'".   | %                        |         |
+-------------+----------------------------------+--------------------------+---------+

The ISO 8601 year and ISO 8601 week directives are not interchangeable
with the year and week number directives above. Calling "strptime()"
with incomplete or ambiguous ISO 8601 directives will raise a
"ValueError".

Several additional directives not required by the C11 standard are
included for convenience.

+-------------+----------------------------------+--------------------------+---------+
| Οδηγία      | Σημασία                          | Παράδειγμα               | Σημειώ  |
|             |                                  |                          | σεις    |
|=============|==================================|==========================|=========|
| "%f"        | Μικροδευτερόλεπτο ως δεκαδικό    | 000000, 000001, ...,     | (5)     |
|             | νούμερο, μηδενικά-γεμισμένο σε 6 | 999999                   |         |
|             | ψηφία.                           |                          |         |
+-------------+----------------------------------+--------------------------+---------+
| "%:z"       | UTC διαφορά σε μορφή             | (empty), +00:00, -04:00, | (6)     |
|             | "±HH:MM[:SS[.ffffff]]" (κενή     | +10:30, +06:34:15,       |         |
|             | συμβολοσειρά αν το αντικείμενο   | -03:07:12.345216         |         |
|             | είναι αδαές).                    |                          |         |
+-------------+----------------------------------+--------------------------+---------+

Το πλήρες σύνολο των κωδικών μορφοποίησης που υποστηρίζονται διαφέρει
μεταξύ των πλατφορμών, επειδή η Python καλεί τη λειτουργία
"strftime()" της βιβλιοθήκης C της πλατφόρμας, και οι παραλλαγές
πλατφόρμας είναι συχνές. Για να δείτε το πλήρες σύνολο των κωδικών
μορφοποίησης που υποστηρίζονται στην πλατφόρμα σας, συμβουλευτείτε την
τεκμηρίωση *strftime(3)*. Υπάρχουν επίσης διαφορές μεταξύ των
πλατφορμών στην επεξεργασία μη υποστηριζόμενων προδιαγραφών
μορφοποίησης.

Added in version 3.6: "%G", "%u" και "%V" προστέθηκαν.

Added in version 3.12: "%:z" was added for "strftime()".

Added in version 3.15: "%D", "%F", "%n", "%t", and "%:z" were added
for "strptime()".


Technical detail
----------------

Σε γενικές γραμμές, το "d.strftime(fmt)" λειτουργεί όπως το
"time.strftime(fmt, d.timetuple())" του module "time" αν και, δεν
υποστηρίζουν όλα τα αντικείμενα μια μέθοδο "timetuple()".

For the "datetime.strptime()" and "date.strptime()" class methods, the
default value is "1900-01-01T00:00:00.000": any components not
specified in the format string will be pulled from the default value.

Σημείωση:

  Format strings without separators can be ambiguous for parsing. For
  example, with "%Y%m%d", the string "2026111" may be parsed either as
  "2026-11-01" or as "2026-01-11". Use separators to ensure the input
  is parsed as intended.

Σημείωση:

  When used to parse partial dates lacking a year,
  "datetime.strptime()" and "date.strptime()" will raise when
  encountering February 29 because the default year of 1900 is *not* a
  leap year.  Always add a default leap year to partial date strings
  before parsing.

   >>> import datetime as dt
   >>> value = "2/29"
   >>> dt.datetime.strptime(value, "%m/%d")
   Traceback (most recent call last):
   ...
   ValueError: day 29 must be in range 1..28 for month 2 in year 1900
   >>> dt.datetime.strptime(f"1904 {value}", "%Y %m/%d")
   datetime.datetime(1904, 2, 29, 0, 0)

Η χρήση του "datetime.strptime(date_string, format)" είναι ισοδύναμη
με:

   datetime(*(time.strptime(date_string, format)[0:6]))

εκτός αν η μορφή περιλαμβάνει υπο-δευτερόλεπτα ή πληροφορίες ζώνης
ώρας, οι οποίες υποστηρίζονται στο "datetime.strptime" αλλά
απορρίπτονται από το "time.strptime".

Για τα αντικείμενα "time", οι κωδικοί μορφοποίησης για το έτος, τον
μήνα και την ημέρα δεν πρέπει να χρησιμοποιούνται, καθώς τα
αντικείμενα "time" δεν έχουν τέτοιες τιμές. Εάν χρησιμοποιηθούν ούτως
ή άλλως, το έτος αντικαθίσταται με το 1900, και ο μήνας και η ημέρα με
το 1.

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

Για τον ίδιο λόγο, η επεξεργασία συμβολοσειρών μορφοποίησης που
περιέχουν σημεία κώδικα Unicode που δεν μπορούν να αναπαρασταθούν στο
charset της τρέχουσας τοποθεσίας είναι επίσης εξαρτώμενη από την
πλατφόρμα. Σε ορισμένες πλατφόρμες, τέτοια σημεία κώδικα διατηρούνται
άθικτα στην έξοδο, ενώ σε άλλες το *strftime* μπορεί να κάνει raise
μια "UnicodeError" ή να επιστρέψει μια κενή συμβολοσειρά.

Σημειώσεις:

* This format code is currently unsupported by "strptime()".

* Επειδή η μορφή εξαρτάται από την τρέχουσα τοποθεσία, θα πρέπει να
  προσέχετε όταν κάνετε υποθέσεις σχετικά με την τιμή εξόδου. Οι
  διατάξεις πεδίων θα διαφέρουν (για παράδειγμα, "μήνας/ημέρα/έτος" σε
  σύγκριση με "ημέρα/μήνας/έτος"), και η έξοδος μπορεί να περιέχει
  μη-ASCII χαρακτήρες.

* Η μέθοδος "strptime()" μπορεί να αναλύσει έτη στο πλήρες εύρος [1,
  9999], αλλά τα έτη < 1000 πρέπει να είναι μηδενικά γεμισμένα σε
  πλάτος 4 ψηφίων.

  Άλλαξε στην έκδοση 3.2: Σε προηγούμενες εκδόσεις, η μέθοδος
  "strftime()" περιορίζεται σε έτη >= 1900.

  Άλλαξε στην έκδοση 3.3: Στην έκδοση 3.2, η μέθοδος "strftime()"
  περιορίζεται σε έτη >= 1000.

* Όταν χρησιμοποιείται με τη μέθοδο "strptime()", η οδηγία "%p"
  επηρεάζει μόνο το πεδίο εξόδου ώρας εάν η οδηγία "%I"
  χρησιμοποιείται για να αναλύσει την ώρα.

* Σε αντίθεση με το "time", το "datetime" δεν υποστηρίζει δευτερόλεπτα
  άλματος (leap seconds).

* Όταν χρησιμοποιείται με τη μέθοδο "strptime()", η οδηγία "%f"
  αποδέχεται από ένα έως έξι ψηφία και γεμίζει με μηδενικά στα δεξιά.
  Η Η "%f" είναι μια επέκταση του συνόλου χαρακτήρων μορφοποίησης στο
  C standard (αλλά υλοποιημένη χωριστά σε αντικείμενα datetime, και
  επομένως πάντα διαθέσιμη).

* Για ένα αδαές αντικείμενο, οι κωδικοί μορφοποίησης "%z", "%:z" και
  "%Z" αντικαθίστονται με κενές συμβολοσειρές.

  Για ένα ενήμερο αντικείμενο:

  "%z"
     Η "utcoffset()" μετατρέπεται σε μια συμβολοσειρά της μορφής
     "±HHMM[SS[.ffffff]]", όπου "HH" είναι μια 2-ψήφια συμβολοσειρά
     που δίνει τον αριθμό των ωρών διαφοράς UTC, "MM" είναι μια
     2-ψήφια συμβολοσειρά που δίνει τον αριθμό των λεπτών διαφοράς
     UTC, "SS" είναι μια 2-ψήφια συμβολοσειρά που δίνει τον αριθμό των
     δευτερολέπτων διαφοράς UTC και "ffffff" είναι μια 6-ψήφια
     συμβολοσειρά που δίνει τον αριθμό των μικροδευτερολέπτων διαφοράς
     UTC. Το τμήμα "ffffff" παραλείπεται όταν η διαφορά είναι ένας
     ακέραιος αριθμός δευτερολέπτων και τόσο το τμήμα "ffffff" όσο και
     το τμήμα "SS" παραλείπονται όταν η διαφορά είναι ένας ακέραιος
     αριθμός λεπτών. Για παράδειγμα, εάν η "utcoffset()" επιστρέψει
     "timedelta(hours=-3, minutes=-30)", το "%z" αντικαθίσταται με τη
     συμβολοσειρά "'-0330'".

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

  Άλλαξε στην έκδοση 3.7: When the "%z" directive is provided to the
  "strptime()" method, the UTC offsets can have a colon as a separator
  between hours, minutes and seconds. For example, both "'+010000'"
  and "'+01:00:00'" will be parsed as an offset of one hour. In
  addition, providing "'Z'" is identical to "'+00:00'".

  "%:z"
     When used with "strftime()", behaves exactly as "%z", except that
     a colon separator is added between hours, minutes and seconds.

     When used with "strptime()", the UTC offset is *required* to have
     a colon as a separator between hours, minutes and seconds. For
     example, "'+01:00:00'" (but *not* "'+010000'") will be parsed as
     an offset of one hour. In addition, providing "'Z'" is identical
     to "'+00:00'".

  "%Z"
     Στην "strftime()", το "%Z" αντικαθίσταται με μια κενή
     συμβολοσειρά αν η "tzname()" επιστρέψει "None" · διαφορετικά το
     "%Z" αντικαθίσταται με την επιστρεφόμενη τιμή, η οποία πρέπει να
     είναι μια συμβολοσειρά.

     Η "strptime()" δέχεται μόνο συγκεκριμένες τιμές για το "%Z":

     1. οποιαδήποτε τιμή στο "time.tzname" για την τοποθεσία του
        μηχανήματός σας

     2. οι σταθερές τιμές "UTC" και "GMT"

     Έτσι, κάποιος που ζει στην Ιαπωνία μπορεί να έχει "JST", "UTC"
     και "GMT" ως έγκυρες τιμές, αλλά πιθανότατα όχι "EST". Θα γίνει
     raise "ValueError" για μη έγκυρες τιμές.

  Άλλαξε στην έκδοση 3.2: Όταν η οδηγία "%z" παρέχεται στη μέθοδο
  "strptime()", ένα αντικείμενο "datetime" με γνώση ζώνης θα παραχθεί.
  Το "tzinfo" του αποτελέσματος θα ρυθμιστεί σε μια "timezone"
  παρουσία.

* Όταν χρησιμοποιείται με τη μέθοδο "strptime()", το "%U" και το "%W"
  χρησιμοποιούνται μόνο σε υπολογισμούς όταν η ημέρα της εβδομάδας και
  το ημερολογιακό έτος ("%Y") είναι καθορισμένα.

* Παρόμοια με "%U" και "%W", το "%V" χρησιμοποιείται μόνο σε
  υπολογισμούς όταν η ημέρα της εβδομάδας και το ISO έτος ("%G") είναι
  καθορισμένα σε μια συμβολοσειρά μορφής "strptime()". Σημειώστε
  επίσης ότι "%G" και "%Y" δεν είναι ανταλλάξιμα.

* Όταν χρησιμοποιείται με τη μέθοδο "strptime()", το μηδενικό ψηφίο
  μπροστά είναι προαιρετικό για τις μορφές "%d", "%m", "%H", "%I",
  "%M", "%S", "%j", "%U", "%W" και "%V". Η μορφή "%y" απαιτεί μπροστά
  μηδενικό ψηφίο.

* When parsing a month and day using "strptime()", always include a
  year in the format.  If the value you need to parse lacks a year,
  append an explicit dummy leap year.  Otherwise your code will raise
  an exception when it encounters leap day because the default year
  used by the parser (1900) is not a leap year.  Users run into that
  bug every leap year.

     >>> month_day = "02/29"
     >>> dt.datetime.strptime(f"{month_day};1984", "%m/%d;%Y")  # No leap year bug.
     datetime.datetime(1984, 2, 29, 0, 0)

  Άλλαξε στην έκδοση 3.15: Using "%d" without a year now raises
  "ValueError".

  Καταργήθηκε από την έκδοση 3.15, θα αφαιρεθεί στην έκδοση 3.17:
  "strptime()" calls using a format string containing "%e" without a
  year now emit a "DeprecationWarning".

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

[1] If, that is, we ignore the effects of relativity.

[2] Αυτό ταιριάζει με τον ορισμό του "proleptic Gregorian" ημερολογίου
    στο βιβλίο των Dershowitz και Reingold *Calendrical Calculations*,
    όπου αποτελεί τη βασική μέθοδο για όλους τους υπολογισμούς. Δείτε
    το βιβλίο για αλγορίθμους μετατροπής μεταξύ προληπτικών
    Γρηγοριανών αριθμών και πολλών άλλων συστημάτων ημερολογίου.

[3] Δείτε τον οδηγό του R. H. van Gent για τα μαθηματικά του
    ημερολογίου ISO 8601 <https://web.archive.org/web/20220531051136/
    https://webspace.science.uu.nl/~gent0113/calendar/isocalendar.htm>
    για μια καλή εξήγηση.
