10 choses surprenantes que vous pouvez faire avec le module Time de Python

Image de l’éditeur | Chatte

# Introduction

La plupart des développeurs Python connaissent le time module, pour ses fonctions pratiques telles que time.sleep(). Cela fait de la modification de l’exécution de la pause, un outil simple mais essentiel. Cependant, le time Le module est beaucoup plus polyvalent, offrant une suite de fonctions pour une mesure précise, une conversion temporelle et un formatage qui passent souvent inaperçus. L’exploration de ces capacités peut débloquer des moyens plus efficaces de gérer les tâches liées au temps dans vos projets de science des données et d’autres projets de codage.

J’ai eu un flack pour la dénomination des articles précédents « 10 choses surprenantes », et je comprends. « Oui, c’est tellement surprenant que je peux effectuer des tâches de date et d’heure avec le module DateTime, merci. » Critique valide. Cependant, le nom colle parce qu’il est accrocheur, alors traitez-le 🙂

Dans tous les cas, voici 10 choses surprenantes et utiles que vous pouvez faire avec Python time module.

# 1. Mesurer avec précision le temps de blocage mural écoulé avec time.monotonic()

Alors que vous pourriez aller automatiquement time.time() Pour mesurer la durée d’une fonction, elle a un défaut critique: il est basé sur le horloge systèmequi peut être modifié manuellement ou par des protocoles de temps de réseau. Cela peut conduire à des différences de temps inexactes ou même négatives. Une solution plus robuste est time.monotonic(). Cette fonction renvoie la valeur d’une horloge monotonique, qui ne peut pas reculer et n’est pas affectée par les mises à jour du temps du système. Cela en fait vraiment le choix idéal pour mesurer les durées de manière fiable.

import time

start_time = time.monotonic()

# Simulate a task
time.sleep(2)

end_time = time.monotonic()
duration = end_time - start_time

print(f"The task took {duration:.2f} seconds.")

Sortir:

The task took 2.01 seconds.

# 2. Mesurer le temps de traitement du processeur avec time.process_time()

Parfois, vous ne vous souciez pas du temps total passé (temps mural). Au lieu de cela, vous voudrez peut-être savoir combien de temps le processeur a réellement passé à exécuter votre code. Ceci est crucial pour l’efficacité des algorithmes d’analyse comparative, car il ignore le temps passé à dormir ou à attendre les opérations d’E / S. Le time.process_time() La fonction renvoie la somme du temps du système et du processeur utilisateur du processus actuel, fournissant une pure mesure de l’effort de calcul.

import time

start_cpu = time.process_time()

# A CPU-intensive task
total = 0
for i in range(10_000_000):
    total += i

end_cpu = time.process_time()
cpu_duration = end_cpu - start_cpu

print(f"The CPU-intensive task took {cpu_duration:.2f} CPU seconds.")

Sortir:

The CPU-intensive task took 0.44 CPU seconds.

# 3. Obtenez des horodatages de haute précision avec time.perf_counter()

Pour un timing très précis, en particulier pour les durées très courtes, time.perf_counter() est un outil essentiel. Il renvoie la valeur d’un compteur de performances haute résolution, qui est l’horloge la plus précise disponible sur votre système. Il s’agit d’un nombre à l’échelle du système, y compris le temps écoulé pendant le sommeil, ce qui le rend parfait pour les scénarios de référence où chaque nanoseconde compte.

import time

start_perf = time.perf_counter()

# A very short operation
_ = (x*x for x in range(1000))

end_perf = time.perf_counter()
perf_duration = end_perf - start_perf

print(f"The short operation took {perf_duration:.6f} seconds.")

Sortir:

The short operation took 0.000028 seconds.

# 4. Convertir les horodatages en chaînes lisibles avec time.ctime()

La sortie de time.time() est un flotteur représentant quelques secondes depuis «l’époque» (1er janvier 1970 pour les systèmes UNIX). Bien que utile pour les calculs, il n’est pas lisible par l’homme. Le time.ctime() La fonction prend cet horodatage et la convertit en un format de chaîne standard et facile à lire, comme «Thu 31 juil 16:32:30 2025».

import time

current_timestamp = time.time()
readable_time = time.ctime(current_timestamp)

print(f"Timestamp: {current_timestamp}")
print(f"Readable Time: {readable_time}")

Sortir:

Timestamp: 1754044568.821037
Readable Time: Fri Aug  1 06:36:08 2025

# 5. Temps d’analyse d’une chaîne avec time.strptime()

Disons que vous avez des informations de temps stockées en tant que chaîne et que vous devez la convertir en un objet temporel structuré pour un traitement ultérieur. time.strptime() (Temps d’analyse des chaînes) est votre fonction. Vous fournissez la chaîne et un code de format qui spécifie comment les composants de la date et de l’heure sont organisés. Il renvoie un struct_time Objet, qui est un tuple contenant des éléments – comme l’année, le mois, le jour, etc. – qui peut ensuite être extrait.

import time

date_string = "31 July, 2025"
format_code = "%d %B, %Y"

time_struct = time.strptime(date_string, format_code)

print(f"Parsed time structure: {time_struct}")
print(f"Year: {time_struct.tm_year}, Month: {time_struct.tm_mon}")

Sortir:

Parsed time structure: time.struct_time(tm_year=2025, tm_mon=7, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=212, tm_isdst=-1)
Year: 2025, Month: 7

# 6. Format du temps en chaînes personnalisées avec time.strftime()

L’opposé de l’analyse est le formatage. time.strftime() (temps de format de chaîne) prend un struct_time objet (comme celui renvoyé par strptime ou localtime) et le formate en une chaîne en fonction de vos codes de format spécifié. Cela vous donne un contrôle total sur la sortie, que vous préfériez « 2025-07-31 » ou « jeudi 31 juillet ».

import time

# Get current time as a struct_time object
current_time_struct = time.localtime()

# Format it in a custom way
formatted_string = time.strftime("%Y-%m-%d %H:%M:%S", current_time_struct)
print(f"Custom formatted time: {formatted_string}")

day_of_week = time.strftime("%A", current_time_struct)
print(f"Today is {day_of_week}.")

Sortir:

Custom formatted time: 2025-08-01 06:41:33
Today is Friday

# 7. Obtenez des informations de base de fuseau horaire avec time.timezone et time.tzname

Pendant que le DateTime module (et bibliothèques comme pytz) sont meilleurs pour la manipulation complexe du fuseau horaire, le time Le module offre des informations de base. time.timezone Fournit le décalage du fuseau horaire local non-DST (temps d’été) en quelques secondes à l’ouest de l’UTC, tandis que time.tzname est un tuple contenant les noms des fuseaux horaires non DST et DST locaux.

import time

# Offset in seconds west of UTC
offset_seconds = time.timezone

# Timezone names (standard, daylight saving)
tz_names = time.tzname

print(f"Timezone offset: {offset_seconds / 3600} hours west of UTC")
print(f"Timezone names: {tz_names}")

Sortir:

Timezone offset: 5.0 hours west of UTC
Timezone names: ('EST', 'EDT')

# 8. Convertir entre UTC et l’heure locale avec time.gmtime() et time.localtime()

Travailler avec différents fuseaux horaires peut être délicat. Une pratique courante consiste à stocker toutes les données de toutes les temps en temps universel coordonné (UTC) et à le convertir en temps local uniquement pour l’affichage. Le time Le module facilite cela avec time.gmtime() et time.localtime(). Ces fonctions prennent un horodatage en secondes et renvoient un struct_time objet – gmtime() le retourne dans UTC, tandis que localtime() Le renvoie pour le fuseau horaire configuré de votre système.

import time

timestamp = time.time()

# Convert timestamp to struct_time in UTC
utc_time = time.gmtime(timestamp)

# Convert timestamp to struct_time in local time
local_time = time.localtime(timestamp)

print(f"UTC Time: {time.strftime('%Y-%m-%d %H:%M:%S', utc_time)}")
print(f"Local Time: {time.strftime('%Y-%m-%d %H:%M:%S', local_time)}")

Sortir:

UTC Time: 2025-08-01 10:47:58
Local Time: 2025-08-01 06:47:58

# 9. effectuer l’inverse de time.time() avec time.mktime()

time.localtime() convertit un horodat en un struct_time Objet, qui est utile … mais comment allez-vous dans le sens inverse? Le time.mktime() La fonction fait exactement cela. Il faut un struct_time Object (représentant le temps local) et le transforme en un nombre à virgule flottante représentant des secondes depuis l’époque. Ceci est alors utile pour calculer les horodatages futurs ou passés ou la réalisation de la date arithmétique.

import time

# Get current local time structure
now_struct = time.localtime()

# Create a modified time structure for one hour from now
future_struct_list = list(now_struct)
future_struct_list(3) += 1 # Add 1 to the hour (tm_hour)
future_struct = time.struct_time(future_struct_list)

# Convert back to a timestamp
future_timestamp = time.mktime(future_struct)

print(f"Current timestamp: {time.time():.0f}")
print(f"Timestamp in one hour: {future_timestamp:.0f}")

Sortir:

Current timestamp: 1754045415
Timestamp in one hour: 1754049015

# 10. Obtenez le temps de processeur spécifique au fil avec time.thread_time()

Dans des applications multipliques, time.process_time() Vous donne le temps total du processeur pour l’ensemble du processus. Mais que se passe-t-il si vous souhaitez profiler l’utilisation du processeur d’un fil spécifique? Dans ce cas, time.thread_time() est la fonction que vous recherchez. Cette fonction renvoie la somme du temps du système et du processeur utilisateur pour le thread actuelvous permettant d’identifier quels threads sont les plus chers par calcul.

import time
import threading

def worker_task():
    start_thread_time = time.thread_time()

    # Simulate work
    _ = (i * i for i in range(10_000_000))

    end_thread_time = time.thread_time()

    print(f"Worker thread CPU time: {end_thread_time - start_thread_time:.2f}s")

# Run the task in a separate thread
thread = threading.Thread(target=worker_task)
thread.start()
thread.join()

print(f"Total process CPU time: {time.process_time():.2f}s")

Sortir:

Worker thread CPU time: 0.23s
Total process CPU time: 0.32s

# Emballage

Le time Le module est un segment intégral et puissant de la bibliothèque standard de Python. Alors que time.sleep() est sans aucun doute sa fonction la plus célèbre, ses capacités de synchronisation, de mesure de durée et de mise en forme du temps en font un outil pratique pour toutes sortes de tâches pratiquement utiles.

En allant au-delà des bases, vous pouvez apprendre de nouvelles astuces pour écrire un code plus précis et plus efficace. Pour une manipulation de date et d’heure plus avancée et orientée objet, assurez-vous de vérifier Des choses surprenantes que vous pouvez faire avec le datetime module suivant.

Matthew Mayo (@ Mattmayo13) est titulaire d’une maîtrise en informatique et d’un diplôme d’études supérieures en exploration de données. En tant que rédacteur en chef de Kdnuggets & Statologieet rédacteur en chef à Maîtrise de l’apprentissage automatiqueMatthew vise à rendre les concepts de science des données complexes accessibles. Ses intérêts professionnels incluent le traitement du langage naturel, les modèles de langue, les algorithmes d’apprentissage automatique et l’exploration de l’IA émergente. Il est motivé par une mission pour démocratiser les connaissances dans la communauté des sciences des données. Matthew est codant depuis l’âge de 6 ans.