A Python Timer osztály megértése példákkal

a Python több ezer modullal és könyvtárral rendelkezik a kódoló igényeinek kielégítésére. Ahhoz azonban, hogy hasznosak legyenek, először meg kell értenie őket, majd alkalmaznia kell őket. Bizonyos modulok előzetes ismerete nélkül bizonytalan, hogy mit akarsz csinálni,és mit csinál a modul. Az idő a kódolási problémák egyik fontos tényezője. Minden kód célja, hogy csökkentse az emberi munka segítségével a hatékony algoritmusok. Az időgazdálkodás nagy hatással van a kód teljesítményének elemzésére. Ezért ma alaposan megtanuljuk, hogyan működik az időzítő Pythonban.

a Python Timer egy osztály/könyvtár a kód időösszetettségének kezelésére. Több időmodul használatával létrehozhat egy rendszert a kódjában, hogy ellenőrizze a megfelelő kódrészlet által eltöltött időt. Különböző típusú időzítő implementációk vannak a Pythonban a felhasználói igényeknek megfelelően, nevezetesen a python időzítő funkció (a szkript végrehajtási idejének ellenőrzésére), a python threading timer (a szál befejezésének időtartamának ellenőrzésére), a python countdown timer (hozzon létre egy visszaszámlálót) és az alapvető python időmodul (más tevékenységek segítésére).

ezek az időzítő implementációk eltérően működnek, és arra összpontosítanak, hogy különböző felhasználást biztosítsanak a végfelhasználónak. Ebben a bejegyzésben részletesen végigmegyünk minden időzítő megvalósításán. A Tartalomjegyzék segítségével ugorhat a megfelelő python időzítő megvalósításra.

alapvető Python időzítő funkciók

a python legfontosabb modulja az idő. Ez a modul tartalmazza az összes alapvető funkciót az idő ellenőrzéséhez és elemzéséhez. Ez az elemzés segít megérteni a kód teljesítményét és hatékonyságát. Végigmegyünk a modul minden fontos funkcióján, annak példáival együtt.

az alábbiakban az alapvető Python időzítő funkciók segítségével az idő modul–

• idő.idő ()
• idő.thread_time ()
• idő.process_time ()
• idő.perf_counter ()
• idő.monoton()

funkció idő.idő

time.time() az idő másodpercben (float) a korszak után. Általában, a korszak januárra van állítva 1, 1970, 00:00:00 (UTC), valamint az e korszak utáni másodpercek számát adja vissza. Ez a funkció a másodpercek számának kiszámításához szükséges számítógépes időtől függ. Ha megváltoztatja a számítógép idejét a python végrehajtása között, furcsa számokat kaphat ezzel a funkcióval.

példa–

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

magyarázat –

először az időmodul importálásával kezdjük. Ez a modul tartalmazza az összes alapvető időfunkciót, amelyet ebben a szakaszban használunk. A kód elején a start változót time.time() – ként deklaráljuk. Ez tárolja a CPU aktuális idejét úszó számban az epoch – tól. Ezt a kezdő változót használjuk referenciapontként az idő mérésére. A következő rész tartalmazza az összes használni kívánt kódot (ebben a példában az A for loops-t használtuk). Hasonlóképpen jegyezze fel a CPU befejezési idejét (alapértelmezett idő), és ellenőrizze a teljes végrehajtási időt az end – start használatával.

ez másodpercben kinyomtatja a kód által vett időt. Ennek a technikának a használatával ellenőrizheti a kód által eltöltött időt. Az egyetlen probléma ezzel a módszerrel az, hogy a CPU ideje megváltoztatható a kód futása közben. Ez problémás viselkedést eredményez a python timerben.

működési idő.Thread_time

time.thread_time() visszaadja a rendszer és a CPU idő (float) összegét az aktuális futó szálban. Ezenkívül nem tartalmazza a time.sleep() funkcióban töltött időt. Mivel a függvény szálspecifikus, ezzel a funkcióval rögzítheti az időbeli különbségeket, amennyiben az időhivatkozások ugyanahhoz a szálhoz tartoznak.

példa–

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

magyarázat –

mivel a thread_time szálspecifikus időt ad vissza, ügyelnünk kell arra, hogy hivatkozásokat használjunk ugyanabban a szálban. Ebből a célból példányosítottuk a ‘hello’ függvény szálát, és kiszámítottuk a benne lévő szál idejét. Ügyeljen azonban arra, hogy a thread_time() hívásával ne tudja lekérni az aktuális időt, mert tört értéket ad vissza. De mindenképpen ellenőrizheti a különbséget két egymást követő hivatkozás között, amennyiben azok ugyanabba a szálba tartoznak.

működési idő.Process_time

time.process_time() a rendszeridő és az aktuális folyamat CPU-idejének összegét adja vissza frakcionált másodpercben (float). Ugyanaz, mint a thread_time, ez a függvény nem méri a time.sleep() függvényben töltött időt. Ezenkívül ez a funkció referenciát hoz létre a folyamat alapján. Ennek eredményeként csak a két egymást követő hivatkozás közötti időbeli különbségnek lesz értelme.

példa–

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)

magyarázat –

a process_time függvény importálásával kezdjük, és rögzítjük a kód közötti kezdési és befejezési időt. Az egyetlen különbség a régebbi time.time() és time.proces_time() között az, hogy a feldolgozási idő rögzíti az aktuális folyamat időhivatkozásait, míg a time() rögzíti a rendszer abszolút idejét.

működési idő.Perf_counter

a Perf számláló a teljesítményszámlálót jelenti. Ez a függvény az idő nagy felbontású értékét adja vissza, amely rövid ideig érvényes. Ez a funkció a két hivatkozás közötti pontos időszámításra szolgál. Mivel más python időzítő funkciók nem tartalmazzák az alvási időt, a perf_counter szintén nem tartalmazza. Lépjünk egy példára –

példa–

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) 

magyarázat –

a perf számlálót ugyanúgy használhatja, mint a folyamat időzítőt vagy a menet időzítőt. Az egyetlen különbség az, hogy a perf számláló az eltelt idő nagy pontos értékét adja vissza. De győződjön meg róla, hogy ezt a kis folyamatok között használja, mivel nagy pontosságot használ. Egy egyszerű hurkot használtunk az általa eltöltött idő ellenőrzésére.

működési idő.monoton

monoton egy python időzítő, hogy vidám megy hátra. A python parancsfájl végrehajtásakor a felhasználó megváltoztathatja az időt, és hatalmas különbséget tehet az időzítő végrehajtásában a Pythonban. A monoton időzítő azonban biztosítja, hogy az időhivatkozások alkalmazkodjanak a külső változásokhoz.

példa–

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) 

magyarázat –

először importáljuk a monoton funkciót az idő modulból. Ezután hozzon létre két hivatkozást, amelyek neve start és end a kód felső és alsó oldalán. Ez méri a két hivatkozás közötti időt, és elkerüli a rendszeridők minden külső változását.

egyéni Python időzítő osztályok

létrehozhat saját egyéni időzítő osztályt, hogy a dolgokat az Ön igényeinek megfelelően végezze el. Az egyéni osztály létrehozásának egyik fő előnye, hogy egész idő alatt egyetlen sorban kezelheti. Nem kell minden alkalommal importálnia az időosztályt, és rögzítenie kell a hivatkozásokat. Sőt, akkor dump az adatokat, és rögzíti az összes elmúlt időben végrehajtások kiválasztani a legjobb algoritmus az Ön számára.

ez a szakasz egy egyéni osztályt hoz létre az idő kezelésére és a kódok összes időbeli különbségének naplózására. Merüljünk bele –

időzítő.py–

kezdjük az időmodul importálásával. Ezután inicializálja a python Timer osztályt, és kezdje el meghatározni az attribútumokat és metódusokat. Eddig csak az alapvető attribútumot vettük fel, hogy megtartsuk az osztály kezdő hivatkozását. Ahhoz, hogy bonyolultabb legyen, több attribútumot is létrehozhat. Eddig az alábbiakban három módszer van felsorolva–

1. start – (opcionális) az időzítő elindításához.
2. log – a kezdési időre vonatkozó aktuális idő naplózása.
3. milestone – az időzítő alaphelyzetbe állítása és a számlálás indítása 0-ról.

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 –

példák a fenti osztály használatára az alábbiakban találhatók. Mint látható, akkor tartsa a kódot tiszta létrehozásával egyéni időzítő osztály és növeli a rugalmasságot.

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

kimenet–

Time log - 0.054854631423950195Time log - 0.10871052742004395

Python Timer használata Threading

ha azt akarjuk, hogy végre valamilyen műveletet, vagy szeretné, hogy a funkció futtatni egy bizonyos idő után, akkor használja a Python Timer osztály. A timer osztály a threading osztály alosztálya. Technikailag azt mondhatjuk, hogy időzítő objektumokat hozunk létre, amikor az idő által határolt műveleteket (funkciókat) akarunk.

tegyük fel például, hogy kvízt akarunk szervezni, ahol a résztvevőnek minden kérdésre 10 másodpercen belül válaszolnia kell. Itt létrehozhatunk egy időzítőt, amely a háttérben fut, közben pedig a résztvevő a válaszon gondolkodik. Most értsük meg, hogyan lehet létrehozni egy időzítő objektumot.

a Timer osztály szintaxisa a Pythonban

ha még nem értette, mit csinál az Timer osztály, akkor így gondolhat rá – egy Timer osztály a megadott másodpercek után hív egy funkciót.

az időzítő elindításához meg kell hívnunk a start () – t(mint a normál szálak), és az időzítő leállításához, amíg még a háttérben van, hívhatjuk a cancel () – t.

az időzítő osztály használatához importálnunk kell a

menetosztályt.Időzítő (intervallum, funkció, args=nincs, kwargs=nincs)

paraméterek-

intervallum– az az idő (másodpercben), amelyet várni szeretne a következő funkció meghívása előtt. Ez lehet úszó vagy egész szám. Például 3 másodpercig, intervallum=3.

Function – az a funkció, amelyet a megadott időintervallum után meg szeretne hívni.

a *args és **kwargs paraméterek leírásának átfogó módja: – hozzon létre egy időzítő objektumot, amely az args argumentumokkal és a kwargs kulcsszó argumentumokkal futtatja a függvényt az intervallum másodpercek eltelte után. Az Args-nek lista formájában kell lennie0 kulcsszó args vagy kwargs szótár formájában.

visszatérési típus-

csak a paraméterekben megadott függvényt hívja.

módszerek a Timer osztályban

1. start() – az időzítő végrehajtásának kezdetét jelenti.
2. Cancel ()– az időzítő végrehajtása során hívhatjuk a cancel-t, ha meg akarjuk állítani ().

időzítő objektum létrehozása

a. Az alapok megértése

az időzítő objektum működésének megértéséhez hozzunk létre egy kis programot, amely segít megérteni az osztály alapjait.

# 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

jobban meg fogja érteni a fenti program működését, amikor megpróbálja futtatni a saját rendszerén.

b. a cancel módszer használata

nézzük meg, hogyan kell használni a Timer osztály cancel() függvényét.

# 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. A python timer osztály ‘args’ paraméterének használata

amikor meg kell adnunk az argumentumokat a meghívandó függvénynek, akkor az args paramétert használjuk. Meg kell adnunk az args argumentumot egy tömbben.

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

most, hogy sokat beszéltünk az időről, mint bónusz, készítsünk egy programot, amely Visszaszámlálóként fog működni.

visszaszámláló a Pythonban

az időmodul használata

# 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

a python Timer osztály használata

# 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

a Python Időzítők mint Kontextuskezelők

a Kontextuskezelők a legjobb módszerek a memóriahibák és az azt követő összeomlások elkerülésére. Mindenkinek tudnia kellett a Python” with ” állításáról. Ez az állítás biztosítja, hogy nem kell sok objektumról gondoskodnunk ahhoz, hogy önállóan bezárjunk. Lehet, hogy mindenki használta a with és open() függvény kombinációjával. Tehát a fő kérdésre áttérve létrehozhatunk-e Kontextuskezelőket a Python időzítőkhöz?

Igen. A többszörös túlterhelési funkciók miatt néhány sorban könnyen létrehozhatjuk saját python időzítőnket kontextuskezelőként. Kezdjük egy példával, ahol meg kell mérni a program futási idejét. Az összes változó újradefiniálása nélkül egy kontextuskezelő többször is használható az idő többszöri mérésére. A következő program bemutatja.

példa–

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

kimenet–

Time to finish the task: 0.05392050743103027

magyarázat –

kezdjük egy “Timer_Pythonpool” nevű osztály létrehozásával.”Ezután testreszabjuk az operátorokat, hogy kontextuskezelőként hasznosak legyenek. _az _ enter _ _ függvény a kontextus elején, az __exit__ pedig a kontextus végén fut le. Ha e két függvény között referenciapontot hoz létre, megadhatja a kontextus által a végrehajtáshoz szükséges pontos időt.

Python időzítő dekorátorok

dekorátorok a kiegészítő támogatást bármilyen funkciót. Is nevezik metaprogramozás, akkor módosíthatja / hozzá funkciókat is. Python időzítő dekorátorok a legegyszerűbb módja annak, hogy végre az időzítő funkciók python. A deklarálás után a dekorátorokat egy sorban használhatja anélkül, hogy tudná őket. Hozzáadva, alkalmazhatja őket a kód minden funkciójára, hogy ellenőrizze, melyik kód végrehajtása veszi a legtöbb időt.

Syntax –

láncoló dekorátor létrehozásához több beágyazott függvényt kell deklarálnia. Nevezze meg a másik funkciót fő dekoratőr neveként, belső pedig bármilyen véletlenszerű névre. A belső funkció lekéri a lakberendező alatt használt funkció hivatkozását.

példa–

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

kimenet–

Time taken to execute function is 0.24933218955993652

magyarázat –

mint általában, a legfontosabb modul importálásával kezdjük python ” idő.”Ezután létrehozunk egy “check_time” nevű lakberendezőt.”Benne egy beágyazott belső függvényt adunk hozzá, ahol létrehozhatjuk az idő referenciáit. Ez a két hivatkozás úgy van elhelyezve, hogy mindkettő a függvény végrehajtása közé kerüljön.

továbbá létrehozunk egy “feladat” nevű tesztelési funkciót annak ellenőrzésére, hogy a feladatunk működik-e. Ezután adjon hozzá egy dekorátort a tetejére. Most a dekoratőr megteszi a varázslatát, és kinyomtatja a funkció által eltöltött időt.

Python Timer Cooldown

Python Timer Cooldown egy módja annak, hogy mérni az időzítőt hátra. Egyéni időzítő osztály létrehozásával naplózhatjuk az időt a kód minden pontján. Ezt az osztályt modulként exportálhatja, és függőségként telepítheti a kódba. Ezután egyetlen sor használatával importálhatja–

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

Egyéb Python időzítő modulok

a Python több ezer modult és több millió kódrészletet tartalmaz. Mindig használhatjuk a nyílt forráskódú modulokat a python időzítők használatához. A Github a legnagyobb hely az ilyen modulok megtalálásához. Ugorjunk jobbra ezekre a modulokra–

1. termdown: speciális python időzítő, amelyet különböző ASCII karakterek felhasználásával készítettek. Ezzel a szkriptet, akkor létrehozhat egy egyszerű visszaszámláló a terminálon, és végre egy parancsot a végén. A legfontosabb, hogy támogatja a hang visszaszámlálását.
2. MobTimer.Python: a grafikus alapú időzítő készült python. Ez a szkript teljes képernyős alapú időzítőket hoz létre több lehetőséggel. Ezzel együtt a program használatával egyszerre több időzítőt is futtathat a képernyőn.
3. timer: Ez a legalapvetőbb GUI alapú időzítő készült python (Tkinter). Az olyan funkciók, mint a több időzítő, a címkék és a többszálú, életképesebbé teszik más programokkal szemben.
4. codetiming: ez az időzítő osztály rögzíti az összes korábbi végrehajtási időt egy adott nevű folyamathoz. Ellenőrizheti a minimális időt, a maximális időt, az időtartamot és a medián időt az adott folyamathoz a rekordokkal együtt. Ez a modul többféle módon használható, nevezetesen kontextuskezelőként és dekoratőrként.
5. cTimer: a cTime egy nanoszekundumos precíziós időzítő Pythonban. Ez a modul a c nyelv API-t használja az idő pontos rögzítésére. Ha keres egy hardcore precíziós idő felvételi modulok, ez a legjobb. (Megjegyzés: a python legutóbbi frissítéseiben az időmodul olyan funkciókkal egészül ki, amelyek nanoszekundumokban rögzítik az időt)

el kell olvasni:

• hogyan lehet átalakítani String kisbetűs
• hogyan kell kiszámítani négyzetgyök
• felhasználói Input / Input () funkció / billentyűzet bemenet
• legjobb könyv tanulni Python

következtetés

többnyire mindenki használja időzítő három célra. Az első az, hogy rögzítse a kódfuttatás idejét. A második pedig az, hogy emlékeztetőt adjon valamire egy időzítő segítségével. Szerencsére mindkettő létrehozható Pythonban. Különböző modulok és könyvtárak használatával biztosíthatja, hogy pontos pontossággal rögzítse az időt.

végül, de nem utolsósorban, a timer egy alosztálya a threading osztály python. Ha egy bizonyos időintervallum után bármilyen funkciót akarunk futtatni, használhatjuk a python timer osztályt. Az args paraméterben, amely alapértelmezés szerint nincs, megadhatjuk azokat az argumentumokat, amelyeket meg akarunk adni a visszahívási metódusnak.

próbálja meg futtatni a programokat az Ön oldalán, és tudassa velünk, ha bármilyen kérdése van.