Comprendre la date et l'heure Python, avec des exemples

Dans cet article, nous explorerons comment utiliser la date et l'heure dans Python. Nous verrons des exemples réels de travail avec la date et l'heure à l'aide des modules Python DateTime et Time.

Travailler avec les temps et les dates est inévitable lors de la construction de projets réels, et il y a de nombreux cas d'utilisation pour eux. Heureusement, Python a quelques modules qui facilitent le travail avec les dates et les temps à travers différents fuseaux horaires.

Le code de ce tutoriel peut être trouvé sur github .

Contenu:

1. le module de temps
   • La fonction Time ()
   • la fonction gmtime ()
   • la fonction localtime ()
   • la fonction ctime ()
   • la fonction strftime ()
   • la fonction sleep ()
2. Le module DateTime
3. Obtenir la date et l'heure actuelles dans Python
4. Obtenir la date actuelle dans Python
5. Les classes du module DateTime
6. la classe de date
7. la classe temporelle
8. La classe DateTime
9. La classe Timedelta
10. Python DateTime Formatting
    • Formatage DateTime avec la méthode strftime ()
    • Formatage de DateTime avec la méthode strptime ()
11. Travailler avec Timedelta

Les plats clés

• Python fournit les modules «DateTime» et «Time» pour gérer les opérations de date et d'heure, qui sont essentielles pour les projets réels.
• Le module «DateTime» comprend des classes comme «Date», «Time», «DateTime», «TimeDelta», «Tzinfo» et `Timezone» pour la manipulation complète de la date et de l'heure.
• Utilisez `DateTime.Now ()` et `Date.today ()` Méthodes pour récupérer la date et l'heure actuelles, avec des options de formatage disponibles via `strftime ()` et `strptime ()`.
• La classe «TimeDelta» est utile pour calculer les différences dans les dates et les heures, permettant l'addition, la soustraction et d'autres calculs basés sur le temps.
• La manipulation du fuseau horaire est facilitée par le module `ZoneInfo`, permettant la création d'objets DateTime Aware-Timezone.
• L'approche de Python à la mise en forme des dattes et de l'heure adhère aux normes ISO 8601, mais permet également à la personnalisation des préférences régionales.

Le module de temps

Le module de temps Python est pour effectuer des opérations liées au temps. Nous allons maintenant mettre en évidence certaines des fonctions les plus couramment utilisées dans le module TIME, avec des exemples.

La fonction Time ()

La fonction Time () renvoie l'heure actuelle en secondes depuis le début d'une époque définie comme numéro de point flottant. L'époque utilisée commence le 1er janvier 1970, 00:00:00 (UTC):

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

la fonction gmtime ()

La fonction gmtime () renvoie un struct_time dans UTC à partir du temps exprimé en secondes depuis le début de l'époque. Un struct_time est un type de séquence de valeur de temps avec une interface tuple nommée renvoyée par gmtime (), localtime () et strptime ():

Time <span>in sceconds from epoch 1680712853.0801558</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
utc_time_in_seconds <span>= time_module.gmtime()
</span><span>print("Time struct in UTC", utc_time_in_seconds)</span>

la fonction localtime ()

La fonction localtime () renvoie un struct_time dans le temps local à partir du temps exprimé en secondes depuis le début de l'époque:

Time struct <span>in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
local_time <span>= time_module.localtime()
</span><span>print("Time struct in local time:", local_time)</span>

la fonction ctime ()

La méthode ctime () convertit le temps en secondes du début de l'époque en un format de chaîne. Si aucun argument n'est transmis à la fonction, il renvoie une chaîne de temps pour l'heure actuelle en secondes:

Time struct <span>in local time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_secs <span>= 1678671984.939945  
</span>
time_string <span>= time_module.ctime(time_in_secs)
</span><span>print("Time string: ",time_string)</span>

la fonction strftime ()

La méthode strftime () convertit un struct_time en une chaîne de temps comme spécifié par un argument de format donné:

Time string: Thu Apr <span>20 01:46:24 2023</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_tuple <span>= time_module.gmtime()
</span>time_format <span>= "%y/%m/%d %I:%M:%S %p"
</span>
time_in_string <span>= time_module.strftime(time_format, time_tuple)
</span>
<span>print("Time expressed as formatted string:", time_in_string)</span>

la fonction sleep ()

La fonction Sleep () retarde l'exécution d'un thread pour un nombre spécifié de secondes:

Time expressed as formatted string: <span>23/04/20 04:40:04 PM</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module 
</span>
<span>for i in range(5):
</span>    local_time <span>= time_module.localtime()
</span>    seconds <span>= local_time.tm_sec
</span>    <span>print(seconds)
</span>    time_module<span>.sleep(2)</span>

Dans le code ci-dessus, le numéro 2 est passé comme un argument de la fonction Sleep (), ce qui fait retarder la boucle de deux secondes avant l'exécution. Les nombres qui sont sortis valident notre code.

Le module DateTime

Le module DateTime fournit des cours pour manipuler les dates et les heures.

Ces classes sont essentielles pour la manipulation, l'extraction et la mise en forme de sortie faciles des intervalles de temps, des temps et des dates. Habituellement, la date et l'heure ne sont pas considérées comme des types de données dans Python, mais ce sont des objets date et heure des classes de modules DateTime. Les classes DateTime ont également différentes méthodes disponibles pour gérer les objets date et heure.

Obtenir la date et l'heure actuelles dans Python

Pour obtenir la date et l'heure actuelles, importez la classe DateTime à partir du module DateTime. La classe DateTime a une méthode, maintenant (), qui renvoie la date et l'heure actuelles:

<span>49
</span><span>51
</span><span>53
</span><span>55
</span><span>57</span>

Voici la sortie du code ci-dessus:

<span>from  datetime  import  datetime
</span>
current_date_time <span>= datetime.now()
</span><span>print(current_date_time)</span>

Obtenir la date actuelle dans Python

Pour obtenir la date actuelle, importez la classe de date du module DateTime. La classe de date a une méthode, aujourd'hui (), qui renvoie la date actuelle:

<span>2023-04-20 13:47:02.362424</span>

Voici la sortie du code ci-dessus:

<span>from datetime import date
</span>
current_date <span>= date.today()
</span><span>print(current_date)</span>

Les classes du module DateTime

Le module DateTime propose actuellement six classes, chacune avec différentes méthodes pour manipuler les objets de date et de temps. Les classes sont répertoriées comme suit:

• Date
• temps
• DateTime
• Timedelta
• tzinfo
• Fuseau horaire

la classe de date

Un objet de date représente une date (année, mois et jour) dans un calendrier idéalisé - le calendrier grégorien actuel indéfiniment étendu dans les deux directions.

Un objet date peut être instancié comme suit:

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

Le constructeur d'objets de date prend trois arguments entiers et doit être dans la plage spécifiée:

• minyear
• 1
• 1

Dans le code ci-dessus, Minyear est 1 et Maxyear est 9999. Les valeurs représentent le numéro d'année le plus petit et le plus grand autorisé dans un objet Date ou DateTime objet.

Lorsque les arguments sont hors de portée, il lance une valeur d'énergie et les arguments non entières jettent une émergente.

Exemple: créez un objet de date

Pour créer un objet de date, importez la classe de date du module DateTime et adoptez des arguments pour l'année, le mois et le jour dans le constructeur de date. Les arguments doivent être des entiers et dans la plage spécifiée:

Time <span>in sceconds from epoch 1680712853.0801558</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
utc_time_in_seconds <span>= time_module.gmtime()
</span><span>print("Time struct in UTC", utc_time_in_seconds)</span>

Exemple: Obtenez la date actuelle

Pour obtenir la date locale actuelle, utilisez la classe de date aujourd'hui () et ctime () Méthodes:

Time struct <span>in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

La méthode Today () renvoie une date locale, tandis que la méthode ctime () rend la date en tant que chaîne. Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
local_time <span>= time_module.localtime()
</span><span>print("Time struct in local time:", local_time)</span>

Exemple: créez la date à partir du format ISO

Un objet date peut être créé à partir d'une chaîne de date au format ISO 8601. Utilisez la méthode FromSoFormat () de la classe Date pour ce faire:

Time struct <span>in local time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Remarque: ISO 8601 est un format standardisé pour présenter les dates et le temps sans créer de confusion dans différentes régions ou fuseaux horaires. ISO 8601 prend le format yyyy-mm-dd.

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_secs <span>= 1678671984.939945  
</span>
time_string <span>= time_module.ctime(time_in_secs)
</span><span>print("Time string: ",time_string)</span>

Exemple: Créer un objet date à partir de la chaîne

Pour créer un objet de date, passez une chaîne de date et le format correspondant à la méthode strptime (). Extraire la date en utilisant la méthode date () de l'objet DateTime renvoyé:

Time string: Thu Apr <span>20 01:46:24 2023</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_tuple <span>= time_module.gmtime()
</span>time_format <span>= "%y/%m/%d %I:%M:%S %p"
</span>
time_in_string <span>= time_module.strftime(time_format, time_tuple)
</span>
<span>print("Time expressed as formatted string:", time_in_string)</span>

Exemple: Obtenez l'année, mois, jour à partir de l'objet de date

pour extraire l'année, le mois et le jour à partir d'un objet de date, utilisez les attributs .year, .month et .day de la classe de date:

Time expressed as formatted string: <span>23/04/20 04:40:04 PM</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module 
</span>
<span>for i in range(5):
</span>    local_time <span>= time_module.localtime()
</span>    seconds <span>= local_time.tm_sec
</span>    <span>print(seconds)
</span>    time_module<span>.sleep(2)</span>

la classe temporelle

Un objet temporel représente un temps (local) de la journée, indépendant de tout jour particulier, et soumis à un ajustement via un objet tzinfo.

Un objet date peut être instancié comme suit:

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

L'objet temporel peut être instancié sans aucun argument. Tous les arguments sont facultatifs avec une valeur par défaut de 0, sauf tzinfo, qui n'est pas. Tous les arguments doivent être entiers dans une plage spécifiée, tandis que l'argument tzinfo doit être une instance de la sous-classe Tzinfo:

• 0
• 0
• 0
• 0

Lorsque des arguments qui sont hors de portée sont transmis au constructeur, il soulève une valeur d'énergie.

Exemple: créez un objet temporel

Pour créer un objet Time, importez la classe temporelle du module DateTime. Passer des arguments pendant des heures, des minutes, des secondes, des microsecondes et du tzinfo. N'oubliez pas que tous les arguments sont facultatifs, donc quand aucun argument n'est transmis au constructeur, l'objet Time Retour 00:00:00:

Time <span>in sceconds from epoch 1680712853.0801558</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
utc_time_in_seconds <span>= time_module.gmtime()
</span><span>print("Time struct in UTC", utc_time_in_seconds)</span>

Exemple: créez du temps à partir du format ISO

Un objet temporel peut être créé à partir d'une chaîne temporelle au format ISO 8601. Utilisez la méthode FromSoFORMAT () de la classe temporelle pour ce faire:

Time struct <span>in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
local_time <span>= time_module.localtime()
</span><span>print("Time struct in local time:", local_time)</span>

Exemple: Créer un objet Time à partir de String

Pour créer un objet temporel, passez une chaîne de date et le format correspondant à la méthode strptime (). Extraire le temps en utilisant la méthode Time () de l'objet DateTime renvoyé:

Time struct <span>in local time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_secs <span>= 1678671984.939945  
</span>
time_string <span>= time_module.ctime(time_in_secs)
</span><span>print("Time string: ",time_string)</span>

Exemple: Obtenez des heures, des minutes, des secondes et des microsecondes de l'objet temporel

Pour extraire les valeurs pendant des heures, des minutes, des secondes et des microsecondes, utilisez les attributs heure, minute, seconde et microseconde de l'objet temporel:

Time string: Thu Apr <span>20 01:46:24 2023</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_tuple <span>= time_module.gmtime()
</span>time_format <span>= "%y/%m/%d %I:%M:%S %p"
</span>
time_in_string <span>= time_module.strftime(time_format, time_tuple)
</span>
<span>print("Time expressed as formatted string:", time_in_string)</span>

La classe DateTime

Un objet DateTime est un seul objet contenant toutes les informations d'un objet Date et d'un objet Time.

Un objet DateTime peut être instancié comme suit:

Time expressed as formatted string: <span>23/04/20 04:40:04 PM</span>

Le constructeur DateTime nécessite les arguments de l'année, du mois et du jour. La valeur par défaut tzinfo n'est pas ou une instance de la sous-classe Tzinfo. Les arguments de temps sont facultatifs, mais les arguments doivent être des entiers et à portée:

• minyear
• 1
• 1
• 0
• 0
• 0
• 0

Une valeur d'énergie est soulevée si les arguments sont hors de portée.

Exemple: créez un objet DateTime

Pour créer un objet DateTime, importez la classe DateTime à partir du module DateTime et transmettez les arguments suivants:

<span>import time as time_module 
</span>
<span>for i in range(5):
</span>    local_time <span>= time_module.localtime()
</span>    seconds <span>= local_time.tm_sec
</span>    <span>print(seconds)
</span>    time_module<span>.sleep(2)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

Exemple: Obtenez la date et l'heure locales actuelles

Pour obtenir la date et l'heure locales actuelles, utilisez la méthode maintenant () de la classe DateTime:

Time <span>in sceconds from epoch 1680712853.0801558</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
utc_time_in_seconds <span>= time_module.gmtime()
</span><span>print("Time struct in UTC", utc_time_in_seconds)</span>

Exemple: créer une date de date à partir du format ISO

Pour créer un objet DateTime à partir d'une chaîne de date de date au format ISO 8601, utilisez la méthode FromSoFORMAT () de la classe DateTime:

Time struct <span>in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

REMARQUE: Si l'argument de la chaîne de date transmis dans la méthode FromSoOrt () n'est pas une chaîne de format ISO valide, une exception ValueError est élevée. La sortie de date ici est assez similaire au résultat obtenu à partir de DateTime.now ().

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
local_time <span>= time_module.localtime()
</span><span>print("Time struct in local time:", local_time)</span>

Exemple: Obtenez des attributs de date et d'heure à partir de l'objet DateTime

Un objet DateTime propose les attributs suivants: année, mois, jour, heure, minute, deuxième, microseconde, tzinfo et pli. Les attributs sont accessibles comme suit:

Time struct <span>in local time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_secs <span>= 1678671984.939945  
</span>
time_string <span>= time_module.ctime(time_in_secs)
</span><span>print("Time string: ",time_string)</span>

Remarque: La valeur d'attribut par défaut pour Tzinfo n'est pas, car il n'y a pas d'argument d'objet passé, et le pli renverra 0 par défaut. Pour en savoir plus sur l'attribut de pli (qui a été introduit dans Python version 3.6), consultez les documents.

La classe Timedelta

Un objet TimeDelta représente une durée, la différence entre deux dates ou heures.

Un objet TimeDelta peut être instancié comme suit:

Time string: Thu Apr <span>20 01:46:24 2023</span>

Tous les arguments sont facultatifs, avec une valeur par défaut de 0. Les entiers ou flotteurs, les nombres positifs ou négatifs sont des arguments valides pour le constructeur.

Les arguments sont convertis comme suit:

• Une milliseconde est convertie en 1000 microsecondes.
• Une minute est convertie en 60 secondes.
• Une heure est convertie en 3600 secondes.
• Une semaine est convertie en 7 jours.

Tous les arguments devraient se situer dans la plage suivante comme spécifié dans les documents:

• 0
• 0
• -999999999

Un gerflowerror est augmenté si les arguments sont en dehors de la plage de jours normalisés.

Exemple: créez un objet TimeDelta

Pour créer un objet TimeDelta, importez la classe TimeDelta à partir du module DateTime. Passez les arguments appropriés à la fonction du constructeur:

<span>import time as time_module
</span>
time_tuple <span>= time_module.gmtime()
</span>time_format <span>= "%y/%m/%d %I:%M:%S %p"
</span>
time_in_string <span>= time_module.strftime(time_format, time_tuple)
</span>
<span>print("Time expressed as formatted string:", time_in_string)</span>

Voici la sortie du code ci-dessus:

Time expressed as formatted string: <span>23/04/20 04:40:04 PM</span>

Python DateTime Formatting

Les formats de date et d'heure diffèrent d'une région à l'autre et d'un pays à l'autre. C'est à cause de ces différences de formats de date et de temps que le format ISO 8601 a été introduit, comme moyen de normaliser la date et l'heure. Cependant, il peut être nécessaire de formater la date et l'heure d'une manière particulière basée sur un pays ou une région.

Formatage DateTime avec la méthode strftime ()

Le formatage de DateTime peut être fait avec la méthode strftime (). La méthode STRFTIME () est une méthode d'instance de temps, de date et de datetime, ce qui signifie que nous devons créer un objet date, heure ou datetime pour appliquer la méthode. La méthode prend un code de format donné comme un argument et renvoie une chaîne représentant l'heure, la date ou la datetime au format souhaité.

La signature de la méthode ressemble à ceci:

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

Habituellement, un code de format de chaîne est passé comme un argument à la méthode strftime () pour formater la date. Certains des codes de format sont les suivants:

• % A: nom abrégé en semaine - comme le soleil, le lundi, etc.
• % b: mois comme nom abrégé - comme janvier, février, etc.
• % Y: Année sans siècle comme un nombre décimal zéro padded - tels que 00, 01, 02, etc.
  

Une table plus détaillée avec du code de format peut être trouvée dans les documents Python.

Exemple: Date et heure du format dans un objet DateTime

Tout comme dans les exemples précédents, nous pouvons transmettre un argument de la chaîne de format de la sortie de date et de temps souhaitée à la méthode strftime ():

Time <span>in sceconds from epoch 1680712853.0801558</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
utc_time_in_seconds <span>= time_module.gmtime()
</span><span>print("Time struct in UTC", utc_time_in_seconds)</span>

Formatage de DateTime avec la méthode strptime ()

Contrairement à Strftime (), le strptime () est une méthode de classe DateTime, ce qui signifie qu'il peut être utilisé sans créer un objet de la classe. La méthode renvoie un objet DateTime à partir d'une chaîne et d'un format de date donné.

La signature de la méthode ressemble à ceci:

Time struct <span>in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Un code de format de chaîne est passé comme un argument à la méthode strptime () pour formater la date.

Exemple: String to DateTime Object

Pour créer un objet DateTime, nous passerons deux arguments à la méthode Strptime (), une chaîne de date et un format correspondant. Une valeur de valeur est augmentée lorsque la chaîne de date ne correspond pas au format fourni:

<span>import time as time_module
</span>
local_time <span>= time_module.localtime()
</span><span>print("Time struct in local time:", local_time)</span>

Voici la sortie du code ci-dessus:

Time struct <span>in local time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Travailler avec Timedelta

La classe TimeDelta dans Python est utilisée pour calculer la différence entre les dates, le calcul des différences de temps entre les dates spécifiques et la réalisation d'autres calculs en utilisant des unités spécifiques de temps (comme les semaines ou les heures).

Exemple: calculer une date future

<span>import time as time_module
</span>
time_in_secs <span>= 1678671984.939945  
</span>
time_string <span>= time_module.ctime(time_in_secs)
</span><span>print("Time string: ",time_string)</span>

Voici la sortie du code ci-dessus:

Time string: Thu Apr <span>20 01:46:24 2023</span>

À partir de l'exemple ci-dessus, nous obtenons d'abord une date et une heure locales actuelles et un objet TimeDelta de sept jours. Étant donné que TimedElta prend en charge les opérations comme l'ajout, nous ajoutons l'objet DateTime et l'objet TimeDelta pour obtenir une journée future en sept jours. Si notre date actuelle est 2023-04-20, en sept jours, la date sera de 2023-04-27.

Exemple: calculer la différence entre deux objets TimeDelta

<span>import time as time_module
</span>
time_tuple <span>= time_module.gmtime()
</span>time_format <span>= "%y/%m/%d %I:%M:%S %p"
</span>
time_in_string <span>= time_module.strftime(time_format, time_tuple)
</span>
<span>print("Time expressed as formatted string:", time_in_string)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_seconds <span>= time_module.time()
</span><span>print("Time in sceconds from epoch", time_in_seconds)</span>

Dans l'extrait de code ci-dessus, nous avons créé deux objets TimeDelta, Time_delta1 et Time_delta2, et calculé la différence entre eux.

Exemple: Calculez la somme de deux objets TimeDelta

Time <span>in sceconds from epoch 1680712853.0801558</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
utc_time_in_seconds <span>= time_module.gmtime()
</span><span>print("Time struct in UTC", utc_time_in_seconds)</span>

Comme le montre ci-dessus, les objets TimeDelta prennent en charge l'opération d'addition et le résultat est sorti de la console. Les objets TimeDelta prennent en charge les opérations comme la soustraction, la multiplication et la division.

Travailler avec les fuseaux horaires

L'utilisation des fuseaux horaires est nécessaire si nous voulons créer des objets de date et d'heure. Un objet de conscience ou de date de conscience comprend des informations sur le fuseau horaire. Il est également important pour afficher des objets de temps ou de date par rapport à une région particulière.

ZoneInfo est un module Python intégré pour travailler avec les fuseaux horaires.

Exemple: Créez un objet DateTime avec des informations sur le fuseau horaire

Time struct <span>in UTC: time.struct_time(tm_year=2023, tm_mon=3, tm_mday=16, tm_hour=14, tm_min=47, tm_sec=28, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
local_time <span>= time_module.localtime()
</span><span>print("Time struct in local time:", local_time)</span>

Tout d'abord, nous importons la classe DateTime à partir du module DateTime et ZoneInfo du module ZoneInfo. Nous créons un objet ZoneInfo puis un objet DateTime, mais cette fois, nous passons l'objet Timezone TZ à la méthode Now ().

Lorsque nous vérifions la valeur de l'attribut tzinfo, il renvoie le nom du fuseau horaire Africa / Accra, pas aucun.

Exemple: convertir un objet DateTime d'un fuseau horaire à un autre

Time struct <span>in local time: time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=15, tm_min=46, tm_sec=15, tm_wday=3, tm_yday=75, tm_isdst=0)</span>

Voici la sortie du code ci-dessus:

<span>import time as time_module
</span>
time_in_secs <span>= 1678671984.939945  
</span>
time_string <span>= time_module.ctime(time_in_secs)
</span><span>print("Time string: ",time_string)</span>

Pour convertir entre les fuseaux horaires, nous utilisons la méthode astimeZone () de l'objet DateTime, passant dans un nouvel objet de fuseau horaire. L'AstimeZone () renvoie un nouvel objet DateTime avec des informations de fuseau horaire mises à jour.

Conclusion

Garder le temps est un aspect important de notre vie quotidienne, ce qui se traduit également par la programmation. Lorsque nous construisons des projets du monde réel, il est toujours nécessaire de tenir des journaux de temps pour les activités des utilisateurs comme la connexion et la déconnexion, entre autres cas d'utilisation. Il est également important de mettre un horodatage sur le contenu généré en ligne et d'afficher l'heure et la date en fonction de la région ou du fuseau horaire d'un utilisateur.

Pour mieux gérer les temps et les dates dans nos programmes ou applications, Python fournit les modules de temps et de DateTime. Ces modules ont des fonctions, des classes et des méthodes pour gérer les tâches liées au temps. Dans cet article, nous avons mis en évidence certaines fonctions et méthodes couramment utilisées, fournissant des exemples de la façon dont ils peuvent être utilisés.

Le code de ce tutoriel peut être trouvé sur github .

Questions fréquemment posées (FAQ) sur la date et l'heure Python

Comment puis-je convertir une chaîne en une date dans Python?

Dans Python, vous pouvez convertir une chaîne en une date à l'aide de la fonction Strptime () du module DateTime. Cette fonction prend deux arguments: la chaîne que vous souhaitez convertir et un code de format qui correspond au format de date de la chaîne. Par exemple, si vous avez une chaîne de date «2022-03-01» dans le format «yyyy-mm-dd», vous pouvez le convertir en une date comme ceci:

à partir de Datetime Import Datetime
date_string = "2022-03-01"
date_object = datetime.strptime (date_string, "% y-% m-% d")

Comment puis-je obtenir la date et l'heure actuelles dans Python?

Le module DateTime de Python fournit la fonction DateTime.Now (), qui renvoie la date et l'heure actuelles. Voici comment vous pouvez l'utiliser:

à partir de DateTime Import DateTime
current_datetime = dateTime.now ()
print (current_datetime)

comment puis-je formater une date dans Python?

Le module DateTime de Python fournit la fonction strftime (), que vous pouvez utiliser pour formater une date. Cette fonction prend un code de format comme argument et renvoie une chaîne représentant la date au format spécifié. Par exemple, pour formater une date dans le format «Yyyy-mm-dd», vous pouvez le faire:

à partir de DateTime Import DateTime
current_datetime = datetime.now ()
formatted_date = current_datetime. Strftime ("% y-% m-% d")
imprimer (formatted_date)

comment puis-je ajouter ou soustraire des jours à partir d'une date dans Python?

Le module DateTime de Python fournit le module Classe TimeDelta, que vous pouvez utiliser pour ajouter ou soustraire un certain nombre de jours à partir d'une date. Voici comment vous pouvez l'utiliser:

à partir de DateTime Import DateTime, TimeDelta
current_date = dateTime.now ()
new_date = current_date TimeDelta (days = 5)
print (new_date)

Comment puis-je comparer deux dates dans Python?

Dans Python, vous pouvez comparer deux dates à l'aide d'opérateurs de comparaison comme , == ,! =, =. Voici un exemple:

à partir de DateTime Import DateTime
date1 = DateTime (2022, 3, 1)
date2 = DateTime (2022, 4, 1)
if date1 print ("date1 est antérieure à la date2")

comment puis-je obtenir le jour de la semaine à Python?

Le module DateTime de Python fournit la fonction de semaine (), qui renvoie le jour du jour La semaine en tant qu'ender (où le lundi est 0 et dimanche a 6 ans). Voici comment vous pouvez l'utiliser:

à partir de DateTime Import DateTime
current_date = dateTime.now ()
day_of_week = current_date.weekday ()
print (day_of_week)

Comment puis-je convertir une date en horodatage dans Python?

Dans Python, vous pouvez convertir une date en horodatage en utilisant la fonction horodat () du module DateTime. Voici un exemple:

à partir de DateTime Import DateTime
current_date = dateTime.now ()
timestamp = current_date.timestamp ()
imprimer (horodatage)

Comment puis-je analyser une date à partir d'une chaîne dans Python?

Le module DateUtil de Python fournit la fonction parser.parse (), qui peut analyser une date à partir d'une chaîne. Voici comment vous pouvez l'utiliser:

à partir de DateUtil Import Parser
date_string = "2022-03-01"
date_object = parser.parse (date_string)
print (date_object)

Comment puis-je obtenir l'heure actuelle dans Python?

Le module DateTime de Python fournit la fonction DateTime.Now (), qui renvoie la date et l'heure actuelles. Si vous voulez seulement l'heure, vous pouvez utiliser la fonction Time () comme ceci:

à partir de DateTime Import DateTime
current_time = datetime.now (). Time ()
print (current_time)

Comment puis-je convertir un horodatage en une date dans Python?

Dans Python, vous pouvez convertir un horodatage en une date à l'aide de la fonction DateTime.fromtimeStamp (). Voici un exemple:

à partir de DateTime Import DateTime
timestamp = 1646332800
date_object = datetime.fromtimestamp (horodatamp)
print (date_object)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!