Hvordan legge til forsinkelser i kode

Denne opplæringen vil lære deg hvordan du bruker sleep()-funksjonen fra Pythons innebygde tidsmodul for å legge til tidsforsinkelser i kode.

Når du kjører et enkelt Python-program, skjer kjøringen av koden sekvensielt – den ene setningen etter den andre – uten noen tidsforsinkelse. Imidlertid kan det hende du må utsette utføringen av kode i noen tilfeller. Sleep()-funksjonen fra Python innebygde tidsmodul hjelper deg med dette.

I denne opplæringen lærer du syntaksen for å bruke sleep()-funksjonen i Python og flere eksempler for å forstå hvordan den fungerer. La oss komme i gang!

Syntaks for Python time.sleep()

Tidsmodulen, innebygd i Python-standardbiblioteket, gir flere nyttige tidsrelaterte funksjoner. Som et første trinn, importer tidsmodulen til arbeidsmiljøet ditt:

import time

Siden sleep()-funksjonen er en del av tidsmodulen, kan du nå få tilgang til og bruke den med følgende generelle syntaks:

time.sleep(n) 

Her er n antall sekunder å sove. Det kan være et heltall eller et flyttall.

Noen ganger kan den nødvendige forsinkelsen være noen få millisekunder. I disse tilfellene kan du konvertere varigheten i millisekunder til sekunder og bruke den i anropet til dvalefunksjonen. Hvis du for eksempel vil innføre en forsinkelse på 100 millisekunder, kan du angi den som 0,1 sekund: time.sleep(0,1).

▶ Du kan også importere bare dvalefunksjonen fra tidsmodulen:

from time import sleep

Hvis du bruker metoden ovenfor for å importere, kan du kalle sleep()-funksjonen direkte – uten å bruke time.sleep().

Nå som du har lært syntaksen til Python sleep()-funksjonen, la oss kode eksempler for å se funksjonen i aksjon. Du kan laste ned Python-skriptene som brukes i denne opplæringen fra python-sleep-mappen i denne GitHub-repoen. 👩🏽‍💻

Forsinket kjøring av kode med dvale()

Som et første eksempel, la oss bruke dvalefunksjonen til å forsinke utførelsen av et enkelt Python-program.

I følgende kodebit:

  • Den første print()-setningen utføres uten forsinkelse.
  • Vi introduserer deretter en forsinkelse på 5 sekunder ved å bruke sleep()-funksjonen.
  • Den andre print()-setningen vil bli utført først etter at dvaleoperasjonen er ferdig.
# /python-sleep/simple_example.py
import time

print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")

Kjør nå filen simple_example.py og observer utdataene:

$ python3 simple_example.py

Legg til forskjellige forsinkelser i en kodeblokk

I forrige eksempel introduserte vi en fast forsinkelse på 5 sekunder mellom utførelse av to print()-setninger. Deretter, la oss kode et annet eksempel for å introdusere forskjellige forsinkelsestider når du går gjennom en iterabel.

  6 beste ECAD-programvare for å designe elektroniske produkter

I dette eksemplet ønsker vi å gjøre følgende:

  • Gå gjennom en setning, få tilgang til hvert ord og skriv det ut.
  • Etter å ha skrevet ut hvert ord, vil vi gjerne vente i en bestemt tidsperiode – før vi skriver ut neste ord i setningen.

Looping gjennom en streng med strenger

Tenk på strengen, setningen. Det er en streng hvor hvert ord er en streng i seg selv.

Hvis vi går gjennom 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 dette vi ønsker. Vi vil gjerne gå gjennom setningen og få tilgang til hvert ord. For å gjøre dette kan vi kalle split()-metoden på setningsstrengen. Dette vil returnere en liste over strenger – oppnådd ved å dele opp setningsstrengen – på alle forekomster av mellomrom.

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

# Output
How
long
will
this
take?

Looping gjennom Iterables med forskjellige forsinkelser

La oss se på eksemplet på nytt:

  • setning er strengen vi ønsker å gå gjennom for å få tilgang til hvert ord.
  • delay_times er listen over forsinkelsestider vi vil bruke som argument for sleep()-funksjonen under hver passering gjennom løkken.

Her ønsker vi å gå gjennom to lister samtidig: forsinkelsestider-listen og listen over strenger oppnådd ved å dele setningsstrengen. Du kan bruke zip()-funksjonen til å utføre denne parallelle iterasjonen.

Python zip()-funksjonen: zip(liste1, liste2) returnerer en iterator av tupler, der hver tuppel inneholder 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)

Uten dvalefunksjonen ville kontrollen umiddelbart gå videre til neste iterasjon. Fordi vi har innført en forsinkelse, skjer neste passering gjennom sløyfen først etter at dvaleoperasjonen er fullført.

  Capsa er et omfattende nettverksanalyseverktøy for LAN og WLAN

Kjør nå delay_times.py og observer utgangen:

$ python3 delay_times.py

De påfølgende ordene i strengen vil bli skrevet ut etter en forsinkelse. Forsinkelsen etter utskrift av ordet ved indeks i i strengen er tallet ved indeks i i listen over forsinkelsestider.

Nedtellingstidtaker i Python

Som et neste eksempel, la oss kode en enkel nedtellingstidtaker i Python.

La oss definere en funksjon 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)

Deretter, la oss analysere definisjonen av countDown()-funksjonen:

  • Funksjonen tar inn et tall n som argument og teller ned til null fra det tallet n.
  • Vi bruker time.sleep(1) for å oppnå en forsinkelse på ett sekund mellom tellingene.
  • Når tellingen når 0, skriver funksjonen ut «Klar til å gå!».

🎯 For å oppnå nedtellingsoperasjonen har vi brukt range()-funksjonen med en negativ trinnverdi på -1. range(n, -1, -1) vil hjelpe oss å gå gjennom rekkevidden av tall i n, n – 1, n – 2, og så videre opp til null. Husk at endepunktet er ekskludert som standard når du bruker range()-funksjonen.

La oss deretter legge til et kall til funksjonen countDown() med 5 som argument.

countDown(5)

Kjør nå skriptet countdown.py og se nedtellingsfunksjonen i aksjon!

$ python3 countdown.py

Sovefunksjon i multithreading

Python-trådingsmodul tilbyr ferdige multithreading-funksjoner. I Python sikrer Global Interpreter Lock eller GIL at det kun er én aktiv tråd som kjører til enhver tid.

Under I/O-operasjoner og venteoperasjoner som hvilemodus, kan imidlertid prosessoren suspendere utførelsen av gjeldende tråd og bytte til en annen tråd som venter.

For å forstå hvordan dette fungerer, la oss ta et eksempel.

Opprette og kjøre tråder i Python

Tenk på følgende funksjoner, func1(), func2() og func3(). De går gjennom en rekke tall og skriver dem ut. Dette etterfølges av en dvaleoperasjon – i et spesifikt antall sekunder – under hver passasje gjennom sløyfen. Vi har brukt forskjellige forsinkelsestider for hver av funksjonene for bedre å forstå hvordan utførelsen bytter mellom tråder samtidig.

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 bruke Thread()-konstruktøren til å instansiere et trådobjekt. Ved å bruke syntaksen threading.Thread(target = …, args = …) opprettes en tråd som kjører målfunksjonen med argumentet spesifisert i args-tuppelen.

  Vil du overleve ransomware? Slik beskytter du PC-en din

I dette eksemplet tar ikke funksjonene func1, func2 og func3 inn noen argumenter. Så det er nok å spesifisere bare navnet på funksjonen som målet. Vi definerer deretter trådobjekter, t1, t2 og t3 med henholdsvis 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 den komplette koden for 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 utgangen. Utførelsen veksler mellom de tre trådene. Tråden t3 har den laveste ventetiden, så den er suspendert i minst mulig tid. Tråd t1 har den lengste søvnvarigheten på to sekunder, så det er den siste tråden som fullfører utførelsen.

For å lære mer, les veiledningen om det grunnleggende om multithreading i Python.

Konklusjon

I denne opplæringen har du lært hvordan du bruker Pythons sleep()-funksjon for å legge til tidsforsinkelser i kode.

Du kan få tilgang til sleep()-funksjonen fra den innebygde tidsmodulen, time.sleep(). For å utsette utførelsen med n sekunder, bruk time.sleep(n). Du har også sett eksempler på å forsinke påfølgende iterasjoner i en løkke med forskjellige verdier, nedtelling og multithreading.

Du kan nå utforske mer avanserte funksjoner i tidsmodulen. Vil du jobbe med datoer og klokkeslett i Python? I tillegg til tidsmodulen kan du utnytte funksjonaliteten til dato- og kalendermodulene.

Deretter lærer du å beregne tidsforskjell i Python.⏰

x