Как сделать задержку в python

45) время сна Python ()

Что такое Python Sleep?

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

В этом уроке вы узнаете:

Синтаксис

Параметры:

секунды : количество секунд, которое вы хотите, чтобы выполнение вашего кода было остановлено.

Пример: использование функции sleep () в Python

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

Шаг 1:

Шаг 2: Добавьте time.sleep ()

Число 5, заданное как input для sleep (), – это количество секунд, в течение которого вы хотите, чтобы выполнение кода было остановлено при его выполнении.

Вот рабочий код вместе с сообщениями внутри print (), чтобы показать задержку отображения сообщения на терминале при выполнении.

Вывод:

Как отложить выполнение функции с помощью sleep ()?

Пример, показанный ниже, имеет функцию, называемую display (). Функция display () выводит сообщение «Welcome to Guru99 Tutorials». Когда функция вызывается, она запускается и отображает сообщение внутри терминала.

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

Пример:

Вывод:

Как можно добавить задержку в скрипте Python?

Использование функции sleep ()

Ранее мы видели несколько примеров использования time.sleep (). Давайте попробуем другой пример, используя time.sleep ().

Пример:

В коде есть цикл for, который будет принимать строковую переменную и печатать каждый символ с задержкой в ​​1 секунду.

Вывод:

Использование функции asyncio.sleep доступно из (Python 3.4 или выше)

Вы можете использовать asyncio.sleep с Python версии 3.4 и выше. Чтобы использовать метод сна asyncio, вам нужно добавить async и await в функцию, как показано в примере ниже:

В скрипте есть вызов функции display (), который выводит сообщение «Добро пожаловать в Guru99». В функции async и await используются два ключевых слова. Ключевое слово async добавляется в начале определения функции, а ожидание добавляется непосредственно перед asyncio.sleep (). Оба ключевых слова async / await предназначены для выполнения асинхронной задачи.

Когда вызывается функция display (), и она встречает await asyncio.sleep (5), код остановится или остановится в этой точке на 5 секунд и, как только будет выполнено, напечатает сообщение.

Использование Event (). Wait

Метод Event (). Wait происходит из модуля потоков. Метод Event.wait () остановит выполнение любого процесса на количество секунд, которое он принимает в качестве аргумента. Работа Event показана в примере ниже:

Код использует Event (). Wait (5). Число 5 – это количество секунд, в течение которых код будет задерживаться для перехода к следующей строке, которая вызывает функцию display (). По истечении 5 секунд будет вызвана функция display (), и сообщение будет напечатано внутри терминала.

Вывод:

Использование таймера

Таймер – это еще один метод, доступный в Threading, который помогает получить те же функции, что и в спящем режиме. Работа таймера показана в примере ниже:

Python sleep(): Как выполнить код с задержкой?

Python sleep(): Как выполнить код с задержкой?

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

В Python есть возможность вызвать функцию sleep() для симуляции задержки в выполнении программы. Быть может, вам нужно дождаться загрузки, скачивания или появления графического объекта на экране. Также может потребоваться сделать паузу между вызовами к веб API или запросами к базе данных. В таких случаях поможет добавление вызова функции sleep() в программу.

Главные аспекты данного руководства по вызову sleep() в Python:

Данная статья предназначена для разработчиков Python среднего уровня, что стремятся повысить свою квалификацию. Если это похоже на вас, приступим!

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

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

Далее дан пример использования time.sleep() :

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

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

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

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

Вызов sleep() с декораторами

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

Другим возможным случаем использования sleep() является необходимость проверки состояния пользовательского интерфейса во время автоматического теста. В зависимости от компьютера, на котором запускается тест, пользовательский интерфейс может грузиться быстрее или медленнее обычного. Это может изменить отображаемое на экране во время проверки программой чего-то.

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

Для добавления системного вызова sleep() в Python можно использовать декоратор в каждом из данных случаев. Разберем следующий пример:

Теперь переписывается uptime_bot() для использования нового декоратора:

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

Вызов sleep() в потоках

Могут возникнуть ситуации, когда в Python требуется добавить вызов sleep() для потока. К примеру, запуск скрипта миграции для базы данных с миллионами записей. Здесь важно избежать простоя, а также не ждать дольше необходимого для завершения миграции, поэтому можно использовать потоки.

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

Использование time.sleep() в threading

Попробуйте запустить вышеуказанный код в терминале. Ваш вывод должен походить на следующий:

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

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

Далее показан пример добавления в Python вызова sleep() с Event.wait() :

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

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

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

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

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

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

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

Вызов sleep() в Tkinter и wxPython

Вызовы sleep() в Python можно добавить не только для приложений командной строки. При создании графического пользовательского интерфейса (GUI) периодически нужно добавлять отсрочки. К примеру, при создании приложения FTP для скачивания около миллиона файлов будет разумно добавить вызов sleep() между партиями, чтобы снизить нагрузку на сервер.

GUI код выполнит всю обработку в основном потоке, называемом циклом обработки событий, или event loop. При использовании time.sleep() внутри кода GUI заблокируется цикл обработки событий.

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

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

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

Метод CallLater() — Погружение в сон для wxPython Python

Между wxPython и Tkinter есть два важных различия:

Фреймворк wxPython не поставляется с Python вместе, поэтому его нужно установить wxPython самостоятельно. Если вы не знакомы с wxPython, можете изучить курс из 55 уроков по wxPython.

Для добавления вызова sleep() в wxPython можно использовать wx.CallLater() :

Заключение

Подведем итоги. Основные, рассмотренные в статье инструменты, для добавления вызовов sleep() в Python:

Теперь вы можете использовать полученные знания и погружать ваш код на Python в сон.

Rukovodstvo

статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.

Python: сделать временную задержку (спящий режим) для выполнения кода

Время чтения: 8 мин.

Вступление

Код задержки с time.sleep ()

time.sleep() есть один серьезный недостаток, очень заметный в многопоточных средах.

Асинхронное и реактивное программирование

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

И асинхронные, и реактивные приложения сильно страдают от блокировки кода, поэтому использование чего-то вроде time.sleep() для них не подходит. Давайте посмотрим на некоторые варианты задержки неблокирующего кода.

Код задержки с asyncio.sleep ()

Установим модуль через pip :

После установки мы можем import его в наш скрипт и переписать нашу функцию:

Как и в предыдущем примере, это будет напечатано два раза с интервалом в 5 секунд:

Все они выполняются одновременно, и время ожидания для трех из них не 15 секунд, а 5.

С другой стороны, если бы мы настроили этот код, чтобы вместо time.sleep()

Мы будем ждать 5 секунд между каждым оператором print()

Код задержки с таймером

Создадим функцию и выполним ее через Timer :

Метод cancel() очень удобен, если у нас работает несколько функций, и мы хотели бы отменить выполнение функции на основе результатов другой или другого условия.

Выполнение этого кода несколько раз будет выглядеть примерно так:

Код задержки с событием

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

У каждого официанта будет свой собственный поток, в то время как управление находится в основном потоке и звонит, когда каждый может позвонить домой. Поскольку сегодня они чувствуют себя очень щедрыми, они сократят рабочее время и отпустят официантов домой через 4 секунды работы:

Выполнение этого кода приводит к:

end_of_work здесь использовалось для синхронизации двух потоков и управления, когда они работают, а когда нет, задерживая выполнение кода на установленное время между проверками.

Заключение

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

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

Класс Timer задерживает выполнение кода и при необходимости может быть отменен.

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

Python sleep(): How to Add Time Delays to Your Code

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Using sleep() to Code a Python Uptime Bot

Have you ever needed to make your Python program wait for something? Most of the time, you’d want your code to execute as quickly as possible. But there are times when letting your code sleep for a while is actually in your best interest.

For example, you might use a Python sleep() call to simulate a delay in your program. Perhaps you need to wait for a file to upload or download, or for a graphic to load or be drawn to the screen. You might even need to pause between calls to a web API, or between queries to a database. Adding Python sleep() calls to your program can help in each of these cases, and many more!

In this tutorial, you’ll learn how to add Python sleep() calls with:

This article is intended for intermediate developers who are looking to grow their knowledge of Python. If that sounds like you, then let’s get started!

Free Bonus: Get our free «The Power of Python Decorators» guide that shows you three advanced decorator patterns and techniques you can use to write to cleaner and more Pythonic programs.

Adding a Python sleep() Call With time.sleep()

Python has built-in support for putting your program to sleep. The time module has a function sleep() that you can use to suspend execution of the calling thread for however many seconds you specify.

Here’s an example of how to use time.sleep() :

If you run this code in your console, then you should experience a delay before you can enter a new statement in the REPL.

Note: In Python 3.5, the core developers changed the behavior of time.sleep() slightly. The new Python sleep() system call will last at least the number of seconds you’ve specified, even if the sleep is interrupted by a signal. This does not apply if the signal itself raises an exception, however.

You can test how long the sleep lasts by using Python’s timeit module:

Let’s create something a bit more realistic. A system administrator needs to know when one of their websites goes down. You want to be able to check the website’s status code regularly, but you can’t query the web server constantly or it will affect performance. One way to do this check is to use a Python sleep() system call:

If no errors occur, then your code prints out that all is well. Regardless of what happens, your program will sleep for 60 seconds. This means that you only access the website once every minute. The URL used in this example is bad, so it will output the following to your console once every minute:

Adding a Python sleep() Call With Decorators

There are times when you need to retry a function that has failed. One popular use case for this is when you need to retry a file download because the server was busy. You usually won’t want to make a request to the server too often, so adding a Python sleep() call between each request is desirable.

Another use case that I’ve personally experienced is where I need to check the state of a user interface during an automated test. The user interface might load faster or slower than usual, depending on the computer I’m running the test on. This can change what’s on the screen at the moment my program is verifying something.

In this case, I can tell the program to sleep for a moment and then recheck things a second or two later. This can mean the difference between a passing and failing test.

You can use a decorator to add a Python sleep() system call in either of these cases. If you’re not familiar with decorators, or if you’d like to brush up on them, then check out Primer on Python Decorators. Let’s look at an example:

Now rewrite uptime_bot() to use your new decorator:

Note: If you’d like to brush up on exception handling in Python, then check out Python Exceptions: An Introduction.

There are a few improvements that you could make to your decorator. If it runs out of retries and still fails, then you could have it re-raise the last error. The decorator will also wait 3 seconds after the last failure, which might be something you don’t want to happen. Feel free to try these out as an exercise!

Adding a Python sleep() Call With Threads

There are also times when you might want to add a Python sleep() call to a thread. Perhaps you’re running a migration script against a database with millions of records in production. You don’t want to cause any downtime, but you also don’t want to wait longer than necessary to finish the migration, so you decide to use threads.

Note: Threads are a method of doing concurrency in Python. You can run multiple threads at once to increase your application’s throughput. If you’re not familiar with threads in Python, then check out An Intro to Threading in Python.

To prevent customers from noticing any kind of slowdown, each thread needs to run for a short period and then sleep. There are two ways to do this:

Using time.sleep()

Try running the code above in your terminal. You should see output similar to the following:

As each thread runs and then sleeps, the logging output is printed to the console. Now that you’ve tried an example, you’ll be able to use these concepts in your own code.

Using Event.wait()

Here’s how you add a Python sleep() call with Event.wait() :

Note: If you’d like to learn more about dictionaries, then check out Dictionaries in Python.

Take a closer look at the code block above. How would you pass in a different sleep time to each worker thread? Can you figure it out? Feel free to tackle this exercise on your own!

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.

asyncio is a module that lets you add a Python sleep() 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 main() and have it sleep for one second between two print() calls.

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

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

When you run this code, your program will execute await 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:

Adding a Python sleep() Call With GUIs

Command-line applications aren’t the only place where you might need to add Python sleep() calls. When you create a Graphical User Interface (GUI), you’ll occasionally need to add delays. For example, you might create an FTP application to download millions of files, but you need to add a sleep() call between batches so you don’t bog down the server.

GUI code will run all its processing and drawing in a main thread called the event loop. If you use time.sleep() inside of GUI code, then you’ll block its event loop. From the user’s perspective, the application could appear to freeze. The user won’t be able to interact with your application while it’s sleeping with this method. (On Windows, you might even get an alert about how your application is now unresponsive.)

Sleeping in Tkinter

Once you’ve run the code, press the button in your GUI. The button will stick down for three seconds as it waits for sleep() to finish. If the application had other buttons, then you wouldn’t be able to click them. You can’t close the application while it’s sleeping, either, since it can’t respond to the close event.

To get tkinter to sleep properly, you’ll need to use after() :

Here you create an application that is 400 pixels wide by 400 pixels tall. It has no widgets on it. All it will do is show a frame. Then, you call self.root.after() where self.root is a reference to the Tk() object. after() takes two arguments:

You could use this functionality to improve user experience. By adding a Python sleep() call, you can make the application appear to load faster and then start some longer-running process after it’s up. That way, the user won’t have to wait for the application to open.

Sleeping in wxPython

There are two major differences between wxPython and Tkinter:

The wxPython framework is not included with Python, so you’ll need to install it yourself. If you’re not familiar with wxPython, then check out How to Build a Python GUI Application With wxPython.

In wxPython, you can use wx.CallLater() to add a Python sleep() call:

When you run this code, you should see a small blank window appear without any widgets. After 4 seconds, you’ll see the string ‘I was delayed’ printed to stdout.

One of the benefits of using wx.CallLater() is that it’s thread-safe. You can use this method from within a thread to call a function that’s in the main wxPython application.

Conclusion

With this tutorial, you’ve gained a valuable new technique to add to your Python toolbox! You know how to add delays to pace your applications and prevent them from using up system resources. You can even use Python sleep() calls to help your GUI code redraw more effectively. This will make the user experience much better for your customers!

To recap, you’ve learned how to add Python sleep() calls with the following tools:

Now you can take what you’ve learned and start putting your code to sleep!

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Using sleep() to Code a Python Uptime Bot

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Mike Driscoll

Mike has been programming in Python for over a decade and loves writing about Python!

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas:

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!

Related Tutorial Categories: intermediate python

Python sleep(): Как выполнить код с задержкой?

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

Содержание статьи

В Python есть возможность вызвать функцию sleep() для симуляции задержки в выполнении программы. Быть может, вам нужно дождаться загрузки, скачивания или появления графического объекта на экране. Также может потребоваться сделать паузу между вызовами к веб API или запросами к базе данных. В таких случаях поможет добавление вызова функции sleep() в программу.

Главные аспекты данного руководства по вызову sleep() в Python:

Данная статья предназначена для разработчиков Python среднего уровня, что стремятся повысить свою квалификацию. Если это похоже на вас, приступим!

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

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

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Далее дан пример использования time.sleep() :

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

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

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

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

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

Вызов sleep() с декораторами

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

Другим возможным случаем использования sleep() является необходимость проверки состояния пользовательского интерфейса во время автоматического теста. В зависимости от компьютера, на котором запускается тест, пользовательский интерфейс может грузиться быстрее или медленнее обычного. Это может изменить отображаемое на экране во время проверки программой чего-то.

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

Для добавления системного вызова sleep() в Python можно использовать декоратор в каждом из данных случаев. Разберем следующий пример:

Теперь переписывается uptime_bot() для использования нового декоратора:

На заметку: При желании более подробно узнать о том, как справляться с исключениями в Python, можете ознакомиться со статьей: Обработка исключений в Python

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

Вызов sleep() в потоках

Могут возникнуть ситуации, когда в Python требуется добавить вызов sleep() для потока. К примеру, запуск скрипта миграции для базы данных с миллионами записей. Здесь важно избежать простоя, а также не ждать дольше необходимого для завершения миграции, поэтому можно использовать потоки.

На заметку: Потоки являются одним из методов использования конкурентности в Python. Можно запустить несколько потоков одновременно, чтобы увеличить производительность приложения. Если потоки в Python являются для вас новой темой, ознакомьтесь со статьей модуль threading.

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

Работа с модулем времени(time) в Python

Модуль времени Python предоставляет нам различные функции для внедрения системного времени в наше приложение с помощью сценариев.

Чтобы начать работу с модулем времени, нам нужно импортировать его в наш скрипт python, используя следующую инструкцию:

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

Эпоха — это начальная точка времени, от которой следует отсчитывать время.

Функции модуля времени Python

Модуль времени Python предлагает хороший набор функций для работы с отметкой времени.

Ниже приведены наиболее часто используемые функции:

1 метод time.time()

В модуле времени Python есть метод time.time() который дает секунды текущего местного времени.

2 метод time.sleep()

Метод time.sleep() обеспечивает интервал времени или задержку между выполнением текущих процессов или потоков.

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

3 метод time.localtime()

Модуль времени Python содержит класс struct_time, доступ к которому можно получить с помощью различных функций. Это помогает нам получить доступ к различным полям местной метки времени, таким как год, час, секунды и т. д.

Класс struct_time состоит из следующих атрибутов:

Функция time.localtime() запускает функцию time.time() в серверной части и возвращает детали текущего времени в формате класса struct_time по местному времени.

Мы также можем передать количество секунд с начала эпохи в качестве аргумента функции.

4 метод time.ctime()

Метод time.ctime() принимает значение секунд с начала или результат функции time() в качестве аргумента и возвращает строковое значение, представляющее текущее местное время.

5 Метод time.mktime()

Метод time.mktime() является обратным методу time.localtime().

Он принимает struct_time (все кортежи класса struct_time) в качестве аргумента и возвращает время в секундах, которое прошло с начала.

В приведенном выше примере мы использовали метод locatime() для получения кортежей класса struct_time и передали его методу mktime().

6 Метод time.gmtime()

Функция time.gmtime() запускает функцию time.time() в серверной части и возвращает детали текущего времени в формате класса struct_time в UTC.

7 метод time.strptime()

Метод time.strptime() принимает строку, представляющую время, и возвращает сведения о времени в формате struct_time.

In Python, how can I put a thread to sleep until a specific time?

I know that I can cause a thread to sleep for a specific amount of time with:

How can I make a thread sleep until 2AM? Do I have to do math to determine the number of seconds until 2AM? Or is there some library function?

( Yes, I know about cron and equivalent systems in Windows, but I want to sleep my thread in python proper and not rely on external stimulus or process signals.)

13 Answers 13

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Here’s a half-ass solution that doesn’t account for clock jitter or adjustment of the clock. See comments for ways to get rid of that.

One possible approach is to sleep for an hour. Every hour, check if the time is in the middle of the night. If so, proceed with your operation. If not, sleep for another hour and continue.

If the user were to change their clock in the middle of the day, this approach would reflect that change. While it requires slightly more resources, it should be negligible.

Building on the answer of @MZA and the comment of @Mads Y

I tried the «pause» pacakage. It does not work for Python 3.x. From the pause package I extracted the code required to wait until a specific datetime and made the following def.

Slightly more generalized solution (based off of Ross Rogers’) in case you’d like to add minutes as well.

Slightly beside the point of the original question:

Even if you don’t want to muck around with crontabs, if you can schedule python scripts to those hosts, you might be interested to schedule anacron tasks? anacron’s major differentiator to cron is that it does not rely the computer to run continuously. Depending on system configuration you may need admin rights even for such user-scheduled tasks.

A similar, more modern tool is upstart provided by the Ubuntu folks: http://upstart.ubuntu.com/ This does not yet even have the required features. But scheduling jobs and replacing anacron is a planned feature. It has quite some traction due to its usage as Ubuntu default initd replacement. (I am not affiliated with the project)

Of course, with the already provided answer, you can code the same functionality into your python script and it might suit you better in your case.

Still, for others, anacron or similar existing systems might be a better solution. anacron is preinstalled on many current linux distributions (there are portability issues for windows users).

If you do go for a python version I’d look at the asynchronous aspect, and ensure the script works even if the time is changed (daylight savings, etc) as others have commented already. Instead of waiting til a pre-calculated future, I’d always at maximum wait one hour, then re-check the time. The compute cycles invested should be negligible even on mobile, embedded systems.

Correct way to pause a Python program

I’ve been using the input function as a way to pause my scripts:

Is there a formal way to do this?

16 Answers 16

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

It seems fine to me (or raw_input() in Python 2.X). Alternatively, you could use time.sleep() if you want to pause for a certain number of seconds.

For Windows only, use:

So, I found this to work very well in my coding endeavors. I simply created a function at the very beginning of my program,

and now I can use the pause() function whenever I need to just as if I was writing a batch file. For example, in a program such as this:

Now obviously this program has no objective and is just for example purposes, but you can understand precisely what I mean.

NOTE: For Python 3, you will need to use input as opposed to raw_input

I assume you want to pause without input.

I have had a similar question and I was using signal:

, which will send signal 2 (i.e. SIGINT) to your python program. Your program will call your registered handler and proceed running.

I use the following for Python 2 and Python 3 to pause code execution until user presses Enter

As pointed out by mhawke and steveha’s comments, the best answer to this exact question would be:

For a long block of text, it is best to use input(‘Press to continue’) (or raw_input(‘Press to continue’) on Python 2.x) to prompt the user, rather than a time delay. Fast readers won’t want to wait for a delay, slow readers might want more time on the delay, someone might be interrupted while reading it and want a lot more time, etc. Also, if someone uses the program a lot, he/she may become used to how it works and not need to even read the long text. It’s just friendlier to let the user control how long the block of text is displayed for reading.

Anecdote: There was a time where programs used «press [ANY] key to continue». This failed because people were complaining they could not find the key ANY on their keyboard 🙂

Функции тайминга Python: три способа контролировать ваш код

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

В этом уроке вы узнаете, как использовать:

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

Таймеры Python

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

Функции таймера Python

Если вы посмотрите на встроенный модуль time в Python, то заметите несколько функций, которые могут измерять время:

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

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

Пример: Последовательность Фибоначчи

Чтобы лучше сравнить различные способы добавления таймера Python к своему коду, вы будете применять разные функции таймера Python к одному и тому же примеру кода в этом руководстве. Если у вас уже есть код, который вы хотели бы измерить, смело следуйте этим примерам.

Вычисление n-го числа ряда Фибоначчи с помощью цикла while:

Ваш первый таймер Python

Теперь вы можете добавить таймер Python к коду примера:

Обратите внимание, что perf_counter() вызывается как до, так и после вычисления значения функции. Затем печатается время, необходимое для вычисления, вычисляя разницу между двумя вызовами.

f-строки доступны только в Python 3.6 и более поздних версиях. Для получения дополнительной информации ознакомьтесь с официальной документацией Python 3.

Теперь, когда вы запустите пример, вы увидите потраченное время на вычисления:

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

Python класс Timer

В этом руководстве вы создадите и обновите класс Timer, который вы можете использовать для определения таймингов кода несколькими различными способами. Окончательный код также доступен в PyPI под названием codetiming. Вы можете установить в вашу систему следующим образом:

Понимание классов в Python

Создание класса таймера Python

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

Использование класса Timer :

Сравните это с предыдущим примером, где вы использовали perf_counter() напрямую. Структура кода довольно похожа, но теперь код стал более понятным, и это является одним из преимуществ использования классов. Тщательно выбирая имена классов, методов и атрибутов, вы можете сделать свой код очень информативным!

Использование класса Timer Python

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

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

Добавление большего удобства и гибкости

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

После обновления timer.py вы можете изменить текст следующим образом:

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

Когда вы запускаете эти примеры в интерактивной оболочке, Python автоматически печатает возвращаемое значение.

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

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

В обоих случаях код возвращает один и тот же пустой словарь классов.

Затем добавим дополнительные имена к вашему таймеру Python. Вы можете использовать имя для двух разных целей:

Теперь вернёмся к series_numbers.py и убедиться, что измеряется только время, потраченное на вычисления:

Повторный запуск сценария даст такой же результат, как и раньше, хотя сейчас измеряется только фактическое время вычислений:

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

В Python 3.7 классы данных были добавлены в стандартную библиотеку. Они обеспечивают несколько удобств для ваших классов, включая более информативную строку представления.

Вот несколько заметок о классе данных Timer :

Новый класс данных Timer работает так же, как ваш предыдущий обычный класс, за исключением того, что теперь он имеет хорошее представление:

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

Использование класса для создания таймера, Python предлагает несколько преимуществ:

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

Менеджер контекста Python Timer

Python класс Timer прошел долгий путь! По сравнению с первым созданным таймером Python код стал достаточно мощным. Тем не менее, для использования таймера все еще есть немного стандартного кода:

Понимание контекстных менеджеров в Python

Менеджеры контекста были частью Python в течение долгого времени. Они были представлены PEP 343 в 2005 году и впервые реализованы в Python 2.5. Вы можете распознать контекстные менеджеры в коде с помощью ключевого слова with :

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

Что это значит, что fp является контекстным менеджером? Технически это означает, что fp реализует протокол менеджера контекста. В основе языка Python лежит много разных протоколов. Вы можете думать о протоколе как о контракте, в котором указано, какие конкретные методы должен реализовывать ваш код.

Протокол менеджера контекста состоит из двух методов:

Вы можете увидеть, что «See you later, Rascal» печатается, даже если в коде есть ошибка.

Теперь вы знаете, что такое контекстные менеджеры и как вы можете создать свой собственный. Если вы хотите погрузиться глубже, то посмотрите contextlib в стандартной библиотеке. Он включает в себя удобные способы определения новых контекстных менеджеров, а также готовые контекстные менеджеры, которые можно использовать для закрытия объектов, устранения ошибок или даже бездействия!

Создание менеджера контекста Python Timer

Вы также должны отметить еще две тонкие детали:

Использование менеджера контекста Python Timer

Давайте посмотрим, как использовать менеджер контекста Timer для определения времени вычисления числа Фибоначчи. Вспомните, как вы использовали Timer ранее:

Запуск скрипта должен дать знакомый результат:

Есть несколько преимуществ для добавления возможностей менеджера контекста к вашему классу таймера Python:

Python Timer декоратор

Ваш класс Timer теперь очень универсален. Однако есть один вариант использования, где он может быть еще более упорядоченным. Скажем, вы хотите отслеживать время, проведенное внутри одной данной функции в вашей кодовой базе. Используя контекстный менеджер, у вас есть два основных варианта:

1. Используйте Timer каждый раз, когда вы вызываете функцию:

Если вы вызовете do_something() во многих местах, это станет громоздко и сложно в обслуживании.

2. Обернём код функцией содержащей внутри контекстный менеджер:

Понимание декораторов в Python

В качестве первого примера создадим декоратор, который ничего не делает:

Вместо этого create_multiplier() используется для создания новых функций умножения, каждая из которых основана на различном factor :

Символ @ используется для применения декораторов. В этом случае @triple означает, что triple() применяется к функции, определенной сразу после нее.

Иногда декорированные функции должны иметь правильные метаданные. @functools.wraps исправляют именно эту проблему:

С новым определением @triple метаданные сохраняются:

Обратите внимание, что knock() теперь сохраняет свое собственное имя, даже после того, как был декорирован. Это хорошая форма, чтобы использовать @functools.wraps всякий раз, когда вы определяете декоратор. Схема, которую вы можете использовать для большинства ваших декораторов, выглядит следующим образом:

Создание декоратора Timer Python

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

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

Обратите внимание, насколько wrapper_timer() напоминает ранний шаблон, установленный вами для замеров кода Python. Вы можете применить @timer следующим образом:

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

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

@timer делает свою работу. Тем не менее, в некотором смысле вы вернулись к исходной точке, поскольку @timer не обладает никакой гибкостью или удобством Timer. Можете ли вы также заставить свой класс Timer действовать как декоратор?

Здесь square-это экземпляр, который может быть вызван и может содержать квадрат числа, точно так же, как функция square() в первом примере.

Это дает вам возможность добавить возможности декоратора к существующему классу таймера:

Теперь вы можете использовать Timer в качестве декоратора:

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

Использование декоратора таймера Python

Если вы сравните эту реализацию с оригинальной реализацией без какого-либо времени, то заметите, что единственными различиями являются импорт Timer в строке 3 и применение @Timer() в строке 6. Существенным преимуществом использования декораторов является то, что они обычно просты в применении, как вы видите.

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

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

При использовании таймера в качестве декоратора вы увидите те же преимущества, что и при использовании контекстных менеджеров:

Однако декораторы не так гибки, как контекстные менеджеры. Вы можете применять их только для выполнения функций. Можно добавить декораторы к уже определенным функциям, но это немного неуклюже и менее распространено.

Код Timer Python

Вы можете использовать код самостоятельно, сохранив его в файле с именем timer.py и импортировать его в вашу программу. Запустим новый таймер в качестве менеджера контекста:

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

Другие функции таймеры в Python

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

В этом разделе вы сначала узнаете больше о различных функциях, доступных в стандартной библиотеке для измерения времени, и о том, почему perf_counter() предпочтительнее. Затем вы увидите альтернативы оптимизации вашего кода, для которых таймер не очень хорошо подходит.

Использование альтернативных функций таймеров в Python

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

Одна из причин, почему существует несколько функций, заключается в том, что Python представляет время как float. Числа с плавающей запятой по своей природе неточны. Возможно, вы уже видели подобные результаты раньше:

Float Python следует стандарту IEEE 754 для арифметики с плавающей запятой, который пытается представить все числа с плавающей запятой в 64 битах. Поскольку существует бесконечно много чисел с плавающей запятой, вы не можете выразить их в виде конечного числа битов.

IEEE 754 предписывает систему, в которой плотность чисел, которые вы можете представить, изменяется. Чем ближе вы к 1, тем больше чисел вы можете представить. Для больших чисел есть больше пространства между числами, которые вы можете выразить. Это имеет некоторые последствия, когда вы используете float для представления времени.

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

Поскольку perf_counter() уже обеспечивает наносекундное разрешение, у использования perf_counter() меньше преимуществ.

Примечание: perf_counter_ns() доступен только в Python 3.7 и более поздних версиях. В этом уроке вы использовали perf_counter() в своем классе Timer. Таким образом, таймер можно использовать и в более старых версиях Python. Для получения дополнительной информации о функциях _ns в time ознакомьтесь с новыми классными функциями в Python 3.7.

Результаты могут быть разными в вашей системе.

PIP 418 описывает некоторые обоснования введения этих функций. Она включает в себя следующие краткие описания:

Как вы можете видеть, обычно это лучший выбор для вас, чтобы использовать perf_counter() для вашего таймера Python.

Оценка времени работы со временем timeit

Допустим, нужно выжать из кода последний бит производительности и задаетесь вопросом о наиболее эффективном способе преобразования списка в множество. Вы хотите сравнить, использование set() и литерал множества <. >. Для этого вы можете использовать свой таймер Python:

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

Лучше всего воспользоваться стандартной библиотекой. Она предназначен именно для измерения времени выполнения небольших фрагментов кода. Для этого импортируем и вызовем timeit.timeit() из Python как обычную функцию в интерфейсе командной строки. Вы можете рассчитать эти два варианта следующим образом:

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

Наконец, интерактивная оболочка IPython и Jupyter notebook имеют дополнительную поддержку этой функции с помощью команды %timeit magic :

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

Поиск узких мест в коде с помощью профилирования

timeit отлично подходит для бенчмаркинга конкретного фрагмента кода. Однако было бы очень громоздко использовать его для проверки всех частей вашей программы и определения того, какие разделы занимают больше всего времени. Вместо этого можно использовать профилировщик.

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

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

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

Для получения более мощного интерфейса для анализа данных профиля, запустите программу KCacheGrind. Он использует свой собственный формат данных, но вы можете конвертировать данные из профиля с помощью pyprof2calltree :

Примечание: Вы также можете профилировать потребление памяти вашего кода. Это выходит за рамки данного руководства. Однако вы можете взглянуть на memory-profiler, если вам нужно контролировать потребление памяти вашими программами.

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

Перед запуском профилировщика необходимо указать ему, какие функции следует профилировать. Это выполняется, добавлением декоратора @profile в свой исходный код. Например, для профилирования Timer.stop() вы добавляете следующее в timer.py :

Вывод

В этом руководстве вы увидели несколько разных подходов к добавлению таймера Python в свой код:

Теперь вы можете добавить функции Timer Python в свой собственный код! Отслеживание скорости выполнения вашей программы в журналах поможет вам отслеживать ваши сценарии.

Time Delay in Python

Problem Statement: How can I make a time delay in Python?

Normally when you are coding, you want to execute the code and get the output immediately without any delay or discontinuity. However, there can be situations wherein you want to delay the execution of a certain piece of your code. For example, let’s say that you want to visualize the effect of multithreading with the help of a code. In this case, a slight time delay between the respective threads in the program can help you to better visualize the output and thereby enhance your understanding. So, this is when time delay becomes an extremely useful tool.

You can use the time delay function between any two statements or between any part of the program as per your requirement. You can also use the time delay when you are waiting for any other process to complete, e.g., a file to upload.

Now, let’s have a look at the different methods to incorporate time delay in our Python code.

Method 1: Using sleep() Method of Time Module

sleep() is a built-in method of the time module in Python that is used to delay the execution of your code by the number of seconds specified by you. Let’s have a look at the syntax of the sleep method –

Here, the delay in time can be passed as a parameter to the sleep method, which specifies the number of seconds by which you want to delay your script. Also, note that you must import the time module so that you can use its sleep method in your code.

Example 1: Creating a time delay of 6 seconds between two print statements.

Output:

Try to execute the following snippet in your compiler 😉

Method 2: Using sleep() Method of Asyncio Library

Here’s what the official documentation says about the asyncio library –

source: https://docs.python.org/3/library/asyncio.html

Well, let’s have a look at an example to understand the working of the sleep method of the asyncio library.

Output:

Difference between time.sleep and asyncio.sleep

The difference between time.sleep and asyncio.sleep is that generally the time.sleep() function is used for the purpose of blocking, and asyncio.sleep() is used for non-blocking. This means that the time.sleep() function blocks the entire execution of the script when it gets called, and the script gets put on hold while doing nothing. However, when you call await asyncio.sleep() function asks the event loop to run something else while the await statement finishes its execution.

Output:

Explanation: Since asyncio.sleep() does not block the entire script hence the first print statements for the foo() method get executed as foo() is called twice. Hence, the output is as shown above. In case the script was blocked, then the script would wait and print each print statement for the respective function calls before moving on to the next call.

Method 3: Using Event.wait()

Event.wait() is a function of the threading module in Python. The function is used to delay the execution of any process for the number of seconds that it takes as an argument. Event class is used to generate the events where any single event can be listened to by multiple threads.

Example:

Output:

Method 4: Using Timer

Timer is another method from the threading module that is used to implement time delay in Python. The method is used to run and execute the operations only after a certain period has passed, thereby delaying the execution. To start the timer function, you have to call the start() method. The method accepts two parameter values where the first one denotes the number of seconds to wait before executing the code and the second parameter denotes a function that you need to run after the specific time.

Syntax:

Example:

Output:

Example:

(Case 1- If the func2 returns number less than 5) Output:

(Case 2- If the func2 returns a number greater than 5) Output:

Conclusion

In this article we discussed numerous ways to implement time delays in your Python code. I hope it has helped to answer your queries. Please subscribe and stay tuned for more interesting articles in the future.

I am a professional Python Blogger and Content creator. I have published numerous articles and created courses over a period of time. Presently I am working as a full-time freelancer and I have experience in domains like Python, AWS, DevOps, and Networking.