Comprendre la classe Python Timer avec des exemples

Python a des milliers de modules et de bibliothèques pour satisfaire les demandes du codeur. Cependant, pour les rendre utiles, vous devez d’abord les comprendre, puis les appliquer. Sans la connaissance préalable de certains modules, il est incertain de ce que vous voulez faire et de ce que le module fait réellement. Le temps est l’un des facteurs importants des problèmes de codage. Tous les codes sont destinés à réduire le travail humain en utilisant leurs algorithmes puissants. La gestion du temps crée un impact important sur l’analyse des performances de votre code. C’est pourquoi aujourd’hui, nous allons en apprendre davantage sur le fonctionnement du minuteur en Python.

Python Timer est une classe / bibliothèque pour gérer la complexité temporelle de votre code. En utilisant plusieurs modules de temps, vous pouvez créer un système dans votre code pour vérifier le temps pris par l’extrait de code respectif. Il existe différents types d’implémentations de minuterie en python en fonction des besoins de l’utilisateur, à savoir la fonction de minuterie python (pour vérifier le temps d’exécution du script), la minuterie de threading python (pour vérifier le temps mis par un thread pour terminer), la minuterie de compte à rebours python (créer un compte à rebours) et le module de temps python de base (pour aider à d’autres activités).

Toutes ces implémentations de temporisateur fonctionnent différemment et se concentrent sur une utilisation différente pour l’utilisateur final. Dans cet article, nous allons passer en revue chaque implémentation de minuteur en détail. Vous pouvez utiliser la Table des matières pour passer à l’implémentation respective du temporisateur python.

Fonctions de base de la minuterie Python

Le module le plus important en python en ce qui concerne le temps est le temps. Ce module contient toutes les fonctions de base pour vérifier l’heure et l’analyser. Cette analyse vous aidera à comprendre les performances de votre code et son efficacité. Nous passerons en revue chacune des fonctions importantes de ce module ainsi que ses exemples.

Voici les fonctions de base de la minuterie Python utilisant le module de temps –

• temps.temps ()
• temps.thread_time()
• temps.process_time()
• temps.perf_counter()
• temps.monotone()

Temps de fonction.time

time.time() renvoie le temps en secondes (float) après l’époque. Généralement, l’époque est fixée à janvier 1, 1970, 00:00:00 ( UTC), et le nombre de secondes après cette époque est renvoyé. Cette fonction dépend de l’heure de calcul du nombre de secondes par l’ordinateur. Si vous modifiez l’heure de l’ordinateur entre l’exécution de Python, vous pouvez obtenir des nombres étranges en utilisant cette fonction.

Exemple –

import timestart = time.time() #start timefor i in range(1000000): passend = time.time()print("Elapsed time is {}".format(end-start))

Explication –

Tout d’abord, nous commençons par importer le module de temps. Ce module contient toutes les fonctions horaires de base que nous utiliserons dans cette section. Au début du code, nous déclarerons la variable de démarrage comme time.time(). Cela stockera l’heure actuelle du CPU en nombre flottant de l’époque. Nous utiliserons cette variable de départ comme point de référence pour mesurer le temps. La partie suivante contient tous les codes que vous souhaitez utiliser (Dans cet exemple, nous avons utilisé des boucles for). De même, enregistrez l’heure de fin de la CPU (heure par défaut) et vérifiez le temps d’exécution total en utilisant end–start.

Cela imprimera le temps pris par le code en secondes. Avec l’utilisation de cette technique, vous pouvez vérifier le temps pris par votre code. Le seul problème avec cette méthode est que le temps CPU peut être modifié pendant l’exécution du code. Cela entraînera un comportement problématique dans le temporisateur python.

Temps de fonction.Thread_time

time.thread_time() renvoie la somme du temps système et CPU (float) dans le thread en cours d’exécution. De plus, il n’inclut pas le temps que vous passez dans la fonction time.sleep(). Comme la fonction est spécifique au thread, vous pouvez utiliser cette fonction pour enregistrer les différences de temps tant que les références de temps appartiennent au même thread.

Exemple –

import timeimport threadingend = Nonestart = Nonedef hello(): global start, end start = time.thread_time() x = 0 while x < 10000000: pass x += 1 end = time.thread_time()t = threading.Thread(target = hello, args = ())t.start() t.join()print("The time spent is {}".format(end - start))

Explication –

Comme le thread_time renvoie l’heure spécifique au thread, nous devons nous assurer d’utiliser des références dans le même thread. À cette fin, nous avons instancié le thread de la fonction ‘hello’ et calculé le temps pris par le thread à l’intérieur. Cependant, assurez-vous que vous ne pouvez pas obtenir l’heure actuelle en appelant thread_time() car elle renvoie une valeur fractionnaire. Mais vous pouvez certainement vérifier la différence entre deux références consécutives tant qu’elles appartiennent au même thread.

Temps de fonction.Process_time

time.process_time() renvoie la référence de temps en secondes fractionnaires (float) de la somme du temps système et du temps CPU de la progression en cours. Identique à thread_time, cette fonction ne mesure pas le temps passé dans la fonction time.sleep(). De plus, cette fonction crée une référence basée sur le processus. De ce fait, seule la différence de temps entre deux références consécutives aura un sens.

Exemple –

from time import process_time, sleepiterations = 100000start = process_time() for i in range(iterations): print(i, end=" ") # Stop the stopwatch / counter end = process_time()print(end, start)print("Elapsed time in seconds:", end-start)

Explication –

Nous commençons par importer la fonction process_time et enregistrons l’heure de début et de fin entre le code. La seule différence entre les anciens time.time() et time.proces_time() est que le temps de traitement enregistre les références de temps du processus en cours, tandis que time() enregistre le temps absolu du système.

Temps de fonction.Perf_counter

Compteur de performances signifie Compteur de performances. Cette fonction renvoie la valeur haute résolution du temps, qui est valable pour une courte période de temps. Cette fonction est utilisée pour obtenir le nombre de temps précis entre deux références. Comme les autres fonctions de minuterie Python n’incluent pas le temps de sommeil, perf_counter ne l’inclut pas non plus. Passons à un exemple – Exemple

–

from time import perf_counter, sleep # integer input from user, 2 input in single linen = 3 # Start the stopwatch / counter start = perf_counter() for i in range(n): sleep(1)end = perf_counter() print("Elapsed time in seconds:", end-start) 

Explication –

Vous pouvez utiliser le compteur de perf de la même manière que le minuteur de processus ou le minuteur de thread. La seule différence est que le compteur de perf retournera une valeur précise élevée du temps écoulé. Mais assurez-vous de l’utiliser entre de petits processus, car il utilise une haute précision. Nous avons utilisé une simple boucle pour vérifier le temps qu’elle prend.

Temps de fonction.monotonic

Monotonic est un temporisateur python qui ne peut pas reculer. Lors de l’exécution d’un script python, l’heure peut être modifiée par l’utilisateur et peut faire une énorme différence dans l’implémentation de la minuterie en python. Mais la minuterie monotone garantit que les références de temps s’ajustent aux changements externes.

Exemple –

from time import monotonic, sleep # integer input from user, 2 input in single linen = 3 # Start the stopwatch / counter start = monotonic() for i in range(n): sleep(1)end = monotonic() print("Elapsed time in seconds:", end-start) 

Explication –

Nous importons d’abord la fonction monotone du module de temps. Créez ensuite deux références nommées start et end en haut et en bas du code. Cela mesurera le temps entre les deux références et évitera toutes les modifications externes aux heures du système.

Classes de minuterie Python personnalisées

Vous pouvez créer votre propre classe de minuterie personnalisée pour faire les choses selon vos besoins. L’un des principaux avantages de la création d’une classe personnalisée est que vous pouvez gérer tout le temps sur une seule ligne. Vous n’avez pas besoin d’importer la classe time à chaque fois et d’enregistrer les références. De plus, vous pouvez vider vos données et enregistrer toutes les exécutions passées pour choisir le meilleur algorithme pour vous.

Cette section va créer une classe personnalisée pour gérer l’heure et enregistrer toutes les différences de temps dans vos codes. Plongeons-y directement – Minuterie

.py –

Nous allons commencer par importer le module de temps. Initialisez ensuite la classe python Timer et commencez à définir les attributs et les méthodes. Jusqu’à présent, nous n’avons inclus que l’attribut basic pour conserver une référence de début de la classe. Pour le rendre plus complexe, vous pouvez créer plusieurs attributs. Jusqu’à présent, il existe trois méthodes énumérées ci-dessous –

1. start – (Facultatif) Pour démarrer la minuterie.
2. log – Pour enregistrer le temps écoulé actuel concernant l’heure de début.
3. milestone – Pour réinitialiser le minuteur et commencer son décompte à partir de 0.

import timeclass Timer: def __init__(self): self.start = time.time() def start(self): self.start = time.time() def log(self): logger = time.time() - self.start print('Time log -',logger) def milestone(self): self.start = time.time()

example.py –

Des exemples d’utilisation de la classe ci-dessus sont donnés ci-dessous. Comme vous pouvez le voir, vous pouvez garder votre code propre en créant une classe de minuterie personnalisée et augmenter la flexibilité.

import timertime = timer.Timer()for i in range(1000000):passp = 1time.log()for i in range(1000000):passp = 1time.log()

Sortie –

Time log - 0.054854631423950195Time log - 0.10871052742004395

Temporisateur Python utilisant le Threading

Lorsque nous voulons effectuer une opération ou que notre fonction s’exécute après un certain temps, nous utilisons la classe Temporisateur Python. La classe timer est une sous-classe de la classe threading. Techniquement, vous pouvez dire que nous créons des objets Timer lorsque nous voulons des actions (fonctions) limitées par le temps.

Par exemple, supposons que nous souhaitions organiser un quiz, où le participant doit répondre à chaque question en 10 secondes. Ici, nous pouvons créer une minuterie qui s’exécutera en arrière-plan, et pendant ce temps, le participant réfléchira à la réponse. Maintenant, comprenons comment créer un objet timer.

Syntaxe de la classe Timer en Python

Si vous n’avez pas compris ce que fait la classe Timer, vous pouvez y penser de cette façon – Une classe Timer appelle une fonction après le nombre de secondes spécifié.

Pour démarrer une minuterie, nous devons appeler start() (tout comme les threads normaux), et pour arrêter la minuterie alors qu’elle est encore en arrière-plan, nous pouvons appeler cancel().

Pour utiliser la classe Timer, nous devons importer la classe de threading

threading.Timer(interval, function, args=None, kwargs=None)

Parameters –

Interval – Le temps (en secondes) que vous souhaitez attendre avant d’appeler la fonction suivante. Il peut être en float ou en entier. Par exemple, pendant 3 secondes, intervalle = 3. Fonction

– Fonction que vous souhaitez appeler après l’intervalle de temps spécifié.

Une façon omniprésente de décrire les paramètres *args et **kwargs est de créer un objet timer qui exécute la fonction avec les arguments ‘args’ et les arguments de mots clés ‘kwargs’ après que les secondes d’intervalle se soient écoulées. Les args doivent être sous la forme d’une liste et0 args de mots clés ou kwargs sous la forme d’un dictionnaire.

Type de retour –

Il appelle simplement la fonction spécifiée dans les paramètres.

Méthodes dans la classe Timer

1. start() – Cela signifie le début de l’exécution du timer.
2. Cancel() – Pendant l’exécution du minuteur, nous pouvons appeler l’annulation si nous voulons l’arrêter().

Création d’un objet Timer

a. Comprendre les bases

Pour comprendre le fonctionnement de l’objet Timer, créons un petit programme pour nous aider à comprendre les bases de la classe.

# Importing the Timer subclass from the threading Classfrom threading import Timer# creating a basic function that will print "hello"def hello(): print ("hello, world")# creating the object of the Timer subclass# Here, 5 sec means that the execution of the function="hello" after 5 secondst = Timer(interval=5.0, function=hello)# starting the executiont.start() # after 30 seconds, "hello, world" will be printed

Output-hello, world

Vous comprendrez mieux le fonctionnement du programme ci-dessus lorsque vous essaierez de l’exécuter sur votre propre système.

b. En utilisant la méthode cancel

Voyons comment utiliser la fonction cancel() de la classe Timer.

# Importing the Timer subclass from the threading Classfrom threading import Timer# creating a basic function that will print "hello"def hello(): print ("hello world") # creating the object of the Timer subclass# Here, 5 sec means that the execution of the function="hello" after 5 secondst = Timer(interval=5.0, function=hello) # starting the executiont.start() # after 30 seconds, "hello, world" will be printedprint("Execution begins")# cancelling the execution of the 'hello' functiont.cancel()print("END")

Execution begins END

c. Comment utiliser le paramètre ‘args’ de la classe python timer

Lorsque nous devons donner les arguments à la fonction à appeler, nous utilisons le paramètre args. Nous devons donner l’argument args dans un tableau.

import threading# To take multiple inputs we can use *before the parameter.def print_name(*names): # From the array of names pick one name and print it for name in names: print("Hello",name)# In the args parameter, give an array of names t = threading.Timer(3, print_name,)# start the executiont.start()print("Execution begins...")

Execution begins...Hello AshwiniHello VandyHello Arijit

Maintenant que nous avons beaucoup parlé du temps, en prime, faisons un programme qui agira comme un compte à rebours.

Compte à rebours en python

En utilisant le module de temps

# We will use the time moduleimport time# Create a function that will print the timedef create_countdown_timer(time): print(time,"......")time_in_sec=int(input("Please entert the time in seconds:"))for times in range(time_in_sec): # call the function and pass the current time left create_countdown_timer(time_in_sec-times) # call the function in every 1 second. time.sleep(1) print("Time is up")

Please entert the time in seconds:77 ......6 ......5 ......4 ......3 ......2 ......1 ......Time is up

Utilisation de la classe python Timer

# We will use the time moduleimport timefrom threading import Timer# Create a function that will print the timedef create_countdown_timer(time): print(time,"......")# Here you have to enter the time for which the timer will runtime_in_sec=int(input("Please enter the time in seconds:"))# For the first time we will call the function manuallycreate_countdown_timer(time_in_sec) for times in range(1,time_in_sec): # calling the Timer class every second t = Timer(1,create_countdown_timer,) t.start() time.sleep(1) print("\n Time is up") 

Please entert the time in seconds:1010 ......9 ......8 ......7 ......6 ......5 ......4 ......3 ......2 ......1 ......Time is up

Les minuteries Python en tant que gestionnaires de contexte

Les gestionnaires de contexte sont les meilleurs moyens d’éviter les erreurs de mémoire et les plantages ultérieurs. Tout le monde devait savoir « avec » l’instruction en Python. Cette déclaration garantit que nous n’avons pas à prendre soin de nombreux objets pour fermer indépendamment. Tout le monde l’a peut-être utilisé avec la combinaison de la fonction with et open(). Donc, en passant à la question principale, pouvons-nous créer des gestionnaires de contexte pour les minuteries Python?

Oui. En raison de multiples fonctions de surcharge, nous pouvons facilement créer notre propre temporisateur python en tant que gestionnaire de contexte en quelques lignes seulement. Commençons par un exemple où vous devez mesurer le temps d’exécution du programme. Sans redéfinir toutes les variables, un gestionnaire de contexte peut être utilisé à plusieurs reprises pour mesurer le temps plusieurs fois. Le programme suivant le démontre.

Exemple –

import timeclass Timer_Pythonpool(): """ Context manager as a python timer """ def __init__(self): self.start = None def __enter__(self): """ Notes the time at the start of the iteration """ self.start = time.time() return self def __exit__(self, exc_type, exc_value, exc_traceback): """ Prints the time taken at the end of the iteration """ print("Time to finish the task: ", time.time()-self.start) with Timer_Pythonpool() as timer: for i in range(1000000): x = 0 pass

Sortie –

Time to finish the task: 0.05392050743103027

Explication –

Nous commençons par créer une classe nommée « Timer_Pythonpool. »Ensuite, nous personnalisons les opérateurs pour les rendre utiles en tant que gestionnaire de contexte. _la fonction __enter__ s’exécute au début du contexte et __exit__ s’exécute à la fin du contexte. La création d’un point de référence entre ces deux fonctions peut vous donner le temps exact mis par le contexte à s’exécuter.

Décorateurs de minuterie Python

Les décorateurs sont le support supplémentaire pour tout type de fonction. Également appelé métaprogrammation, vous pouvez y modifier / ajouter des fonctionnalités. Les décorateurs de minuterie Python sont le moyen le plus simple d’implémenter les fonctions de minuterie en python. Une fois déclarés, vous pouvez utiliser les décorateurs en une seule ligne sans même les connaître. En y ajoutant, vous pouvez les appliquer à chaque fonction de votre code pour vérifier quel code prend le plus de temps à s’exécuter.

Syntaxe –

Pour créer un décorateur de chaînage, vous devez déclarer plusieurs fonctions imbriquées. Nommez l’autre fonction comme nom de décorateur principal et interne à n’importe quel nom aléatoire. La fonction interne récupérera la référence de la fonction utilisée sous le décorateur.

Exemple –

import timedef check_time(func): def inner(*args, **kwargs): start = time.time() func(*args, **kwargs) end = time.time() print("Time taken to execute function is ", end-start) return inner@check_timedef task(): # do something for i in range(10000000): x = 0 passtask()

Sortie –

Time taken to execute function is 0.24933218955993652

Explication –

Comme d’habitude, nous commençons par importer le module le plus important de python « time. »Ensuite, nous créons un décorateur nommé « check_time. »À l’intérieur, nous ajoutons une fonction intérieure imbriquée où nous pouvons créer les références du temps. Ces deux références sont placées de sorte qu’elles soient toutes deux placées entre l’exécution de la fonction.

De plus, nous créons une fonction de test nommée « tâche » pour vérifier si notre tâche fonctionne. Ajoutez ensuite un décorateur dessus. Maintenant, le décorateur va faire sa magie et imprimer le temps pris par la fonction.

Temps de recharge de la minuterie Python

Le temps de recharge de la minuterie Python est un moyen de mesurer la minuterie en arrière. En créant une classe de minuterie personnalisée, nous pouvons enregistrer l’heure à chaque point de votre code. Vous pouvez exporter cette classe en tant que module et l’installer en tant que dépendance dans votre code. Ensuite, en utilisant une seule ligne, vous pouvez l’importer –

import timeclass Timer: """ Timer class """ def __init__(self): self.start = time.time() ''' Restarts the timer. ''' def restart(self): self.start = time.time() ''' Returns the time elapsed and resets the counter. ''' def get_new_time(self): value = time.time() - self.start self.restart() return value ''' Prints the time elapsed and resets the counter. ''' def print_new_time(self): print (self.get_new_time()) ''' Returns the time elapsed (Does not reset the counter). ''' def get_time(self): return time.time() - self.start self.restart() ''' Prints the time elapsed (Does not reset the counter). ''' def print_time(self): print(self.get_time()) ''' Returns the time elapsed in HH:mm:ss (Does not reset the counter). ''' def get_time_hhmmss(self): end = time.time() m, s = divmod(end - self.start, 60) h, m = divmod(m, 60) time_str = "%02d:%02d:%02d" % (h, m, s) return time_strtimer = Timer() #Initialize the timer#wash clothes for 5 secondstimer.print_time() #Print the time elapsed since Initialization (in seconds)#dry clothes for 3 secondstimer.print_new_time() #Print the time elapsed since Initialization and reset the timer#burn clothes for 10 secondsprint(str('Task done for ' + str(timer.get_time()) + ' seconds.'))

Autres modules de temporisation Python

Python contient des milliers de modules et des millions d’extraits de code. Nous pouvons toujours utiliser les modules open source pour utiliser des minuteries python. Github est le plus grand endroit pour trouver de tels modules. Sautons directement dans ces modules –

1. terminaison: Une minuterie python avancée réalisée en utilisant différents caractères ASCII. En utilisant ce script, vous pouvez créer un compte à rebours simple dans votre terminal et exécuter une commande à la fin. Plus important encore, il prend en charge le compte à rebours vocal.
2. MobTimer.Python: Une minuterie basée sur une interface graphique faite en python. Ce script crée des minuteries en plein écran avec plusieurs options. Parallèlement, vous pouvez exécuter plusieurs minuteries sur votre écran en même temps en utilisant ce programme.
3. minuterie: Il s’agit de la minuterie basée sur l’interface graphique la plus basique fabriquée en python (Tkinter). Des fonctionnalités telles que plusieurs minuteries, étiquettes et multithreading le rendent plus viable par rapport aux autres programmes.
4. codetiming: Cette classe de temporisation enregistre tous vos temps d’exécution passés pour un processus nommé spécifique. Vous pouvez vérifier le temps minimum, le temps maximum, l’intervalle et le temps médian pour le processus spécifique ainsi que les enregistrements. Ce module peut être utilisé de multiples façons, notamment en tant que gestionnaire de contexte et en tant que décorateur.
5. cTimer: cTime est un minuteur de précision en nanosecondes en python. Ce module utilise l’API du langage c pour enregistrer l’heure avec précision. Si vous recherchez un module d’enregistrement de temps de précision hardcore, c’est le meilleur. (Remarque: Dans les mises à jour récentes de python, le module de temps est ajouté avec des fonctions pour enregistrer le temps en nanosecondes)

Doit Lire:

• Comment convertir une chaîne en Minuscules dans
• Comment Calculer la Racine carrée
• Entrée utilisateur | Fonction Input() / Entrée au clavier
• Meilleur livre pour apprendre Python

Conclusion

La plupart du temps, tout le monde utilise des minuteries à trois fins. Le premier étant d’enregistrer le temps d’exécution de votre code. Et le second étant, d’ajouter un rappel pour quelque chose en utilisant une minuterie. Heureusement, les deux peuvent être créés en Python. En utilisant différents modules et bibliothèques, vous pouvez vous assurer d’enregistrer l’heure avec une précision extrême.

Enfin et surtout, le timer est une sous-classe de la classe de threading en python. Si nous voulons exécuter une fonction après un certain intervalle de temps, nous pouvons utiliser la classe python timer. Dans le paramètre args, qui est None par défaut, nous pouvons spécifier les arguments que nous voulons donner à la méthode de rappel.

Essayez d’exécuter les programmes de votre côté et faites-nous savoir si vous avez des questions.