Înțelegerea clasei Python Timer Cu Exemple

Python are mii de module și biblioteci pentru a satisface cerințele coderului. Cu toate acestea, pentru a le face utile, trebuie să le înțelegeți mai întâi și apoi să le aplicați. Fără cunoașterea prealabilă a anumitor module, nu este sigur ce vrei să faci și ce face modulul de fapt. Timpul este unul dintre factorii importanți în problemele de codificare. Toate codurile sunt menite să reducă munca umană prin utilizarea algoritmilor lor puternici. Gestionarea timpului creează un impact mare asupra analizei performanței codului dvs. De aceea, astăzi, vom învăța în profunzime despre modul în care funcționează cronometrul în Python.

Python Timer este o clasă/bibliotecă pentru a gestiona complexitatea de timp a codului. Folosind mai multe module de timp, puteți crea un sistem în codul dvs. pentru a verifica timpul necesar fragmentului de cod respectiv. Există diferite tipuri de implementări timer în python în funcție de nevoile utilizatorilor, și anume, funcția Python timer (pentru a verifica timpul de execuție script), python threading timer (pentru a verifica timpul necesar de un fir pentru a termina), python countdown timer (a crea un temporizator) și modul de bază python time (pentru a ajuta cu alte activități).

toate aceste funcții de implementare timer diferit și se concentrează pe furnizarea de utilizare diferite pentru utilizatorul final. În acest post, vom trece prin fiecare implementare timer în detaliu. Puteți utiliza cuprinsul pentru a trece la implementarea respectivă a cronometrului python.

funcții de bază Python Timer

cel mai important modul în python în ceea ce privește timpul este timpul. Acest modul conține toate funcțiile de bază pentru a verifica timpul și a-l analiza. Această analiză vă va ajuta să înțelegeți performanța codului dvs. și eficiența acestuia. Vom parcurge fiecare dintre funcțiile importante din acest modul împreună cu exemplele sale.

următoarele sunt funcțiile de bază Python Timer folosind modulul de timp–

• timpul.timp ()
• timp.thread_time ()
• timp.process_time ()
• timp.perf_counter ()
• timp.monotonă()

funcția de timp.timpul

time.time() returnează timpul în secunde (float) după epocă. În general, Epoca este setată la Ianuarie 1, 1970, 00:00:00 (UTC), iar numărul de secunde după această epocă este returnat. Această funcție depinde de timpul computerului pentru calcularea numărului de secunde. Dacă schimbați timpul computerului între execuția python, puteți obține numere ciudate folosind această funcție.

exemplu–

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

explicație –

în primul rând, începem cu importul modulului de timp. Acest modul conține toate funcțiile de timp de bază pe care le vom folosi în această secțiune. La începutul codului, vom declara variabila start ca time.time(). Aceasta va stoca ora curentă a procesorului în număr float din epocă. Vom folosi această variabilă de pornire ca punct de referință pentru a măsura timpul. Următoarea parte conține toate codurile pe care doriți să le utilizați (în acest exemplu, am folosit A pentru bucle). În mod similar, înregistrați ora de terminare a procesorului (ora implicită) și verificați timpul total de execuție utilizând end – start.

aceasta va imprima timpul necesar codului în câteva secunde. Cu ajutorul acestei tehnici, puteți verifica timpul necesar codului dvs. Singura problemă cu această metodă este că timpul procesorului poate fi schimbat în timp ce codul rulează. Acest lucru va duce la un comportament problematic în Python timer.

timpul funcției.Thread_time

time.thread_time() returnează suma timpului de sistem și CPU (float) în firul de rulare curent. În plus, nu include timpul petrecut în time.sleep() funcție. Deoarece funcția este specifică firului, puteți utiliza această funcție pentru a înregistra diferențele de timp, atâta timp cât referințele de timp aparțin aceluiași fir.

exemplu–

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))

explicație –

pe măsură ce thread_time returnează timpul specific firului, trebuie să ne asigurăm că folosim referințe în același fir. În acest scop, am instanțiat firul funcției ‘hello’ și am calculat timpul necesar firului din interiorul acestuia. Cu toate acestea, asigurați-vă că nu puteți obține ora curentă apelând thread_time() deoarece returnează o valoare fracționată. Dar puteți verifica cu siguranță diferența dintre două referințe consecutive, atâta timp cât aparțin aceluiași fir.

timpul funcției.Process_time

time.process_time() returnează referința de timp în secunde fracționare (float) a sumei timpului sistemului și a timpului procesorului progresului curent. La fel ca thread_time, această funcție nu măsoară timpul petrecut în time.sleep() funcție. Mai mult, această funcție creează o referință bazată pe proces. Drept urmare, numai diferența de timp dintre două referințe consecutive va avea sens.

exemplu–

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)

explicație –

începem cu importul funcției process_time și înregistrăm ora de început și de sfârșit între Cod. Singura diferență între moștenirea time.time() și time.proces_time() este că timpul de procesare înregistrează referințele de timp ale procesului curent, în timp ce time() înregistrează timpul absolut al sistemului.

timpul funcției.Perf_counter

Perf Counter reprezintă contorul de performanță. Această funcție returnează valoarea de înaltă rezoluție a timpului, care este valabilă pentru o perioadă scurtă de timp. Această funcție este utilizată pentru a obține numărul exact de timp între două referințe. Deoarece alte funcții ale cronometrului python nu includ timpul de somn, perf_counter de asemenea, nu îl include. Să trecem la un exemplu-

exemplu–

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) 

explicație –

puteți utiliza contorul perf în același mod ca și cronometrul de proces sau temporizatorul firului. Singura diferență este, contra perf va returna o valoare precisă ridicată a timpului scurs. Dar asigurați-vă că utilizați acest lucru între procese mici, deoarece utilizează o precizie ridicată. Am folosit o buclă simplă pentru a verifica timpul necesar.

timpul funcției.monotonic

Monotonic este un cronometru python care cant merge înapoi. Când executați un script python, timpul poate fi schimbat de utilizator și poate face o diferență uriașă în implementarea cronometrului în python. Dar timer monotonă asigură că referințele de timp se adapteze la schimbările externe.

exemplu–

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) 

explicație –

importăm mai întâi funcția monotonă din modulul de timp. Apoi creați două referințe numite start și sfârșit în partea de sus și de jos a codului. Aceasta va măsura timpul dintre cele două referințe și va evita toate modificările externe ale timpilor sistemului.

clase personalizate Python Timer

puteți crea propria clasă Timer personalizat pentru a face lucrurile în funcție de nevoia ta. Un avantaj principal al creării unei clase personalizate este că puteți gestiona tot timpul într-o singură linie. Nu este nevoie să importați clasa de timp de fiecare dată și să înregistrați referințele. Mai mult, puteți să vă aruncați datele și să înregistrați toate execuțiile de timp din trecut pentru a alege cel mai bun algoritm pentru dvs.

această secțiune va crea o clasă personalizată pentru a gestiona ora și a înregistra toate diferențele de timp din codurile dvs. Să se arunca cu capul chiar în ea –

Timer.py–

vom începe cu importul modulului de timp. Apoi inițializați clasa Python Timer și începeți să definiți atributele și metodele. Până în prezent, am inclus doar atributul de bază pentru a păstra o referință de început a clasei. Pentru ao face mai complexă, puteți crea mai multe atribute. Până în prezent, există trei metode enumerate mai jos–

1. start – (opțional) pentru a porni cronometrul.
2. log – pentru a înregistra timpul scurs curent cu privire la ora de începere.
3. milestone – pentru a reseta cronometrul și a începe numărarea acestuia de la 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 –

Exemple de utilizare a clasei de mai sus sunt prezentate mai jos. După cum puteți vizualiza, puteți păstra codul curat prin crearea unei clase de cronometru personalizat și de a crește flexibilitatea.

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

ieșire–

Time log - 0.054854631423950195Time log - 0.10871052742004395

Python Timer folosind filetare

când dorim să efectuăm o operație sau dorim ca funcția noastră să ruleze după o anumită perioadă de timp, folosim clasa Python Timer. Clasa timer este o subclasă a clasei de filetare. Din punct de vedere tehnic, puteți spune că creăm obiecte temporizate atunci când dorim acțiuni (funcții) delimitate de timp.

de exemplu, să presupunem că dorim să organizăm un test, unde participantul trebuie să răspundă la fiecare întrebare în 10 secunde. Aici, putem crea un cronometru care va rula în fundal, iar între timp, participantul se va gândi la răspuns. Acum, să înțelegem cum să creăm un obiect cronometru.

sintaxa clasei Timer în Python

dacă nu ați înțeles ce face clasa Timer, vă puteți gândi în acest fel – o clasă Timer apelează o funcție după numărul specificat de secunde.

pentru a porni un cronometru, trebuie să apelăm start()(la fel ca firele normale) și pentru a opri cronometrul în timp ce acesta este încă în fundal, putem apela cancel().

pentru a utiliza clasa Timer, avem nevoie pentru a importa clasa threading

threading.Timer (interval, funcție, args = None, kwargs = None)

parametri –

Interval– timpul (în secunde) pe care doriți să îl așteptați înainte de a apela următoarea funcție. Poate fi în float sau întreg. De exemplu, timp de 3 secunde, interval=3.

Funcție – Funcția pe care doriți să o apelați după intervalul de timp specificat.

un mod omniprezent de a descrie parametrii *args și **kwargs este – Creați un obiect temporizator care rulează funcția cu argumentele’ args’ și argumentele cuvintelor cheie’ kwargs’ după ce au trecut secunde de interval. Args ar trebui să fie sub forma unei liste și0 cuvinte cheie args sau kwargs sub forma unui dicționar.

Tip retur-

apelează doar funcția specificată în parametri.

metode din clasa temporizatorului

1. start() – semnifică începutul executării temporizatorului.
2. Cancel ()– în timpul execuției cronometrului, putem apela cancel dacă dorim să-l oprim ().

crearea unui obiect temporizator

a. Înțelegerea elementele de bază

pentru a înțelege de lucru obiectului Timer, să ne creeze un mic program pentru a ne ajuta să înțelegem elementele de bază ale clasei.

# 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

veți înțelege mai bine funcționarea programului de mai sus atunci când încercați să-l rulați pe propriul sistem.

b. utilizarea metodei anulare

să vedem cum să folosim funcția Anulare() a clasei temporizatorului.

# 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. Cum se utilizează parametrul ‘args’ al clasei Python timer

când trebuie să dăm argumentele funcției care trebuie apelată, folosim parametrul args. Trebuie să dăm argumentul args într-o matrice.

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

acum, că am vorbit mult despre timp, ca un bonus, să ne facă un program care va acționa ca un cronometru.

temporizator în python

folosind modulul de timp

# 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

utilizarea clasei 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

cronometrele Python ca manageri de Context

managerii de Context sunt cele mai bune modalități de a evita erorile de memorie și blocările ulterioare. Toată lumea trebuie să fi știut despre „cu” declarația în Python. Această afirmație ne asigură că nu trebuie să avem grijă de multe obiecte pentru a închide independent. Toată lumea ar fi folosit-o cu combinația de cu și open() funcția. Deci, trecând la întrebarea principală, putem crea manageri de Context pentru cronometrele Python?

Da. Datorită funcțiilor multiple de supraîncărcare, putem crea cu ușurință propriul nostru cronometru python ca manager de context în doar câteva rânduri. Să începem cu un exemplu în care trebuie să măsurați timpul programului pentru a rula. Fără a redefini toate variabilele, un manager de context poate fi utilizat în mod repetat pentru a măsura timpul de mai multe ori. Următorul program o demonstrează.

exemplu–

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

ieșire–

Time to finish the task: 0.05392050743103027

explicație –

începem prin crearea unei clase numite „Timer_Pythonpool.”Apoi personalizăm operatorii pentru a-i face utili ca manager de context. __ enter _ _ function se execută la începutul contextului, iar __exit__ se execută la sfârșitul contextului. Crearea unui punct de referință între aceste două funcții vă poate oferi timpul exact necesar contextului pentru a executa.

Decoratori Python Timer

decoratori sunt suportul suplimentar pentru orice tip de funcție. De asemenea, numit ca metaprogramming, puteți modifica/adăuga funcționalitate la acesta. Decoratorii cu cronometru Python sunt cel mai simplu mod de a implementa funcțiile temporizatorului în python. Odată declarat, puteți folosi decoratorii într-o singură linie fără să le cunoașteți. Adăugând la acesta, le puteți aplica fiecărei funcții din codul dvs. pentru a verifica ce Cod necesită cel mai mult timp pentru a executa.

sintaxă –

pentru a crea un decorator înlănțuit, trebuie să declarați mai multe funcții imbricate. Denumiți cealaltă funcție ca nume principal de decorator și interior pentru orice nume aleatoriu. Funcția interioară va prelua referința funcției utilizate sub decorator.

exemplu–

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()

ieșire–

Time taken to execute function is 0.24933218955993652

explicație –

ca de obicei, începem cu importul celui mai important modul din python „time.”Nextly, vom crea un decorator numit” check_time.”În interiorul ei, adăugăm o funcție interioară imbricată în care putem crea referințele timpului. Aceste două referințe sunt plasate astfel încât ambele să fie plasate între execuția funcției.

mai mult, creăm o funcție de testare numită „sarcină” pentru a verifica dacă sarcina noastră funcționează. Apoi adăugați un decorator deasupra acestuia. Acum Decoratorul își va face magia și va imprima timpul necesar funcției.

Python Timer Cooldown

Python Timer Cooldown este o modalitate de a măsura cronometrul înapoi. Prin crearea unei clase temporizator personalizat, ne putem conecta ora la fiecare punct al Codului. Puteți exporta această clasă ca un modul și instalați-l ca o dependență în codul. Apoi, folosind o singură linie, îl puteți importa–

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.'))

alte module Python Timer

Python conține mii de module și milioane de fragmente de cod. Putem folosi întotdeauna modulele open-source pentru a utiliza cronometre python. Github este cel mai mare loc pentru a găsi astfel de module. Să sărim direct în aceste module–

1. termdown: un cronometru python avansat realizat folosind diferite caractere ASCII. Folosind acest script, puteți crea un cronometru simplu în terminalul dvs. și puteți executa o comandă la sfârșit. Cel mai important, are suport pentru numărătoarea inversă vocală.
2. MobTimer.Python: Un cronometru bazat pe GUI realizat în python. Acest script creează cronometre bazate pe ecran complet cu mai multe opțiuni. Împreună cu acesta, puteți rula mai multe cronometre pe ecran în același timp utilizând acest program.
3. timer: acesta este cel mai de bază cronometru bazat pe GUI realizat în python (Tkinter). Caracteristici cum ar fi mai multe cronometre, etichete, și multithreading face mai viabilă față de alte programe.
4. codetiming: această clasă timer înregistrează toate timpii de execuție din trecut pentru un anumit proces numit. Puteți verifica timpul minim, timpul maxim, între timp și timpul median pentru procesul specific împreună cu înregistrările. Acest modul poate fi utilizat în mai multe moduri, și anume, ca manager de context și ca decorator.
5. cTimer: cTime este un timer nanosecunde precizie în python. Acest modul utilizează API-ul C language pentru a înregistra timpul cu precizie. Dacă sunteți în căutarea unui modul de înregistrare a timpului de precizie hardcore, acesta este cel mai bun. (Notă: în actualizările recente ale python, modulul de timp este adăugat cu funcții pentru a înregistra timpul în nanosecunde)

trebuie citit:

• cum se convertește șirul în litere mici în
• cum se calculează rădăcina pătrată
• intrare utilizator | intrare () funcție | intrare tastatură
• cea mai bună carte pentru a învăța Python

concluzie

în mare parte, toată lumea folosește cronometre în trei scopuri. Primul fiind, pentru a înregistra timpul pentru executarea codului. Și a doua ființă, pentru a adăuga un memento pentru ceva folosind un cronometru. Din fericire, ambele pot fi create în Python. Utilizând diferite module și biblioteci, vă puteți asigura că înregistrați timpul cu precizie precisă.

nu în ultimul rând, cronometrul este o subclasă a clasei de filetare în python. Dacă dorim să rulăm orice funcție după un anumit interval de timp, putem folosi clasa Python timer. În parametrul args, care nu este implicit, putem specifica argumentele pe care dorim să le oferim metodei de apel invers.

încercați să rulați programele de partea dvs. și anunțați-ne dacă aveți întrebări.