Како додати кашњења у код

Овај водич ће вас научити како да користите функцију спавања() из Питхон-овог уграђеног временског модула за додавање временских одлагања коду.

Када покренете једноставан Питхон програм, извршавање кода се дешава узастопно — једна изјава за другом — без икаквог временског одлагања. Међутим, можда ћете морати да одложите извршење кода у неким случајевима. Функција слееп() из уграђеног временског модула Питхон-а вам помаже у томе.

У овом водичу ћете научити синтаксу коришћења функције слееп() у Питхон-у и неколико примера да бисте разумели како она функционише. Хајде да почнемо!

Синтакса Питхон-а тиме.слееп()

Модул времена, уграђен у стандардну библиотеку Питхон-а, пружа неколико корисних функција везаних за време. Као први корак, увезите временски модул у своје радно окружење:

import time

Како је функција слееп() део модула времена, сада јој можете приступити и користити је са следећом општом синтаксом:

time.sleep(n) 

Овде је н број секунди до спавања. Може бити цео број или број са покретним зарезом.

Понекад потребно кашњење може бити неколико милисекунди. У овим случајевима можете да конвертујете трајање у милисекундама у секунде и да га користите у позиву функције спавања. На пример, ако желите да уведете кашњење од 100 милисекунди, можете га одредити као 0,1 секунду: тиме.слееп(0,1).

▶ Такође можете увести само функцију спавања из временског модула:

from time import sleep

Ако користите горњи метод за увоз, тада можете директно позвати функцију слееп()—без употребе тиме.слееп().

Сада када сте научили синтаксу функције Питхон слееп(), хајде да напишемо примере кода да бисте видели функцију у акцији. Можете преузети Питхон скрипте које се користе у овом водичу из фасцикле питхон-слееп у овом ГитХуб репо-у. 👩🏽‍💻

  8 најбољих АИ претраживача за употребу као Гоогле алтернативе

Одложите извршење кода са слееп()

Као први пример, употребимо функцију спавања да одложимо извршавање једноставног Питхон програма.

У следећем исечку кода:

  • Прва изјава принт() се извршава без икаквог одлагања.
  • Затим уводимо кашњење од 5 секунди помоћу функције слееп().
  • Друга изјава принт() биће извршена тек након што се операција мировања заврши.
# /python-sleep/simple_example.py
import time

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

Сада покрените датотеку симпле_екампле.пи и посматрајте излаз:

$ python3 simple_example.py

Додајте различита кашњења у блок кода

У претходном примеру, увели смо фиксно кашњење од 5 секунди између извршења две изјаве принт(). Затим, хајде да кодирамо још један пример да уведемо различита времена кашњења при петљи кроз итерабле.

У овом примеру желимо да урадимо следеће:

  • Прођите кроз реченицу, приступите свакој речи и одштампајте је.
  • Након штампања сваке речи, желели бисмо да сачекамо одређено време—пре него што одштампамо следећу реч у реченици.

Петља кроз низ низова

Размотрите низ, реченицу. То је низ где је свака реч низ за себе.

Ако прођемо кроз стринг, добићемо сваки знак, као што је приказано:

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

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

Али ово није оно што желимо. Желели бисмо да прођемо кроз реченицу и приступимо свакој речи. Да бисмо то урадили, можемо позвати методу сплит() на стрингу реченице. Ово ће вратити листу стрингова—добијену поделом низа реченица—на свим појављивањима размака.

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

# Output
How
long
will
this
take?

Петља кроз итерабле са различитим кашњењима

Хајде да се вратимо на пример:

  • реченица је низ који желимо да прођемо да бисмо приступили свакој речи.
  • делаи_тимес је листа времена кашњења које ћемо користити као аргумент функцији слееп() током сваког проласка кроз петљу.

Овде бисмо желели да истовремено прођемо кроз две листе: листу делаи_тимес и листу стрингова добијених дељењем низа реченица. Можете користити зип() функцију да извршите ову паралелну итерацију.

  Да ли је Микпанел алтернатива Гоогле аналитике коју тражите?

Функција Питхон зип(): зип(лист1, лист2) враћа итератор торки, где сваки тупле садржи ставку са индексом и у листи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)

Без функције спавања, контрола би одмах прешла на следећу итерацију. Пошто смо увели кашњење, следећи пролаз кроз петљу се дешава тек након што се операција мировања заврши.

Сада покрените делаи_тимес.пи и посматрајте излаз:

$ python3 delay_times.py

Следеће речи у низу ће бити одштампане након одлагања. Кашњење након штампања речи са индексом и у низу је број у индексу и на листи делаи_тимес.

Тајмер за одбројавање у Питхон-у

Као следећи пример, хајде да кодирамо једноставан тајмер за одбројавање у Питхон-у.

Хајде да дефинишемо функцију цоунтДовн():

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

Затим, хајде да рашчланимо дефиницију функције цоунтДовн():

  • Функција узима број н као аргумент и одбројава до нуле почевши од тог броја н.
  • Користимо тиме.слееп(1) да постигнемо кашњење од једне секунде између бројања.
  • Када број достигне 0, функција исписује „Спремни за рад!“.

🎯 Да бисмо постигли операцију одбројавања, користили смо функцију ранге() са негативном вредношћу корака од -1. опсег(н, -1, -1) ће нам помоћи да прођемо кроз опсег бројева у н, н – 1, н – 2, и тако даље до нуле. Подсетимо се да је крајња тачка подразумевано искључена када се користи функција ранге().

Затим додајмо позив функцији цоунтДовн() са 5 као аргументом.

countDown(5)

Сада покрените скрипту цоунтдовн.пи и погледајте функцију цоунтДовн у акцији!

$ python3 countdown.py

Функција спавања у вишенитном раду

Питхон модул за обраду навојем нуди готове могућности вишенитног рада. У Питхон-у, Глобално закључавање тумача или ГИЛ осигурава да постоји само једна активна нит у било ком тренутку.

Међутим, током И/О операција и операција чекања као што је спавање, процесор може да суспендује извршење тренутне нити и да се пребаци на другу нит која чека.

  Како креирати анкете у иМессаге групним четовима на иПхоне-у и иПад-у

Да бисмо разумели како ово функционише, узмимо пример.

Креирање и покретање нити у Питхон-у

Размотрите следеће функције, фунц1(), фунц2() и фунц3(). Они провлаче низ бројева и штампају их. Ово је праћено операцијом спавања – на одређени број секунди – током сваког проласка кроз петљу. Користили смо различита времена кашњења за сваку од функција да бисмо боље разумели како се извршавање истовремено пребацује између нити.

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)

У Питхон-у можете користити конструктор Тхреад() за инстанцирање објекта нити. Користећи синтаксу тхреадинг.Тхреад(таргет = …, аргс = …) креира нит која покреће циљну функцију са аргументом наведеним у аргс тупле.

У овом примеру функције, фунц1, фунц2 и фунц3, не узимају никакве аргументе. Дакле, довољно је навести само име функције као циљ. Затим дефинишемо објекте нити, т1, т2 и т3 са фунц1, фунц2 и фунц3 као циљевима, респективно.

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

Посматрајте излаз. Извршење се мења између три нити. Нит т3 има најкраће време чекања, тако да је суспендована најмање време. Нит т1 има најдуже трајање мировања од две секунде, тако да је последња нит која завршава извршење.

Да бисте сазнали више, прочитајте туторијал о основама вишенитног рада у Питхон-у.

Закључак

У овом туторијалу научили сте како да користите Питхон-ову функцију слееп() за додавање временских одлагања коду.

Можете приступити функцији спавања() из уграђеног временског модула, тиме.слееп(). Да бисте одложили извршење за н секунди, користите тиме.слееп(н). Такође, видели сте примере одлагања наредних итерација у петљи за различите вредности, одбројавање и вишенитност.

Сада можете истражити напредније могућности модула времена. Желите да радите са датумима и временима у Питхон-у? Поред модула времена, можете искористити функционалност модула датума и календара.

Затим научите да израчунате временску разлику у Питхон-у.⏰