Как да добавите забавяния към кода

Този урок ще ви научи как да използвате функцията sleep() от вградения модул за време на Python, за да добавите времеви забавяния към кода.

Когато изпълнявате проста програма на Python, изпълнението на кода се извършва последователно — един оператор след друг — без забавяне във времето. В някои случаи обаче може да се наложи да забавите изпълнението на кода. Функцията sleep() от вградения в Python модул за време ви помага да направите това.

В този урок ще научите синтаксиса за използване на функцията sleep() в Python и няколко примера, за да разберете как работи. Да започваме!

Синтаксис на Python time.sleep()

Модулът за време, вграден в стандартната библиотека на Python, предоставя няколко полезни функции, свързани с времето. Като първа стъпка импортирайте модула за време във вашата работна среда:

import time

Тъй като функцията sleep() е част от модула за време, сега можете да получите достъп и да я използвате със следния общ синтаксис:

time.sleep(n) 

Тук n е броят секунди за заспиване. Може да бъде цяло число или число с плаваща запетая.

Понякога необходимото забавяне може да бъде няколко милисекунди. В тези случаи можете да конвертирате продължителността в милисекунди в секунди и да я използвате в извикването на функцията за заспиване. Например, ако искате да въведете забавяне от 100 милисекунди, можете да го посочите като 0,1 секунда: time.sleep(0,1).

▶ Можете също да импортирате само функцията за заспиване от часовия модул:

from time import sleep

Ако използвате горния метод за импортиране, можете да извикате функцията sleep() директно – без да използвате time.sleep().

Сега, след като научихте синтаксиса на функцията sleep() на Python, нека кодираме примери, за да видим функцията в действие. Можете да изтеглите скриптовете на Python, използвани в този урок, от папката python-sleep в това репо на GitHub. 👩🏽‍💻

Забавяне на изпълнението на код с sleep()

Като първи пример, нека използваме функцията за заспиване, за да забавим изпълнението на проста програма на Python.

  Как да конвертирате WAV в MP3

В следния кодов фрагмент:

  • Първият оператор print() се изпълнява без никакво забавяне.
  • След това въвеждаме забавяне от 5 секунди с помощта на функцията sleep().
  • Вторият оператор print() ще бъде изпълнен само след като приключи операцията за заспиване.
# /python-sleep/simple_example.py
import time

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

Сега стартирайте файла simple_example.py и наблюдавайте резултата:

$ python3 simple_example.py

Добавяне на различни забавяния към кодов блок

В предишния пример въведохме фиксирано забавяне от 5 секунди между изпълнението на два оператора print(). След това нека кодираме друг пример, за да въведем различни времена на забавяне, когато преминаваме през итерируем.

В този пример бихме искали да направим следното:

  • Прегледайте изречение, достъпете всяка дума и я отпечатайте.
  • След като отпечатаме всяка дума, бихме искали да изчакаме определен период от време, преди да отпечатаме следващата дума в изречението.

Преминаване през низ от низове

Помислете за низа, изречението. Това е низ, където всяка дума е низ сама по себе си.

Ако преминем през низа, ще получим всеки знак, както е показано:

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

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

Но това не е, което искаме. Бихме искали да преминем през изречението и да имаме достъп до всяка дума. За да направим това, можем да извикаме метода split() на низа на изречението. Това ще върне списък от низове – получен чрез разделяне на низа на изречението – за всички появявания на интервали.

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

# Output
How
long
will
this
take?

Преминаване през итерируеми елементи с различни закъснения

Нека преразгледаме примера:

  • изречение е низът, през който бихме искали да преминем, за да имаме достъп до всяка дума.
  • delay_times е списъкът с времена на забавяне, които ще използваме като аргумент на функцията sleep() по време на всяко преминаване през цикъла.

Тук бихме искали едновременно да преминем през два списъка: списъкът delay_times и списъкът с низове, получени чрез разделяне на низа на изречението. Можете да използвате функцията zip(), за да извършите тази паралелна итерация.

Функцията zip() на Python: zip(list1, list2) връща итератор от кортежи, където всеки кортеж съдържа елемента с индекс i в списък1 и списък2.

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

Без функцията за заспиване управлението веднага ще премине към следващата итерация. Тъй като въведохме забавяне, следващото преминаване през цикъла се случва само след като операцията за заспиване приключи.

  11 начина за коригиране на код за грешка 523 на Roblox

Сега стартирайте delay_times.py и наблюдавайте резултата:

$ python3 delay_times.py

Следващите думи в низа ще бъдат отпечатани след забавяне. Забавянето след отпечатването на думата с индекс i в низа е числото с индекс i в списъка delay_times.

Таймер за обратно отброяване в Python

Като следващ пример, нека кодираме прост таймер за обратно отброяване в Python.

Нека дефинираме функция 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)

След това нека анализираме дефиницията на функцията countDown():

  • Функцията приема число n като аргумент и отброява до нула, започвайки от това число n.
  • Използваме time.sleep(1), за да постигнем забавяне от една секунда между броенето.
  • Когато броячът достигне 0, функцията отпечатва „Готово за работа!“.

🎯 За да постигнем операцията за обратно броене, използвахме функцията range() с отрицателна стойност на стъпка от -1. range(n, -1, -1) ще ни помогне да преминем през диапазона от числа в n, n – 1, n – 2 и така нататък до нула. Спомнете си, че крайната точка е изключена по подразбиране, когато използвате функцията range().

След това нека добавим извикване към функцията countDown() с 5 като аргумент.

countDown(5)

Сега стартирайте скрипта countdown.py и вижте функцията countDown в действие!

$ python3 countdown.py

Функция за заспиване при многопоточност

Модулът за нишки на Python предлага готови възможности за многонишковост. В Python Global Interpreter Lock или GIL гарантира, че има само една активна нишка, работеща във всеки един момент.

Въпреки това, по време на I/O операции и операции на изчакване, като заспиване, процесорът може да спре изпълнението на текущата нишка и да превключи към друга нишка, която чака.

За да разберем как работи това, нека вземем пример.

Създаване и изпълнение на нишки в Python

Разгледайте следните функции, func1(), func2() и func3(). Те преминават през диапазон от числа и ги отпечатват. Това е последвано от операция на заспиване – за определен брой секунди – по време на всяко преминаване през цикъла. Използвахме различни времена на забавяне за всяка от функциите, за да разберем по-добре как изпълнението превключва между нишки едновременно.

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)

В Python можете да използвате конструктора Thread(), за да създадете обект на нишка. Използвайки синтаксиса threading.Thread(target = …, args = …) създава нишка, която изпълнява целевата функция с аргумента, посочен в кортежа args.

  SQL тригери: Основното ръководство

В този пример функциите func1, func2 и func3 не приемат никакви аргументи. Така че е достатъчно да посочите само името на функцията като цел. След това дефинираме обекти на нишка, t1, t2 и t3 с func1, func2 и func3 като цели, съответно.

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

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

Ето пълния код за примера за резба:

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

Наблюдавайте изхода. Изпълнението се променя между трите нишки. Нишката t3 има най-малко време на изчакване, така че е спряна за най-малко време. Нишка t1 има най-дългата продължителност на заспиване от две секунди, така че това е последната нишка, която завършва изпълнението.

За да научите повече, прочетете урока за основите на многонишковостта в Python.

Заключение

В този урок научихте как да използвате функцията sleep() на Python, за да добавите времеви забавяния към кода.

Можете да получите достъп до функцията sleep() от вградения модул за време, time.sleep(). За да забавите изпълнението с n секунди, използвайте time.sleep(n). Също така сте виждали примери за забавяне на последващи итерации в цикъл чрез различни стойности, обратно броене и многопоточност.

Вече можете да изследвате по-разширени възможности на модула за време. Искате ли да работите с дати и часове в Python? В допълнение към модула за време можете да използвате функционалността на модулите за дата, час и календар.

След това се научете да изчислявате часовата разлика в Python.⏰

x