En savoir plus sur le module time en python

Le contenu de cet article est de partager avec vous une compréhension approfondie du module time en python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer

En Python In , les modules liés au traitement du temps incluent : l'heure, la date et le calendrier. Cet article explique principalement le module horaire.

Avant de commencer, il faut d'abord expliquer ces points :

1. En Python, il existe généralement plusieurs façons de représenter le temps : 1) l'horodatage 2) chaîne de temps formatée 3) tuple (struct_time) avec neuf éléments au total. Étant donné que l'implémentation du module temporel de Python appelle principalement la bibliothèque C, chaque plate-forme peut être différente.

2. UTC (Temps universel coordonné) est l’heure astronomique de Greenwich, l’heure standard mondiale. En Chine, il est UTC+8. DST (Daylight Saving Time) correspond à l’heure d’été.

3. Méthode d'horodatage (timestamp) : De manière générale, l'horodatage représente les secondes à partir du

   1er janvier 1970 00:00:00 Le décalage calculé. Nous exécutons "type(time.time())" et le type de retour est float. Les fonctions qui renvoient des horodatages incluent principalement time(), clock(), etc.

4. Méthode Tuple (struct_time) : Le tuple struct_time a un total de 9 éléments. Les fonctions qui renvoient struct_time incluent principalement gmtime(), localtime() et strptime(). Vous trouverez ci-dessous plusieurs éléments dans les tuples de cette manière :

Index	Attribut	Valeurs
0	tm_year (année)	Par exemple, 2011
1	tm_mon (mois)	1 - 12
2	tm_mday (jour)	1 - 31
3	tm_hour (heure)	0 - 23
4	tm_min (minutes)	0 - 59
5	tm_sec (secondes)	0 - 61
6	tm_wday (jour de la semaine)	0 - 6 (0 signifie dimanche)
7	tm_yday (jour de l'année)	1 - 366
8	tm_isdst (qu'il s'agisse de l'heure d'été)	La valeur par défaut est -1

Ensuite, nous introduisons plusieurs fonctions couramment utilisées dans le module time :

1) time.localtime([secs]) : Convertit un horodatage en horodatage actuel struct_time pour le fuseau horaire. Si le paramètre secs n’est pas fourni, l’heure actuelle prévaudra.

>>> time.localtime()
time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=14, tm_min=14, tm_sec=50, tm_wday= 3, tm_yday=125, tm_isdst=0)
>>> time.localtime(1304575584.1361799)
time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=14, tm_min= 6, tm_sec=24, tm_wday=3, tm_yday=125, tm_isdst=0)

2)heure.gmtime([secs]) : Semblable à la méthode localtime(), la méthode gmtime() convertit un horodatage en struct_time dans le fuseau horaire UTC (fuseau horaire 0).

>>>time.gmtime()
time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=6, tm_min=19, tm_sec=48, tm_wday=3, tm_yday=125, tm_isdst=0)

Remarque : tm_wday=3 représente ici le jour de la semaine, mais il doit être basé sur cette valeur de retour Le repousser un jour signifie jeudi et non mercredi.

3) time.time() : Renvoie l'horodatage de l'heure actuelle.

>>>time.time()
1304575584.1361799

4) time.mktime(t) : Convertit un struct_time en un horodatage.

>>> time.mktime(time.localtime())
1304576839.0

5) heure.dormir( secs) : le thread retarde son exécution pendant la durée spécifiée. L'unité est la seconde.

6) time.clock() : Il convient de noter que a des significations différentes selon les systèmes. Sur les systèmes UNIX, il renvoie le « temps de processus », qui est un nombre à virgule flottante (horodatage) exprimé en secondes. Sous WINDOWS, le premier appel renvoie l’heure réelle d’exécution du processus. Les appels après la deuxième fois correspondent à la durée écoulée depuis le premier appel jusqu'au présent. (En fait basé sur QueryPerformanceCounter() sur WIN32, qui est plus précis que la représentation en millisecondes)

1. import time    
   if __name__ == '__main__':    
       time.sleep(1)    
       print "clock1:%s" % time.clock()    
       time.sleep(1)    
       print "clock2:%s" % time.clock()    
       time.sleep(1)    
       print "clock3:%s" % time.clock()

clock1:3.35238137808e-006 Résultats d'exécution :

clock2:1.00004944763
clock3:2.00012040636

La sortie de la première horloge() est la durée d'exécution du programme

🎜>Les deuxième et troisième sorties clock() sont les intervalles de temps à partir de la première horloge

7) time.asctime([t]) : Représente un tuple ou struct_time représentant l'heure sous cette forme : 'Dim. 20 juin 23:21:05 1993'. S'il n'y a pas de paramètres, time.localtime() sera transmis en paramètre.

>>> time.asctime()
'Jeudi 5 mai 14:55:43 2011'

8)heure. ctime([secs]) : Convertit un horodatage (un nombre à virgule flottante calculé en secondes) sous la forme de time.asctime(). Si le paramètre n'est pas donné ou vaut None, time.time() sera utilisé comme paramètre par défaut. Sa fonction est équivalente à time.asctime(time.localtime(secs)).

>>> time.ctime()
'Jeudi 5 mai 14:58:09 2011'
>>>
'Jeudi 5 mai 14:58:39 2011'
>>> time.ctime(1304579615)
'Jeudi 5 mai 15:13:35 2011'

9) time.strftime(format[, t]) : Mettez un tuple représentant l'heure ou struct_time (comme time. localtime( ) et time.gmtime() return) dans une chaîne de temps formatée. Si t n'est pas spécifié, time.localtime() sera transmis. Si un élément du tuple sort des limites, une ValueError sera levée.

Format	Signification	Remarques
%a	locale ) Simplifié nom de la semaine
%A	Nom de la semaine complète locale
%b	Nom du mois local simplifié
%B	Mois complet local nom
%c	Représentation locale de la date et de l'heure correspondante
%d	Jour du mois (01 - 31)
%H	Jour du jour Le numéro de l'heure (horloge 24 heures, 00 - 23)
%I	Le numéro de l'heure (horloge 12 heures, 01 - 12)
%j	Jour de l'année (001 - 366)
%m	Mois (01 - 12)
%M	Nombre de minutes (00 - 59)
%p	Le caractère correspondant du matin ou de l'après-midi local	un
%S	Secondes (01 - 61)	Deux
%U	Le nombre de semaines dans l'année. (Le dimanche 00 - 53 est le début de la semaine.) Tous les jours précédant le premier dimanche sont placés dans la semaine 0.	Trois
%w	Le jour de la semaine (0 - 6, 0 est dimanche)	Trois
%W	est fondamentalement identique à %U, sauf que %W commence la semaine le lundi.
%x	Date locale correspondante
%X	Heure locale correspondante
%y	Année moins siècle (00 - 99)
%Y	Année complète
%Z	Le nom du fuseau horaire (caractère nul si non présent)
%%	caractère '%'

Remarques :

1. "%p" n'a d'effet que lorsqu'il est utilisé en conjonction avec "%I".

2. Le document souligne qu'il s'agit bien de 0 - 61, et non de 59, et que les secondes des années bissextiles comptent pour deux secondes (sweat one).

3. Lors de l'utilisation de la fonction strptime(), %U et %W sont calculés uniquement lorsque le nombre de semaines et de jours dans l'année est déterminé.

Par exemple :

>>> time.strftime("%Y-%m-%d %X", time.localtime() )
'2011-05-05 16:37:06'

10)heure.strptime(string[, format ]) : Convertit une chaîne de temps formatée en struct_time. En fait, c'est l'opération inverse de strftime().

>>> time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
time.struct_time(tm_year =2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, ​​​​tm_wday=3, tm_yday=125, tm_isdst=-1)

Dans cette fonction, les formats par défaut à :"%a %b %d %H:%M:%S %Y".

Enfin, faisons un résumé du module temps. Selon la description précédente, il existe trois méthodes d'expression en Python : 1) timestamp 2) tuple ou struct_time 3) chaîne formatée.

La conversion entre eux est comme indiqué sur la figure :

Recommandations associées :

Explication détaillée du temps Python

bibliothèque de temps python

module de temps python

Analyse du module de temps du module de temps Python

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!