Deze tutorial leert je hoe je de sleep() functie van de ingebouwde tijdmodule van Python kunt gebruiken om tijdvertragingen aan code toe te voegen.
Wanneer u een eenvoudig Python-programma uitvoert, gebeurt de uitvoering van de code sequentieel – de ene instructie na de andere – zonder enige vertraging. Het kan echter zijn dat u in sommige gevallen de uitvoering van de code moet uitstellen. De sleep() functie van de ingebouwde tijdmodule van Python helpt je hierbij.
In deze tutorial leer je de syntaxis van het gebruik van de sleep()-functie in Python en verschillende voorbeelden om te begrijpen hoe het werkt. Laten we beginnen!
Syntaxis van Python time.sleep()
De tijdmodule, ingebouwd in de standaardbibliotheek van Python, biedt verschillende handige tijdgerelateerde functies. Importeer als eerste stap de tijdmodule in uw werkomgeving:
import time
Aangezien de functie sleep() deel uitmaakt van de tijdmodule, kunt u deze nu openen en gebruiken met de volgende algemene syntaxis:
time.sleep(n)
Hier is n het aantal seconden om te slapen. Het kan een geheel getal of een getal met drijvende komma zijn.
Soms kan de vereiste vertraging enkele milliseconden bedragen. In deze gevallen kunt u de duur in milliseconden omzetten in seconden en deze gebruiken in de oproep naar de slaapfunctie. Als u bijvoorbeeld een vertraging van 100 milliseconden wilt invoeren, kunt u deze opgeven als 0,1 seconde: time.sleep(0.1).
▶ U kunt ook alleen de slaapfunctie uit de tijdmodule importeren:
from time import sleep
Als u de bovenstaande methode gebruikt om te importeren, kunt u de functie sleep() rechtstreeks aanroepen, zonder time.sleep() te gebruiken.
Nu je de syntaxis van de Python-functie sleep() hebt geleerd, laten we codevoorbeelden maken om de functie in actie te zien. U kunt de Python-scripts die in deze zelfstudie worden gebruikt, downloaden vanuit de map python-sleep in deze GitHub-opslagplaats. 👩🏽💻
Code-uitvoering vertragen met sleep()
Laten we als eerste voorbeeld de slaapfunctie gebruiken om de uitvoering van een eenvoudig Python-programma te vertragen.
In het volgende codefragment:
- De eerste instructie print() wordt zonder enige vertraging uitgevoerd.
- We introduceren dan een vertraging van 5 seconden met behulp van de sleep()-functie.
- De tweede instructie print() wordt pas uitgevoerd nadat de slaapbewerking is voltooid.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Voer nu het bestand simple_example.py uit en bekijk de uitvoer:
$ python3 simple_example.py
Voeg verschillende vertragingen toe aan een codeblok
In het vorige voorbeeld hebben we een vaste vertraging van 5 seconden ingevoerd tussen de uitvoering van twee print()-statements. Laten we vervolgens een ander voorbeeld coderen om verschillende vertragingstijden te introduceren bij het doorlopen van een iterable.
In dit voorbeeld willen we het volgende doen:
- Loop door een zin, open elk woord en druk het af.
- Nadat we elk woord hebben afgedrukt, willen we een bepaalde tijd wachten voordat we het volgende woord in de zin afdrukken.
Een lus maken door een reeks snaren
Overweeg de string, zin. Het is een string waarbij elk woord een string op zich is.
Als we de string doorlopen, krijgen we elk teken, zoals weergegeven:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Maar dit is niet wat we willen. We willen de zin doorlopen en toegang krijgen tot elk woord. Om dit te doen, kunnen we de methode split() op de zinsreeks aanroepen. Dit zal een lijst met tekenreeksen teruggeven – verkregen door de zinreeks te splitsen – voor alle gevallen van witruimte.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Iterables doorlopen met verschillende vertragingen
Laten we het voorbeeld nog eens bekijken:
- zin is de tekenreeks die we willen doorlopen om toegang te krijgen tot elk woord.
- delay_times is de lijst met vertragingstijden die we zullen gebruiken als argument voor de functie sleep() tijdens elke passage door de lus.
Hier willen we tegelijkertijd twee lijsten doorlopen: de delay_times-lijst en de lijst met strings die wordt verkregen door de zinstring te splitsen. U kunt de functie zip() gebruiken om deze parallelle iteratie uit te voeren.
De Python functie zip(): zip(lijst1, lijst2) retourneert een iterator van tupels, waarbij elke tupel het item bevat op index i in lijst1 en lijst2.
# /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)
Zonder de slaapfunctie zou de besturing onmiddellijk doorgaan naar de volgende iteratie. Omdat we een vertraging hebben geïntroduceerd, vindt de volgende passage door de lus pas plaats nadat de slaapoperatie is voltooid.
Voer nu delay_times.py uit en bekijk de uitvoer:
$ python3 delay_times.py
De volgende woorden in de string worden na een vertraging afgedrukt. De vertraging na het afdrukken van het woord bij index i in de string is het getal bij index i in de delay_times lijst.
Afteltimer in Python
Laten we als volgend voorbeeld een eenvoudige afteltimer coderen in Python.
Laten we een functie countDown() definiëren:
# /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)
Laten we vervolgens de definitie van de functie countDown() ontleden:
- De functie neemt een getal n als argument en telt af naar nul vanaf dat getal n.
- We gebruiken time.sleep(1) om een vertraging van één seconde tussen de tellingen te realiseren.
- Wanneer de telling 0 bereikt, drukt de functie “Ready to go!” af.
🎯 Voor het aftellen hebben we de functie range() gebruikt met een negatieve stapwaarde van -1. bereik(n, -1, -1) helpt ons om het bereik van getallen in n, n – 1, n – 2 enzovoort tot nul te doorlopen. Bedenk dat het eindpunt standaard wordt uitgesloten bij gebruik van de functie range().
Laten we vervolgens een aanroep toevoegen aan de functie countDown() met 5 als argument.
countDown(5)
Voer nu het script countdown.py uit en zie de countDown-functie in actie!
$ python3 countdown.py
Slaapfunctie bij multithreading
Python threading-module biedt out-of-the-box multithreading-mogelijkheden. In Python zorgt de Global Interpreter Lock of GIL ervoor dat er op elk moment slechts één actieve thread actief is.
Tijdens I/O-bewerkingen en wachtbewerkingen zoals slaapstand kan de processor echter de uitvoering van de huidige thread onderbreken en overschakelen naar een andere thread die wacht.
Laten we een voorbeeld nemen om te begrijpen hoe dit werkt.
Threads maken en uitvoeren in Python
Beschouw de volgende functies, func1(), func2() en func3(). Ze doorlopen een reeks getallen en printen ze uit. Dit wordt gevolgd door een slaapoperatie – gedurende een bepaald aantal seconden – tijdens elke passage door de lus. We hebben verschillende vertragingstijden gebruikt voor elk van de functies om beter te begrijpen hoe de uitvoering gelijktijdig tussen threads schakelt.
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)
In Python kunt u de Thread()-constructor gebruiken om een thread-object te instantiëren. Met behulp van de syntaxis threading.Thread(target = …, args = …) wordt een thread gemaakt die de doelfunctie uitvoert met het argument dat is opgegeven in de args-tuple.
In dit voorbeeld nemen de functies func1, func2 en func3 geen argumenten op. Het volstaat dus alleen de naam van de functie als doel op te geven. Vervolgens definiëren we thread-objecten, t1, t2 en t3 met respectievelijk func1, func2 en func3 als doelen.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Hier is de volledige code voor het threading-voorbeeld:
# /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()
Observeer de uitvoer. De uitvoering wisselt tussen de drie threads. De thread t3 heeft de laagste wachttijd, dus wordt deze zo kort mogelijk onderbroken. Thread t1 heeft de langste slaapduur van twee seconden, dus het is de laatste thread die de uitvoering voltooit.
Lees voor meer informatie de tutorial over de basisprincipes van multithreading in Python.
Conclusie
In deze tutorial heb je geleerd hoe je de sleep()-functie van Python kunt gebruiken om tijdvertragingen aan code toe te voegen.
U hebt toegang tot de functie sleep() via de ingebouwde tijdmodule time.sleep(). Gebruik time.sleep(n) om de uitvoering met n seconden te vertragen. Je hebt ook voorbeelden gezien van het vertragen van opeenvolgende iteraties in een lus door verschillende waarden, aftellen en multithreading.
U kunt nu meer geavanceerde mogelijkheden van de tijdmodule verkennen. Wil je werken met datums en tijden in Python? Naast de tijdmodule kunt u gebruikmaken van de functionaliteit van de datum/tijd- en kalendermodules.
Leer vervolgens het tijdsverschil berekenen in Python.⏰
