Innføring i `time.sleep()` i Python
Denne guiden tar for seg hvordan du kan bruke `sleep()`-funksjonen fra Pythons innebygde `time`-modul for å introdusere pauser i programutførelsen.
Normalt vil et Python-program kjøre linje for linje uten forsinkelser. Men i visse situasjoner kan det være nødvendig å pause utførelsen i en spesifikk tidsperiode. Dette er der `sleep()`-funksjonen kommer inn i bildet, ved å tilby en enkel måte å kontrollere tidspunktene for utførelse.
I denne opplæringen skal vi se nærmere på hvordan `sleep()`-funksjonen fungerer, ved å gå gjennom syntaksen og en rekke praktiske eksempler for å illustrere bruken. La oss sette i gang!
Syntaks for `time.sleep()`
`time`-modulen, som er en del av Pythons standardbibliotek, har mange nyttige funksjoner relatert til tid. For å begynne å bruke `sleep()`, må du først importere `time`-modulen:
import time
Etter at modulen er importert, kan du kalle `sleep()`-funksjonen ved hjelp av denne syntaksen:
time.sleep(n)
Her representerer `n` antall sekunder programmet skal «sove». Verdien kan være både et heltall og et desimaltall.
I noen tilfeller kan det være nødvendig med svært korte forsinkelser, for eksempel i millisekunder. Da må du konvertere millisekunder til sekunder før du kaller `sleep()`. For eksempel, for å pause i 100 millisekunder, må du bruke `time.sleep(0.1)`.
Du kan også importere bare `sleep()`-funksjonen direkte:
from time import sleep
Ved å bruke denne metoden, kan du kalle `sleep()` uten å måtte skrive `time.sleep()`, bare `sleep()`.
Nå som du har fått en forståelse for hvordan `sleep()`-funksjonen fungerer, la oss se på noen praktiske eksempler. Alle kodeeksemplene i denne opplæringen er tilgjengelige i python-sleep-mappen i dette GitHub-repoet.
Grunnleggende bruk av `sleep()`
La oss begynne med et enkelt eksempel som illustrerer hvordan `sleep()` kan brukes for å forsinke programutførelsen.
Koden under viser hvordan:
- Den første `print()`-setningen kjøres umiddelbart.
- Deretter bruker vi `time.sleep(5)` for å introdusere en 5-sekunders pause.
- Den andre `print()`-setningen kjøres først etter at pausen er over.
import time
print("Skriv ut nå")
time.sleep(5)
print("Skriv ut etter 5 sekunders pause")
For å se dette i praksis, lagre koden som en fil `simple_example.py` og kjør den fra kommandolinjen:
$ python3 simple_example.py
Variabel forsinkelse i en løkke
I det forrige eksemplet så vi hvordan man kunne introdusere en fast forsinkelse. La oss nå se på hvordan man kan bruke `sleep()` for å introdusere varierende forsinkelser mens man itererer gjennom en samling.
Vi skal gjøre følgende:
- Gå gjennom en setning, ord for ord.
- Skrive ut hvert ord.
- Legge inn en variabel forsinkelse mellom hvert ord.
Iterere gjennom en streng
Tenk deg strengen: «Dette er en test». Dette er en streng der hvert ord er en streng i seg selv.
Hvis vi bare går gjennom denne strengen, får vi ut hvert enkelt tegn, slik:
>>> setning = "Dette er en test"
>>> for tegn in setning:
... print(tegn)
# Output (forkortet)
D
e
t
t
e
...
Dette er ikke hva vi ønsker. Vi ønsker å iterere gjennom hvert ord i setningen. For å gjøre dette, kan vi bruke `split()`-metoden på setningen. Dette vil returnere en liste med ord.
>>> setning.split()
['Dette', 'er', 'en', 'test']
>>> for ord in setning.split():
... print(ord)
# Output
Dette
er
en
test
Iterasjon med varierende forsinkelser
La oss se på dette eksemplet igjen:
- `setning` er strengen vi ønsker å gå gjennom.
- `forsinkelse_tider` er listen med forsinkelser vi ønsker å bruke i `sleep()` funksjonen.
Her skal vi iterere gjennom to lister samtidig. Vi kan bruke `zip()`-funksjonen for å utføre denne parallelle iterasjonen. `zip(liste1, liste2)` vil returnere en iterator med tupler, hvor hver tuppel inneholder elementer fra hver liste.
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "Dette er en lang setning"
for sleep_time, word in zip(sleep_times, sentence.split()):
print(word)
time.sleep(sleep_time)
Uten `sleep()` ville programmet gått direkte til neste iterasjon. Med `sleep()`-funksjonen vil programmet pause før det går videre.
Lagre koden som `delay_times.py`, og kjør den:
$ python3 delay_times.py
Hvert ord vil bli skrevet ut med den angitte forsinkelsen. For eksempel vil det første ordet skrives ut, deretter vil programmet vente 3 sekunder før neste ord skrives ut og så videre.
Nedtellingstidtaker
La oss lage en enkel nedtellingstidtaker med Python:
Vi definerer funksjonen `countDown()`:
import time
def countDown(n):
for i in range(n, -1, -1):
if i == 0:
print("Klar!")
else:
print(i)
time.sleep(1)
La oss analysere definisjonen av funksjonen:
- Funksjonen tar et tall n som argument.
- Vi bruker `time.sleep(1)` for å introdusere en 1-sekund pause mellom hvert tall.
- Når tellingen når 0, skriver funksjonen ut «Klar!».
Vi bruker `range()`-funksjonen med en negativ stegverdi `-1`. `range(n, -1, -1)` gjør at vi kan gå gjennom tallene n, n-1, n-2 og så videre ned til 0. Husk at sluttverdien ikke inkluderes med `range()`.
La oss kalle `countDown(5)`:
countDown(5)
Lagre som `countdown.py` og kjør programmet:
$ python3 countdown.py
`sleep()` med multitråding
Pythons `threading`-modul gir mulighet for multitråding. I Python er det imidlertid en global lås, GIL, som sikrer at kun en tråd kjører samtidig.
Ved I/O-operasjoner, som `sleep()`, kan prosessoren sette en tråd på pause og bytte til en annen tråd som venter.
Oppretting av tråder i Python
Tenk deg funksjonene `func1()`, `func2()` og `func3()`. Hver av disse itererer gjennom en rekke tall og skriver dem ut. Deretter introduseres en forsinkelse med `time.sleep()`. Vi bruker forskjellige forsinkelser i hver funksjon for å vise hvordan programutførelsen bytter mellom tråder:
import time
import threading
def func1():
for i in range(5):
print(f"Kjører t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Kjører t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Kjører t3, print {i}.")
time.sleep(0.5)
I Python kan man lage et trådobjekt med `threading.Thread()`. Syntaksen for dette er `threading.Thread(target = …, args = …)`, som oppretter en tråd som kjører `target`-funksjonen med argumentene angitt i `args`.
I vårt tilfelle har `func1`, `func2` og `func3` ingen argumenter. Derfor kan vi bare spesifisere funksjonsnavnet som `target` når vi oppretter tråder. Vi definerer trådobjektene `t1`, `t2` og `t3` med `func1`, `func2` og `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()
Her er hele koden:
import time
import threading
def func1():
for i in range(5):
print(f"Kjører t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Kjører t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Kjører 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()
Legg merke til hvordan utførelsen veksler mellom de tre trådene. Tråd `t3` har den korteste ventetiden og vil derfor slippe raskest til. Tråd `t1` har den lengste ventetiden og vil være den siste som fullfører.
For mer informasjon om dette, se introduksjonen til multitråding i Python.
Oppsummering
I denne opplæringen har vi sett hvordan vi kan bruke `time.sleep()` til å legge inn forsinkelser i kode.
Vi har gått gjennom:
- Hvordan du kan kalle `sleep()` fra `time`-modulen (`time.sleep()`).
- Hvordan man forsinker utførelsen med et angitt antall sekunder (`time.sleep(n)`).
- Hvordan man kan bruke `sleep()` i en løkke med variable forsinkelser.
- Hvordan lage en nedtellingstidtaker.
- Hvordan `sleep()` fungerer med multitråding.
Du kan nå utforske mer avanserte funksjoner i `time`-modulen. Hvis du vil jobbe med datoer og klokkeslett, kan du utforske `datetime` og `calendar`-modulene i tillegg.
Lær mer om hvordan du beregner tidsforskjell i Python.⏰