Denne tutorial vil lære dig, hvordan du bruger sleep()-funktionen fra Pythons indbyggede tidsmodul til at tilføje tidsforsinkelser til kode.
Når du kører et simpelt Python-program, sker kodeudførelsen sekventielt – den ene sætning efter den anden – uden nogen tidsforsinkelse. Det kan dog være nødvendigt at forsinke udførelsen af kode i nogle tilfælde. Sleep()-funktionen fra Pythons indbyggede tidsmodul hjælper dig med at gøre dette.
I denne vejledning lærer du syntaksen for at bruge sleep()-funktionen i Python og flere eksempler for at forstå, hvordan det virker. Lad os komme igang!
Indholdsfortegnelse
Syntaks for Python time.sleep()
Tidsmodulet, der er indbygget i Python-standardbiblioteket, giver flere nyttige tidsrelaterede funktioner. Som et første trin skal du importere tidsmodulet til dit arbejdsmiljø:
import time
Da sleep()-funktionen er en del af tidsmodulet, kan du nu få adgang til og bruge den med følgende generelle syntaks:
time.sleep(n)
Her er n antallet af sekunder til at sove. Det kan være et heltal eller et flydende kommatal.
Nogle gange kan den nødvendige forsinkelse være et par millisekunder. I disse tilfælde kan du konvertere varigheden i millisekunder til sekunder og bruge den i opkaldet til dvalefunktionen. For eksempel, hvis du vil indføre en forsinkelse på 100 millisekunder, kan du angive den som 0,1 sekund: time.sleep(0,1).
▶ Du kan også kun importere dvalefunktionen fra tidsmodulet:
from time import sleep
Hvis du bruger ovenstående metode til at importere, kan du derefter kalde sleep()-funktionen direkte – uden at bruge time.sleep().
Nu hvor du har lært syntaksen for Python sleep()-funktionen, lad os kode eksempler for at se funktionen i aktion. Du kan downloade Python-scripts, der bruges i denne tutorial, fra python-sleep-mappen i denne GitHub-repo. 👩🏽💻
Forsinket udførelse af kode med sleep()
Som et første eksempel, lad os bruge sleep-funktionen til at forsinke udførelsen af et simpelt Python-program.
I følgende kodestykke:
- Den første print()-sætning udføres uden nogen forsinkelse.
- Vi introducerer derefter en forsinkelse på 5 sekunder ved hjælp af sleep()-funktionen.
- Den anden print()-sætning udføres først, når dvaleoperationen er afsluttet.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Kør nu filen simple_example.py og observer outputtet:
$ python3 simple_example.py
Tilføj forskellige forsinkelser til en kodeblok
I det foregående eksempel introducerede vi en fast forsinkelse på 5 sekunder mellem udførelsen af to print()-sætninger. Lad os derefter kode et andet eksempel for at introducere forskellige forsinkelsestider, når vi går gennem en iterable.
I dette eksempel vil vi gerne gøre følgende:
- Gå gennem en sætning, få adgang til hvert ord, og print det ud.
- Efter at have udskrevet hvert ord, vil vi gerne vente i en bestemt tidsperiode – før vi udskriver det næste ord i sætningen.
Sløjfe gennem en streng af strenge
Overvej strengen, sætningen. Det er en streng, hvor hvert ord er en streng i sig selv.
Hvis vi går gennem strengen, får vi hvert tegn, som vist:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Men det er ikke det, vi ønsker. Vi vil gerne gå gennem sætningen og få adgang til hvert ord. For at gøre dette kan vi kalde split()-metoden på sætningsstrengen. Dette vil returnere en liste over strenge – opnået ved at opdele sætningsstrengen – på alle forekomster af mellemrum.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Looping gennem Iterables med forskellige forsinkelser
Lad os gense eksemplet:
- sætning er den streng, vi gerne vil sløjfe igennem for at få adgang til hvert ord.
- delay_times er listen over forsinkelsestider, vi vil bruge som argument til sleep()-funktionen under hver passage gennem løkken.
Her vil vi gerne gå gennem to lister samtidigt: forsinkelsestider-listen og listen over strenge opnået ved at opdele sætningsstrengen. Du kan bruge zip()-funktionen til at udføre denne parallelle iteration.
Python zip()-funktionen: zip(liste1, liste2) returnerer en iterator af tupler, hvor hver tuple indeholder elementet ved indeks i i liste1 og liste2.
# /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)
Uden dvalefunktionen ville kontrollen straks fortsætte til næste iteration. Fordi vi har indført en forsinkelse, sker den næste passage gennem sløjfen først, efter at dvaleoperationen er fuldført.
Kør nu delay_times.py og observer outputtet:
$ python3 delay_times.py
De efterfølgende ord i strengen vil blive printet ud efter en forsinkelse. Forsinkelsen efter udskrivning af ordet ved indeks i i strengen er tallet ved indeks i i listen over delay_times.
Nedtællingstimer i Python
Som et næste eksempel, lad os kode en simpel nedtællingstimer i Python.
Lad os definere en funktion 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)
Lad os derefter analysere definitionen af funktionen countDown():
- Funktionen tager et tal n som argument og tæller ned til nul fra det tal n.
- Vi bruger time.sleep(1) til at opnå en forsinkelse på et sekund mellem tællingerne.
- Når optællingen når 0, udskriver funktionen “Klar til start!”.
🎯 For at opnå nedtællingsoperationen har vi brugt range()-funktionen med en negativ trinværdi på -1. range(n, -1, -1) hjælper os med at gå gennem rækken af tal i n, n – 1, n – 2 og så videre op til nul. Husk, at slutpunktet er udelukket som standard, når du bruger range()-funktionen.
Lad os derefter tilføje et kald til countDown()-funktionen med 5 som argument.
countDown(5)
Kør nu scriptet countdown.py og se nedtællingsfunktionen i aktion!
$ python3 countdown.py
Søvnfunktion i Multithreading
Python threading modul tilbyder out-of-the-box multithreading muligheder. I Python sikrer Global Interpreter Lock eller GIL, at der kun kører én aktiv tråd på ethvert tidspunkt.
Imidlertid kan processoren under I/O-operationer og venteoperationer, såsom dvale, suspendere udførelsen af den aktuelle tråd og skifte til en anden tråd, der venter.
For at forstå, hvordan dette fungerer, lad os tage et eksempel.
Oprettelse og kørsel af tråde i Python
Overvej følgende funktioner, func1(), func2() og func3(). De går gennem en række tal og udskriver dem. Dette efterfølges af en dvaleoperation – i et bestemt antal sekunder – under hver passage gennem løkken. Vi har brugt forskellige forsinkelsestider for hver af funktionerne for bedre at forstå, hvordan udførelsen skifter mellem tråde samtidigt.
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)
I Python kan du bruge Thread()-konstruktøren til at instansiere et trådobjekt. Ved at bruge syntaksen threading.Thread(target = …, args = …) oprettes en tråd, der kører målfunktionen med argumentet angivet i args-tuplen.
I dette eksempel tager funktionerne func1, func2 og func3 ingen argumenter ind. Så det er tilstrækkeligt kun at angive navnet på funktionen som målet. Vi definerer derefter trådobjekter, t1, t2 og t3 med henholdsvis func1, func2 og func3 som målene.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Her er den komplette kode til trådeksemplet:
# /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()
Observer outputtet. Udførelsen skifter mellem de tre tråde. Tråden t3 har den laveste ventetid, så den er suspenderet i mindst tid. Tråd t1 har den længste søvnvarighed på to sekunder, så det er den sidste tråd, der afslutter eksekveringen.
For at lære mere, læs selvstudiet om det grundlæggende i multithreading i Python.
Konklusion
I denne tutorial har du lært, hvordan du bruger Pythons sleep()-funktion til at tilføje tidsforsinkelser til kode.
Du kan få adgang til sleep()-funktionen fra det indbyggede tidsmodul time.sleep(). Brug time.sleep(n) for at forsinke udførelsen med n sekunder. Du har også set eksempler på at forsinke efterfølgende iterationer i en loop med forskellige værdier, nedtælling og multithreading.
Du kan nu udforske mere avancerede funktioner i tidsmodulet. Vil du arbejde med datoer og tidspunkter i Python? Ud over tidsmodulet kan du udnytte funktionaliteten af datetime og kalendermodulerne.
Dernæst skal du lære at beregne tidsforskel i Python.⏰