Python sleep()

Вызов sleep() через time.sleep()

В Python есть встроенная поддержка для погружения программы в сон. У модуля есть функция , что позволяет отсрочить выполнение вызываемого потока на указанное количество секунд.

Мы собрали ТОП Книг для Python программиста которые помогут быстро изучить язык программирования Python.
Список книг: Книги по Python

Далее дан пример использования :

Python

import time
time.sleep(3) # Сон в 3 секунды

1 2	importtime time.sleep(3)# Сон в 3 секунды

При запуске кода из консоли, задержку нужно проводить перед вводом нового оператора в REPL.

Вы можете протестировать, как долго продлиться сон с помощью модуля Python timeit:

Shell

$ python3 -m timeit -n 3 «import time; time.sleep(3)»
3 loops, best of 3: 3 sec per loop

1 2	$python3-mtimeit-n3″import time; time.sleep(3)» 3loops,best of33sec per loop

Здесь модуль запускается с параметром , что указывает , сколько раз выполнять последующий оператор. Можно заметить, что выполнил оператор 3 раза, а лучшее время длилось 3 секунды, чего и следовало ожидать.

По умолчанию будет запускать код миллион раз. Если бы вы запустили вышеуказанный код, оставив значение по умолчанию, тогда при 3 секундах на итерацию код завис бы примерно на 34 дня! У модуля есть несколько других настроек для командной строки, с которыми можно ознакомиться в .

Создадим что-то более практичное. Системному администратору всегда нужно быть в курсе, если какой-то из сайтов упал. Вы бы хотели иметь возможность проверить код состояния сайта регулярно, но запрашивать веб сервер постоянно нельзя, ведь это сильно повлияет на производительность. В Python одним из простых способов совершить такую проверку является использование системного вызова :

Python

import time
import urllib.request
import urllib.error

def uptime_bot(url):
while True:
try:
conn = urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
# Отправка admin / log
print(f’HTTPError: {e.code} для {url}’)
except urllib.error.URLError as e:
# Отправка admin / log
print(f’URLError: {e.code} для {url}’)
else:
# Сайт поднят
print(f'{url} поднят’)
time.sleep(60)

if __name__ == ‘__main__’:
url = ‘http://www.google.com/py’
uptime_bot(url)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 20 21 22

importtime importurllib.request importurllib.error defuptime_bot(url) whileTrue try conn=urllib.request.urlopen(url) excepturllib.error.HTTPError ase # Отправка admin / log print(f’HTTPError: {e.code} для {url}’) excepturllib.error.URLError ase # Отправка admin / log print(f’URLError: {e.code} для {url}’) else # Сайт поднят print(f'{url} поднят’) if__name__==’__main__’ url=’http://www.google.com/py’ uptime_bot(url)

Здесь создается , что принимает URL в качестве аргумента. Затем функция пытается открыть данный URL c . При возникновении или программа перехватывает ошибку и выводит на экран. На практике вам, скорее всего, придется зафиксировать ошибку и отправить письмо веб-мастеру или системному администратору.

Если ошибок нет, код спокойно выполняется. Вне зависимости от того, что произойдет, программа уходит в сон на 60 секунд. Это значит, что доступ к сайту будет раз за минуту. URL, используемый в примере, содержит ошибки. Ежеминутный вывод на консоли выглядит следующим образом:

Shell

HTTPError: 404 для http://www.google.com/py

1	HTTPError404дляhttpwww.compy

Попробуйте обновить код, используя проверенный хороший URL, к примеру https://www.google.com/. После этого вы можете перезапустить программу и проверить, что изменилось. Также можно попробовать обновить код для отправки сообщения или записи об ошибке. Для получения более подробной информации можете ознакомиться со статьями отправка писем smtp и логирование.

Подклассы потоков

При запуске Thread выполняет базовую инициализацию и затем вызывает свой метод run(). Он в свою очередь вызывает целевую функцию, переданную конструктору. Чтобы создать подкласс Thread, переопределите run().

import threading
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

class MyThread(threading.Thread):

    def run(self):
        logging.debug('running')
        return

for i in range(5):
    t = MyThread()
    t.start()

Возвращаемое значение метода run() игнорируется.

$ python threading_subclass.py

(Thread-1  ) running
(Thread-2  ) running
(Thread-3  ) running
(Thread-4  ) running
(Thread-5  ) running

Значения args и kwargs, передаваемые в конструктор Thread, сохраняются в private переменных. Поэтому к ним трудно получить доступ из подкласса.

Для передачи аргументов пользовательскому потоку, переопределите конструктор, чтобы сохранить значения в атрибуте экземпляра.

import threading
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

class MyThreadWithArgs(threading.Thread):

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, verbose=None):
        threading.Thread.__init__(self, group=group, target=target, name=name,
                                  verbose=verbose)
        self.args = args
        self.kwargs = kwargs
        return

    def run(self):
        logging.debug('running with %s and %s', self.args, self.kwargs)
        return

for i in range(5):
    t = MyThreadWithArgs(args=(i,), kwargs={'a':'A', 'b':'B'})
    t.start()

MyThreadWithArgs использует тот же API, что и Thread. Но другой класс может легко изменить метод конструктора, чтобы принимать другие аргументы, связанные с назначением потока.

$ python threading_subclass_args.py

(Thread-1  ) running with (0,) and {'a': 'A', 'b': 'B'}
(Thread-2  ) running with (1,) and {'a': 'A', 'b': 'B'}
(Thread-3  ) running with (2,) and {'a': 'A', 'b': 'B'}
(Thread-4  ) running with (3,) and {'a': 'A', 'b': 'B'}
(Thread-5  ) running with (4,) and {'a': 'A', 'b': 'B'}

Время выполнения программы

Существует множество разных задач, для решения которых нужно найти время, потраченное на работу программы либо отдельных ее блоков. Чтобы найти данную величину, достаточно посчитать разницу в секундах между точкой старта определенной функции и местом, где она завершает свою работу. В следующем примере демонстрируется применение методов time() для получения текущего времени, чтобы в конечном итоге выявить, как долго работал блок кода. Метод sleep() здесь увеличивает время выполнения программы на 5 секунд.

import time
start = time.time()
time.sleep(5)
finish = time.time()
result = finish - start
print("Program time: " + str(result) + " seconds.")

Program time: 5.005090236663818 seconds.

Несмотря на простоту вышеописанного подхода, использовать его в серьезных целях, где требуется точный и независимый от ОС результат, не рекомендуется. Все дело в том, что числовое значение времени, получаемое таким образом, может иметь погрешности за счет внутренних особенностей работы компьютера, в среде которого выполняется программа. Например, системные часы могут быть подкорректированы вручную пользователем во время выполнения программы. Корректировка может произойти и автоматически, если настроена синхронизация системных часов по NTP.

Таким образом, может случиться такая ситуация, что функция вернет значение меньшее, чем при предыдущем вызове.

monotonic

По этой причине лучше всего использовать метод monotonic(), впервые появившийся в версии Python 3.3 на некоторых платформах, а начиная с выпуска 3.5 ставший доступным абсолютно везде. Его главной особенностью является точное представление измеряемого количества времени, вне зависимости от работы ОС и текущей платформы. Используемый таймер никогда не вернет при повторном вызове метода значение, которое будет меньше предыдущего. Это позволяет избежать многих ошибок, а также неожиданного поведения.

import time
start = time.monotonic()
time.sleep(15)
result = time.monotonic() - start
print("Program time: {:>.3f}".format(result) + " seconds.")

Program time: 15.012 seconds.

В примере программы, описанном выше, продемонстрирована работа функции monotonic(). Принцип ее применения такой же, как и в предыдущем примере, однако здесь результат обладает гарантированной точностью и независим от внешних условий. Для отображения времени в более комфортной форме используется небольшое форматирование результата.

The Circadian Rhythm

What is your sleep-wake cycle dictated by?

Answer: the circadian rhythm. The circadian rhythm is a biological cycle of different processes that happen over a time span of about 24 hours.

Here are some key points in the typical 24-hour cycle:

• 6 A.M. Cortisol levels increase to wake your brain and body
• 7 A.M. Melatonin production stops
• 9 A.M. Sex hormone production peaks
• 10 A.M. Mental alertness levels peak
• 2:30 P.M. Best motor coordination
• 3:30 P.M. Fastest reaction time
• 5 P.M. Greatest cardiovascular efficiency and muscle strength
• 7 P.M. Highest blood pressure and body temperature
• 9 P.M. Melatonin production begins to prepare the body for sleep
• 10 P.M. Bowel movements suppressed as the body quiets down
• 2 A.M. Deepest sleep
• 4 A.M. Lowest body temperature

Obviously, these times are not exact and merely display the general pattern of the circadian rhythm. The exact times of your circadian rhythm will vary based on daylight, your habits, and other factors we will discuss later in this guide.

The circadian rhythm is impacted by three main factors: light, time, and melatonin.

Light. Light is probably the most significant pace setter of the circadian rhythm. Staring into a bright light for 30 minutes or so can often reset your circadian rhythm regardless of what time of day it is. More commonly, the rising of the sun and light striking your eyes triggers the transition to a new cycle.

Time. The time of day, your daily schedule, and the order in which you perform tasks can all impact your sleep-wake cycle.

Melatonin. This is the hormone that causes drowsiness and controls body temperature. Melatonin is produced in a predictable daily rhythm, increasing after dark and decreasing before dawn. Researchers believe that the melatonin production cycle helps keep the sleep-wake cycle on track.

Adding a Python sleep() Call With Async IO

Asynchronous capabilities were added to Python in the 3.4 release, and this feature set has been aggressively expanding ever since. Asynchronous programming is a type of parallel programming that allows you to run multiple tasks at once. When a task finishes, it will notify the main thread.

is a module that lets you add a Python call asynchronously. If you’re unfamiliar with Python’s implementation of asynchronous programming, then check out Async IO in Python: A Complete Walkthrough and Python Concurrency & Parallel Programming.

Here’s an example from Python’s own documentation:

In this example, you run and have it sleep for one second between two calls.

Here’s a more compelling example from the Coroutines and Tasks portion of the documentation:

In this code, you create a worker called that takes in the number of seconds to and the to print out. Then, you use Python’s keyword to wait for the code to run. is required here because has been marked as an function, so you can’t call it like you would a normal function.

When you run this code, your program will execute 3 times. The code will wait for 1, 2, and 3 seconds, for a total wait time of 6 seconds. You can also rewrite the code so that the tasks run in parallel:

Ok, But Can You Catch Up on Sleep?

Extra sleep can remedy some of the negative effects of several bad nights of sleep. New research found that catching up on sleep on the weekends brought daytime sleepiness and inflammation levels back to baseline; however, cognitive performance did NOT rebound.

What exactly does that mean? If you’re not getting enough sleep during the week, you cannot depend on catch-up sleep on the weekends to restore your focus and attention. The only way to keep levels of those performance measures high is to make sure you’re getting adequate sleep every night.

Now does this mean you shouldn’t even try to catch up on sleep? No. If you’re already sleep deprived, you should definitely try to get some extra sleep. But the best thing to do, both for immediate performance and for the long-term, is to prioritize sleep every night—not just on the weekends.

Пример

В этом примере мы объединим все наши знания воедино.

Предположим, нам нужно выполнить какие-то задачи. Для этого мы будем использовать несколько процессов. Один будет содержать задачи, а другой – журнал выполненных задач.

Затем мы создаем экземпляры процессов для выполнения задачи

Обратите внимание, что класс Lock уже синхронизирован. Это означает, что нам не нужно использовать класс Lock, чтобы блокировать несколько процессов для доступа к одному и тому же объекту очереди

Поэтому в этом случае нам не нужно использовать класс Lock.

Ниже приведена реализация, в которой мы добавляем задачи в очередь, затем создаем процессы и запускаем их, а затем используем join() для завершения процессов. Наконец, печатаем журнал из второй очереди.

from multiprocessing import Lock, Process, Queue, current_process
import time
import queue # imported for using queue.Empty exception


def do_job(tasks_to_accomplish, tasks_that_are_done):
    while True:
        try:
            '''
                try to get task from the queue. get_nowait() function will 
                raise queue.Empty exception if the queue is empty. 
                queue(False) function would do the same task also.
            '''
            task = tasks_to_accomplish.get_nowait()
        except queue.Empty:

            break
        else:
            '''
                if no exception has been raised, add the task completion 
                message to task_that_are_done queue
            '''
            print(task)
            tasks_that_are_done.put(task + ' is done by ' + current_process().name)
            time.sleep(.5)
    return True


def main():
    number_of_task = 10
    number_of_processes = 4
    tasks_to_accomplish = Queue()
    tasks_that_are_done = Queue()
    processes = []

    for i in range(number_of_task):
        tasks_to_accomplish.put("Task no " + str(i))

    # creating processes
    for w in range(number_of_processes):
        p = Process(target=do_job, args=(tasks_to_accomplish, tasks_that_are_done))
        processes.append(p)
        p.start()

    # completing process
    for p in processes:
        p.join()

    # print the output
    while not tasks_that_are_done.empty():
        print(tasks_that_are_done.get())

    return True


if __name__ == '__main__':
    main()

В зависимости от количества задач, коду потребуется некоторое время, чтобы показать вам результат. Вывод следующего кода будет время от времени изменяться.

Метод after() — Погружение в сон для Tkinter

tkinter является частью стандартной библиотеки Python. В случае, если вы используете заранее установленную версию Python на Linux или Mac, он может быть вам недоступен. При получении ошибки стоит самостоятельно добавить его в систему. В том случае, если вы ранее установили Python сами, должен быть доступен.

Начнем с разбора примера, где используется . Запустите следующий код и посмотрите, что произойдет при неправильном добавлении вызова в Python:

Python

import tkinter
import time

class MyApp:
def __init__(self, parent):
self.root = parent
self.root.geometry(«400×400″)
self.frame = tkinter.Frame(parent)
self.frame.pack()
b = tkinter.Button(text=»click me», command=self.delayed)
b.pack()

def delayed(self):
time.sleep(3)

if __name__ == «__main__»:
root = tkinter.Tk()
app = MyApp(root)
root.mainloop()

1 2 3 4 5 6 7 8 9 10 11 12 13 15 16 17 18 19

importtkinter importtime classMyApp def__init__(self,parent) self.root=parent self.root.geometry(«400×400») self.frame=tkinter.Frame(parent) self.frame.pack() b=tkinter.Button(text=»click me»,command=self.delayed) b.pack() defdelayed(self) if__name__==»__main__» root=tkinter.Tk() app=MyApp(root) root.mainloop()

После запуска кода нажмите кнопку в GUI. Кнопка не будет реагировать три секунды, ожидая завершения . Если в приложении есть другие кнопки, на них тоже нельзя будет нажать. Закрыть приложение во время сна нельзя, так как оно не будет откликаться на событие закрытия.

Для должного погружения в сон потребуется использовать :

Python

import tkinter

class MyApp:
def __init__(self, parent):
self.root = parent
self.root.geometry(«400×400»)
self.frame = tkinter.Frame(parent)
self.frame.pack()
self.root.after(3000, self.delayed)

def delayed(self):
print(‘Я задержался’)

if __name__ == «__main__»:
root = tkinter.Tk()
app = MyApp(root)
root.mainloop()

1 2 3 4 5 6 7 8 10 11 12 13 14 15 16 17

importtkinter classMyApp def__init__(self,parent) self.root=parent self.root.geometry(«400×400») self.frame=tkinter.Frame(parent) self.frame.pack() defdelayed(self) print(‘Я задержался’) if__name__==»__main__» root=tkinter.Tk() app=MyApp(root) root.mainloop()

Здесь создается приложение, высота которого 400 пикселей, и ширина также 400 пикселей. На нем нет виджетов. Оно только показывает фрейм. Затем вызывается , где является отсылкой к объекту . принимает два аргумента:

1. Количество миллисекунд для сна;
2. Метод который вызовется после завершения сна.

В данном случае приложение выведет строку в стандартный поток вывода (stdout) через 3 секунды. Можно рассматривать как Tkinter-версию того же , только он добавляет способность вызова функции после завершения сна.

Данную функциональность можно использовать для улучшения работы пользователя. Добавив в Python вызов , можно ускорить процесс загрузки приложения, после чего начать какой-то длительный процесс. В таком случае пользователю не придется ждать открытия приложения.

All 10 Replies

http-equiv=»Content-Type» content=»text/html;charset=UTF-8″>id=»js-replies» class=»dw-replies position-relative»>

Module subprocess, specifically subprocess.Popen(), has a wait() method. Here is a typical example:

I tried to substitute os.system for subprocess.call but that did not help.

Ilya

P.S: I posted this before Ene Uran’s post, I’ll try your suggestion now.

Hello,

I modified the code in the following way:

I am getting the following error :

Removing close_fds=True argument did not help, as the code now crashes with

(again, os.system and subprocess.call managed to run the process, they simply didn’t wait).

Any suggestions?

Thank you,

Ilya

May be because your code block indentations are screwed up.

just checked, it seems that the indentation is correct….

Hello,

This code doesn’t crash but it doesn’t wait either, I’m starting to wonder if the problem lies with matlab2007b….

Ilya

I am currently using time.sleep() function, I guess I’ll make some work around with matlab generating a temp file marking operations «complete» which python will wait and check periodically. I just wish something less ugly could be done.

-Ilya

The problem apparently has to do with the way the command line matlab launcher operates in Windows. The launcher spawns a separate process and then immediately exits unless you use the -wait flag.

Warning concerning Popen.wait()

This will deadlock when using stdout=PIPE and/or stderr=PIPE and the child process generates enough output to a pipe such that it blocks waiting for the OS pipe buffer to accept more data. Use communicate() to avoid that.

I had a similar problem when I was trying to run Excel. If would work if Excel wasn’t running, but would fail when other instances of Excel were already in memory. The code shown below worked for me. I think it might work with programs like Matlab that spawn subprocesses, because child processes inherit stdin and stdout from their parent.

from subprocess import Popen, PIPE, STDOUT
P=Popen(‘EXCEL.EXE’,shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
Excel_output=P.stdout.read()
Status=P.wait()

Be a part of the DaniWeb community

We’re a friendly, industry-focused community of
1.21 million developers, IT pros, digital marketers,
and technology enthusiasts learning and sharing knowledge.

Sign Up — It’s Free!

Что такое класс Process в Python?

Класс Process в Python – это абстракция, которая настраивает другой процесс Python, предоставляет его для выполнения кода.

К классу Process принадлежат две важные функции – start() и join().

Сначала нам нужно написать функцию, которая будет запускаться процессом. Затем нам нужно создать экземпляр объекта процесса.

Если мы создадим объект процесса, ничего не произойдет, пока мы не скажем ему начать обработку с помощью функции start(). Затем процесс запустится и вернет свой результат. После этого мы говорим процессу завершиться через функцию join().

Без вызова функции join() процесс останется бездействующим и не завершится.

Поэтому, если вы создадите много процессов и не завершите их, вы можете столкнуться с нехваткой ресурсов. Тогда вам может потребоваться удалить их вручную.

Одна важная вещь: если вы хотите передать какой-либо аргумент через процесс, вам нужно использовать аргумент ключевого слова args. Следующий код будет полезен для понимания использования класса Process.

from multiprocessing import Process


def print_func(continent='Asia'):
    print('The name of continent is : ', continent)

if __name__ == "__main__":  # confirms that the code is under main function
    names = 
    procs = []
    proc = Process(target=print_func)  # instantiating without any argument
    procs.append(proc)
    proc.start()

    # instantiating process with arguments
    for name in names:
        # print(name)
        proc = Process(target=print_func, args=(name,))
        procs.append(proc)
        proc.start()

    # complete the processes
    for proc in procs:
        proc.join()

Вызов sleep() с Async IO на примерах

Асинхронные возможности были добавлены в Python 3.4, и с тех пор данный аспект постоянно распространяется и улучшается. Асинхронное программирование является типом параллельного программирования, что позволяет одновременно запускать множество задач. По завершении задачи выводится уведомления для основного потока.

Модуль asyncio позволяет добавлять в Python вызов асинхронно.

Вот пример, данный в официальной документации Python:

Python

import asyncio

async def main():
print(‘Hello …’)
await asyncio.sleep(1)
print(‘… World!’)

# Python 3.7+
asyncio.run(main())

1 2 3 4 6 7 8 9

importasyncio async defmain() print(‘Hello …’) print(‘… World!’)   # Python 3.7+ asyncio.run(main())

В данном примере запускается , что погружается в сон на секунду между двумя вызовами .

Вот более подробный пример из раздела о Сопрограммах и задачах документации :

Python

import asyncio
import time

async def output(sleep, text):
await asyncio.sleep(sleep)
print(text)

async def main():
print(f»Started: {time.strftime(‘%X’)}»)
await output(1, ‘First’)
await output(2, ‘Second’)
await output(3, ‘Third’)
print(f»Ended: {time.strftime(‘%X’)}»)

# Python 3.7+
asyncio.run(main())

1 2 3 4 6 7 8 9 10 11 13 14 15 16

importasyncio importtime async defoutput(sleep,text) print(text) async defmain() print(f»Started: {time.strftime(‘%X’)}») await output(1,’First’) await output(2,’Second’) print(f»Ended: {time.strftime(‘%X’)}»)   # Python 3.7+ asyncio.run(main())

В данном коде создается рабочий поток , что принимает количество секунд для и выводит . После этого используется ключевое слово Python для ожидания запуска кода . Здесь требуется , так как был отмечен как функция , и теперь не может вызываться как обычная функция.

При запуске кода программа выполнит 3 раза. Код будет ждать 1, 2 и 3 секунды, общее время ожидания равно 6 секундам. Можно также переписать код таким образом, чтобы задачи выполнялись параллельно:

Python

import asyncio
import time

async def output(text, sleep):
while sleep > 0:
await asyncio.sleep(1)
print(f'{text} counter: {sleep} seconds’)
sleep -= 1

async def main():
task_1 = asyncio.create_task(output(‘First’, 1))
task_2 = asyncio.create_task(output(‘Second’, 2))
task_3 = asyncio.create_task(output(‘Third’, 3))
print(f»Started: {time.strftime(‘%X’)}»)
await task_1
await task_2
await task_3
print(f»Ended: {time.strftime(‘%X’)}»)

if __name__ == ‘__main__’:
asyncio.run(main())

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

importasyncio importtime async defoutput(text,sleep) whilesleep> await asyncio.sleep(1) print(f'{text} counter: {sleep} seconds’) sleep-=1 async defmain() task_1=asyncio.create_task(output(‘First’,1)) task_2=asyncio.create_task(output(‘Second’,2)) task_3=asyncio.create_task(output(‘Third’,3)) print(f»Started: {time.strftime(‘%X’)}») await task_1 await task_2 await task_3                                 print(f»Ended: {time.strftime(‘%X’)}») if__name__==’__main__’ asyncio.run(main())

Теперь вы используете концепт задач, что можно создать через . При использовании задач в Python будет запускать задачи асинхронно. Таким образом, выполнение программы завершится через 3 секунды вместо 6.

Класс time.struct_time

Некоторые функции в модуле времени, такие как gmtime(), asctime() и т.д., либо принимают объект time.struct_time в качестве аргумента, либо возвращают его.

Вот пример объекта time.struct_time:

time.struct_time(tm_year=2018, tm_mon=12, tm_mday=27, 
                    tm_hour=6, tm_min=35, tm_sec=17, 
                    tm_wday=3, tm_yday=361, tm_isdst=0)

Индекс	Атрибут	Значение
tm_year	0000, …., 2018, …, 9999
1	tm_mon	1, 2, …, 12
2	tm_mday	1, 2, …, 31
3	tm_hour	0, 1, …, 23
4	tm_min	0, 1, …, 59
5	tm_sec	0, 1, …, 61
6	tm_wday	0, 1, …, 6; Понедельник 0
7	tm_yday	1, 2, …, 366
8	tm_isdst	0, 1 или -1

Значения (элементы) объекта time.struct_time доступны как с помощью индексов, так и атрибутов.

Модуль time

Модуль time открывает разработчику Python доступ к нескольким связанным со временем функциям. Модуль основан на «эпохе», точке, с которой начинается время. Для систем Unix, эпоха началась в 1970 году. Чтобы узнать, какая эпоха в вашей системе, попробуйте запустить следующий код:

Python

import time
print(time.gmtime(0))

1 2	importtime print(time.gmtime())

Результат

Python

time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=\
0, tm_wday=3, tm_yday=1, tm_isdst=0)

1 2	time.struct_time(tm_year=1970,tm_mon=1,tm_mday=1,tm_hour=,tm_min=,tm_sec=\ ,tm_wday=3,tm_yday=1,tm_isdst=)

Я запустил его на Windows 7, которая также уверена в том, что начало времен датируется 1970м годом. В любом случае, в данном разделе мы ознакомимся со следующими функциями:

• time.ctime
• time.sleep
• time.strftime
• time.time

Приступим!

Использование Event.wait() в многопоточности Python

Модуль предоставляет , которого можно использовать как . Однако преимущество в том, что он более отзывчив. Причина в том, что когда событие установлено, программа сразу выходит из цикла. В Python с коду надо будет подождать завершения вызова до выхода из потока.

Причина, по которой здесь лучше использовать в том, что он не блокируется, в то время, как блокируется. Это значит, что при использовании вы заблокируете выполнение основного потока, пока тот будет ждать завершения вызова . решает данную проблему. Более подробнее прочитать о принципах работы потоков можно в .

Далее показан пример добавления в Python вызова с :

Python

import logging
import threading

def worker(event):
while not event.isSet():
logging.debug(«рабочий поток вносится»)
event.wait(1)

def main():
logging.basicConfig(
level=logging.DEBUG,
format=»%(relativeCreated)6d %(threadName)s %(message)s»
)
event = threading.Event()

thread = threading.Thread(target=worker, args=(event,))
thread_two = threading.Thread(target=worker, args=(event,))
thread.start()
thread_two.start()

while not event.isSet():
try:
logging.debug(«Добавление из главного потока»)
event.wait(0.75)
except KeyboardInterrupt:
event.set()
break

if __name__ == «__main__»:
main()

1 2 3 4 5 6 8 9 10 11 12 13 15 16 17 18 19 20 21 22 23 25 26 27 28 29 30

importlogging importthreading defworker(event) whilenotevent.isSet() logging.debug(«рабочий поток вносится»)   defmain() logging.basicConfig( level=logging.DEBUG, format=»%(relativeCreated)6d %(threadName)s %(message)s» )   thread=threading.Thread(target=worker,args=(event,)) thread_two=threading.Thread(target=worker,args=(event,)) thread.start() thread_two.start() whilenotevent.isSet() try logging.debug(«Добавление из главного потока») exceptKeyboardInterrupt event.set() break if__name__==»__main__» main()

В данном примере создается и передается к . Вспомните, что в предыдущем примере вместо этого передавался словарь.

Затем устанавливаются циклы для проверки, настроено ли событие . Если это не так, тогда код выведет сообщение и немного подождет перед повторной проверкой. Для установки события можно воспользоваться комбинацией . Как только событие установлено, вернется, и цикл оборвется, завершив программу.

Рассмотрите подробнее код выше. Как бы вы передали разное время сна каждому работающему потоку? Справитесь с задачей? Не бойтесь экспериментировать!