Le module time

Adresse : http://docs.python.org/3.3/library/time.html

Utilité : accéder à des mesures de durée, de dates, et effectuer des conversions durées/dates.

Syntaxe : import time, ou from time import *, ou from time import sleep, etc.

Le module time opère sur des dates exprimées en secondes depuis la date 0 du système d’exploitation (le 1er janvier 1970 sur les systèmes Unix), ou exprimées sous une forme structurée (avec indication de l’année, du mois, etc.).

Une date structurée peut être renvoyée au format GMT (Greenwich Mean Time) mais le nouveau nom est plutôt UTC (Coordinated Universal Time) ou au format local (pour tenir compte du fuseau horaire tel qu’il est réglé sur la machine).

>>> from time import * # importe la totalité du module time

>>> lt = localtime(); lt # renvoie la date structurée locale actuelle

time.struct_time(tm_year=2013, tm_mon=2, tm_mday=3, tm_hour=14, tm_min=26, tm_sec=31,

tm_wday=6, tm_yday=34, tm_isdst=0)

>>> asctime(lt) # convertit cette date en qqchose de plus lisible

'Sun Feb 3 14:26:31 2013'

>>> mktime(lt) # convertit en secondes depuis le 1er janvier 1970 à 0h00

1359897991.0

Voici quelques fonctions du module time (on note dst une date structurée et sec une durée en secondes).

`gmtime(`sec`)` `localtime(`sec`)`	convertit un nombre de secondes (depuis la date 0) en la date GMT structurée convertit un nombre de secondes (depuis la date 0) en la date locale structurée
`calendar.timegm(`dst`)` `mktime(`dst`)`	convertit une date structurée GMT en un nombre de secondes depuis la date 0 convertit une date structurée locale en un nombre de secondes depuis la date 0
`asctime(`dst`)` `ctime(`sec`)` `strftime(`f t`,`sec`)` `strptime(`ch`,`f t`)`	convertit une date structurée en une chaîne plus lisible convertit des secondes (depuis la date 0) en chaîne (date locale) `ctime(0)`⇒`’Thu Jan 1 01:00:00 1970’` et `ctime(1e9)`⇒`’Sun Sep 9 03:46:40 2001’` convertit des secondes (depuis la date 0) en chaîne, avec une chaîne de formatage f t `strftime("%a, %d %b %Y %H:%M:%S", localtime())`⇒ `’Sun, 03 Feb 2013 15:06:25’` convertit en date structurée une chaîne ch (date lisible), avec formatage par f t `time.strptime("30 Nov 00", "%d %b %y")` ⇒ `time.struct_time(tm_year=2000,...`

Plusieurs fonctions permettent de mesurer des durées (c’est utile pour étudier l’efficacité temporelle d’un algorithme).

Le sujet est rendu assez compliqué par les différences qui existent entre les plateformes (Windows, Mac, etc.).

Pour plus d’informations, consulter : http://www.python.org/dev/peps/pep-0418/

Voici quelques fonctions disponibles (pour mesurer une durée, on utilisera la différence entre deux valeurs renvoyées par la fonction choisie, par exemple perf_counter, car les origines de ces “horloges” sont indéfinies).

`sleep(`sec`)`	suspend l’exécution pendant le nombre indiqué sec de secondes
`time()`	donne l’heure locale actuelle, exprimée en secondes depuis la date 0 (déconseillé pour mesurer des courtes durées, par manque de précision)
`clock()`	valeur de l’horloge-processeur à un instant donné, exprimée en microsecondes (efficace sous Windows, beaucoup moins sous Unix)
`monotonic()`	horloge-processeur “monotone”, indépendante des modifications du système
`perf_counter()` `process_time()`	horloge précise sur toutes plateformes (depuis `Python` 3.3) idem, mais n’inclut pas les pauses générées par la fonction `sleep`

Exemple : on va comparer trois fonctions formant la liste lc des ${k^2}$ , pour 0 ≤ k ≤ n (avec n entier passé en argument).

Ces fonctions ne renvoient pas lc (elles la fabriquent, juste), mais le temps passé (sur 6 décimales). test1 crée lc par ajouts des [k*k] (mauvais !), test2 par des append successifs (bien mieux) et test3 forme la liste en compréhension (encore mieux).

def test1(n):

from time import perf_counter as pc

top = pc(); lc = []

for k in range(n): lc = lc + [k*k]

return round(pc()-top,6)

def test2(n):

from time import perf_counter as pc

top = pc(); lc = []

for k in range(n): lc.append(k*k)

return round(pc()-top,6)

def test3(n):

from time import perf_counter as pc

top = pc();

lc = [k*k for k in range(n)]

return round(pc()-top,6)

NB : on remarquera comment on a renommé localement la fonction perf_counter en pc.

Voici combien de temps mettent ces trois fonctions, pour ${n=10^3}$ , ${n=10^4}$ et ${n=10^5}$ (no comment pour test1) :

>>> [test1(10**n) for n in [3,4,5]] # test1 est une très mauvaise solution

[0.001771, 0.174184, 23.001052]

>>> [test2(10**n) for n in [3,4,5]] # la fonction test2 est bien meilleure

[0.000133, 0.001309, 0.012158]

>>> [test3(10**n) for n in [3,4,5]] # test3 est encore meilleure (et plus élégante)

[0.000142, 0.000712, 0.00709]

Remarque : à la place de la fonction perf_counter, on aurait pu utiliser les fonctions clock, time, process_time ou monotonic. Il est difficile sur un seul exemple de se rendre compte de ce qui les différencie réellement. La documentation Python recommande en tout cas de ne pas utiliser les fonctions time ou clock (soit par leur imprécision sur des mesures de durées faibles, soit par dépendance relativement au système d’exploitation utilisé).

NB : On pourra aussi consulter les modules datetime (http://docs.python.org/3.3/library/datetime.html) et calendar (http://docs.python.org/3.3/library/calendar.html)

Le module time

Retour à l’accueil du cours Python/Numpy

Sommaire du chapitre 7