Forstå Python Timer Klassen Med Eksempler

Python har tusenvis av moduler og biblioteker for å tilfredsstille koderens krav. Men for å gjøre dem nyttige, må du først forstå dem og deretter bruke dem. Uten forkunnskaper om visse moduler er det usikkert hva du vil gjøre og hva modulen faktisk gjør. Tid er en av de viktigste faktorene i kodingsproblemer. Alle kodene er ment å redusere menneskelig arbeid ved å bruke sine kraftige algoritmer. Tidsstyring skaper en stor innvirkning på analysen av ytelsen til koden din. Det er derfor i dag, vil vi lære i dybden om hvordan timeren fungerer I Python.

Python Timer er en klasse / bibliotek for å administrere tiden kompleksiteten av koden. Ved hjelp av flere tidsmoduler kan du opprette et system i koden din for å sjekke tiden som er tatt av den respektive kodebiten. Det finnes ulike typer timer implementeringer i python i henhold til brukerens behov, nemlig python timerfunksjon (for å sjekke skriptets kjøretid), python threading timer (for å sjekke tiden tatt av en tråd for å fullføre), python nedtellingstimer (opprett en nedtellingstimer) og grunnleggende python tidsmodul (for å hjelpe med andre aktiviteter).

alle disse timerimplementeringene fungerer annerledes og fokuserer på å gi forskjellig bruk til sluttbrukeren. I dette innlegget går vi gjennom hver timerimplementering i detalj. Du kan bruke Innholdsfortegnelsen til å hoppe til den respektive python timer implementering.

Grunnleggende Python Timerfunksjoner

den viktigste modulen i python angående tid er tid. Denne modulen inneholder alle grunnleggende funksjoner for å sjekke tiden og analysere den. Denne analysen vil hjelpe deg å forstå ytelsen til koden din og dens effektivitet. Vi går gjennom hver av de viktige funksjonene fra denne modulen sammen med eksemplene.

Følgende er de grunnleggende Python Timerfunksjonene ved hjelp av tidsmodulen–

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

Funksjonstid.tid

time.time() returnerer tiden i sekunder (flyte) etter epoken. Vanligvis er epoken satt til januar 1, 1970, 00:00:00 (UTC), og antall sekunder etter denne epoken returneres. Denne funksjonen avhenger av datamaskinens tid for å beregne antall sekunder. Hvis du endrer datamaskinens tid mellom python-utførelsen, kan du få rare tall ved hjelp av denne funksjonen.

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 å importere tidsmodulen. Denne modulen inneholder alle de grunnleggende tidsfunksjonene som vi bruker i denne delen. Ved starten av koden erklærer vi startvariabelen som time.time(). Dette vil lagre GJELDENDE TID FOR CPU i float nummer fra epoken. Vi bruker denne startvariabelen som referansepunkt for å måle tiden. Den neste delen inneholder alle kodene du vil bruke (i dette eksemplet har vi brukt a for looper). På samme måte registrerer du sluttiden TIL CPU (Standardtid) og kontrollerer total kjøretid ved å bruke sluttstart.

dette vil skrive ut tiden som koden tar i sekunder. Ved bruk av denne teknikken kan du sjekke tiden som koden din tar. Det eneste problemet med denne metoden er AT CPU-tiden kan endres mens koden kjorer. Dette vil resultere i problematisk oppforsel i python-timeren.

Funksjonstid.Thread_time

time.thread_time() returnerer summen av system-OG CPU-tid (float) i gjeldende løpende tråd. Videre inkluderer det ikke tiden du bruker i time.sleep() – funksjonen. Siden funksjonen er trådspesifikk, kan du bruke denne funksjonen til å registrere tidsforskjellene så lenge tidsreferansene tilhører 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 –

som thread_time returnerer trådspesifikk tid, må vi sørge for å bruke referanser i samme tråd. For dette formålet har vi instantiated tråden av funksjonen ‘ hei ‘ og beregnet tiden tatt av tråden inne i den. Kontroller imidlertid at du ikke kan få gjeldende klokkeslett ved å ringe thread_time () fordi den returnerer en brøkverdi. Men du kan definitivt sjekke forskjellen mellom to påfølgende referanser så lenge de hører hjemme i samme tråd.

Funksjonstid.Process_time

time.process_time() returnerer tidsreferansen i brøkdelte sekunder (float) av summen av systemtid og CPU-TID for gjeldende fremgang. Samme som thread_time, måler denne funksjonen ikke tiden brukt i time.sleep() – funksjonen. Videre oppretter denne funksjonen en referanse basert på prosessen. Som et resultat av dette vil bare tidsforskjellen mellom to påfølgende referanser være fornuftig.

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 å importere process_time-funksjonen og registrere start – og sluttidspunktet mellom koden. Den eneste forskjellen mellom eldre time.time() og time.proces_time() er at behandlingstiden registrerer tidsreferansene for den nåværende prosessen, mens time() registrerer systemets absolutte tid.

Funksjonstid.Perf_counter

Perf Teller står For Ytelse Teller. Denne funksjonen returnerer den høyoppløselige verdien av tiden, som er gyldig i en kort periode. Denne funksjonen brukes til å få nøyaktig tidstelling mellom to referanser. Som andre python-timerfunksjoner ikke inkluderer søvntid, inkluderer perf_counter heller ikke det. La oss 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 bruke perf-telleren på samme måte som process timer eller thread timer. Den eneste forskjellen er, perf teller vil returnere en høy presis verdi av medgått tid. Men sørg for at du bruker dette mellom små prosesser, da det bruker høy presisjon. Vi har brukt en enkel sløyfe for å sjekke tiden det tar.

Funksjonstid.monotonic

Monotonic Er en python-timer som ikke kan gå bakover. Når du utfører et python-skript, kan tiden endres av brukeren og kan gjøre en stor forskjell i implementeringen av timeren i python. Men monotonic timer sikrer at tidsreferansene tilpasser seg de eksterne endringene.

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 monotonisk funksjon fra tidsmodulen. Deretter oppretter du to referanser som heter start og slutt på toppen og bunnen av koden. Dette vil måle tiden mellom de to referansene og unngå alle eksterne endringer i systemtider.

Custom Python Timer Klasser

Du kan lage din egen Tilpassede Timer klasse for å gjøre ting i henhold til dine behov. En hovedfordel ved å opprette en egendefinert klasse er at du kan administrere hele tiden i en enkelt linje. Du trenger ikke å importere tidsklassen hver gang og registrere referansene. Videre kan du dumpe dataene dine og registrere alle de siste tidskreftene for å velge den beste algoritmen for deg.

denne delen vil opprette en egendefinert klasse for å administrere tiden og logge alle tidsforskjellene i kodene dine. La oss dykke rett inn i det –

Timer.py–

vi begynner med å importere tidsmodulen. Deretter initialiser python Timer-klassen og begynn å definere attributter og metoder. Så langt har vi bare tatt med det grunnleggende attributtet for å holde en startreferanse av klassen. For å gjøre det mer komplekst, kan du opprette flere attributter. Så langt er det tre metoder som er oppført nedenfor–

1. start – (Valgfritt) for å starte timeren.
2. logg-for å logge gjeldende medgått tid angående starttid.
3. milepæl-for å tilbakestille timeren og starte tellingen 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å bruk av ovennevnte klasse er gitt nedenfor. Som du kan se, kan du holde koden ren ved å opprette en tilpasset Timer klasse og øke fleksibiliteten.

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

Utgang–

Time log - 0.054854631423950195Time log - 0.10871052742004395

Python Timer ved Hjelp Av Threading

Når vi vil utføre en operasjon Eller vil at vår funksjon skal løpe etter en viss tid, bruker Vi Python Timer-klassen. Timeren klassen er en underklasse av threading klassen. Teknisk kan du si at vi lager Timerobjekter når vi vil ha handlinger (funksjoner) begrenset av tiden.

anta for eksempel at vi vil organisere en quiz, hvor deltakeren må svare på hvert spørsmål om 10 sekunder. Her kan vi lage en timer som vil kjøre i bakgrunnen, og i mellomtiden vil deltakeren tenke på svaret. Nå, la oss forstå hvordan du lager et timerobjekt.

Syntaks Av Timer Klasse I Python

hvis Du ikke har forstått hva Timer klasse gjør, kan du tenke på det på denne måten – En Timer Klasse kaller en funksjon etter det angitte antall sekunder.

for å starte en timer, må vi ringe start () (akkurat som vanlige tråder), og for å stoppe timeren mens den fortsatt er i bakgrunnen, kan vi ringe avbryt ().

for å bruke Timeren klassen, må vi importere threading klasse

threading.Timer (intervall, funksjon, args=Ingen, kwargs=Ingen)

Parametere –

Intervall-tiden (i sekunder) du vil vente før du ringer til neste funksjon. Det kan enten være i float eller heltall. For eksempel, i 3 sekunder, intervall=3.

Funksjon-funksjonen du vil ringe etter det angitte tidsintervallet.

en gjennomgripende måte å beskrive *args og **kwargs parametere er – lag en timer objekt som kjører funksjonen med argumenter ‘args’ og søkeord argumenter ‘kwargs’ etter intervall sekunder har gått. Args skal være i form av en liste og0 søkeord args eller kwargs i form av en ordbok.

Returtype-

det kaller bare funksjonen som er angitt i parametrene.

Metoder I Timer klasse

1. start() – det betyr begynnelsen av utførelsen av timeren.
2. Cancel () – Under timeren utførelse, kan vi ringe avbryt hvis vi ønsker å stoppe det ().

Opprette Et Tidsobjekt

a. Forstå grunnleggende

For å forstå Tidsobjektets arbeid, la oss lage et lite program for å hjelpe oss å forstå klassens grunnleggende.

# 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å funksjonen til programmet ovenfor når du prøver å kjøre det på ditt eget system.

b. bruk avbryt-metoden

la oss se hvordan du bruker avbryt () – funksjonen Til Timer-klassen.

# 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. Slik bruker du parameteren ‘args’ i python-timerklassen

når vi må gi argumentene til funksjonen som må kalles, bruker vi args-parameteren. Vi ma gi args-argumentet i en matrise.

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

Nå som vi har snakket mye om tid, som en bonus, la oss lage et program som vil fungere Som En Nedtellingstimer.

Nedtellingstimer i python

Bruke tidsmodulen

# 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

bruke 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 Kontekst Ledere

Kontekst Ledere er de beste måtene å unngå minnefeil og påfølgende krasjer. Alle ma ha kjent om » med » uttalelsen I Python. Denne erklæringen sikrer at vi ikke trenger å ta vare på mange objekter for å lukke uavhengig. Alle kan ha brukt den med kombinasjonen av med og open () – funksjonen. Så, flytte til hovedspørsmålet, kan vi lage Kontekstledere for Python-Timere?

Ja. På grunn av flere overbelastningsfunksjoner kan vi enkelt lage vår egen python-timer som kontekstleder på bare noen få linjer. La oss starte med et eksempel der du må måle programmets tid til å kjøre. Uten å omdefinere alle variablene, kan en kontekst manager brukes flere ganger for å måle tiden flere ganger. 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

Utgang–

Time to finish the task: 0.05392050743103027

Forklaring –

vi starter med å lage en klasse som heter » Timer_Pythonpool.»Deretter tilpasser vi operatørene for å gjøre dem nyttige som kontekstleder. __ enter_ _ – funksjonen utføres ved starten av konteksten, og _ _ exit _ _ utføres ved slutten av konteksten. Å lage et referansepunkt mellom disse to funksjonene kan gi deg den nøyaktige tiden konteksten tar for å utføre.

Python Timer Dekoratører

Dekoratører er den ekstra støtten for enhver form for funksjon. Også betegnet som metaprogramming, kan du endre / legge til funksjonalitet til den. Python Timer Dekoratører er den enkleste måten å implementere timerfunksjoner i python. Når du er erklært, kan du bruke dekoratørene i en linje uten å kjenne dem. Legge til det, kan du bruke dem til hver funksjon i koden din for å sjekke hvilken kode som tar mest tid å utføre.

Syntaks –

for å opprette en kjededekoratør må du deklarere flere nestede funksjoner. Navn den andre funksjonen som hoved dekoratør navn og indre til noen tilfeldig navn. Den indre funksjonen vil hente referansen til funksjonen som brukes 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()

Utgang–

Time taken to execute function is 0.24933218955993652

Forklaring –

som vanlig starter vi med å importere den viktigste modulen fra python » tid.»Neste, skaper vi en dekoratør som heter» check_time .»Inne i det legger vi til en nestet indre funksjon der vi kan lage referanser av tid. Disse to referansene er plassert slik at begge er plassert mellom funksjonsutførelsen.

Videre lager vi en testfunksjon som heter «task» for å sjekke om oppgaven vår fungerer. Legg deretter til en dekoratør på toppen av den. Nå vil dekoratøren gjøre sin magi og skrive ut tiden som funksjonen tar.

Python Timer Cooldown

Python Timer Cooldown er en måte å måle timeren bakover. Ved å opprette en tilpasset timer klasse, kan vi logge tiden på hvert punkt av koden. Du kan eksportere denne klassen som en modul og installere den som en avhengighet i koden din. Ved å bruke en enkelt linje kan du importere den–

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 inneholder tusenvis av moduler og millioner av kodebiter. Vi kan alltid bruke open source-modulene til å bruke python-timere. Github er det største stedet å finne slike moduler. La oss hoppe rett inn i disse modulene–

1. termdown: en avansert python timer laget ved hjelp av forskjellige ASCII-tegn. Ved hjelp av dette skriptet kan du lage en enkel nedtellingstimer i terminalen din og utføre en kommando på slutten. Viktigst, den har støtte for taletelling.
2. MobTimer.Python: EN GUI basert timer laget i python. Dette skriptet skaper fullskjermbaserte timere med flere alternativer. Sammen med det, kan du kjøre flere tidtakere på skjermen samtidig ved hjelp av dette programmet.
3. timer: Dette er den mest grunnleggende GUI basert timer laget i python (Tkinter). Funksjoner som flere timere, etiketter og multithreading gjør det mer levedyktig over andre programmer.
4. codetiming: denne timerklassen registrerer alle tidligere kjøretider for en bestemt navngitt prosess. Du kan sjekke minimum tid, maksimal tid, mellomtiden, og median tid for den spesifikke prosessen sammen med poster. Denne modulen kan brukes på flere måter, nemlig som kontekstleder og som dekoratør.
5. cTimer: cTime er en nanosekund-presisjon timer i python. Denne modulen bruker c språk API for å registrere tiden nøyaktig. Hvis du leter etter en hardcore presisjon tid opptak moduler, er dette den beste. (Merk: i nyere oppdateringer av python er tidsmodulen lagt til med funksjoner for å registrere tid i nanosekunder)

Må Lese:

• Hvordan Konvertere Streng Til Små Bokstaver i
• Hvordan Beregne Kvadratroten
• Bruker Input / Input () Funksjon / Tastatur Input
• Beste Boken For Å Lære Python

Konklusjon

Stort sett bruker alle timere for tre formål. Den første er å registrere tiden for kodekjøring. Og andre er, for å legge til en påminnelse om noe ved å bruke en timer. Heldigvis kan begge disse opprettes i Python. Ved å bruke forskjellige moduler og biblioteker kan du sikre at du registrerer tiden med stor nøyaktighet.

Sist men ikke minst, er timeren en underklasse av threading-Klassen i python. Hvis vi ønsker å kjøre noen funksjon etter et visst tidsintervall, kan vi bruke python timer klassen. I args-parameteren, Som Ikke Er standard, kan vi angi argumentene vi vil gi til tilbakeringingsmetoden.

Prøv å kjøre programmene på din side og gi oss beskjed hvis du har spørsmål.