Forstå Python Timer klasse med eksempler

Python har tusindvis af moduler og biblioteker til at opfylde koderens krav. Men for at gøre dem nyttige skal du først forstå dem og derefter anvende dem. Uden forudgående kendskab til visse moduler er det usikkert, hvad du vil gøre, og hvad modulet rent faktisk gør. Tid er en af de vigtige faktorer i kodningsproblemer. Alle koder er beregnet til at reducere menneskeligt arbejde ved hjælp af deres kraftfulde algoritmer. Tidsstyring skaber stor indflydelse på analysen af ydeevnen af din kode. Derfor lærer vi i dag dybtgående om, hvordan timeren fungerer i Python.

Python Timer er et klasse/bibliotek til at styre tidskompleksiteten af din kode. Ved hjælp af flere tidsmoduler kan du oprette et system i din kode for at kontrollere den tid, det respektive kodestykke tager. Der er forskellige typer timerimplementeringer i python i henhold til brugernes behov, nemlig python-timerfunktion (for at kontrollere scriptudførelsestid), python-gevindtimer (for at kontrollere den tid, det tager af en tråd at afslutte), python-nedtællingstimer (Opret en nedtællingstimer) og grundlæggende python-tidsmodul (for at hjælpe med andre aktiviteter).

alle disse timer implementering fungerer forskelligt og fokuserer på at give forskellig brug til slutbrugeren. I dette indlæg gennemgår vi hver timerimplementering i detaljer. Du kan bruge indholdsfortegnelsen til at springe til den respektive python-timerimplementering.

grundlæggende Python Timer funktioner

det vigtigste modul i python vedrørende tid er tid. Dette modul indeholder alle de grundlæggende funktioner til at kontrollere tiden og analysere den. Denne analyse vil hjælpe dig med at forstå udførelsen af din kode og dens effektivitet. Vi gennemgår hver af de vigtige funktioner fra dette modul sammen med dets eksempler.

Følgende er de grundlæggende Python-timerfunktioner ved hjælp af tidsmodulet–

• tid.tid ()
• tid.thread_time ()
• tid.process_time ()
• tid.perf_counter ()
• tid.monoton()

funktion tid.tid

time.time() returnerer tiden i sekunder (float) efter epoken. Generelt, epoken er indstillet til januar 1, 1970, 00:00:00 (UTC), og antallet af sekunder efter denne epoke returneres. Denne funktion afhænger af computerens tid til beregning af antallet af sekunder. Hvis du ændrer computertiden mellem python-udførelsen, kan du få underlige tal ved hjælp af denne funktion.

eksempel–

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

forklaring –

for det første starter vi med at importere tidsmodulet. Dette modul indeholder alle de grundlæggende tidsfunktioner, som vi vil bruge i dette afsnit. I starten af koden erklærer vi startvariablen som time.time(). Dette vil gemme den aktuelle tid for CPU i float nummer fra epoken. Vi bruger denne startvariabel som referencepunkt til at måle tiden. Den næste del indeholder alle de koder, du vil bruge (i dette eksempel har vi brugt a til sløjfer). På samme måde skal du registrere sluttidspunktet for CPU ‘ en (standardtid) og kontrollere den samlede eksekveringstid ved hjælp af slutstart.

dette udskriver den tid, koden tager på få sekunder. Ved brug af denne teknik kan du kontrollere den tid, din kode tager. Det eneste problem med denne metode er, at CPU-tiden kan ændres, mens koden kører. Dette vil resultere i problematisk adfærd i python timer.

funktionstid.Thread_time

time.thread_time() Returnerer summen af system-og CPU-tid (float) i den aktuelle løbende tråd. Desuden inkluderer det ikke den tid, du bruger i time.sleep() funktion. Da funktionen er trådspecifik, kan du bruge denne funktion til at registrere tidsforskellene, så længe tidsreferencerne hører til den samme tråd.

eksempel–

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

forklaring –

da thread_time returnerer trådspecifik tid, skal vi sørge for at bruge referencer i samme tråd. Til dette formål har vi instantieret tråden af funktionen ‘hej’ og beregnet den tid, der er taget af tråden inde i den. Sørg dog for, at du ikke kan få det aktuelle klokkeslæt ved at ringe til thread_time (), fordi det returnerer en brøkværdi. Men du kan helt sikkert kontrollere forskellen mellem to på hinanden følgende referencer, så længe de hører hjemme i samme tråd.

funktionstid.Process_time

time.process_time() returnerer tidsreferencen i brøkdele sekunder (float) af summen af systemtid og CPU-tid for nuværende fremskridt. Samme som thread_time, denne funktion måler ikke tiden brugt i time.sleep() funktion. Desuden skaber denne funktion en reference baseret på processen. Som et resultat af dette vil kun tidsforskellen mellem to på hinanden følgende referencer give mening.

eksempel–

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)

forklaring –

vi starter med at importere process_time-funktionen og registrere start-og sluttidspunktet mellem koden. Den eneste forskel mellem arv time.time() og time.proces_time() er, at behandlingstiden registrerer tidsreferencerne for den aktuelle proces, mens time() registrerer systemets absolutte tid.

funktionstid.Perf_counter

Perf tæller står for Performance Counter. Denne funktion returnerer tidsværdien i høj opløsning, som er gyldig i en kort periode. Denne funktion bruges til at få den præcise tidstælling mellem to referencer. Da andre python-timerfunktioner ikke inkluderer søvntid, inkluderer perf_counter det heller ikke. Lad os flytte til et eksempel –

eksempel–

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) 

forklaring –

du kan bruge perf-tælleren på samme måde som procestimeren eller trådtimeren. Den eneste forskel er, perf tæller vil returnere en høj præcis værdi af den forløbne tid. Men sørg for, at du bruger dette mellem små processer, da det bruger høj præcision. Vi har brugt en simpel løkke til at kontrollere den tid, det tager.

funktionstid.monotonic

Monotonic er en python-timer, der ikke kan gå baglæns. Når du udfører et python-script, kan tiden ændres af brugeren og kan gøre en enorm forskel i implementeringen af timeren i python. Men monotonic timer sikrer, at tiden referencer tilpasse sig de eksterne ændringer.

eksempel–

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) 

forklaring –

vi importerer først den monotone funktion fra tidsmodulet. Opret derefter to referencer med navnet start og slut i øverste og nederste side af koden. Dette måler tiden mellem de to referencer og undgår alle eksterne ændringer i systemtiderne.

brugerdefinerede Python Timer klasser

du kan oprette din egen brugerdefinerede Timer klasse til at gøre tingene efter dit behov. En største fordel ved at oprette en brugerdefineret klasse er, at du kan styre hele tiden i en enkelt linje. Du behøver ikke at importere tidsklassen hver gang og registrere referencerne. Desuden kan du dumpe dine data og registrere alle de seneste tid henrettelser til at vælge den bedste algoritme for dig.

dette afsnit opretter en brugerdefineret klasse til at styre tiden og logge alle tidsforskelle i dine koder. Lad os dykke lige ind i det –

Timer.py–

vi begynder med at importere tidsmodulet. Derefter initialisere python Timer klasse og begynde at definere de attributter og metoder. Indtil videre har vi kun inkluderet den grundlæggende attribut for at holde en startreference for klassen. For at gøre det mere komplekst kan du oprette flere attributter. Indtil videre er der tre metoder, der er anført nedenfor–

1. start – (valgfrit) for at starte timeren.
2. log – for at logge den aktuelle forløbne tid vedrørende starttid.
3. milepæl – for at nulstille timeren og starte dens optælling fra 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 –

eksempler på brug af ovenstående klasse er angivet nedenfor. Som du kan se, kan du holde din kode ren ved at oprette en brugerdefineret Timerklasse og øge fleksibiliteten.

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

Output–

Time log - 0.054854631423950195Time log - 0.10871052742004395

Python-Timer ved hjælp af gevindskæring

når vi vil udføre en operation eller ønsker, at vores funktion skal køre efter en vis tid, bruger vi Python-Timerklassen. Timerklassen er en underklasse af gevindklassen. Teknisk set kan du sige, at vi opretter Timerobjekter, når vi vil have handlinger (funktioner) afgrænset af tiden.

Antag for eksempel, at vi ønsker at organisere en test, hvor deltageren skal besvare hvert spørgsmål på 10 sekunder. Her kan vi oprette en timer, der kører i baggrunden, og i mellemtiden vil deltageren tænke på svaret. Lad os nu forstå, hvordan du opretter et timerobjekt.

syntaks for Timerklasse i Python

hvis du ikke har forstået, hvad Timerklasse gør, kan du tænke på det på denne måde – en Timerklasse kalder en funktion efter det angivne antal sekunder.

for at starte en timer skal vi ringe til start()(ligesom normale tråde), og for at stoppe timeren, mens den stadig er i baggrunden, kan vi ringe til Annuller().

for at bruge Timerklassen skal vi importere gevindklasse

gevindskæring.Timer (interval, funktion, args=ingen, kvargs=ingen)

parametre-

Interval– den tid (i sekunder), du vil vente, før du ringer til den næste funktion. Det kan enten være i float eller heltal. For eksempel i 3 sekunder, interval=3.

funktion – den funktion, du vil ringe efter det angivne tidsinterval.

en gennemgribende måde at beskrive *args og **kvargs parametre er – Opret et timerobjekt, der kører funktionen med argumenter’ args’ og nøgleordsargumenter’ kvargs’ efter interval sekunder er gået. Args skal være i form af en liste OG0 søgeord args eller kvargs i form af en ordbog.

returtype –

det kalder bare den funktion, der er angivet i parametrene.

metoder i Timerklasse

1. start() – det betyder begyndelsen af udførelsen af timeren.
2. Annuller ()– under timerens udførelse kan vi ringe til Annuller, hvis vi vil stoppe det ().

oprettelse af et Timerobjekt

a. Forstå det grundlæggende

for at forstå Timerobjektets arbejde, lad os oprette et lille program, der hjælper os med at forstå klassens grundlæggende.

# 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

du vil bedre forstå funktionen af ovenstående program, når du forsøger at køre det på dit eget system.

b. brug af Annuller-metoden

lad os se, hvordan du bruger funktionen Annuller() i Timerklasse.

# 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. Sådan bruges ‘args’ – parameteren i python-timerklassen

når vi skal give argumenterne til den funktion, der skal kaldes, bruger vi args-parameteren. Vi må give args-argumentet i et array.

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

nu hvor vi har talt meget om tid, som en bonus, lad os lave et program, der fungerer som en nedtællingstimer.

nedtællingsur i python

brug af tidsmodulet

# 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

brug af python Timer-klassen

# 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

Python timere som Kontekstledere

Kontekstledere er de bedste måder at undgå hukommelsesfejl og efterfølgende nedbrud på. Alle må have kendt til ” med ” udsagnet i Python. Denne erklæring sikrer, at vi ikke behøver at tage os af mange objekter for at lukke uafhængigt. Alle kunne have brugt det med kombinationen af med og åben() funktion. Så flytter vi til hovedspørgsmålet, Kan vi oprette Kontekstforvaltere til Python-timere?

Ja. På grund af flere overbelastningsfunktioner kan vi nemt oprette vores egen python-timer som kontekstmanager på få linjer. Lad os starte med et eksempel, hvor du skal måle programmets tid til at køre. Uden at omdefinere alle variablerne kan en kontekststyring bruges gentagne gange til at måle tiden flere gange. Følgende program demonstrerer det.

eksempel–

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

Output–

Time to finish the task: 0.05392050743103027

forklaring –

vi starter med at oprette en klasse med navnet “Timer_Pythonpool.”Så tilpasser vi operatørerne for at gøre dem nyttige som kontekstmanager. __ enter_ _ funktion udføres i starten af konteksten, og __afslut__ udføres i slutningen af konteksten. Oprettelse af et referencepunkt mellem disse to funktioner kan give dig den nøjagtige tid, som konteksten tager at udføre.

Python Timer dekoratører

dekoratører er den ekstra støtte til enhver form for funktion. Også betegnet som metaprogramming, kan du ændre/tilføje funktionalitet til det. Python Timer dekoratører er den nemmeste måde at gennemføre timeren funktioner i python. Når du er erklæret, kan du bruge dekoratørerne i en linje uden selv at kende dem. Når du tilføjer det, kan du anvende dem på alle funktioner i din kode for at kontrollere, hvilken kode der tager mest tid at udføre.

syntaks –

for at oprette en kædedekorator skal du erklære flere indlejrede funktioner. Navngiv den anden funktion som din vigtigste dekoratør navn og indre til enhver tilfældig navn. Den indre funktion henter referencen til den funktion, der bruges under dekoratøren.

eksempel–

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

Output–

Time taken to execute function is 0.24933218955993652

forklaring –

som sædvanligt starter vi med at importere det vigtigste modul fra python “time.”Dernæst opretter vi en dekoratør ved navn “check_time.”Inde i det tilføjer vi en indlejret indre funktion, hvor vi kan oprette tidens referencer. Disse to referencer er placeret, så begge er placeret mellem funktionsudførelsen.

yderligere opretter vi en testfunktion med navnet “opgave” for at kontrollere, om vores opgave fungerer. Tilføj derefter en dekoratør oven på den. Nu vil dekoratøren gøre sin magi og udskrive den tid, som funktionen tager.

Python Timer nedkøling

Python Timer nedkøling er en måde at måle timeren baglæns. Ved at oprette en brugerdefineret timerklasse kan vi logge tiden på hvert punkt i din kode. Du kan eksportere denne klasse som et modul og installere det som en afhængighed i din kode. Derefter kan du importere den ved hjælp af en enkelt linje–

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

andre Python Timer moduler

Python indeholder tusindvis af moduler og millioner af kodestykker. Vi kan altid bruge open source-modulerne til at bruge python-timere. Github er det største sted at finde sådanne moduler. Lad os hoppe lige ind i disse moduler–

1. en avanceret python-timer lavet ved hjælp af forskellige ASCII-tegn. Ved hjælp af dette script kan du oprette en simpel nedtællingstimer i din terminal og udføre en kommando i slutningen. Vigtigst er det, at det har støtte til stemmetælling.
2. MobTimer.Python: en GUI baseret timer lavet i python. Dette script skaber fuld skærm-baserede timere med flere muligheder. Sammen med det kan du køre flere timere på skærmen på samme tid ved at bruge dette program.
3. timer: dette er den mest grundlæggende GUI baseret timer lavet i python (Tkinter). Funktioner som flere timere, etiketter og multithreading gør det mere levedygtigt i forhold til andre programmer.
4. codetiming: denne timerklasse registrerer alle dine tidligere udførelsestider for en bestemt navngivet proces. Du kan kontrollere minimumstid, maksimal tid, mellemtiden og mediantid for den specifikke proces sammen med poster. Dette modul kan bruges på flere måder, nemlig som kontekstmanager og som dekoratør.
5. cTimer: cTime er en nanosekund-præcision timer i python. Dette modul bruger C sprog API til at registrere tiden præcist. Hvis du leder efter en hardcore præcision tidsregistrering moduler, dette er den bedste. (Bemærk: i de seneste opdateringer af python tilføjes tidsmodulet med funktioner til registrering af tid i nanosekunder)

skal læse:

• Sådan konverteres streng til små bogstaver i
• Sådan beregnes kvadratrod
• brugerinput | Input () funktion | tastaturindgang
• bedste bog til at lære Python

konklusion

for det meste bruger alle timere til tre formål. Den første er at registrere tidspunktet for din kodeudførelse. Og for det andet at tilføje en påmindelse om noget ved hjælp af en timer. Heldigvis kan begge disse oprettes i Python. Ved at bruge forskellige moduler og biblioteker kan du sikre dig, at du registrerer tiden med stor nøjagtighed.

sidst men ikke mindst er timeren en underklasse af gevindklassen i python. Hvis vi vil køre en funktion efter et bestemt tidsinterval, kan vi bruge python-timerklassen. I args-parameteren, som som standard ikke er nogen, kan vi specificere de argumenter, vi vil give til tilbagekaldsmetoden.

prøv at køre programmerne på din side og lad os vide, hvis du har spørgsmål.