# `time` --- Time access and conversions

Ce module fournit différentes fonctions liées au temps. Pour les fonctionnalités associées, voir aussi les modules `datetime` et `calendar`.

Bien que ce module soit toujours disponible, toutes les fonctions ne sont pas disponibles sur toutes les plateformes. La plupart des fonctions définies dans ce module délèguent à des fonctions de même nom de la bibliothèque C. Il peut parfois être utile de consulter la documentation de la plate-forme, car la sémantique de ces fonctions peut varier.

Vous trouvez ci-dessous, mises en ordre, quelques explications relative à la terminologie et aux conventions.

- L'epoch est le point de départ du temps, le résultat de `time.gmtime(0)` est le 1er janvier 1970 à 00:00:00 (UTC) pour toutes les plateformes.

- Le terme secondes depuis *epoch* désigne le nombre total de secondes écoulées depuis epoch, souvent en excluant les secondes intercalaires (leap seconds). Les secondes intercalaires sont exclues de ce total sur toutes les plates-formes conformes POSIX.

- Les fonctions de ce module peuvent ne pas gérer les dates et heures antérieures à epoch ou dans un avenir lointain. Le seuil du futur est déterminé par la bibliothèque C ; pour les systèmes 32 bits, il s’agit généralement de 2038.

- La fonction `strptime()` peut analyser des années à 2 chiffres lorsque le format `%y` est spécifié. Lorsque les années à deux chiffres sont analysées, elles sont converties conformément aux normes POSIX et ISO C : les valeurs 69—99 correspondent à 1969—1999 et les valeurs 0—68 à 2000—2068.

- UTC is Coordinated Universal Time and superseded Greenwich Mean Time or GMT as the basis of international timekeeping. The acronym UTC is not a mistake but conforms to an earlier, language-agnostic naming scheme for time standards such as UT0, UT1, and UT2.

- Le DST (Daylight Saving Time) correspond à l’heure d’été, un ajustement du fuseau horaire d’une heure (généralement) pendant une partie de l’année. Les règles de DST sont magiques (déterminées par la loi locale) et peuvent changer d’année en année. La bibliothèque C possède une table contenant les règles locales (souvent, elle est lue dans un fichier système par souci de souplesse) et constitue la seule source fiable.

- La précision des diverses fonctions en temps réel peut être inférieure à celle suggérée par les unités dans lesquelles leur valeur ou leur argument est exprimé. Par exemple, sur la plupart des systèmes Unix, l’horloge ne « bat » que 50 ou 100 fois par seconde.

- On the other hand, the precision of `time()` and `sleep()` is better than their Unix equivalents: times are expressed as floating-point numbers, `time()` returns the most accurate time available (using Unix `gettimeofday()` where available), and `sleep()` will accept a time with a nonzero fraction (Unix `select()` is used to implement this, where available).

- La valeur temporelle renvoyée par `gmtime()`, `localtime()` et `strptime()`, et acceptée par `asctime()`, `mktime()` et `strftime()`, est une séquence de 9 nombres entiers. Les valeurs de retour de `gmtime()`, `localtime()` et `strptime()` proposent également des noms d’attributs pour des champs individuels.

  Voir `struct_time` pour une description de ces objets.

  Modifié dans la version 3.3: The `struct_time` type was extended to provide the `tm_gmtoff` and `tm_zone` attributes when platform supports corresponding `struct tm` members.

  Modifié dans la version 3.6: The `struct_time` attributes `tm_gmtoff` and `tm_zone` are now available on all platforms.

- Utilisez les fonctions suivantes pour convertir des représentations temporelles :

  De | À | Utilisez
  --- | --- | ---
  secondes depuis epoch | `struct_time` en UTC | `gmtime()`
  secondes depuis epoch | `struct_time` en heure locale | `localtime()`
  `struct_time` en UTC | secondes depuis epoch | `calendar.timegm()`
  `struct_time` en heure locale | secondes depuis epoch | `mktime()`

## Fonctions

time.asctime([t])

  Convertit un n-uplet ou `struct_time` représentant une heure renvoyée par `gmtime()` ou `localtime()` en une chaîne de la forme suivante : `'Sun Jun 20 23:21:05 1993'`. Le numéro du jour est un champ de deux caractères complété par une espace si celui-ci n'a qu'un seul chiffre, par exemple : `'Wed Jun 9 04:26:40 1993'`.

  Si t n’est pas fourni, l’heure actuelle renvoyée par `localtime()` est utilisée. Les informations sur les paramètres régionaux ne sont pas utilisées par `asctime()`.

  Note

  Contrairement à la fonction C du même nom, `asctime()` n’ajoute pas de caractère de fin de ligne.

time.pthread_getcpuclockid(thread_id)

  Renvoie le clk_id de l'horloge du temps CPU spécifique au fil d'exécution pour le thread_id spécifié.

  Utilisez `threading.get_ident()` ou l'attribut `ident` de `threading.Thread` pour obtenir une valeur appropriée pour thread_id.

  Avertissement

  Passer un thread_id invalide ou arrivé à expiration peut entraîner un comportement indéfini, tel qu’une erreur de segmentation.

  Disponibilité: Unix

  Se reporter à la page de manuel pthread_getcpuclockid(3) pour plus d’informations.

  Ajouté dans la version 3.7.

time.clock_getres(clk_id)

  Renvoie la résolution (précision) de l’horloge clk_id. Référez-vous à Constantes d’identification d’horloge pour une liste des valeurs acceptées pour clk_id.

  Disponibilité: Unix.

  Ajouté dans la version 3.3.

time.clock_gettime(clk_id) → float

  Renvoie l’heure de l’horloge clk_id. Référez-vous à Constantes d’identification d’horloge pour une liste des valeurs acceptées pour clk_id.

  Use `clock_gettime_ns()` to avoid the precision loss caused by the `float` type.

  Disponibilité: Unix.

  Ajouté dans la version 3.3.

time.clock_gettime_ns(clk_id) → int

  Similaire à `clock_gettime()` mais le temps renvoyé est exprimé en nanosecondes.

  Disponibilité: Unix.

  Ajouté dans la version 3.7.

time.clock_settime(clk_id, time)

  Définit l’heure de l’horloge clk_id. Actuellement, `CLOCK_REALTIME` est la seule valeur acceptée pour clk_id.

  Use `clock_settime_ns()` to avoid the precision loss caused by the `float` type.

  Disponibilité: Unix, not Android, not iOS.

  Ajouté dans la version 3.3.

  Modifié dans la version 3.15: Accepts any real number as time, not only integer or float.

time.clock_settime_ns(clk_id, time: int)

  Similaire à `clock_settime()` mais définit l’heure avec des nanosecondes.

  Disponibilité: Unix, not Android, not iOS.

  Ajouté dans la version 3.7.

time.ctime([secs])

  Convertit une heure exprimée en secondes depuis epoch en une chaîne représentant l’heure locale sous la forme suivante : `'Sun Jun 20 23:21:05 1993'`. Le numéro du jour est un champ de deux caractères complété par une espace si celui-ci n'a qu'un seul chiffre, par exemple : `'Wed Jun 9 04:26:40 1993'`.

  Si secs n’est pas fourni ou vaut `None`, l’heure actuelle renvoyée par `time()` est utilisée. `ctime(secs)` est équivalent à `asctime(localtime(secs))`. Les informations sur les paramètres régionaux ne sont pas utilisées par `ctime()`.

  Modifié dans la version 3.15: Accepts any real number, not only integer or float.

time.get_clock_info(name)

  Renvoie des informations sur l’horloge spécifiée en tant qu’objet d’espace de nom. Les noms d’horloge pris en charge et les fonctions correspondantes permettant de lire leur valeur sont les suivants :

  - `'monotonic'` : `time.monotonic()`

  - `'perf_counter'` : `time.perf_counter()`

  - `'process_time'` : `time.process_time()`

  - `'thread_time'` : `time.thread_time()`

  - `'time'` : `time.time()`

  Le résultat a les attributs suivants :

  - adjustable: `True` if the clock can be set to jump forward or backward in time, `False` otherwise. Does not refer to gradual NTP rate adjustments.

  - implementation : nom de la fonction C sous-jacente utilisée pour obtenir la valeur d’horloge. Voir Constantes d’identification d’horloge pour les valeurs possibles.

  - monotonic : `True` si l’horloge ne peut pas revenir en arrière, `False` autrement

  - resolution : La résolution de l’horloge en secondes (`float`)

  Ajouté dans la version 3.3.

time.gmtime([secs])

  Convertit un temps exprimé en secondes depuis epoch en un `struct_time` au format UTC dans lequel le drapeau dst est toujours égal à zéro. Si secs n’est pas fourni ou vaut `None`, l’heure actuelle renvoyée par `time()` est utilisée. Les fractions de seconde sont ignorées. Voir ci-dessus pour une description de l’objet `struct_time`. Voir `calendar.timegm()` pour l’inverse de cette fonction.

  Modifié dans la version 3.15: Accepts any real number, not only integer or float.

time.localtime([secs])

  Comme `gmtime()` mais convertit le résultat en heure locale. Si secs n’est pas fourni ou vaut `None`, l’heure actuelle renvoyée par `time()` est utilisée. Le drapeau dst est mis à `1` lorsque l’heure d’été s’applique à l’heure indiquée.

  `localtime()` may raise `OverflowError`, if the timestamp is outside the range of values supported by the platform C `localtime()` or `gmtime()` functions, and `OSError` on `localtime()` or `gmtime()` failure. It's common for this to be restricted to years between 1970 and 2038.

  Modifié dans la version 3.15: Accepts any real number, not only integer or float.

time.mktime(t)

  This is the inverse function of `localtime()`. Its argument is the `struct_time` or full 9-tuple (since the dst flag is needed; use `-1` as the dst flag if it is unknown) which expresses the time in local time, not UTC. It returns a floating-point number, for compatibility with `time()`. If the input value cannot be represented as a valid time, either `OverflowError` or `ValueError` will be raised (which depends on whether the invalid value is caught by Python or the underlying C libraries). The earliest date for which it can generate a time is platform-dependent.

time.monotonic() → float

  Renvoie la valeur (en quelques fractions de secondes) d’une horloge monotone, c’est-à-dire une horloge qui ne peut pas revenir en arrière. L’horloge n’est pas affectée par les mises à jour de l’horloge système. Le point de référence de la valeur renvoyée n’est pas défini, de sorte que seule la différence entre les résultats d’appels consécutifs est valide.

  Clock:

  - On Windows, call `QueryPerformanceCounter()` and `QueryPerformanceFrequency()`.

  - On macOS, call `mach_absolute_time()` and `mach_timebase_info()`.

  - On HP-UX, call `gethrtime()`.

  - Call `clock_gettime(CLOCK_HIGHRES)` if available.

  - Otherwise, call `clock_gettime(CLOCK_MONOTONIC)`.

  Use `monotonic_ns()` to avoid the precision loss caused by the `float` type.

  Ajouté dans la version 3.3.

  Modifié dans la version 3.5: The function is now always available and the clock is now the same for all processes.

  Modifié dans la version 3.10: On macOS, the clock is now the same for all processes.

time.monotonic_ns() → int

  Similaire à `monotonique()`, mais le temps de retour est exprimé en nanosecondes.

  Ajouté dans la version 3.7.

time.perf_counter() → float

  Return the value (in fractional seconds) of a performance counter, i.e. a clock with the highest available resolution to measure a short duration. It does include time elapsed during sleep. The clock is the same for all processes. The reference point of the returned value is undefined, so that only the difference between the results of two calls is valid.

  Particularité de l'implémentation CPython : On CPython, use the same clock as `time.monotonic()` and is a monotonic clock, i.e. a clock that cannot go backwards.

  Use `perf_counter_ns()` to avoid the precision loss caused by the `float` type.

  Ajouté dans la version 3.3.

  Modifié dans la version 3.10: On Windows, the clock is now the same for all processes.

  Modifié dans la version 3.13: Use the same clock as `time.monotonic()`.

time.perf_counter_ns() → int

  Similaire à `perf_counter()`, mais renvoie le temps en nanosecondes.

  Ajouté dans la version 3.7.

time.process_time() → float

  Return the value (in fractional seconds) of the sum of the system and user CPU time of the current process. It does not include time elapsed during sleep. It is process-wide by definition. The reference point of the returned value is undefined, so that only the difference between the results of two calls is valid.

  Use `process_time_ns()` to avoid the precision loss caused by the `float` type.

  Ajouté dans la version 3.3.

time.process_time_ns() → int

  Similaire à `process_time()` mais renvoie le temps en nanosecondes.

  Ajouté dans la version 3.7.

time.sleep(secs)

  Suspend execution of the calling thread for the given number of seconds. The argument may be a non-integer to indicate a more precise sleep time.

  If the sleep is interrupted by a signal and no exception is raised by the signal handler, the sleep is restarted with a recomputed timeout.

  The suspension time may be longer than requested by an arbitrary amount, because of the scheduling of other activity in the system.

  Windows implementation

  On Windows, if secs is zero, the thread relinquishes the remainder of its time slice to any other thread that is ready to run. If there are no other threads ready to run, the function returns immediately, and the thread continues execution. On Windows 10 and newer the implementation uses a high-resolution timer which provides resolution of 100 nanoseconds. If secs is zero, `Sleep(0)` is used.

  Unix implementation

  - Use `clock_nanosleep()` if available (resolution: 1 nanosecond);

  - Or use `nanosleep()` if available (resolution: 1 nanosecond);

  - Or use `select()` (resolution: 1 microsecond).

  Note

  To emulate a "no-op", use `pass` instead of `time.sleep(0)`.

  To voluntarily relinquish the CPU, specify a real-time scheduling policy and use `os.sched_yield()` instead.

  Raises an auditing event `time.sleep` with argument `secs`.

  Modifié dans la version 3.5: La fonction dort maintenant au moins secondes même si le sommeil est interrompu par un signal, sauf si le gestionnaire de signaux lève une exception (voir PEP 475 pour la justification).

  Modifié dans la version 3.11: On Unix, the `clock_nanosleep()` and `nanosleep()` functions are now used if available. On Windows, a waitable timer is now used.

  Modifié dans la version 3.13: Raises an auditing event.

  Modifié dans la version 3.15: Accepts any real number, not only integer or float.

time.strftime(format[, t])

  Convertit un n-uplet ou `struct_time` représentant une heure renvoyée par `gmtime()` ou `localtime()` en une chaîne spécifiée par l’argument format. Si t n’est pas fourni, l’heure actuelle renvoyée par `localtime()` est utilisée. format doit être une chaîne. Si l’un des champs de t se situe en dehors de la plage autorisée, une `ValueError` est levée .

  0 est un argument légal pour toute position dans le n-uplet temporel ; s’il est normalement illégal, la valeur est forcée à une valeur correcte.

  Les directives suivantes peuvent être incorporées dans la chaîne format. Ils sont affichés sans la spécification facultative de largeur de champ ni de précision, et sont remplacés par les caractères indiqués dans le résultat de `strftime()` :

  Directive | Signification | Notes
  --- | --- | ---
  `%a` | Nom abrégé du jour de la semaine selon les paramètres régionaux. |
  `%A` | Le nom de semaine complet de la région. |
  `%b` | Nom abrégé du mois de la région. |
  `%B` | Nom complet du mois de la région. |
  `%c` | Représentation appropriée de la date et de l’heure selon les paramètres régionaux. |
  `%d` | Jour du mois sous forme décimale [01,31]. |

  `%f`

  Microseconds as a decimal number

    [000000,999999].

  (1)

  `%H` | Heure (horloge sur 24 heures) sous forme de nombre décimal [00,23]. |
  `%I` | Heure (horloge sur 12 heures) sous forme de nombre décimal [01,12]. |
  `%j` | Jour de l’année sous forme de nombre décimal [001,366]. |
  `%m` | Mois sous forme décimale [01,12]. |
  `%M` | Minutes sous forme décimale [00,59]. |
  `%p` | L’équivalent local de AM ou PM. | (2)
  `%S` | Secondes sous forme de nombre décimal [00,61]. | (3)
  `%U` | Numéro de semaine de l’année (dimanche en tant que premier jour de la semaine) sous forme décimale [00,53]. Tous les jours d’une nouvelle année précédant le premier dimanche sont considérés comme appartenant à la semaine 0. | (4)
  `%u` | Day of the week (Monday is 1; Sunday is 7) as a decimal number [1, 7]. |
  `%w` | Jour de la semaine sous forme de nombre décimal [0 (dimanche), 6]. |
  `%W` | Numéro de semaine de l’année (lundi comme premier jour de la semaine) sous forme décimale [00,53]. Tous les jours d’une nouvelle année précédant le premier lundi sont considérés comme appartenant à la semaine 0. | (4)
  `%x` | Représentation de la date appropriée par les paramètres régionaux. |
  `%X` | Représentation locale de l'heure. |
  `%y` | Année sans siècle comme un nombre décimal [00, 99]. |
  `%Y` | Année complète sur quatre chiffres. |
  `%z` | Décalage de fuseau horaire indiquant une différence de temps positive ou négative par rapport à UTC / GMT de la forme +HHMM ou -HHMM, où H représente les chiffres des heures décimales et M, les chiffres des minutes décimales [-23:59, +23:59] [1] |
  `%Z` | Nom du fuseau horaire (pas de caractères s’il n’y a pas de fuseau horaire). Obsolète. [1] |
  `%G` | ISO 8601 year (similar to `%Y` but follows the rules for the ISO 8601 calendar year). The year starts with the week that contains the first Thursday of the calendar year. |
  `%V` | ISO 8601 week number (as a decimal number [01,53]). The first week of the year is the one that contains the first Thursday of the year. Weeks start on Monday. |
  `%%` | Un caractère `'%'` littéral. |

  Notes :

  1. The `%f` format directive only applies to `strptime()`, not to `strftime()`. However, see also `datetime.datetime.strptime()` and `datetime.datetime.strftime()` where the `%f` format directive applies to microseconds.

  2. Lorsqu’elle est utilisée avec la fonction `strptime()`, la directive `%p` n’affecte le champ d’heure en sortie que si la directive `%I` est utilisée pour analyser l’heure.

  3. La plage est en réalité de `0` à `61` ; la valeur `60` est valide dans les timestamps représentant des secondes intercalaires (leap seconds) et la valeur `61` est prise en charge pour des raisons historiques.

  4. Lorsqu’elles sont utilisées avec la fonction `strptime()`, `%U` et `%W` ne sont utilisées que dans les calculs lorsque le jour de la semaine et l’année sont spécifiés.

  Here is an example, a format for dates compatible with that specified in the RFC 5322 Internet email standard. [1]

      >>> from time import gmtime, strftime
      >>> strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
      'Thu, 28 Jun 2001 14:17:15 +0000'

  Des directives supplémentaires peuvent être prises en charge sur certaines plates-formes, mais seules celles énumérées ici ont une signification normalisée par ANSI C. Pour voir la liste complète des codes de format pris en charge sur votre plate-forme, consultez la documentation strftime(3).

  Sur certaines plates-formes, une spécification facultative de largeur et de précision de champ peut suivre immédiatement le `'%'` initial d’une directive dans l’ordre suivant ; ce n’est pas non plus portable. La largeur du champ est normalement 2 sauf pour `%j` où il est 3.

time.strptime(string[, format])

  Analyse une chaîne représentant une heure selon un format. La valeur renvoyée est une `struct_time` tel que renvoyé par `gmtime()` ou `localtime()`.

  Le paramètre format utilise les mêmes directives que celles utilisées par `strftime()` ; la valeur par défaut est `"%a %b %d %H:%M:%S %Y"` qui correspond à la mise en forme renvoyée par `ctime()`. Si string ne peut pas être analysé selon format, ou s’il contient trop de données après l’analyse, une exception `ValueError` est levée. Les valeurs par défaut utilisées pour renseigner les données manquantes lorsque des valeurs plus précises ne peuvent pas être inférées sont `(1900, 1, 1, 0, 0, 0, 0, 1, -1)`. string et format doivent être des chaînes.

  Par exemple :

      >>> import time
      >>> time.strptime("30 Nov 00", "%d %b %y")
      time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0,
                       tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

  La prise en charge de la directive `%Z` est basée sur les valeurs contenues dans `tzname` et sur le fait de savoir si `daylight` est vrai. Pour cette raison, il est spécifique à la plate-forme, à l’exception de la reconnaissance des heures UTC et GMT, qui sont toujours connues (et considérées comme des fuseaux horaires ne respectant pas l’heure d’été).

  Seules les directives spécifiées dans la documentation sont prises en charge. Parce que `strftime()` peut être implémenté différemment sur chaque plate-forme, il peut parfois offrir plus de directives que celles listées. Mais `strptime()` est indépendant de toute plate-forme et ne supporte donc pas nécessairement toutes les directives disponibles qui ne sont pas documentées comme gérées.

class time.struct_time

  Le type de la séquence de valeur temporelle renvoyé par `gmtime()`, `localtime()` et `strptime()`. Semblable à un named tuple : ses valeurs sont accessibles par index et par nom d’attribut. Les valeurs suivantes sont présentes :

  Index | Attribut | Valeurs

  0

  tm_year

  (par exemple, 1993)

  1

  tm_mon

  plage [1, 12]

  2

  tm_mday

  plage [1, 31]

  3

  tm_hour

  plage [0, 23]

  4

  tm_min

  plage [0, 59]

  5

  tm_sec

  range [0, 61]; see Note (2) in `strftime()`

  6

  tm_wday

  range [0, 6]; Monday is 0

  7

  tm_yday

  plage [1, 366]

  8

  tm_isdst

  `0`, `1` or `-1` ; voir en bas

  N/A

  tm_zone

  abréviation du nom du fuseau horaire

  N/A

  tm_gmtoff

  décalage à l’est de UTC en secondes

  Notez que contrairement à la structure C, la valeur du mois est une plage de [1, 12], pas de [0, 11].

  Dans les appels à `mktime()`, `tm_isdst` peut être défini sur 1 lorsque l’heure d'été est en vigueur et sur 0 lorsque ce n’est pas le cas. Une valeur de `-1` indique que cela n’est pas connu et entraînera généralement le remplissage de l’état correct.

  Lorsqu’un n-uplet de longueur incorrecte est passé à une fonction acceptant une `struct_time`, ou comportant des éléments de type incorrect, une exception `TypeError` est levé.

time.time() → float

  Return the time in seconds since the epoch as a floating-point number. The handling of leap seconds is platform dependent. On Windows and most Unix systems, the leap seconds are not counted towards the time in seconds since the epoch. This is commonly referred to as Unix time.

  Note that even though the time is always returned as a floating-point number, not all systems provide time with a better precision than 1 second. While this function normally returns non-decreasing values, it can return a lower value than a previous call if the system clock has been set back between the two calls.

  Le nombre renvoyé par `time()` peut être converti en un format d’heure plus courant (année, mois, jour, heure, etc.) en UTC en le transmettant à la fonction `gmtime()` ou dans heure locale en le transmettant à la fonction `localtime()`. Dans les deux cas, un objet `struct_time` est renvoyé, à partir duquel les composants de la date du calendrier peuvent être consultés en tant qu’attributs.

  Clock:

  - On Windows, call `GetSystemTimePreciseAsFileTime()`.

  - Call `clock_gettime(CLOCK_REALTIME)` if available.

  - Otherwise, call `gettimeofday()`.

  Use `time_ns()` to avoid the precision loss caused by the `float` type.

Modifié dans la version 3.13: On Windows, calls `GetSystemTimePreciseAsFileTime()` instead of `GetSystemTimeAsFileTime()`.

time.time_ns() → int

  Similaire à `time()` mais renvoie le nombre de nanosecondes depuis epoch sous la forme d'un entier.

  Ajouté dans la version 3.7.

time.thread_time() → float

  Renvoie la valeur (en quelques fractions de secondes) de la somme des temps processeur système et utilisateur du fil d'exécution en cours. Il ne comprend pas le temps écoulé pendant le sommeil. Il est spécifique au fil d'exécution par définition. Le point de référence de la valeur renvoyée est indéfini, de sorte que seule la différence entre les résultats d’appels consécutifs dans le même fil d'exécution est valide.

  Use `thread_time_ns()` to avoid the precision loss caused by the `float` type.

  Disponibilité: Linux, Unix, Windows.

  Systèmes prenant en charge `CLOCK_THREAD_CPUTIME_ID`.

  Ajouté dans la version 3.7.

time.thread_time_ns() → int

  Similaire à `thread_time()` mais renvoie le temps en nanosecondes.

  Ajouté dans la version 3.7.

time.tzset()

  Réinitialise les règles de conversion de temps utilisées par les routines de la bibliothèque. La variable d’environnement `TZ` spécifie comment cela est effectué. La fonction définira également les variables `tzname` (à partir de la variable d’environnement `TZ`), `timezone` (secondes non DST à l’ouest de l’UTC), `altzone` (secondes DST à l’ouest de UTC) et `daylight` (à 0 si ce fuseau horaire ne comporte aucune règle d’heure d’été, ou non nul s’il existe une heure, passée, présente ou future lorsque l’heure d’été est appliquée).

  Disponibilité: Unix.

  Note

  Bien que dans de nombreux cas, la modification de la variable d’environnement `TZ` puisse affecter la sortie de fonctions telles que `localtime()` sans appeler `tzset()`, ce comportement n'est pas garanti.

  La variable d’environnement `TZ` ne doit contenir aucun espace.

  Le format standard de la variable d’environnement `TZ` est (espaces ajoutés pour plus de clarté) :

      std offset [dst [offset [,start[/time], end[/time]]]]

  Où les composants sont :

  `std` et `dst`

    Trois alphanumériques ou plus donnant les abréviations du fuseau horaire. Ceux-ci seront propagés dans time.tzname

  `offset`

    Le décalage a la forme suivante : `± hh[:mm[:ss]]`. Cela indique la valeur ajoutée à l’heure locale pour arriver à UTC. S'il est précédé d’un `'-'`, le fuseau horaire est à l’est du Premier Méridien ; sinon, c’est l’ouest. Si aucun décalage ne suit dst, l’heure d’été est supposée être en avance d’une heure sur l’heure standard.

  `start[/time], end[/time]`

    Indique quand passer à DST et en revenir. Le format des dates de début et de fin est l’un des suivants :

    `Jn`

      Le jour Julien n (1 <= n <= 365). Les jours bissextiles ne sont pas comptabilisés. Par conséquent, le 28 février est le 59e jour et le 1er mars est le 60e jour de toutes les années.

    `n`

      Le jour Julien de base zéro (0 <= n <= 365). Les jours bissextiles sont comptés et il est possible de se référer au 29 février.

    `Mm.n.d`

      Le d jour (0 <= d <= 6) de la semaine n du mois m de l’année (1 <= n <= 5, 1 <= m <= 12, où semaine 5 signifie “le dernier jour du mois m” pouvant se produire au cours de la quatrième ou de la cinquième semaine). La semaine 1 est la première semaine au cours de laquelle le jour se produit. Le jour zéro est un dimanche.

    `time` a le même format que `offset` sauf qu’aucun signe de direction (`'-'` ou `'+'`) n’est autorisé. La valeur par défaut, si l’heure n’est pas spécifiée, est 02:00:00.

      >>> os.environ['TZ'] = 'EST+05EDT,M4.1.0,M10.5.0'
      >>> time.tzset()
      >>> time.strftime('%X %x %Z')
      '02:07:36 05/08/03 EDT'
      >>> os.environ['TZ'] = 'AEST-10AEDT-11,M10.5.0,M3.5.0'
      >>> time.tzset()
      >>> time.strftime('%X %x %Z')
      '16:08:12 05/08/03 AEST'

  Sur de nombreux systèmes Unix (y compris *BSD, Linux, Solaris et Darwin), il est plus pratique d’utiliser la base de données zoneinfo (tzfile (5)) du système pour spécifier les règles de fuseau horaire. Pour ce faire, définissez la variable d’environnement `TZ` sur le chemin du fichier de fuseau horaire requis, par rapport à la racine de la base de données du système zoneinfo, généralement situé à `/usr/share/zoneinfo`. Par exemple, `'US/Eastern'`, `'Australia/Melbourne'`, `'Egypt'` ou `'Europe/Amsterdam'`.

      >>> os.environ['TZ'] = 'US/Eastern'
      >>> time.tzset()
      >>> time.tzname
      ('EST', 'EDT')
      >>> os.environ['TZ'] = 'Egypt'
      >>> time.tzset()
      >>> time.tzname
      ('EET', 'EEST')

## Constantes d’identification d’horloge

Ces constantes sont utilisées comme paramètres pour `clock_getres()` et `clock_gettime()`.

time.CLOCK_BOOTTIME

  Identique à `CLOCK_MONOTONIC`, sauf qu'elle inclut également toute suspension du système.

  Cela permet aux applications d’obtenir une horloge monotone tenant compte de la suspension sans avoir à gérer les complications de `CLOCK_REALTIME`, qui peuvent présenter des discontinuités si l’heure est modifiée à l’aide de `settimeofday()` ou similaire.

  Disponibilité: Linux >= 2.6.39.

  Ajouté dans la version 3.7.

time.CLOCK_HIGHRES

  Le système d’exploitation Solaris dispose d’une horloge `CLOCK_HIGHRES` qui tente d’utiliser une source matérielle optimale et peut donner une résolution proche de la nanoseconde. `CLOCK_HIGHRES` est l’horloge haute résolution non ajustable.

  Disponibilité: Solaris.

  Ajouté dans la version 3.3.

time.CLOCK_MONOTONIC

  Horloge qui ne peut pas être réglée et représente l’heure monotone depuis un point de départ non spécifié.

  Disponibilité: Unix.

  Ajouté dans la version 3.3.

time.CLOCK_MONOTONIC_RAW

  Similaire à `CLOCK_MONOTONIC`, mais donne accès à une heure matérielle brute qui n’est pas soumise aux ajustements NTP.

  Disponibilité: Linux >= 2.6.28, macOS >= 10.12.

  Ajouté dans la version 3.3.

time.CLOCK_MONOTONIC_RAW_APPROX

  Similar to `CLOCK_MONOTONIC_RAW`, but reads a value cached by the system at context switch and hence has less accuracy.

  Disponibilité: macOS >= 10.12.

  Ajouté dans la version 3.13.

time.CLOCK_PROCESS_CPUTIME_ID

  Minuterie haute résolution par processus du CPU.

  Disponibilité: Unix.

  Ajouté dans la version 3.3.

time.CLOCK_PROF

  Minuterie haute résolution par processus du CPU.

  Disponibilité: FreeBSD, NetBSD >= 7, OpenBSD.

  Ajouté dans la version 3.7.

time.CLOCK_TAI

  International Atomic Time

  Le système doit avoir un tableau des secondes intercalaires pour pouvoir donner une réponse correcte. Les logiciels PTP ou NTP savent gérer un tableau des secondes intercalaires.

  Disponibilité: Linux.

  Ajouté dans la version 3.9.

time.CLOCK_THREAD_CPUTIME_ID

  Horloge de temps CPU spécifique au fil d'exécution.

  Disponibilité: Unix.

  Ajouté dans la version 3.3.

time.CLOCK_UPTIME

  Heure dont la valeur absolue correspond à l’heure à laquelle le système a été exécuté et non suspendu, fournissant une mesure précise du temps de disponibilité, à la fois absolue et à intervalle.

  Disponibilité: FreeBSD, OpenBSD >= 5.5.

  Ajouté dans la version 3.7.

time.CLOCK_UPTIME_RAW

  Horloge qui s'incrémente de manière monotone, en suivant le temps écoulé depuis un point arbitraire, n'est pas affectée par les ajustements de fréquence ou de temps et n'est pas incrémentée lorsque le système est en veille.

  Disponibilité: macOS >= 10.12.

  Ajouté dans la version 3.8.

time.CLOCK_UPTIME_RAW_APPROX

  Like `CLOCK_UPTIME_RAW`, but the value is cached by the system at context switches and therefore has less accuracy.

  Disponibilité: macOS >= 10.12.

  Ajouté dans la version 3.13.

La constante suivante est le seul paramètre pouvant être envoyé à `clock_settime()`.

time.CLOCK_REALTIME

  Real-time clock. Setting this clock requires appropriate privileges. The clock is the same for all processes.

  Disponibilité: Unix.

  Ajouté dans la version 3.3.

## Constantes de fuseau horaire

time.altzone

  Décalage du fuseau horaire DST local, en secondes à l’ouest de UTC, s’il en est défini un. Cela est négatif si le fuseau horaire DST local est à l’est de UTC (comme en Europe occidentale, y compris le Royaume-Uni). Utilisez ceci uniquement si `daylight` est différent de zéro. Voir note ci-dessous.

time.daylight

  Non nul si un fuseau horaire DST est défini. Voir note ci-dessous.

time.timezone

  Décalage du fuseau horaire local (hors heure d’été), en secondes à l’ouest de l’UTC (négatif dans la plupart des pays d’Europe occidentale, positif aux États-Unis, nul au Royaume-Uni). Voir note ci-dessous.

time.tzname

  Une paire de chaînes : la première est le nom du fuseau horaire local autre que DST, la seconde est le nom du fuseau horaire DST local. Si aucun fuseau horaire DST n’est défini, la deuxième chaîne ne doit pas être utilisée. Voir note ci-dessous.

Note

For the above Timezone constants (`altzone`, `daylight`, `timezone`, and `tzname`), the value is determined by the timezone rules in effect at module load time or the last time `tzset()` is called and may be incorrect for times in the past. It is recommended to use the `tm_gmtoff` and `tm_zone` results from `localtime()` to obtain timezone information.

Voir aussi

Module `datetime`

  Interface plus orientée objet vers les dates et les heures.

Module `locale`

  Services d’internationalisation. Les paramètres régionaux affectent l’interprétation de nombreux spécificateurs de format dans `strftime()` et `strptime()`.

Module `calendar`

  Fonctions générales liées au calendrier. `timegm()` est l’inverse de `gmtime()` à partir de ce module.

Notes

[1] (1,2,3)

The use of `%Z` is now deprecated, but the `%z` escape that expands to the preferred hour/minute offset is not supported by all ANSI C libraries. Also, a strict reading of the original 1982 RFC 822 standard calls for a two-digit year (`%y` rather than `%Y`), but practice moved to 4-digit years long before the year 2000. After that, RFC 822 became obsolete and the 4-digit year has been first recommended by RFC 1123 and then mandated by RFC 2822, with RFC 5322 continuing this requirement.