Fördröjningar i Python-kod med funktionen sleep()
Denna guide förklarar hur du använder funktionen `sleep()` från Pythons inbyggda tidsmodul för att införa pauser i din programkörning.
När ett Python-program körs utförs koden normalt sekventiellt, en instruktion efter den andra, utan uppehåll. I vissa situationer kan det dock vara nödvändigt att försena utförandet av koden. Funktionen `sleep()`, som finns i Pythons tidsmodul, gör just detta möjligt.
I den här artikeln går vi igenom syntaxen för `sleep()` och ger ett antal exempel som illustrerar hur den fungerar. Låt oss börja!
Användning av `time.sleep()` i Python
Tidsmodulen är en standardkomponent i Python och erbjuder många verktyg för tidshantering. För att använda modulen behöver du först importera den:
import timeEftersom `sleep()` är en del av tidsmodulen kan du sedan använda den genom att anropa den på följande sätt:
time.sleep(n)Här representerar `n` antalet sekunder som programmet ska pausas. Detta kan vara ett heltal eller ett decimaltal.
Det är inte ovanligt att behöva korta fördröjningar, som ett antal millisekunder. I dessa fall konverterar du tiden från millisekunder till sekunder, och använder det värdet i anropet till `sleep()`. Till exempel, för en paus på 100 millisekunder använder du `time.sleep(0.1)`, eftersom 100 millisekunder motsvarar 0.1 sekunder.
▶ Det går också att importera enbart `sleep()` från tidsmodulen:
from time import sleepMed den här importmetoden kan du anropa `sleep()` direkt, utan att ange `time.sleep()`.
Nu när du har koll på syntaxen för `sleep()`, ska vi titta på några praktiska exempel. Du kan hitta alla Python-skript som används i detta exempel i katalogen `python-sleep` på denna GitHub-repo. 👩🏽💻
Fördröjning av kodutförande med `sleep()`
Vi börjar med att använda `sleep()` för att fördröja ett enkelt Python-program.
I följande kod:
- Första utskriften sker omedelbart.
- Vi använder `sleep()` för att införa en 5-sekunders paus.
- Den andra utskriften genomförs först efter att pausen är avslutad.
# /python-sleep/simple_example.py
import time
print("Utskrift direkt")
time.sleep(5)
print("Utskrift efter 5 sekunders paus")Kör nu filen `simple_example.py` för att se resultatet:
$ python3 simple_example.pyOlika fördröjningstider i ett kodblock
I exemplet ovan hade vi en fast fördröjning på 5 sekunder mellan två utskrifter. Nu skapar vi ett exempel som använder olika fördröjningar i en loop.
Vi vill:
- Gå igenom en mening, ord för ord, och skriva ut dem.
- Efter varje ord ska programmet pausas innan nästa ord skrivs ut.
Loopa igenom en sträng av strängar
Tänk på en sträng, till exempel en mening. Det är en sträng där varje ord i sig också är en sträng.
Om vi loopar igenom en mening direkt får vi alla enskilda tecken:
>>> sentence = "Hur lång tid tar det här?"
>>> for char in sentence:
... print(char)
# Output (förkortat för tydlighet)
H
u
r
.
.
.
h
ä
r
?Det är inte det vi är ute efter. Vi vill loopa igenom meningen ord för ord. För att göra det använder vi `split()`-metoden. Det ger en lista med strängar – som erhålls genom att dela upp strängen där det finns blanksteg.
>>> sentence.split()
['Hur', 'lång', 'tid', 'tar', 'det', 'här?']
>>> for word in sentence.split():
... print(word)
# Output
Hur
lång
tid
tar
det
här?Loopa genom iterabla objekt med olika fördröjningar
Låt oss återgå till vårt exempel:
- `sentence` är strängen som vi vill gå igenom för att få tag på varje ord.
- `delay_times` är en lista med väntetider som vi använder som argument i `sleep()`-funktionen under varje iteration.
Här vill vi loopa genom två listor samtidigt: `delay_times` och listan med strängar som vi får från att dela upp meningen. Vi kan använda `zip()` för att loopa genom listorna samtidigt.
Pythons `zip()`-funktion fungerar så här: `zip(lista1, lista2)` returnerar en iterator av tupler, där varje tupel innehåller elementet vid index `i` från `lista1` och `lista2`.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "Hur lång tid tar det här?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)Utan `sleep()` skulle kontrollen gå vidare direkt till nästa iteration. Men eftersom vi har infört en fördröjning kommer nästa loop att genomföras först efter att pausen är avslutad.
Kör nu `delay_times.py` för att se resultatet:
$ python3 delay_times.pyOrden kommer att skrivas ut med fördröjningar. Fördröjningen efter att ha skrivit ut ordet vid index `i` i strängen motsvarar värdet vid index `i` i `delay_times`-listan.
Nedräknare i Python
Låt oss nu skapa en enkel nedräknare i Python.
Vi definierar en funktion `countDown()`:
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Klar!")
else:
print(i)
time.sleep(1)Låt oss analysera definitionen av `countDown()`:
- Funktionen tar in ett tal `n` som argument och räknar ned till noll.
- Vi använder `time.sleep(1)` för att pausa en sekund mellan räkningarna.
- När räkningen når 0 skriver funktionen ut ”Klar!”.
🎯 För att skapa nedräkningen använder vi `range()`-funktionen med ett steg på -1. `range(n, -1, -1)` hjälper oss att iterera genom talen `n`, `n – 1`, `n – 2`, och så vidare, ned till noll. Tänk på att slutpunkten normalt inte inkluderas när du använder `range()`-funktionen.
Låt oss nu anropa funktionen `countDown()` med 5 som argument.
countDown(5)Kör nu skriptet `countdown.py` och se nedräknaren i aktion!
$ python3 countdown.py
`sleep()` i Multithreading
Pythons trådningsmodul erbjuder inbyggt stöd för multithreading. I Python garanterar Global Interpreter Lock (GIL) att bara en tråd kan köras i taget.
Under I/O-operationer och väntetider, som `sleep()`, kan processorn avbryta den nuvarande tråden och gå över till en annan tråd som väntar.
Vi tittar nu på ett exempel.
Skapa och kör trådar i Python
Tänk på funktionerna `func1()`, `func2()` och `func3()`. De loopar genom ett antal tal och skriver ut dem. Detta följs av en `sleep()`-operation med olika väntetider under varje iteration. Vi har använt olika fördröjningstider i varje funktion för att tydliggöra hur exekvering skiftar mellan trådar.
import time
def func1():
for i in range(5):
print(f"Kör t1, skriv ut {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Kör t2, skriv ut {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Kör t3, skriv ut {i}.")
time.sleep(0.5)I Python skapar man en tråd med `Thread()`-konstruktorn. Genom att använda syntaxen `threading.Thread(target = …, args = …)` skapas en tråd som kör målfunktionen med de argument som anges i args-tupeln.
I detta exempel tar inte funktionerna `func1`, `func2` och `func3` några argument. Det räcker därför att ange funktionsnamnet som mål. Vi definierar därefter trådobjekt, `t1`, `t2` och `t3` med `func1`, `func2` och `func3` som mål.
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()Här är hela koden för trådningsexemplet:
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Kör t1, skriv ut {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Kör t2, skriv ut {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Kör t3, skriv ut {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()Lägg märke till utskriften. Exekveringen växlar mellan de tre trådarna. Tråden `t3` har den kortaste väntetiden och avbryts därmed minst. Tråd `t1` har den längsta väntetiden, två sekunder, och avslutar exekveringen sist.
Läs guiden om grunderna i multithreading i Python för att lära dig mer.
Sammanfattning
I den här guiden har du lärt dig hur du använder Pythons `sleep()`-funktion för att införa fördröjningar i din kod.
Du kan komma åt `sleep()` från den inbyggda tidsmodulen via `time.sleep()`. För att fördröja exekveringen med `n` sekunder använder du `time.sleep(n)`. Vi har också sett exempel på fördröjningar mellan loop-iterationer med olika värden, nedräkning och multitrådning.
Nu kan du gå vidare och utforska mer avancerade funktioner i tidsmodulen. Är du intresserad av att arbeta med datum och tider i Python? Förutom tidsmodulen kan du ta hjälp av modulerna `datetime` och `calendar`.
Härnäst lär du dig beräkna tidsskillnader i Python.⏰