Python sleep

Examples¶

It is possible to provide a setup statement that is executed only once at the beginning:

$ python -m timeit -s 'text = "sample string"; char = "g"'  'char in text'
5000000 loops, best of 5: 0.0877 usec per loop
$ python -m timeit -s 'text = "sample string"; char = "g"'  'text.find(char)'
1000000 loops, best of 5: 0.342 usec per loop

>>> import timeit
>>> timeit.timeit('char in text', setup='text = "sample string"; char = "g"')
0.41440500499993504
>>> timeit.timeit('text.find(char)', setup='text = "sample string"; char = "g"')
1.7246671520006203

The same can be done using the class and its methods:

>>> import timeit
>>> t = timeit.Timer('char in text', setup='text = "sample string"; char = "g"')
>>> t.timeit()
0.3955516149999312
>>> t.repeat()

The following examples show how to time expressions that contain multiple lines.
Here we compare the cost of using vs. /
to test for missing and present object attributes:

$ python -m timeit 'try:' '  str.__bool__' 'except AttributeError:' '  pass'
20000 loops, best of 5: 15.7 usec per loop
$ python -m timeit 'if hasattr(str, "__bool__"): pass'
50000 loops, best of 5: 4.26 usec per loop

$ python -m timeit 'try:' '  int.__bool__' 'except AttributeError:' '  pass'
200000 loops, best of 5: 1.43 usec per loop
$ python -m timeit 'if hasattr(int, "__bool__"): pass'
100000 loops, best of 5: 2.23 usec per loop

>>> import timeit
>>> # attribute is missing
>>> s = """\
... try:
...     str.__bool__
... except AttributeError:
...     pass
... """
>>> timeit.timeit(stmt=s, number=100000)
0.9138244460009446
>>> s = "if hasattr(str, '__bool__'): pass"
>>> timeit.timeit(stmt=s, number=100000)
0.5829014980008651
>>>
>>> # attribute is present
>>> s = """\
... try:
...     int.__bool__
... except AttributeError:
...     pass
... """
>>> timeit.timeit(stmt=s, number=100000)
0.04215312199994514
>>> s = "if hasattr(int, '__bool__'): pass"
>>> timeit.timeit(stmt=s, number=100000)
0.08588060699912603

To give the module access to functions you define, you can pass a
setup parameter which contains an import statement:

def test():
    """Stupid test function"""
    L = i for i in range(100)]

if __name__ == '__main__'
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

Another option is to pass to the globals parameter, which will cause the code
to be executed within your current global namespace. This can be more convenient
than individually specifying imports:

def f(x):
    return x**2
def g(x):
    return x**4
def h(x):
    return x**8

import timeit
print(timeit.timeit('', globals=globals()))

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

Существует множество разных задач, для решения которых нужно найти время, потраченное на работу программы либо отдельных ее блоков. Чтобы найти данную величину, достаточно посчитать разницу в секундах между точкой старта определенной функции и местом, где она завершает свою работу. В следующем примере демонстрируется применение методов 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(). Принцип ее применения такой же, как и в предыдущем примере, однако здесь результат обладает гарантированной точностью и независим от внешних условий. Для отображения времени в более комфортной форме используется небольшое форматирование результата.

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

Описание:

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

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

Функция таймера зависит от платформы, дополнительно смотрите документацию к вашей OS и модуль .

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

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

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

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

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

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

Методы объекта .

• ,
• ,
• ,
• ,

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

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

>>> import timeit
>>> timeit.Timer('for i in range(10): oct(i)', 'gc.enable()').timeit()
# 0.7002408580010524

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

Это удобная функция, которая вызывает несколько раз, так что общее время >= 0.2 секунд и возвращая возможное количество циклов, время, затраченное на это количество циклов. Вызывает с возрастающими числами из последовательности 1, 2, 5, 10, 20, 50,… до тех пор, пока время не станет не менее 0,2 секунды.

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

callback(number, time_taken)

Метод вызывает несколько раз.

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

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

Метод помощник для печати трассировки из временного кода.

Типичное использование:

t = Timer(...)
try
    # или t.repeat(...)
    t.timeit(...)
except Exception
    t.print_exc()

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

Специфичные для потока данные

Некоторые ресурсы должны быть заблокированы, чтобы их могли использовать сразу несколько потоков. А другие должны быть защищены от просмотра в потоках, которые не «владеют» ими. Функция local() создает объект, способный скрывать значения для отдельных потоков.

import random
import threading
import logging

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

def show_value(data):
    try:
        val = data.value
    except AttributeError:
        logging.debug('No value yet')
    else:
        logging.debug('value=%s', val)


def worker(data):
    show_value(data)
    data.value = random.randint(1, 100)
    show_value(data)

local_data = threading.local()
show_value(local_data)
local_data.value = 1000
show_value(local_data)

for i in range(2):
    t = threading.Thread(target=worker, args=(local_data,))
    t.start()

Обратите внимание, что значение local_data.value не доступно ни для одного потока, пока не будет установлено

$ python threading_local.py

(MainThread) No value yet
(MainThread) value=1000
(Thread-1  ) No value yet
(Thread-1  ) value=34
(Thread-2  ) No value yet
(Thread-2  ) value=7

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

import random
import threading
import logging

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


def show_value(data):
    try:
        val = data.value
    except AttributeError:
        logging.debug('No value yet')
    else:
        logging.debug('value=%s', val)

def worker(data):
    show_value(data)
    data.value = random.randint(1, 100)
    show_value(data)

class MyLocal(threading.local):
    def __init__(self, value):
        logging.debug('Initializing %r', self)
        self.value = value

local_data = MyLocal(1000)
show_value(local_data)

for i in range(2):
    t = threading.Thread(target=worker, args=(local_data,))
    t.start()

__init __() вызывается для каждого объекта (обратите внимание на значение id()) один раз в каждом потоке

$ python threading_local_defaults.py

(MainThread) Initializing <__main__.MyLocal object at 0x100514390>
(MainThread) value=1000
(Thread-1  ) Initializing <__main__.MyLocal object at 0x100514390>
(Thread-1  ) value=1000
(Thread-2  ) Initializing <__main__.MyLocal object at 0x100514390>
(Thread-1  ) value=81
(Thread-2  ) value=1000
(Thread-2  ) value=54

Daemon потоки non-daemon

До этого момента примеры программ ожидали, пока все потоки не завершат свою работу. Иногда программы порождают такой поток, как демон. Он работает, не блокируя завершение основной программы.

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

Чтобы пометить поток как demon, вызовите метод setDaemon() с логическим аргументом. По умолчанию потоки не являются «демонами», поэтому передача в качестве аргумента значения True включает режим demon.

import threading
import time
import logging

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

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

Обратите внимание, что в выводимых данных отсутствует сообщение «Exiting» от потока-демона. Все потоки, не являющиеся «демонами» (включая основной поток), завершают работу до того, как поток-демон выйдет из двухсекундного сна

$ python threading_daemon.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting

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

import threading
import time
import logging

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

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join()
t.join()

Метод join() позволяет demon вывести сообщение «Exiting».

$ python threading_daemon_join.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting
(daemon    ) Exiting

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

import threading
import time
import logging

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

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join(1)
print 'd.isAlive()', d.isAlive()
t.join()

Истекшее время ожидания меньше, чем время, в течение которого поток-демон спит. Поэтому поток все еще «жив» после того, как метод join() продолжит свою работу.

$ python threading_daemon_join_timeout.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting
d.isAlive() True

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

В 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 и логирование.

The 2-Process Model of Sleep Regulation

In 1982, Dr. Alexander Borbely published an article in the journal Human Neurobiology describing something he called the 2-process model of sleep regulation. This conceptual framework for sleep describes two processes that occur simultaneously to regulate sleep and wake states.

Process 1 is sleep pressure. Basically, sleep pressure mounts from the moment you wake up, to the time when you go to sleep. While you’re sleeping, pressure decreases. If you get a full night of sleep, you start the next day with low sleep pressure.

Process 2 is wake drive, which counteracts sleep pressure and is controlled by a 24-hour rhythm that repeats in a wave-pattern.

It’s important to understand this process because it helps reveal an important point about sleep in our modern world that I learned from sleep scientist Dan Pardi:

For millions of years, humans and our ancestors have evolved to sleep at night (when it is dark) and wake during the day (when it is light). However, in the modern world, we work inside all day, often in areas that are darker than the outside world. And then, at night, we look at bright screens and televisions. Low light during the day, more light at night: It’s the opposite of naturally occurring cycles and it seems quite likely that it could mess up your wake rhythm and circadian rhythm.

The result of this shift? Drowsiness and impaired function through the day. We’ll talk more in just a minute about how to sleep better, including actionable steps you can take to anchor your rhythm, but it pretty much comes down to this: Use common-sense light habits. Get outdoor light exposure during the day, and turn down the lights and turn off your screens after dark.

How to change your Mac’s sleep settings

Apple allows you to automatically put your Mac to sleep after a fixed period of your choice (between one minute and three hours). You can even choose to prevent your Mac from sleeping.

To adjust your Mac’s sleep settings: 

1. Click the Apple icon in the upper-left corner of your screen

2. Choose System Preferences

3. Select Battery

4. Here you can control the energy-saving settings for when your Mac is powered by the battery or the power adapter. We’ll explain each of your options below.

In the Battery tab:

1. Use the Turn display off after slider to choose how long your MacBook should wait before putting your display to sleep (from one minute up to three hours). You can also prevent the display from ever going to sleep by dragging the slider all the way to the right

2. Below the slider, set these additional sleep-related settings:

• Slightly dim the display when on battery power: This setting is good for saving energy
• Enable Power Nap while on battery power: This allows your Mac to occasionally wake from sleep to perform tasks such as checking for new emails. If your priority is saving battery, it’s best to uncheck this one

In the Power Adapter tab:

1. Use the Turn display off after slider to choose your preferred amount of time to wait before automatically turning the display off. You can choose between one minute and three hours, or slide all the way to the right if you never want the display to turn off

2. Below this slider, set these additional sleep-related settings:

• Prevent computer from sleeping automatically when the display is off: This way you can close the lid without putting your MacBook to sleep.
• Wake for network access: Allow your Mac to wake up when your Wi-Fi turns on or when an app requests access to the internet.
• Enable Power Nap while plugged into a power adapter: Let your Mac wake from sleep to perform certain tasks, like checking for emails

Сравните производительность блоков кода

Мы можем легко сравнить производительность нескольких блоков кода с помощью .

Мы будем использовать для этой цели таймер, используя .

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

import timeit

start_time = timeit.default_timer()
function_1()
time_1 = timeit.default_timer() - start_time

start_time = timeit.default_timer()
function_2()
time_2 = timeit.default_timer() - start_time

print('Function 1 took', time_1)
print('Function 2 took', time_2)

Давайте протестируем 2 функции в массиве numpy и и посмотрим, как они сравниваются.

import timeit
import numpy as np

def time_range(size):
    for i in range(size):
        pass

def time_arange(size):
    np.arange(size)

if __name__ == '__main__':
    # For smaller arrays
    print('Array size: 1000')

    start_time = timeit.default_timer();
    time_range(1000)
    range_time_1 = timeit.default_timer() - start_time

    start_time = timeit.default_timer();
    time_arange(1000)
    arange_time_1 = timeit.default_timer() - start_time

    # For large arrays
    print('Array size: 1000000')

    start_time = timeit.default_timer();
    time_range(1000000)
    range_time_2 = timeit.default_timer() - start_time

    start_time = timeit.default_timer();
    time_arange(1000000)
    arange_time_2 = timeit.default_timer() - start_time

    print(f'size 1000: range() took {range_time_1}')
    print(f'size 1000: arange() took {arange_time_1}')
    print(f'size 1000000: range() took {range_time_2}')
    print(f'size 1000000: arange() took {arange_time_2}')

Выход

Array size: 1000
Array size: 1000000
size 1000: range() took 2.2970001737121493e-05
size 1000: arange() took 8.393999451072887e-06
size 1000000: range() took 0.02567379199899733
size 1000000: arange() took 0.0031752489994687494

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

Создайте временную метку

Вот еще один пример рассмотреть.

В приведенном ниже коде я создаю пять меток времени. Я использую Чтобы добавить задержку приблизительно одну секунду между каждым временем.

import time
 
for i in range(5):
   current_time = time.localtime()
   timestamp = time.strftime("%I:%m:%S", current_time)
   time.sleep(1)
   print(timestamp)

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

import time

Затем я создаю цикл для цикла, который повторяется пять раз.

for i in range(5):
...

На каждой итерации я получаю текущее время.

current_time = time.localtime()

Я получаю Timestamp, используя другую функцию в модуле времени, Отказ

timestamp = time.strftime("%I:%m:%S", current_time)

Функция Sleep () находится рядом, что приведет к задержке каждой итерации цикла.

time.sleep(1)

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

Вывод выглядит так:

04:08:37
04:08:38
04:08:39
04:08:40
04:08:41

Сон () и пользовательский опыт

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

from time import sleep
 
story_intro = 
for word in story_intro:
   print(word)
   sleep(1)

Здесь я повторяю список слов в Отказ Чтобы добавить Wisswe, я использую функцию Sleep () для задержки примерно через секунду после печатания каждого слова.

time.sleep(1)

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

Я пишу о том, чтобы учиться программировать, и лучшие способы идти об этом на amymhaddad.com . Я чирикаю о программировании, обучении и производительности: @amymhaddad. .

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

Python has built-in support for putting your program to sleep. The module has a function 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 :

>>>

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 slightly. The new Python 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 module:

Here, you run the module with the parameter, which tells how many times to run the statement that follows. You can see that ran the statement 3 times and that the best run time was 3 seconds, which is what was expected.

The default number of times that will run your code is one million. If you were to run the above code with the default , then at 3 seconds per iteration, your terminal would hang for approximately 34 days! The module has several other command line options that you can check out in its .

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 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: