Késések hozzáadása a kódhoz

Ez az oktatóanyag megtanítja Önnek, hogyan használhatja a Python beépített időmoduljában található sleep() függvényt, hogy késleltetést adjon a kódhoz.

Egy egyszerű Python-program futtatásakor a kód végrehajtása szekvenciálisan történik – egyik utasítás a másik után – minden késedelem nélkül. Előfordulhat azonban, hogy bizonyos esetekben késleltetnie kell a kód végrehajtását. A Python beépített időmoduljának sleep() függvénye segít ebben.

Ebben az oktatóanyagban megismerheti a sleep() függvény használatának szintaxisát a Pythonban, valamint számos példát, amelyekkel megértheti, hogyan működik. Kezdjük el!

A Python time.sleep() szintaxisa

A Python szabványkönyvtárába beépített időmodul számos hasznos időhöz kapcsolódó funkciót biztosít. Első lépésként importálja az időmodult a munkakörnyezetébe:

import time

Mivel a sleep() függvény az időmodul része, mostantól a következő általános szintaxissal érheti el és használhatja:

time.sleep(n) 

Itt n az alvásig eltöltött másodpercek száma. Ez lehet egész szám vagy lebegőpontos szám.

Néha a szükséges késleltetés néhány milliszekundum is lehet. Ezekben az esetekben az időtartamot ezredmásodpercben másodpercekre konvertálhatja, és felhasználhatja az alvó funkció hívásában. Például, ha 100 ezredmásodperces késleltetést szeretne bevezetni, akkor ezt 0,1 másodpercben adhatja meg: time.sleep(0,1).

▶ Az időmodulból csak az alvás funkciót is importálhatja:

from time import sleep

Ha a fenti módszert használja az importáláshoz, akkor közvetlenül hívhatja a sleep() függvényt – time.sleep() használata nélkül.

Most, hogy megtanulta a Python sleep() függvény szintaxisát, lássunk példákat kódolással, hogy lássuk a függvény működését. Az oktatóanyagban használt Python-szkriptek letölthetők a GitHub-tárhely python-sleep mappájából. 👩🏽‍💻

Késleltetett kódvégrehajtás alvással ()

Első példaként használjuk az alvás funkciót egy egyszerű Python program végrehajtásának késleltetésére.

A következő kódrészletben:

  • Az első print() utasítás késedelem nélkül végrehajtódik.
  • Ezután 5 másodperces késleltetést vezetünk be a sleep() függvény segítségével.
  • A második print() utasítás csak az alvási művelet befejezése után kerül végrehajtásra.
# /python-sleep/simple_example.py
import time

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

Most futtassa a simple_example.py fájlt, és figyelje meg a kimenetet:

$ python3 simple_example.py

Különböző késleltetések hozzáadása egy kódblokkhoz

Az előző példában fix 5 másodperces késleltetést vezettünk be két print() utasítás végrehajtása között. Ezután kódoljunk egy másik példát, hogy különböző késleltetési időket vezessünk be egy iterálható cikluson keresztül.

  Hogyan lehet megakadályozni a Chromecast eltérítését egy megosztott hálózaton

Ebben a példában a következőket szeretnénk tenni:

  • Lapozzon végig egy mondaton, érje el az egyes szavakat, és nyomtassa ki.
  • Az egyes szavak kinyomtatása után szeretnénk várni egy meghatározott ideig – mielőtt kinyomtatjuk a mondat következő szavát.

Hurok egy húron keresztül

Tekintsük a karakterláncot, mondatot. Ez egy karakterlánc, ahol minden szó önmagában egy karakterlánc.

Ha végigpörgetjük a karakterláncot, minden karaktert megkapunk, ahogy az ábrán látható:

>>> sentence = "How long will this take?"
>>> for char in sentence:
...     print(char)

# Output (truncated for readability)
H
o
w
.
.
.
t
a
k
e
?

De nem ezt akarjuk. Szeretnénk végigfutni a mondaton, és hozzáférni az egyes szavakhoz. Ehhez meghívhatjuk a split() metódust a mondatban. Ez visszaadja a karakterláncok listáját – amelyet a mondatkarakterlánc felosztásával kapunk – a szóközök minden előfordulásakor.

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

# Output
How
long
will
this
take?

Iterables ciklusok különböző késleltetésekkel

Nézzük újra a példát:

  • A mondat az a karakterlánc, amelyen keresztül szeretnénk elérni az egyes szavakat.
  • A delay_times azoknak a késleltetési időknek a listája, amelyeket a sleep() függvény argumentumaként használunk a cikluson való minden egyes áthaladás során.

Itt egyidejűleg két listán szeretnénk végigmenni: a delay_times listán és a mondatfüzér felosztásával kapott karakterláncok listáján. A párhuzamos iteráció végrehajtásához használhatja a zip() függvényt.

A Python zip() függvénye: a zip(lista1, lista2) egy sor iterátort ad vissza, ahol minden sor tartalmazza az i indexen lévő elemet a list1 és list2 listában.

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

Az alvás funkció nélkül a vezérlés azonnal továbblép a következő iterációra. Mivel késleltetést vezettünk be, a hurkon következő áthaladás csak az alvási művelet befejezése után következik be.

Most futtassa a delay_times.py fájlt, és figyelje meg a kimenetet:

$ python3 delay_times.py

A karakterlánc következő szavai késleltetés után kinyomtatásra kerülnek. A karakterlánc i indexénél lévő szó kinyomtatása utáni késleltetés az i indexnél lévő szám a delay_times listában.

  Alkalmazás- és játékkorlátok beállítása Xbox One-on

Visszaszámláló Pythonban

Következő példaként kódoljunk egy egyszerű visszaszámlálót Pythonban.

Definiáljunk egy countDown() függvényt:

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

Ezután elemezzük a countDown() függvény definícióját:

  • A függvény argumentumként egy n számot vesz fel, és ettől az n számtól kezdve nulláig számol vissza.
  • A time.sleep(1) segítségével egy másodperces késleltetést érünk el a számlálások között.
  • Amikor a szám eléri a 0-t, a funkció kiírja a „Készen áll!” üzenetet.

🎯 A visszaszámlálási művelet eléréséhez a range() függvényt használtuk, negatív lépésértékkel -1. A range(n, -1, -1) segít átugrani az n, n – 1, n – 2 és így tovább nulláig terjedő számok tartományát. Emlékezzünk vissza, hogy a végpont alapértelmezés szerint ki van zárva a range() függvény használatakor.

Ezután adjunk hozzá egy hívást a countDown() függvényhez 5-tel.

countDown(5)

Most futtassa a countdown.py szkriptet, és nézze meg a CountDown funkciót működés közben!

$ python3 countdown.py

Alvó funkció a többszálú üzemmódban

A Python szálfűző modul azonnali többszálas képességeket kínál. A Pythonban a Global Interpreter Lock vagy GIL biztosítja, hogy egy adott időpontban csak egy aktív szál fut.

Az I/O műveletek és a várakozási műveletek, például az alvás közben azonban a processzor felfüggesztheti az aktuális szál végrehajtását, és átválthat egy másik várakozó szálra.

Hogy megértsük, hogyan működik ez, vegyünk egy példát.

Szálak létrehozása és futtatása Pythonban

Tekintsük a következő függvényeket: func1(), func2() és func3(). Végigpörögnek egy számtartományon, és kinyomtatják azokat. Ezt egy alvó művelet követi – meghatározott számú másodpercig – a hurkon való minden egyes áthaladás során. Különböző késleltetési időket használtunk az egyes funkciókhoz, hogy jobban megértsük, hogyan vált a végrehajtás egyidejűleg a szálak között.

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)

A Pythonban a Thread() konstruktor segítségével példányosíthat szálobjektumot. A Thread(target = …, args = …) egy szálat hoz létre, amely a célfüggvényt az args sorában megadott argumentummal futtatja.

  A HomePod mini vagy a HomePod frissítése

Ebben a példában a func1, func2 és func3 függvények nem vesznek fel semmilyen argumentumot. Tehát elegendő csak a függvény nevét megadni célként. Ezután meghatározzuk a t1, t2 és t3 szálobjektumokat, amelyek célpontjai a func1, func2 és func3.

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

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

Íme a szálfűzési példa teljes kódja:

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

Figyelje meg a kimenetet. A végrehajtás a három szál között változik. A t3 szálnak van a legalacsonyabb várakozási ideje, tehát a legkevesebb ideig van felfüggesztve. A t1 szálnak van a leghosszabb alvási időtartama, két másodperc, tehát ez az utolsó szál, amely befejezi a végrehajtást.

Ha többet szeretne megtudni, olvassa el a Python többszálú kezelésének alapjairól szóló oktatóanyagot.

Következtetés

Ebben az oktatóanyagban megtanulta, hogyan használhatja a Python sleep() függvényét, hogy késleltetést adjon a kódhoz.

A sleep() függvényt a beépített time.sleep() időmodulból érhetjük el. A végrehajtás n másodperccel történő késleltetéséhez használja a time.sleep(n) parancsot. Látott már példákat arra is, hogyan késleltetheti a ciklus következő iterációit különböző értékekkel, visszaszámlálással és többszálú kezeléssel.

Mostantól felfedezheti az időmodul fejlettebb lehetőségeit. Szeretne dátumokkal és időpontokkal dolgozni a Pythonban? Az időmodulon kívül kihasználhatja a dátum-idő és a naptár modulok funkcionalitását.

Ezután tanulja meg az időkülönbség kiszámítását Pythonban.⏰