Acest tutorial vă va învăța cum să utilizați funcția sleep() din modulul de timp încorporat din Python pentru a adăuga întârzieri la cod.
Când rulați un program simplu Python, execuția codului are loc secvenţial – o instrucţiune după alta – fără nicio întârziere. Cu toate acestea, poate fi necesar să întârziați execuția codului în unele cazuri. Funcția sleep() din modulul de timp încorporat Python vă ajută să faceți acest lucru.
În acest tutorial, veți învăța sintaxa utilizării funcției sleep() în Python și câteva exemple pentru a înțelege cum funcționează. Să începem!
Cuprins
Sintaxa lui Python time.sleep()
Modulul de timp, încorporat în biblioteca standard Python, oferă câteva funcții utile legate de timp. Ca prim pas, importați modulul de timp în mediul dvs. de lucru:
import time
Deoarece funcția sleep() face parte din modulul de timp, acum o puteți accesa și utiliza cu următoarea sintaxă generală:
time.sleep(n)
Aici, n este numărul de secunde pentru a dormi. Poate fi un număr întreg sau un număr în virgulă mobilă.
Uneori, întârzierea necesară poate fi de câteva milisecunde. În aceste cazuri, puteți converti durata în milisecunde în secunde și o puteți utiliza în apelul la funcția de repaus. De exemplu, dacă doriți să introduceți o întârziere de 100 de milisecunde, o puteți specifica ca 0,1 secunde: time.sleep(0,1).
▶ De asemenea, puteți importa doar funcția de somn din modulul de timp:
from time import sleep
Dacă utilizați metoda de mai sus pentru import, puteți apela direct funcția sleep() fără a utiliza time.sleep().
Acum că ați învățat sintaxa funcției Python sleep(), haideți să codificăm exemple pentru a vedea funcția în acțiune. Puteți descărca scripturile Python utilizate în acest tutorial din folderul python-sleep din acest depozit GitHub. 👩🏽💻
Întârzierea execuției codului cu sleep()
Ca prim exemplu, să folosim funcția sleep pentru a întârzia execuția unui program simplu Python.
În următorul fragment de cod:
- Prima instrucțiune print() este executată fără întârziere.
- Introducem apoi o întârziere de 5 secunde folosind funcția sleep().
- Cea de-a doua instrucțiune print() va fi executată numai după terminarea operației de repaus.
# /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
Adăugați diferite întârzieri la un bloc de cod
În exemplul anterior, am introdus o întârziere fixă de 5 secunde între execuția a două instrucțiuni print(). În continuare, să codificăm un alt exemplu pentru a introduce timpi de întârziere diferiți atunci când parcurgeți un iterabil.
În acest exemplu, am dori să facem următoarele:
- Căutați o propoziție, accesați fiecare cuvânt și imprimați-l.
- După imprimarea fiecărui cuvânt, am dori să așteptăm o anumită perioadă de timp – înainte de a tipări următorul cuvânt din propoziție.
Buclă printr-un șir de șiruri
Luați în considerare șirul, propoziția. Este un șir în care fiecare cuvânt este un șir în sine.
Dacă parcurgem șirul, vom obține fiecare caracter, așa cum se arată:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Dar nu asta ne dorim. Am dori să parcurgem propoziția și să accesăm fiecare cuvânt. Pentru a face acest lucru, putem apela metoda split() pe șirul de propoziție. Aceasta va returna o listă de șiruri de caractere – obținute prin împărțirea șirului de propoziție – pe toate aparițiile spațiilor albe.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Buclă prin iterabile cu diferite întârzieri
Să revedem exemplul:
- propoziția este șirul pe care am dori să-l parcurgem pentru a accesa fiecare cuvânt.
- delay_times este lista timpilor de întârziere pe care le vom folosi ca argument pentru funcția sleep() în timpul fiecărei treceri prin buclă.
Aici am dori să parcurgem simultan două liste: lista delay_times și lista șirurilor de caractere obținute prin împărțirea șirului de propoziție. Puteți utiliza funcția zip() pentru a efectua această iterație 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 de somn, controlul ar trece imediat la următoarea iterație. Deoarece am introdus o întârziere, următoarea trecere prin buclă are loc numai după ce operațiunea de somn este finalizată.
Acum rulați delay_times.py și observați rezultatul:
$ python3 delay_times.py
Cuvintele ulterioare din șir vor fi tipărite după o întârziere. Întârzierea după tipărirea cuvântului de la indexul i din șir este numărul de la indexul i din lista delay_times.
Cronometrul de numărătoare inversă în Python
Ca exemplu următor, să codificăm un cronometru 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)
În continuare, să analizăm definiția funcției countDown():
- Funcția ia un număr n ca argument și numără invers până la zero pornind de la acel număr n.
- Folosim time.sleep(1) pentru a obține o întârziere de o secundă între numărări.
- Când numărul ajunge la 0, funcția afișează „Gata de plecare!”.
🎯 Pentru a realiza operația de numărătoare inversă, am folosit funcția range() cu o valoare negativă a pasului de -1. range(n, -1, -1) ne va ajuta să trecem prin intervalul de numere din n, n – 1, n – 2 și așa mai departe până la zero. Amintiți-vă că punctul final este exclus în mod implicit atunci când utilizați funcția range().
În continuare, să adăugăm un apel la funcția countDown() cu 5 ca argument.
countDown(5)
Acum rulați scriptul countdown.py și vedeți funcția countDown în acțiune!
$ python3 countdown.py
Funcția de somn în Multithreading
Modulul de threading Python oferă capabilități de tip multithreading ieșite din cutie. În Python, Global Interpreter Lock sau GIL asigură că există un singur fir activ care rulează î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 repaus, procesorul poate suspenda execuția firului de execuție curent și poate comuta la un alt fir de execuție care așteaptă.
Pentru a înțelege cum funcționează, să luăm un exemplu.
Crearea și rularea thread-urilor în Python
Luați în considerare următoarele funcții, func1(), func2() și func3(). Acestea parcurg o serie de numere și le imprimă. Aceasta este urmată de o operație de repaus, pentru un anumit număr de secunde, în timpul fiecărei treceri prin buclă. Am folosit timpi de întârziere diferiți pentru fiecare dintre funcții pentru a înțelege mai bine modul în care execuția comută între fire simultan.
import time
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 instanția un obiect thread. Folosind sintaxa threading.Thread(target = …, args = …) creează un fir care rulează funcția țintă cu argumentul specificat în tuplu args.
În acest exemplu, funcțiile func1, func2 și func3 nu preiau niciun argument. Deci este suficient să specificați doar numele funcției ca țintă. Apoi definim obiecte 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 se modifică între cele trei fire. Firul t3 are cel mai mic timp de așteptare, deci este suspendat pentru cel mai mic timp. Thread t1 are cea mai lungă durată de repaus, de două secunde, deci este ultimul fir care finalizează execuția.
Pentru a afla mai multe, citiți tutorialul despre elementele de bază ale multithreadingului în Python.
Concluzie
În acest tutorial, ați învățat cum să utilizați funcția sleep() de la Python pentru a adăuga întârzieri la cod.
Puteți accesa funcția sleep() din modulul de timp încorporat, time.sleep(). Pentru a întârzia execuția cu n secunde, utilizați time.sleep(n). De asemenea, ați văzut exemple de întârziere a iterațiilor ulterioare într-o buclă cu diferite valori, numărătoare inversă și multithreading.
Acum puteți explora capacități mai avansate ale modulului de timp. Doriți să lucrați cu datele și orele în Python? În plus față de modulul de timp, puteți profita de funcționalitatea modulelor datetime și calendar.
Apoi, învață să calculezi diferența de timp în Python.⏰