Guide du débutant pour le module de temps Python – Real Python

Le python temps Le module fournit de nombreuses façons de représenter l'heure dans le code, telles que des objets, des nombres et des chaînes. Il fournit également des fonctionnalités autres que la représentation de l'heure, telles que l'attente pendant l'exécution du code et la mesure de l'efficacité de votre code.

Cet article vous guidera à travers les fonctions et objets les plus couramment utilisés dans temps.

À la fin de cet article, vous pourrez:

• Comprendre Concepts de base au cœur de l'utilisation des dates et des heures, telles que les époques, les fuseaux horaires et l'heure avancée
• Représenter temps dans le code en utilisant des flottants, des n-uplets et struct_time
• Convertir entre différentes représentations temporelles
• Suspendre exécution de fil
• Mesure la performance du code en utilisant perf_counter ()

Vous commencerez par apprendre à utiliser un nombre à virgule flottante pour représenter le temps.

Traiter avec le temps Python en utilisant des secondes

L'un des moyens de gérer le concept de l'heure Python dans votre application consiste à utiliser un nombre à virgule flottante représentant le nombre de secondes écoulées depuis le début d'une époque, c'est-à-dire depuis un certain point de départ.

Voyons ce que cela signifie, pourquoi cela est utile et comment l’utiliser pour implémenter une logique, basée sur le temps Python, dans votre application.

L'époque

Vous avez appris dans la section précédente que vous pouvez gérer le temps Python avec un nombre à virgule flottante représentant le temps écoulé depuis le début d'une époque.

Merriam-Webster définit une époque comme suit:

• Un moment précis à partir duquel une série d'années est comptée
• Un système de notation chronologique calculé à partir d'une date donnée comme base

Le concept important à saisir ici est que, lorsqu’il s’agit du temps Python, vous envisagez une période identifiée par un point de départ. En informatique, vous appelez ce point de départ le époque.

L'époque est donc le point de départ par rapport auquel vous pouvez mesurer le passage du temps.

Par exemple, si vous définissez l’époque comme étant minuit le 1er janvier 1970 UTC (l’époque telle que définie sous Windows et la plupart des systèmes UNIX), vous pouvez représenter minuit le 2 janvier 1970 UTC par 86400 secondes depuis l'époque.

C'est parce qu'il y a 60 secondes dans une minute, 60 minutes dans une heure et 24 heures dans une journée. Le 2 janvier 1970, UTC n’est qu'un jour après l’époque. Vous pouvez donc appliquer les principes mathématiques de base pour arriver à ce résultat:

>>> 60 * 60 * 24
86400

Il est également important de noter que vous pouvez toujours représenter le temps avant l’époque. Le nombre de secondes serait simplement négatif.

Par exemple, vous représenteriez minuit le 31 décembre 1969 UTC (en utilisant une époque du 1er janvier 1970) en tant que -86400 secondes.

Bien que le 1er janvier 1970, l’UTC soit une époque courante, ce n’est pas la seule époque utilisée en informatique. En fait, différents systèmes d'exploitation, systèmes de fichiers et API utilisent parfois des époques différentes.

Comme vous l'avez vu précédemment, les systèmes UNIX définissent l'époque du 1 er janvier 1970. L'API Win32, en revanche, définit l'époque du 1 er janvier 1601.

Vous pouvez utiliser time.gmtime () pour déterminer l’époque de votre système:

>>> importation temps
>>> temps.gmtime(0)
time.struct_time (tm_year = 1970, tm_mon = 1, tm_mday = 1, tm_hour = 0, tm_min = 0, tm_sec = 0, tm_wday = 3, tm_yday = 1, tm_isdst = 0)

Vous apprendrez gmtime () et struct_time tout au long de cet article. Pour l'instant, sachez que vous pouvez utiliser temps découvrir l'époque à l'aide de cette fonction.

Maintenant que vous en savez plus sur la façon de mesurer le temps en secondes en utilisant une époque, jetons un coup d’œil sur Python. temps module pour voir quelles fonctions il offre qui vous aident à le faire.

Temps Python en secondes sous forme de nombre à virgule flottante

Premier, temps temps() renvoie le nombre de secondes écoulées depuis l'époque. La valeur de retour est un nombre à virgule flottante à prendre en compte pour les fractions de seconde:

>>> de temps importation temps
>>> temps()
1551143536.9323719

Le nombre que vous obtenez sur votre machine peut être très différent car le point de référence considéré comme une époque peut être très différent.

Mesurer le temps en secondes est utile pour plusieurs raisons:

• Vous pouvez utiliser un float pour calculer la différence entre deux instants dans le temps.
• Un float est facilement sérialisable, ce qui signifie qu'il peut être stocké pour le transfert de données et en sortir intact de l'autre côté.

Parfois, cependant, vous voudrez peut-être voir l'heure actuelle représentée sous forme de chaîne. Pour ce faire, vous pouvez passer le nombre de secondes que vous obtenez de temps() dans time.ctime ().

Heure Python en secondes en tant que chaîne représentant l'heure locale

Comme vous l'avez vu précédemment, vous souhaiterez peut-être convertir le temps Python, représenté par le nombre de secondes écoulées depuis l'époque, en chaîne. Vous pouvez le faire en utilisant ctime ():

>>> de temps importation temps, temps
>>> t = temps()
>>> temps(t)
'Lundi 25 février 19:11:59 2019'

Ici, vous avez enregistré l’heure actuelle en secondes dans la variable t, puis passé t comme argument pour ctime (), qui retourne une représentation sous forme de chaîne du même temps.

>>> de temps importation temps
>>> temps()
'Lundi 25 février 19:11:59 2019'

La représentation sous forme de chaîne du temps, également appelée horodatage, retourné par ctime () est formaté avec la structure suivante:

1. Jour de la semaine: lun (Lundi)
2. Mois de l'année: fév (février)
3. Jour du mois: 25
4. Heure, minute et seconde en utilisant l'horloge 24 heures: 19:11:59
5. Année: 2019

L'exemple précédent affiche l'horodatage d'un moment particulier capturé à partir d'un ordinateur de la région du centre-sud des États-Unis. Mais disons que vous vivez à Sydney en Australie et que vous exécutez la même commande au même instant.

Au lieu de la sortie ci-dessus, vous constateriez ce qui suit:

>>> de temps importation temps, temps
>>> t = temps()
>>> temps(t)
'Mardi 26 février 12:11:59 2019'

Notez que le jour de la semaine, jour du mois, et heure des parties de l'horodatage sont différentes de celles du premier exemple.

Ces sorties sont différentes car l'horodatage renvoyé par ctime () dépend de votre situation géographique.

La représentation du temps en fonction de votre emplacement physique est appelée heure locale et utilise un concept appelé fuseaux horaires.

Approfondissons un peu la notion de fuseaux horaires afin de mieux comprendre les représentations temporelles Python.

Comprendre les fuseaux horaires

Un fuseau horaire est une région du monde conforme à une heure normalisée. Les fuseaux horaires sont définis par leur décalage par rapport au temps universel coordonné (UTC) et, éventuellement, par l’inclusion de l’heure avancée (que nous traiterons plus en détail plus loin dans cet article).

UTC et fuseaux horaires

UTC est la norme horaire par rapport à laquelle l’ensemble des horloges du monde est synchronisé (ou coordonné). Ce n'est pas, en soi, un fuseau horaire, mais plutôt une norme transcendante qui définit ce que sont les fuseaux horaires.

Le temps UTC est mesuré avec précision en utilisant le temps astronomique, en référence à la rotation de la Terre, et les horloges atomiques.

Les fuseaux horaires sont ensuite définis par leur décalage par rapport à UTC. Par exemple, en Amérique du Nord et du Sud, le fuseau horaire central (CT) est en retard de cinq ou six heures sur le temps UTC et utilise donc la notation UTC-5: 00 ou UTC-6: 00.

Sydney, en Australie, appartient au contraire au fuseau horaire austral oriental (AET), qui a dix ou onze heures d’avance sur UTC (UTC + 10: 00 ou UTC + 11: 00).

Cette différence (UTC-6: 00 à UTC + 10: 00) est la raison de la variance que vous avez observée dans les deux sorties de ctime () dans les exemples précédents:

• Heure centrale (CT): 'Lundi 25 février 19:11:59 2019'
• Heure de l'Est australienne (AET): 'Mardi 26 février 12:11:59 2019'

Ces heures sont séparées par exactement seize heures, ce qui est conforme aux décalages de fuseau horaire mentionnés ci-dessus.

Vous vous demandez peut-être pourquoi CT peut avoir cinq ou six heures de retard sur UTC ou pourquoi AET peut avoir dix ou onze heures d'avance. La raison en est que certaines régions du monde, y compris des zones de ces fuseaux horaires, observent l'heure avancée.

Le temps de l'heure d'été

Les mois d’été sont généralement plus ensoleillés que les mois d’hiver. De ce fait, certaines zones observent l'heure d'été au printemps et en été afin de mieux utiliser ces heures.

Pour les endroits qui observent l'heure d'été, leurs horloges avanceront d'une heure au début du printemps (ce qui leur fait perdre une heure). Ensuite, à l'automne, les horloges seront réinitialisées à l'heure normale.

Les lettres S et D représentent l'heure avancée et l'heure avancée en notation de fuseau horaire:

• Heure normale du Centre (CST)
• Heure avancée de l'Est australienne (AEDT)

Lorsque vous représentez des heures sous forme d'horodatages en heure locale, il est toujours important de déterminer si l'heure d'été est applicable ou non.

ctime () explique l'heure avancée. Ainsi, la différence de sortie répertoriée précédemment serait plus précise que ce qui suit:

• Heure normale du Centre (CST): 'Lundi 25 février 19:11:59 2019'
• Heure avancée australienne de l'Est (AEDT): 'Mardi 26 février 12:11:59 2019'

Gestion du temps Python à l'aide de structures de données

Maintenant que vous maîtrisez parfaitement plusieurs concepts fondamentaux du temps, notamment les époques, les fuseaux horaires et l'UTC, examinons plus de façons de représenter le temps à l'aide de Python. temps module.

Python Time comme un tuple

Au lieu d'utiliser un nombre pour représenter l'heure Python, vous pouvez utiliser une autre structure de données primitive: un tuple.

Le tuple vous permet de gérer le temps un peu plus facilement en extrayant certaines des données et en les rendant plus lisibles.

Lorsque vous représentez le temps en tuple, chaque élément de votre tuple correspond à un élément de temps spécifique:

1. Année
2. Mois sous forme d'entier, compris entre 1 (janvier) et 12 (décembre)
3. Jour du mois
4. Heure sous forme d’entier compris entre 0 (12 AM) et 23 (11 PM)
5. Minute
6. Seconde
7. Jour de la semaine sous forme d'entier, compris entre 0 (lundi) et 6 (dimanche)
8. Jour de l'année
9. Heure d'été sous forme d'entier avec les valeurs suivantes:
   • 1 est l'heure d'été.
   • 0 est l'heure normale.
   • -1 est inconnu.

En utilisant les méthodes que vous avez déjà apprises, vous pouvez représenter la même heure Python de deux manières différentes:

>>> de temps importation temps, temps
>>> t = temps()
>>> t
1551186415.360564
>>> temps(t)
'Mardi 26 février 07:06:55 2019'

>>> time_tuple = (2019, 2, 26, 7, 6, 55, 1, 57, 0)

Dans ce cas, les deux t et time_tuple représente le même temps, mais le tuple fournit une interface plus lisible pour travailler avec des composants de temps.

Bien que le tuple offre une interface plus facile à gérer pour travailler avec le temps Python, il existe un objet encore meilleur: struct_time.

Temps Python en tant qu'objet

Le problème avec la construction de tuple est qu’elle ressemble toujours à un groupe de chiffres, même si elle est mieux organisée qu’un nombre unique basé sur des secondes.

struct_time fournit une solution à cela en utilisant NomméTuple, de Python collections module, pour associer la séquence de chiffres du tuple à des identifiants utiles:

>>> de temps importation struct_time
>>> time_tuple = (2019, 2, 26, 7, 6, 55, 1, 57, 0)
>>> time_obj = struct_time(time_tuple)
>>> time_obj
time.struct_time (tm_year = 2019, tm_mon = 2, tm_mday = 26, tm_hour = 7, tm_min = 6, tm_sec = 55, tm_wday = 1, tm_yday = 57, tm_isdst = 0)

Maintenant, vous pouvez accéder à des éléments spécifiques de time_obj utilisant le nom de l'attribut plutôt qu'un index:

>>> jour_de_année = time_obj.tm_yday
>>> jour_de_année
57
>>> jour du mois = time_obj.tm_mday
>>> jour du mois
26

Au-delà de la lisibilité et de la convivialité de struct_time, il est également important de le savoir car c’est le type de retour de nombreuses fonctions de Python. temps module.

Conversion du temps Python en secondes en objet

Maintenant que vous avez découvert les trois méthodes principales d'utilisation de l'heure Python, vous allez apprendre à convertir entre les différents types de données d'heure.

La conversion entre types de données d'heure dépend de l'heure en UTC ou de l'heure locale.

Temps universel coordonné (UTC)

L'époque utilise UTC pour sa définition plutôt qu'un fuseau horaire. Par conséquent, les secondes écoulées depuis l'époque ne sont pas variables en fonction de votre situation géographique.

Cependant, on ne peut pas en dire autant de struct_time. La représentation d'objet de l'heure Python peut ou non prendre en compte votre fuseau horaire.

Il existe deux manières de convertir un float représentant des secondes en un struct_time:

1. UTC
2. Heure locale

Pour convertir un temps flottant Python en un temps basé sur UTC struct_time, le python temps module fournit une fonction appelée gmtime ().

Tu as vu gmtime () utilisé une fois auparavant dans cet article:

>>> importation temps
>>> temps.gmtime(0)
time.struct_time (tm_year = 1970, tm_mon = 1, tm_mday = 1, tm_hour = 0, tm_min = 0, tm_sec = 0, tm_wday = 3, tm_yday = 1, tm_isdst = 0)

Vous avez utilisé cet appel pour découvrir l’époque de votre système. Maintenant, vous avez une meilleure base pour comprendre ce qui se passe réellement ici.

gmtime () convertit le nombre de secondes écoulées depuis l'époque en un struct_time en UTC. Dans ce cas, vous avez réussi 0 en secondes, c’est-à-dire que vous essayez de trouver l’époque elle-même en UTC.

Comme tu l'as vu auparavant, struct_time ne peut pas représenter des fractions de secondes, donc gmtime () ignore les fractions de secondes dans l'argument:

>>> importation temps
>>> temps.gmtime(1,99)
time.struct_time (tm_year = 1970, tm_mon = 1, tm_mday = 1, tm_hour = 0, tm_min = 0, tm_sec = 1, tm_wday = 3, tm_yday = 1, tm_isdst = 0)

Notez que même si le nombre de secondes que vous avez écoulé était très proche de 2, la 99 les fractions de secondes ont tout simplement été ignorées, comme le montre tm_sec = 1.

le les secondes paramètre pour gmtime () est facultatif, ce qui signifie que vous pouvez appeler gmtime () sans arguments. Cela vous donnera l'heure actuelle en UTC:

>>> importation temps
>>> temps.gmtime()
time.struct_time (tm_year = 2019, tm_mon = 2, tm_mday = 28, tm_hour = 12, tm_min = 57, tm_sec = 24, tm_wday = 3, tm_yday = 59, tm_isdst = 0)

Fait intéressant, il n’ya pas d’inverse pour cette fonction dans temps. Au lieu de cela, vous devrez regarder dans Python calendrier module pour une fonction nommée timegm ():

>>> importation calendrier
>>> importation temps
>>> temps.gmtime()
time.struct_time (tm_year = 2019, tm_mon = 2, tm_mday = 28, tm_hour = 13, tm_min = 23, tm_sec = 12, tm_wday = 3, tm_yday = 59, tm_isdst = 0)
>>> calendrier.timegm(temps.gmtime())
1551360204

timegm () prend un tuple (ou struct_time, puisqu'il s'agit d'une sous-classe de tuple) et renvoie le nombre de secondes correspondant depuis l'époque.

Travailler avec UTC est très utile en programmation car c’est une norme. Vous n'avez pas à vous soucier des informations de l'heure d'été, du fuseau horaire ou des paramètres régionaux.

Cela dit, dans de nombreux cas, vous souhaitez utiliser l’heure locale. Vous verrez ensuite comment convertir des secondes en heure locale afin de pouvoir le faire.

Heure locale

Dans votre application, vous devrez peut-être utiliser l'heure locale plutôt que l'heure UTC. Python temps Le module fournit une fonction permettant d’obtenir l’heure locale à partir du nombre de secondes écoulées depuis l’époque appelée heure locale().

La signature de heure locale() est similaire à gmtime () en ce qu'il prend une option les secondes argument, qu'il utilise pour construire un struct_time en utilisant votre fuseau horaire local:

>>> importation temps
>>> temps.temps()
1551448206.86196
>>> temps.heure locale(1551448206.86196)
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 1, tm_hour = 7, tm_min = 50, tm_sec = 6, tm_wday = 4, tm_yday = 60, tm_isdst = 0)

Remarquerez que tm_isdst = 0. Depuis l'heure d'été compte pour l'heure locale, tm_isdst va changer entre 0 et 1 en fonction de si DST est ou non applicable pour le temps donné. Puisque tm_isdst = 0, L'heure d'été n'est pas applicable pour le 1er mars 2019.

Aux États-Unis, en 2019, l’heure d'été commence le 10 mars. Par conséquent, pour vérifier si l'indicateur DST change correctement, vous devez ajouter 9 secondes de secondes à la les secondes argument.

Pour calculer cela, vous prenez le nombre de secondes dans une journée (86 400) et vous le multipliez par 9 jours:

>>> new_secs = 1551448206.86196 + (86400 * 9)
>>> temps.heure locale(new_secs)
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 10, tm_hour = 8, tm_min = 50, tm_sec = 6, tm_wday = 6, tm_yday = 69, tm_isdst = 1)

Maintenant, vous verrez que le struct_time indique que la date sera le 10 mars 2019 avec tm_isdst = 1. En outre, notez que tm_heure a également pris de l'avance pour 8 au lieu de 7 dans l'exemple précédent, en raison de l'heure avancée.

Depuis Python 3.3, struct_time a également inclus deux attributs qui sont utiles pour déterminer le fuseau horaire de la struct_time:

1. tm_zone
2. tm_gmtoff

Au début, ces attributs dépendaient de la plate-forme, mais ils sont disponibles sur toutes les plates-formes depuis Python 3.6.

Premier, tm_zone enregistre le fuseau horaire local:

>>> importation temps
>>> current_local = temps.heure locale()
>>> current_local.tm_zone
'CST'

Ici, vous pouvez voir que heure locale() renvoie un struct_time avec le fuseau horaire réglé sur CST (Heure normale du Centre).

Comme vous l'avez vu précédemment, vous pouvez également indiquer le fuseau horaire en fonction de deux informations, le décalage UTC et l'heure d'été (le cas échéant):

>>> importation temps
>>> current_local = temps.heure locale()
>>> current_local.tm_gmtoff
-21600
>>> current_local.tm_isdst
0

Dans ce cas, vous pouvez voir que current_local est 21600 secondes après l’heure GMT, qui correspond à l’heure de Greenwich. GMT est le fuseau horaire sans décalage UTC: UTC ± 00: 00.

21600 secondes divisé par secondes par heure (3 600) signifie que current_local le temps est GMT-06: 00 (ou UTC-06: 00).

Vous pouvez utiliser le décalage GMT plus le statut DST pour en déduire que current_local est UTC-06: 00 à l'heure standard, qui correspond au fuseau horaire standard central.

Comme gmtime (), vous pouvez ignorer le les secondes argument lors de l'appel heure locale()et l’heure locale actuelle sera renvoyée dans struct_time:

>>> importation temps
>>> temps.heure locale()
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 1, tm_hour = 8, tm_min = 34, tm_sec = 28, tm_wday = 4, tm_yday = 60, tm_isdst = 0)

contrairement à gmtime (), la fonction inverse de heure locale() existe-t-il en Python temps module. Voyons comment cela fonctionne.

Conversion d'un objet heure locale en secondes

Vous avez déjà vu comment convertir un objet de temps UTC en secondes en utilisant calendar.timegm (). Pour convertir l’heure locale en secondes, vous utiliserez mktime ().

mktime () vous oblige à passer un paramètre appelé t qui prend la forme d'un tuple normal ou d'un struct_time objet représentant l'heure locale:

>>> importation temps

>>> time_tuple = (2019, 3, dix, 8, 50, 6, 6, 69, 1)
>>> temps.mktime(time_tuple)
1552225806.0

>>> structure_heure = temps.struct_time(time_tuple)
>>> temps.mktime(structure_heure)
1552225806.0

Il est important de garder à l’esprit que t doit être un tuple représentant l'heure locale, pas UTC:

>>> de temps importation gmtime, mktime

>>> # 1
>>> current_utc = temps.gmtime()
>>> current_utc
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 1, tm_hour = 14, tm_min = 51, tm_sec = 19, tm_wday = 4, tm_yday = 60, tm_isdst = 0)

>>> # 2
>>> current_utc_secs = mktime(current_utc)
>>> current_utc_secs
1551473479.0

>>> # 3
>>> temps.gmtime(current_utc_secs)
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 1, tm_hour = 20, tm_min = 51, tm_sec = 19, tm_wday = 4, tm_yday = 60, tm_isdst = 0)

Cet exemple montre pourquoi il est important d'utiliser mktime () avec heure locale, plutôt que UTC:

1. gmtime () sans argument renvoie un struct_time en utilisant UTC. current_utc spectacles 1 mars 2019 14:51:19 UTC. C'est exact parce que CST est UTC-06: 00, UTC doit donc être en avance de 6 heures sur l’heure locale.

2. mktime () essaie de renvoyer le nombre de secondes, en attendant l'heure locale, mais vous avez dépassé current_utc au lieu. Donc, au lieu de comprendre que current_utc est le temps UTC, il suppose que vous vouliez dire 1 mars 2019 14:51:19 CST.

3. gmtime () est ensuite utilisé pour convertir ces secondes en UTC, ce qui entraîne une incohérence. C'est maintenant 1 mars 2019 20:51:19 UTC. La raison de cet écart est le fait que mktime () heure locale prévue. Ainsi, la conversion en UTC ajoute un autre 6 heures à l'heure locale.

Il est notoirement difficile de travailler avec des fuseaux horaires. Il est donc important de vous préparer pour le succès en comprenant les différences entre UTC et l’heure locale et les fonctions de l’heure Python qui les concernent.

Conversion d'un objet temporel Python en chaîne

Bien que travailler avec des n-uplets soit amusant, il est parfois préférable de travailler avec des chaînes.

Les représentations temporelles sous forme de chaîne, également appelées horodatages, aident à rendre les heures plus lisibles et peuvent être particulièrement utiles pour la création d'interfaces utilisateur intuitives.

Il y a deux Python temps fonctions que vous utilisez pour convertir un time.struct_time objet à une chaîne:

1. asctime ()
2. strftime ()

Vous allez commencer par apprendreasctime ().

asctime ()

Tu utilises asctime () pour convertir un tuple temporel ou struct_time à un horodatage:

>>> importation temps
>>> temps.Asctime(temps.gmtime())
'Ven 1 mars 18:42:08 2019'
>>> temps.Asctime(temps.heure locale())
'Ven 1 mars 12:42:15 2019'

Tous les deux gmtime () et heure locale() revenir struct_time instances, pour l'heure UTC et l'heure locale, respectivement.

Vous pouvez utiliser asctime () convertir soit struct_time à un horodatage. asctime () fonctionne de manière similaire à ctime (), que vous avez appris précédemment dans cet article, sauf qu'au lieu de passer un nombre à virgule flottante, vous transmettez un tuple. Même le format d'horodatage est le même entre les deux fonctions.

Comme avec ctime (), le paramètre pour asctime () est facultatif. Si vous ne passez pas un objet de temps à asctime (), alors il utilisera l'heure locale actuelle:

>>> importation temps
>>> temps.Asctime()
'Ven 1 mars 12:56:07 2019'

Comme avec ctime (), il ignore également les informations sur les paramètres régionaux.

Un des plus gros inconvénients de asctime () est sa rigidité de format. strftime () résout ce problème en vous permettant de formater vos horodatages.

strftime ()

Vous pouvez vous retrouver dans une position où le format de chaîne de ctime () et asctime () n’est pas satisfaisant pour votre application. Au lieu de cela, vous voudrez peut-être formater vos chaînes de manière plus significative pour vos utilisateurs.

Un exemple de ceci est si vous souhaitez afficher votre heure dans une chaîne qui prend en compte les informations de localisation.

Pour formater des chaînes, étant donné un struct_time ou tuple de temps Python, vous utilisez strftime (), qui signifie “chaîne format temps."

strftime () prend deux arguments:

1. format spécifie l'ordre et la forme des éléments time de votre chaîne.
2. t est un tuple temporel facultatif.

Pour formater une chaîne, vous utilisez les directives. Les directives sont des séquences de caractères commençant par un % qui spécifient un élément temporel particulier, tel que:

• %ré: Jour du mois
• % m: Mois de l'année
• % Y: Année

Par exemple, vous pouvez sortir la date à votre heure locale en utilisant la norme ISO 8601 comme ceci:

>>> importation temps
>>> temps.strftime('% Y-% m-%ré', temps.heure locale())
'2019-03-01'

>>> de date / heure importation rendez-vous amoureux
>>> rendez-vous amoureux(année=2019, mois=3, journée=1).isoformat()
'2019-03-01'

Comme vous l'avez vu auparavant, un grand avantage de l'utilisation de strftime () plus de asctime () est sa capacité à rendre des horodatages qui utilisent des informations spécifiques aux paramètres régionaux.

Par exemple, si vous souhaitez représenter la date et l’heure en tenant compte des paramètres régionaux, vous ne pouvez pas utiliser asctime ():

>>> de temps importation Asctime
>>> Asctime()
'Sam 2 mars 15:21:14 2019'

>>> importation lieu
>>> lieu.setlocale(lieu.LC_TIME, 'zh_HK')  # Chinois - Hong Kong
'zh_HK'
>>> Asctime()
Sam 2 mars 15:58:49 2019

Notez que même après avoir modifié vos paramètres régionaux par programme, asctime () renvoie toujours la date et l'heure dans le même format qu'auparavant.

Quand vous utilisez strftime ()Cependant, vous verrez qu’il faut tenir compte de la locale:

>>> de temps importation strftime, heure locale
>>> strftime('% c', heure locale())
'Sam 2 mars 15:23:20 2019'

>>> importation lieu
>>> lieu.setlocale(lieu.LC_TIME, 'zh_HK')  # Chinois - Hong Kong
'zh_HK'
>>> strftime('% c', heure locale())
'六 3/2 15:58:12 2019' 2019 '

Ici, vous avez utilisé avec succès les informations sur les paramètres régionaux car vous avez utilisé strftime ().

Si le tuple de temps n'est pas passé au paramètre t, puis strftime () utilisera le résultat de heure locale() par défaut. Vous pouvez donc simplifier les exemples ci-dessus en supprimant le deuxième argument facultatif:

>>> de temps importation strftime
>>> strftime('L'heure locale actuelle est: % c')
'L'heure locale actuelle est: ven 1 mars à 23:18:32 2019'

Ici, vous avez utilisé l’heure par défaut au lieu de passer le votre comme argument. Notez également que le format L'argument peut être constitué de texte autre que des directives de formatage.

Le python temps Le module comprend également l'opération inverse consistant à reconvertir un horodatage en un struct_time objet.

Conversion d'une chaîne de temps Python en objet

Lorsque vous travaillez avec des chaînes liées à la date et à l’heure, il peut s'avérer très utile de convertir l’horodatage en objet temporel.

Pour convertir une chaîne de temps en un struct_time, tu utilises strptime (), qui signifie “chaîne analyser temps":

>>> de temps importation temps de repos
>>> temps de repos('2019-03-01', '% Y-% m-%ré')
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 1, tm_hour = 0, tm_min = 0, tm_sec = 0, tm_wday = 4, tm_yday = 60, tm_isdst = -1)

Le premier argument à strptime () doit être l'horodatage que vous souhaitez convertir. Le deuxième argument est le format que l'horodatage est en.

le format paramètre est facultatif et par défaut à '% a% b% d% H:% M:% S% Y'. Par conséquent, si vous avez un horodatage dans ce format, vous n'avez pas besoin de le passer en argument:

>>> temps de repos('Ven. Mars 23:38:40 2019')
time.struct_time (tm_year = 2019, tm_mon = 3, tm_mday = 1, tm_hour = 23, tm_min = 38, tm_sec = 40, tm_wday = 4, tm_yday = 60, tm_isdst = -1)

Depuis un struct_time a 9 composantes clés de date et heure, strptime () doit fournir des valeurs par défaut raisonnables pour les valeurs des composants sur lesquels il ne peut pas analyser. chaîne.

Dans les exemples précédents, tm_isdst = -1. Cela signifie que strptime () par l'horodatage, il est impossible de déterminer s'il représente l'heure d'été ou non.

Vous savez maintenant comment utiliser les heures et les dates Python à l'aide du temps module de différentes manières. Cependant, il existe d'autres utilisations pour temps en dehors de la simple création d'objets temporels, de l'obtention des chaînes temporelles Python et de l'utilisation des secondes écoulées depuis l'époque.

Suspension d'exécution

Une fonction temps Python vraiment utile est dormir(), qui suspend l’exécution du thread pendant un laps de temps spécifié.

Par exemple, vous pouvez suspendre l’exécution de votre programme pendant 10 secondes comme suit:

>>> de temps importation dormir, strftime
>>> strftime('% c')
'Ven. Mars 23:49:26 2019'
>>> dormir(dix)
>>> strftime('% c')
'Ven 1 mars 23:49:36 2019'

Votre programme imprimera le premier formaté date / heure chaîne, puis marquez une pause de 10 secondes, puis imprimez le deuxième formaté date / heure chaîne.

Vous pouvez également passer des fractions de secondes à dormir():

>>> de temps importation dormir
>>> dormir(0.5)

dormir() est utile pour tester ou faire attendre votre programme pour quelque raison que ce soit, mais vous devez veiller à ne pas interrompre votre code de production, à moins que vous n'ayez une bonne raison de le faire.

Avant Python 3.5, un signal envoyé à votre processus pouvait interrompre dormir(). Cependant, dans 3.5 et plus tard, dormir() suspendra toujours l'exécution pendant au moins la durée spécifiée, même si le processus reçoit un signal.

dormir() n’est qu’une fonction temporelle Python qui peut vous aider à tester vos programmes et à les rendre plus robustes.

Mesurer la performance

Vous pouvez utiliser temps pour mesurer la performance de votre programme.

La façon dont vous faites cela est d'utiliser perf_counter () qui, comme son nom l'indique, fournit un compteur de performance avec une résolution élevée pour mesurer de courtes distances.

Utiliser perf_counter (), vous placez un compteur avant que votre code ne commence à être exécuté ainsi qu'après son exécution:

>>> de temps importation perf_counter
>>> def fonction longrunning():
...     pour je dans intervalle(1, 11):
...         temps.dormir(je / je ** 2)
...
>>> début = perf_counter()
>>> fonction longrunning()
>>> fin = perf_counter()
>>> temps d'exécution = (fin - début)
>>> temps d'exécution
8.201258441999926

Premier, début capture le moment avant d'appeler la fonction. fin capture l'instant après le retour de la fonction. Le temps total d’exécution de la fonction a pris (fin - début) secondes.

perf_counter () (ou perf_counter_ns ()) est le moyen le plus précis de mesurer les performances de votre code en une seule exécution. Toutefois, si vous essayez d’évaluer avec précision les performances d’un fragment de code, je vous recommande d’utiliser le code Python. temps module.

temps se spécialise dans l'exécution de code plusieurs fois pour obtenir une analyse plus précise des performances et vous aide à ne pas trop simplifier la mesure de votre temps ainsi que d'autres pièges courants.

Conclusion

Toutes nos félicitations! Vous disposez désormais d'une base solide pour travailler avec des dates et des heures en Python.

Maintenant, vous pouvez:

• Utilisez un nombre à virgule flottante, représentant les secondes écoulées depuis l'époque, pour gérer le temps
• Gérer le temps en utilisant des tuples et struct_time objets
• Convertir entre les secondes, les tuples et les chaînes d'horodatage
• Suspendre l'exécution d'un thread Python
• Mesurer les performances en utilisant perf_counter ()

En plus de tout cela, vous avez appris certains concepts fondamentaux concernant la date et l’heure, tels que:

• Époques
• UTC
• Fuseaux horaires
• Le temps de l'heure d'été

Il est maintenant temps pour vous d’appliquer vos nouvelles connaissances sur l’heure Python dans vos applications réelles!

Lectures complémentaires

Si vous souhaitez continuer à en apprendre davantage sur l'utilisation des dates et des heures dans Python, consultez les modules suivants:

• date / heure: Un module de date et d’heure plus robuste dans la bibliothèque standard de Python
• temps: Un module de mesure de la performance des extraits de code
• astropie: Date de précision plus élevée utilisée en astronomie