Förstå Python Timer-klassen med exempel

Python har tusentals moduler och bibliotek för att tillgodose kodarens krav. Men för att göra dem användbara måste du förstå dem först och sedan tillämpa dem. Utan förkunskaper om vissa moduler är det osäkert vad du vill göra och vad modulen faktiskt gör. Tid är en av de viktiga faktorerna i kodningsproblem. Alla koder är avsedda att minska mänskligt arbete genom att använda sina kraftfulla algoritmer. Tidshantering skapar en stor inverkan på analysen av din kods prestanda. Det är därför vi idag kommer att lära oss djupt om hur timern fungerar i Python.

Python Timer är en klass/bibliotek för att hantera tidskomplexiteten för din kod. Med flera tidsmoduler kan du skapa ett system i din kod för att kontrollera den tid det tar för respektive kodavsnitt. Det finns olika typer av timer implementeringar i python enligt användarens behov, nämligen python timer funktion (för att kontrollera skriptexekveringstid), python threading timer (för att kontrollera den tid som en tråd för att avsluta), python timer (skapa en timer) och grundläggande python Time module (för att hjälpa till med andra aktiviteter).

alla dessa timerimplementeringsfunktioner fungerar annorlunda och fokuserar på att ge slutanvändaren olika användningsområden. I det här inlägget går vi igenom varje timerimplementering i detalj. Du kan använda innehållsförteckningen för att hoppa till respektive python timer implementering.

grundläggande Python Timer funktioner

den viktigaste modulen i python när det gäller tid är tid. Denna modul innehåller alla grundläggande funktioner för att kontrollera tiden och analysera den. Denna analys hjälper dig att förstå prestandan för din kod och dess effektivitet. Vi går igenom var och en av de viktiga funktionerna från den här modulen tillsammans med dess exempel.

Följande är de grundläggande Python-timerfunktionerna med hjälp av tidsmodulen–

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

funktion tid.time

time.time() returnerar tiden i sekunder (float) efter epoken. Rent generellt, epoken är inställd på Januari 1, 1970, 00:00:00 (UTC), och antalet sekunder efter denna epok returneras. Denna funktion beror på datorns tid för beräkning av antalet sekunder. Om du ändrar datortiden mellan python-utförandet kan du få konstiga nummer med den här funktionen.

exempel–

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

förklaring –

för det första börjar vi med att importera tidsmodulen. Denna modul innehåller alla grundläggande tidsfunktioner som vi kommer att använda i det här avsnittet. I början av koden förklarar vi startvariabeln som time.time(). Detta kommer att lagra den aktuella tiden för CPU i float nummer från epoken. Vi använder denna startvariabel som referenspunkt för att mäta tiden. Nästa del innehåller alla koder du vill använda (i det här exemplet har vi använt A för loopar). På samma sätt registrerar du CPU: s sluttid (standardtid) och kontrollerar den totala körtiden med hjälp av end – start.

detta kommer att skriva ut den tid som koden tar i sekunder. Med hjälp av denna teknik kan du kontrollera tiden som din kod tar. Det enda problemet med den här metoden är att CPU-tiden kan ändras medan koden körs. Detta kommer att resultera i problematiskt beteende i python timer.

funktionstid.Thread_time

time.thread_time() Returnerar summan av system-och CPU-tid (float) i den aktuella körtråden. Dessutom inkluderar det inte den tid du spenderar i funktionen time.sleep(). Eftersom funktionen är trådspecifik kan du använda den här funktionen för att registrera tidsskillnaderna så länge tidsreferenserna tillhör samma tråd.

exempel–

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

förklaring –

när thread_time returnerar trådspecifik tid måste vi se till att använda referenser i samma tråd. För detta ändamål har vi instansierat tråden i funktionen ’ hej ’ och beräknat den tid det tar för tråden inuti den. Se dock till att du inte kan få aktuell tid genom att ringa thread_time() eftersom det returnerar ett bråkvärde. Men du kan definitivt kontrollera skillnaden mellan två på varandra följande referenser så länge de hör hemma i samma tråd.

funktionstid.Process_time

time.process_time() returnerar tidsreferensen i bråksekunder (float) av summan av systemtid och CPU-tid för nuvarande framsteg. Samma som thread_time, mäter den här funktionen inte tiden som spenderas i funktionen time.sleep(). Dessutom skapar denna funktion en referens baserad på processen. Som ett resultat av detta är det bara tidsskillnaden mellan två på varandra följande referenser som är vettiga.

exempel–

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)

förklaring –

vi börjar med att importera process_time-funktionen och registrera start-och sluttiden mellan koden. Den enda skillnaden mellan äldre time.time() och time.proces_time() är att behandlingstiden registrerar tidsreferenserna för den aktuella processen, medan time() registrerar systemets absoluta tid.

funktionstid.Perf_counter

Perf Counter står för Performance Counter. Den här funktionen returnerar värdet med hög upplösning för tiden, vilket är giltigt under en kort tidsperiod. Denna funktion används för att få exakt tidsräkning mellan två referenser. Eftersom andra python-timerfunktioner inte inkluderar sömntid, inkluderar perf_counter inte heller den. Låt oss gå till ett exempel-

exempel–

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) 

förklaring –

du kan använda perf-räknaren på samma sätt som processtimern eller trådtimern. Den enda skillnaden är att perf-räknaren returnerar ett högt exakt värde för den tid som förflutit. Men se till att du använder detta mellan små processer, eftersom det använder hög precision. Vi har använt en enkel slinga för att kontrollera den tid det tar.

funktionstid.monotonic

Monotonic är en python timer som inte kan gå bakåt. När du kör ett python-skript kan tiden ändras av användaren och kan göra en stor skillnad i implementeringen av timern i python. Men monoton timer säkerställer att tidsreferenser anpassa sig till de externa förändringar.

exempel–

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) 

förklaring –

vi importerar först den monotona funktionen från tidsmodulen. Skapa sedan två referenser med namnet start och slut i kodens övre och nedre sida. Detta kommer att mäta tiden mellan de två referenserna och undvika alla externa ändringar av systemtiderna.

anpassade Python Timer klasser

du kan skapa din egen anpassade Timer klass för att göra saker enligt dina behov. En stor fördel med att skapa en anpassad klass är att du kan hantera hela tiden på en enda rad. Du behöver inte importera tidsklassen varje gång och registrera referenserna. Dessutom kan du dumpa dina data och spela in alla tidigare avrättningar för att välja den bästa algoritmen för dig.

det här avsnittet skapar en anpassad klass för att hantera tiden och logga alla tidsskillnader i dina koder. Låt oss dyka rakt in i det –

Timer.py–

vi börjar med att importera tidsmodulen. Initiera sedan python Timer-klassen och börja definiera attribut och metoder. Hittills har vi bara inkluderat det grundläggande attributet för att hålla en startreferens för klassen. För att göra det mer komplext kan du skapa flera attribut. Hittills finns det tre metoder som anges nedan–

1. start – (valfritt) för att starta timern.
2. log-för att logga den aktuella förflutna tiden för starttid.
3. milestone – för att återställa timern och starta räkningen från 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 –

exempel på användning av ovanstående klass ges nedan. Som du kan se kan du hålla din kod ren genom att skapa en anpassad Timerklass och öka flexibiliteten.

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

utgång–

Time log - 0.054854631423950195Time log - 0.10871052742004395

Python Timer använder Threading

när vi vill utföra någon operation eller vill att vår funktion ska köras efter en viss tid använder vi Python Timer-klassen. Timerklassen är en underklass av gängklassen. Tekniskt kan du säga att vi skapar Timerobjekt när vi vill ha åtgärder (funktioner) begränsade av tiden.

Antag till exempel att vi vill organisera en frågesport, där deltagaren måste svara på varje fråga på 10 sekunder. Här kan vi skapa en timer som körs i bakgrunden, och under tiden kommer deltagaren att tänka på svaret. Låt oss nu förstå hur man skapar ett timerobjekt.

Syntax för Timerklass i Python

om du inte har förstått vad Timerklassen gör kan du tänka på det på detta sätt – en Timerklass kallar en funktion efter det angivna antalet sekunder.

för att starta en timer måste vi ringa start () (precis som vanliga trådar) och för att stoppa timern medan den fortfarande är i bakgrunden kan vi ringa Avbryt ().

för att använda Timerklassen måste vi importera gängklass

gängning.Timer (intervall, funktion, args = ingen, kwargs = ingen)

parametrar-

intervall– tiden (i sekunder) du vill vänta innan du anropar nästa funktion. Det kan antingen vara i float eller heltal. Till exempel, i 3 sekunder, intervall=3.

funktion – den funktion du vill ringa efter det angivna tidsintervallet.

ett genomgripande sätt att beskriva *args och * * kwargs parametrar är-skapa ett timerobjekt som kör funktionen med argumenten’ args’ och sökordsargument’ kwargs’ efter intervallsekunder har passerat. Args ska vara i form av en lista och0 nyckelord args eller kwargs i form av en ordbok.

returtyp-

det kallar bara den funktion som anges i parametrarna.

metoder i Timerklass

1. start () – det betyder början på utförandet av timern.
2. Avbryt ()– under timerns körning kan vi ringa Avbryt om vi vill stoppa det ().

skapa ett Timerobjekt

a. Förstå grunderna

för att förstå Timerobjektets arbete, låt oss skapa ett litet program som hjälper oss att förstå klassens grunder.

# 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 kommer bättre att förstå hur ovanstående program fungerar när du försöker köra det på ditt eget system.

b. använda avbrytningsmetoden

Låt oss se hur du använder funktionen Avbryt() i Timerklassen.

# 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. Hur man använder ’args’ – parametern i python timer-klassen

när vi behöver ge argumenten till den funktion som behöver ringas använder vi args-parametern. Vi måste ge args-argumentet i en 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 när vi har pratat mycket om tid, som en bonus, låt oss göra ett program som kommer att fungera som en nedräkningstimer.

nedräkningstimer i python

använda 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

använda 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 Timers som Context Managers

Context Managers är de bästa sätten att undvika minnesfel och efterföljande kraschar. Alla måste ha känt till ” med ” uttalandet i Python. Detta uttalande säkerställer att vi inte behöver ta hand om många objekt för att stänga självständigt. Alla kan ha använt den med kombinationen av med och öppen() funktion. Så, flytta till huvudfrågan, kan vi skapa Kontexthanterare för Python-Timers?

Ja. På grund av flera överbelastningsfunktioner kan vi enkelt skapa vår egen python-timer som kontexthanterare på bara några rader. Låt oss börja med ett exempel där du måste mäta programmets tid att köra. Utan att omdefiniera alla variabler kan en kontexthanterare användas upprepade gånger för att mäta tiden flera gånger. Följande program visar det.

exempel–

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

utgång–

Time to finish the task: 0.05392050743103027

förklaring –

vi börjar med att skapa en klass som heter ”Timer_Pythonpool.”Sedan anpassar vi operatörerna för att göra dem användbara som kontexthanterare. __ enter _ _ – funktionen körs i början av sammanhanget och __exit__ körs i slutet av sammanhanget. Att skapa en referenspunkt mellan dessa två funktioner kan ge dig den exakta tid det tar för sammanhanget att utföra.

Python Timer dekoratörer

dekoratörer är det extra stödet för någon form av funktion. Kallas också metaprogrammering, du kan ändra/lägga till funktionalitet till den. Python Timer Decorators är det enklaste sättet att implementera timerfunktionerna i python. När du har deklarerat kan du använda dekoratörerna i en rad utan att ens känna till dem. Om du lägger till det kan du tillämpa dem på varje funktion i din kod för att kontrollera vilken kod som tar mest tid att utföra.

Syntax –

för att skapa en kedjedekorator måste du deklarera flera kapslade funktioner. Namnge den andra funktionen som din huvudsakliga dekoratör namn och inre till någon slumpmässig namn. Den inre funktionen hämtar referensen för funktionen som används under dekoratören.

exempel–

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

utgång–

Time taken to execute function is 0.24933218955993652

förklaring –

som vanligt börjar vi med att importera den viktigaste modulen från python ”time.”Därefter skapar vi en dekoratör som heter ”check_time.”Inuti den lägger vi till en kapslad inre funktion där vi kan skapa tidens referenser. Dessa två referenser placeras så att båda placeras mellan funktionsexekveringen.

vidare skapar vi en testfunktion som heter ”task” för att kontrollera om vår uppgift fungerar. Lägg sedan till en dekoratör ovanpå den. Nu kommer dekoratören att göra sin magi och skriva ut den tid som funktionen tar.

Python Timer Cooldown

Python Timer Cooldown är ett sätt att mäta timern bakåt. Genom att skapa en anpassad timerklass kan vi logga tiden vid varje punkt i din kod. Du kan exportera den här klassen som en modul och installera den som ett beroende i din kod. Sedan genom att använda en enda rad, kan du importera 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.'))

andra Python Timer moduler

Python innehåller tusentals moduler och miljontals kodavsnitt. Vi kan alltid använda Open source-modulerna för att använda python-timers. Github är den största platsen att hitta sådana moduler. Låt oss hoppa rakt in i dessa moduler–

1. termdown: en avancerad python timer görs med hjälp av olika ASCII-tecken. Med det här skriptet kan du skapa en enkel nedräkningstimer i din terminal och utföra ett kommando i slutet. Viktigast, det har stöd för röstnedräkning.
2. MobTimer.Python: en GUI – baserad timer gjord i python. Detta skript skapar helskärmsbaserade timers med flera alternativ. Tillsammans med det kan du köra flera timers på skärmen samtidigt genom att använda det här programmet.
3. timer: detta är den mest grundläggande GUI-baserade timern gjord i python (Tkinter). Funktioner som flera timers, etiketter och multithreading gör det mer lönsamt över andra program.
4. codetiming: denna timer klass registrerar alla dina tidigare exekveringstider för en specifik namngiven process. Du kan kontrollera minsta tid, maximal tid, under tiden och mediantid för den specifika processen tillsammans med poster. Denna modul kan användas på flera sätt, nämligen som kontexthanterare och som dekoratör.
5. cTimer: cTime är en nanosekund-precision timer i python. Denna modul använder C language API för att registrera tiden exakt. Om du letar efter en hardcore precision time recording moduler, detta är den bästa. I de senaste uppdateringarna av python läggs tidsmodulen till med funktioner för att spela in tid i nanosekunder)

måste läsa:

• Hur konvertera sträng till gemener i
• hur man beräknar kvadratroten
• User Input | Input () funktion | tangentbord ingång
• bästa bok att lära Python

slutsats

för det mesta använder alla timers för tre ändamål. Den första är att registrera tiden för din kodkörning. Och den andra är att lägga till en påminnelse om något genom att använda en timer. Lyckligtvis kan båda dessa skapas i Python. Genom att använda olika moduler och bibliotek kan du se till att du registrerar tiden med exakt noggrannhet.

sist men inte minst är timern en underklass av threading-klassen i python. Om vi vill köra någon funktion efter ett visst tidsintervall kan vi använda python timer-klassen. I args-parametern, som är ingen som standard, kan vi ange de argument vi vill ge till återuppringningsmetoden.

försök att köra programmen på din sida och låt oss veta om du har några frågor.