Hur man lägger till fördröjningar i koden

Spread the love

Denna handledning kommer att lära dig hur du använder sleep()-funktionen från Pythons inbyggda tidsmodul för att lägga till tidsfördröjningar till kod.

När du kör ett enkelt Python-program sker kodexekveringen sekventiellt – den ena satsen efter den andra – utan någon tidsfördröjning. Du kan dock behöva fördröja exekveringen av kod i vissa fall. Sleep()-funktionen från Pythons inbyggda tidsmodul hjälper dig att göra detta.

I den här handledningen kommer du att lära dig syntaxen för att använda sleep()-funktionen i Python och flera exempel för att förstå hur det fungerar. Låt oss börja!

Syntax för Python time.sleep()

Tidsmodulen, inbyggd i Python-standardbiblioteket, tillhandahåller flera användbara tidsrelaterade funktioner. Som ett första steg, importera tidsmodulen till din arbetsmiljö:

import time

Eftersom sleep()-funktionen är en del av tidsmodulen kan du nu komma åt och använda den med följande allmänna syntax:

time.sleep(n) 

Här är n antalet sekunder att sova. Det kan vara ett heltal eller ett flyttal.

Ibland kan den nödvändiga fördröjningen vara några millisekunder. I dessa fall kan du konvertera varaktigheten i millisekunder till sekunder och använda den i anropet till vilofunktionen. Om du till exempel vill införa en fördröjning på 100 millisekunder, kan du ange den som 0,1 sekund: time.sleep(0,1).

▶ Du kan också importera endast vilofunktionen från tidsmodulen:

from time import sleep

Om du använder metoden ovan för att importera kan du anropa sleep()-funktionen direkt – utan att använda time.sleep().

Nu när du har lärt dig syntaxen för Python sleep()-funktionen, låt oss koda exempel för att se funktionen i funktion. Du kan ladda ner Python-skripten som används i denna handledning från mappen python-sleep i denna GitHub-repo. 👩🏽‍💻

Fördröj kodexekvering med sleep()

Som ett första exempel, låt oss använda vilofunktionen för att fördröja exekveringen av ett enkelt Python-program.

I följande kodavsnitt:

  • Den första print()-satsen exekveras utan dröjsmål.
  • Vi introducerar sedan en fördröjning på 5 sekunder med hjälp av sleep()-funktionen.
  • Den andra print()-satsen kommer att exekveras först efter att viloläget är avslutat.
# /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 och observera resultatet:

$ python3 simple_example.py

Lägg till olika fördröjningar i ett kodblock

I det föregående exemplet introducerade vi en fast fördröjning på 5 sekunder mellan exekveringen av två print()-satser. Låt oss sedan koda ett annat exempel för att introducera olika fördröjningstider när man loopar genom en iterabel.

  Vilken ska du köpa?

I det här exemplet skulle vi vilja göra följande:

  • Gå igenom en mening, gå till varje ord och skriv ut det.
  • Efter att ha skrivit ut varje ord vill vi vänta en viss tidsperiod – innan vi skriver ut nästa ord i meningen.

Slinga genom en sträng av strängar

Tänk på strängen, meningen. Det är en sträng där varje ord är en sträng i sig.

Om vi ​​går igenom strängen får vi varje tecken, som visas:

>>> 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 här är inte vad vi vill. Vi skulle vilja gå igenom meningen och komma åt varje ord. För att göra detta kan vi anropa split()-metoden på meningssträngen. Detta kommer att returnera en lista med strängar – erhållna genom att dela upp meningssträngen – på alla förekomster av blanksteg.

>>> sentence.split()
['How', 'long', 'will', 'this', 'take?']
>>> for word in sentence.split():
...     print(word)

# Output
How
long
will
this
take?

Loopar genom Iterables med olika fördröjningar

Låt oss återgå till exemplet:

  • meningen är strängen vi vill gå igenom för att komma åt varje ord.
  • delay_times är listan över fördröjningstider som vi kommer att använda som argument till sleep()-funktionen under varje passage genom slingan.

Här skulle vi vilja gå igenom två listor samtidigt: listan delay_times och listan med strängar som erhålls genom att dela upp meningssträngen. Du kan använda zip()-funktionen för att utföra denna parallella iteration.

Python zip()-funktionen: zip(lista1, lista2) returnerar en iterator av tupler, där varje tupel innehåller objektet vid index i i list1 och 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)

Utan vilofunktionen skulle kontrollen omedelbart fortsätta till nästa iteration. Eftersom vi har infört en fördröjning sker nästa passage genom slingan först efter att viloläget är klar.

  Hur man ändrar ett Microsoft Word-dokument till en CSV-fil

Kör nu delay_times.py och observera resultatet:

$ python3 delay_times.py

De efterföljande orden i strängen kommer att skrivas ut efter en fördröjning. Fördröjningen efter att ha skrivit ut ordet vid index i i strängen är numret vid index i i delay_times-listan.

Nedräkningstimer i Python

Som ett nästa exempel, låt oss koda en enkel nedräkningstimer i Python.

Låt oss definiera 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)

Låt oss sedan analysera definitionen av funktionen countDown():

  • Funktionen tar in ett tal n som argument och räknar ner till noll från det numret n.
  • Vi använder time.sleep(1) för att uppnå en fördröjning på en sekund mellan räkningarna.
  • När räkningen når 0, skriver funktionen ut ”Redo to go!”.

🎯 För att uppnå nedräkningsoperationen har vi använt funktionen range() med ett negativt stegvärde på -1. range(n, -1, -1) hjälper oss att gå igenom talintervallet i n, n – 1, n – 2 och så vidare upp till noll. Kom ihåg att slutpunkten exkluderas som standard när du använder funktionen range().

Låt oss sedan lägga till ett anrop till funktionen countDown() med 5 som argument.

countDown(5)

Kör nu skriptet countdown.py och se nedräkningsfunktionen i aktion!

$ python3 countdown.py

Sömnfunktion i Multithreading

Python-trådningsmodulen erbjuder färdiga flertrådsfunktioner. I Python säkerställer Global Interpreter Lock eller GIL att det bara finns en aktiv tråd som körs vid varje tidpunkt.

Under I/O-operationer och vänteoperationer som viloläge kan dock processorn avbryta exekveringen av den aktuella tråden och byta till en annan tråd som väntar.

För att förstå hur detta fungerar, låt oss ta ett exempel.

Skapa och köra trådar i Python

Tänk på följande funktioner, func1(), func2() och func3(). De går igenom ett antal nummer och skriver ut dem. Detta följs av en vilooperation – under ett visst antal sekunder – under varje passage genom slingan. Vi har använt olika fördröjningstider för var och en av funktionerna för att bättre förstå hur exekveringen växlar mellan trådar 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 använda Thread()-konstruktorn för att instansiera ett trådobjekt. Genom att använda syntaxen threading.Thread(target = …, args = …) skapas en tråd som kör målfunktionen med argumentet som anges i args-tuppeln.

  Hur man ansluter vilken smart enhet som helst till HomeKit (med en Raspberry Pi)

I det här exemplet tar inte funktionerna func1, func2 och func3 in några argument. Så det räcker med att endast ange namnet på funktionen som mål. Vi definierar sedan trådobjekt, t1, t2 och t3 med func1, func2 och func3 som mål respektive.

t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)

t1.start()
t2.start()
t3.start()

Här är den fullständiga koden för trådningsexemplet:

# /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()

Observera utgången. Utförandet växlar mellan de tre trådarna. Tråden t3 har den lägsta väntetiden, så den är avstängd under minsta möjliga tid. Tråd t1 har den längsta vilotiden på två sekunder, så det är den sista tråden som avslutar exekveringen.

För att lära dig mer, läs handledningen om grunderna för multithreading i Python.

Slutsats

I den här handledningen har du lärt dig hur du använder Pythons sleep()-funktion för att lägga till tidsfördröjningar i koden.

Du kan komma åt sleep()-funktionen från den inbyggda tidsmodulen, time.sleep(). För att fördröja exekveringen med n sekunder, använd time.sleep(n). Du har också sett exempel på att fördröja efterföljande iterationer i en loop med olika värden, nedräkning och multitrådning.

Du kan nu utforska mer avancerade funktioner i tidsmodulen. Vill du arbeta med datum och tider i Python? Utöver tidsmodulen kan du utnyttja funktionaliteten i modulerna datetime och kalender.

Därefter lär du dig att beräkna tidsskillnaden i Python.⏰