Acest ghid vă va explica cum să folosiți funcția sleep() din modulul time, integrat în Python, pentru a introduce pauze în fluxul codului.
Când un program Python este rulat, instrucțiunile se execută consecutiv, una după alta, fără nicio oprire. Totuși, în anumite scenarii, este util să introducem o întârziere în execuție. Funcția sleep(), inclusă în modulul time din Python, oferă această posibilitate.
În acest material, veți înțelege cum să utilizați sintaxa funcției sleep(), urmând câteva exemple practice pentru a demonstra modul său de operare. Să începem explorarea!
Cum se utilizează time.sleep() în Python
Modulul time, care face parte din biblioteca standard Python, oferă instrumente utile legate de timp. Primul pas este să importați acest modul în mediul dumneavoastră de lucru:
import timeAvând în vedere că funcția sleep() este un membru al modulului time, acum o puteți accesa și utiliza prin următoarea structură generală:
time.sleep(n)Aici, n reprezintă numărul de secunde pentru care execuția va fi oprită. Acesta poate fi un număr întreg sau un număr cu virgulă mobilă.
Uneori, este necesară o pauză de doar câteva milisecunde. În astfel de cazuri, puteți converti durata din milisecunde în secunde pentru a o utiliza în apelul funcției sleep(). De exemplu, o întârziere de 100 de milisecunde poate fi specificată ca 0.1 secunde: time.sleep(0.1).
▶ Alternativ, puteți importa doar funcția sleep din modulul time:
from time import sleepDacă optați pentru această metodă, puteți utiliza funcția sleep() direct, fără a mai specifica time.sleep().
Acum că ați înțeles sintaxa funcției sleep(), vom analiza câteva exemple pentru a observa cum funcționează. Puteți descărca scripturile Python utilizate în acest tutorial din folderul python-sleep din acest depozit GitHub. 👩🏽💻
Introducerea de pauze în cod cu sleep()
Începem cu un exemplu simplu în care folosim funcția sleep pentru a întârzia execuția unui program Python de bază.
În următorul fragment de cod:
- Prima instrucțiune
print()este executată imediat. - Apoi, introducem o întârziere de 5 secunde folosind funcția
sleep(). - A doua instrucțiune
print()va fi executată doar după ce perioada de pauză se încheie.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Acum, rulați fișierul simple_example.py și observați rezultatul:
$ python3 simple_example.py
Pauze variabile într-un bloc de cod
În exemplul anterior, am aplicat o întârziere fixă de 5 secunde între două instrucțiuni print(). Acum vom elabora un alt exemplu pentru a introduce timpi diferiți de pauză în timpul parcurgerii unei structuri iterabile.
În acest scenariu, ne propunem să facem următoarele:
- Să procesăm o propoziție, accesând fiecare cuvânt și afișându-l.
- După afișarea fiecărui cuvânt, să introducem o pauză specifică înainte de a afișa următorul cuvânt din propoziție.
Parcurgerea unui șir de caractere
Să considerăm un șir, numit propoziție. Acesta este un șir în care fiecare cuvânt este, de asemenea, un șir.
Dacă parcurgem șirul, vom obține fiecare caracter individual, după cum urmează:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Acesta nu este comportamentul dorit. Dorim să parcurgem propoziția și să accesăm fiecare cuvânt în parte. Pentru a realiza acest lucru, putem apela metoda split() pe șirul propoziției. Aceasta va returna o listă de șiruri de caractere – obținută prin împărțirea șirului original la fiecare apariție a unui spațiu.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Parcurgerea iterabilelor cu pauze variabile
Să analizăm din nou exemplul:
propozițiaeste șirul pe care dorim să-l parcurgem pentru a accesa fiecare cuvânt.delay_timeseste lista de timpi de pauză pe care îi vom folosi ca argument pentru funcțiasleep()în timpul fiecărei iterații.
În acest caz, dorim să parcurgem simultan două liste: lista delay_times și lista șirurilor de caractere obținute prin împărțirea șirului propoziția. Putem utiliza funcția zip() pentru a realiza această parcurgere paralelă.
Funcția Python zip(): zip(list1, list2) returnează un iterator de tupluri, unde fiecare tuplu conține elementul de la indexul i din list1 și list2.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)
Fără funcția sleep, fluxul de execuție ar trece imediat la următoarea iterație. Deoarece am introdus o întârziere, următoarea iterație va avea loc doar după ce operațiunea de pauză s-a încheiat.
Acum, executați delay_times.py și observați rezultatul:
$ python3 delay_times.py
Cuvintele din șir vor fi afișate cu o întârziere. Întârzierea după afișarea cuvântului de la indexul i din șir este durata de timp de la indexul i din lista delay_times.
Temporizator cu numărătoare inversă în Python
Ca următor exemplu, vom construi un temporizator simplu cu numărătoare inversă în Python.
Să definim o funcție countDown():
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Ready to go!")
else:
print(i)
time.sleep(1)
Să analizăm definiția funcției countDown():
- Funcția primește un număr
nca argument și numără invers până la zero, pornind de la număruln. - Folosim
time.sleep(1)pentru a introduce o pauză de o secundă între fiecare număr. - Când numărul ajunge la 0, funcția afișează „Ready to go!”.
🎯 Pentru a realiza numărătoarea inversă, am utilizat funcția range() cu un pas negativ de -1. range(n, -1, -1) ne va ajuta să trecem prin intervalul de numere de la n, n – 1, n – 2 și așa mai departe până la zero. Trebuie reținut că valoarea finală nu este inclusă în mod implicit când se folosește funcția range().
În continuare, vom adăuga un apel la funcția countDown() cu argumentul 5.
countDown(5)
Acum, executați scriptul countdown.py pentru a vedea funcția countDown în acțiune!
$ python3 countdown.py
Utilizarea funcției sleep în Multithreading
Modulul threading din Python oferă funcționalități de multithreading. În Python, Global Interpreter Lock (GIL) asigură că există un singur fir de execuție activ în orice moment.
Cu toate acestea, în timpul operațiunilor de I/O și a operațiunilor de așteptare, cum ar fi starea de pauză, procesorul poate suspenda execuția firului de execuție curent și poate trece la un alt fir de execuție aflat în așteptare.
Pentru a înțelege cum funcționează acest lucru, vom analiza un exemplu.
Crearea și rularea de fire de execuție în Python
Să considerăm următoarele funcții, func1(), func2() și func3(). Acestea parcurg o serie de numere și le afișează. Urmează apoi o operație de pauză, pentru un anumit număr de secunde, la fiecare pas al buclei. Am folosit timpi de întârziere diferiți pentru fiecare dintre funcții pentru a înțelege mai bine cum execuția trece de la un fir la altul în același timp.
import time
import threading
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
În Python, puteți folosi constructorul Thread() pentru a crea un obiect thread. Sintaxa threading.Thread(target = ..., args = ...) creează un fir de execuție care rulează funcția țintă cu argumentele specificate în tuplul args.
În acest exemplu, funcțiile func1, func2 și func3 nu primesc niciun argument. Prin urmare, este suficient să specificăm numele funcției ca țintă. Apoi, definim obiectele thread t1, t2 și t3, cu func1, func2 și respectiv func3 ca ținte.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Iată codul complet pentru exemplul de threading:
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Observați rezultatul. Execuția alternează între cele trei fire. Firul t3 are cea mai mică durată de așteptare, deci este suspendat pentru cel mai scurt timp. Firul t1 are cea mai lungă durată de pauză, de două secunde, deci este ultimul fir care finalizează execuția.
Pentru mai multe informații, citiți tutorialul despre elementele de bază ale multithreadingului în Python.
Concluzie
În acest tutorial, ați învățat cum să folosiți funcția sleep() din Python pentru a introduce întârzieri în codul dumneavoastră.
Funcția sleep() poate fi accesată din modulul time încorporat: time.sleep(). Pentru a întârzia execuția cu n secunde, utilizați time.sleep(n). Ați văzut, de asemenea, exemple de cum să întârziați iterațiile într-o buclă cu diferite valori, cum să creați o numărătoare inversă și cum să folosiți sleep() în multithreading.
Acum puteți explora funcționalități mai avansate ale modulului time. Doriți să lucrați cu date și ore în Python? Pe lângă modulul time, puteți profita de funcționalitățile oferite de modulele datetime și calendar.
În continuare, aflați cum să calculați diferența de timp în Python.⏰