Python sleep function

Текущее время в Python

Работа методов из модуля time основывается на общепринятой системе описания времени, которая справедлива для Unix, а также для POSIX-совместимых ОС. Согласно ее концепции, текущее время представляется в виде обыкновенного вещественного значения в секундах, прошедших с момента начала эпохи и до сегодняшнего дня. Отправной точкой для времени считается 1 января 1970 года, когда счетчик секунд имел полностью нулевое значение.

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

import time
print(time.time())

1540289822.637441

Как можно увидеть из данного примера, функция print получает в качестве единственного параметра число, возвращенное из метода time(), после чего выводит его на экран. Таким образом, с 1 января 1970 года прошло уже более полтора миллиарда секунд. Но подобное представление времени совсем неудобно для пользователя программы. Чтобы отобразить текущую дату в более комфортном виде, стоит передать функции print результат работы метода ctime(), не забыв произвести импорт соответствующей ему библиотеки time.

import time
print(time.ctime())

Tue Oct 23 10:18:23 2018

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

Методы

Для работы с временем в стандартной библиотеке языка Python имеется множество самых разных методов. Наиболее популярные функции, реализованные в модуле time, описаны в следующей таблице. Здесь можно найти их название, а также краткую характеристику.

Метод	Характеристика
time()	возвращает текущее время, прошедшее с начала 1970 года в секундах
ctime(s)	возвращает местное время в строке или время, полученное из s секунд
clock()	возвращает процессорное время, прошедшее с момента первого вызова этой функции, точность больше 1 микросекунды
sleep(s)	останавливает ход выполнения программы ровно на s секунд
strftime(s)	преобразует переданное в качестве аргумента время s в строку по формату
strptime(s)	разбирает строку s и преобразует в объект времени по формату
mktime(s)	преобразует время s в количество секунд с начала 1970 года
localtime(s)	возвращает объект, представляющий местное время или время s

Timezone Constants¶

A complete guide to the python split function

The offset of the local DST timezone, in seconds west of UTC, if one is defined.
This is negative if the local DST timezone is east of UTC (as in Western Europe,
including the UK). Only use this if is nonzero. See note below.

Nonzero if a DST timezone is defined. See note below.

The offset of the local (non-DST) timezone, in seconds west of UTC (negative in
most of Western Europe, positive in the US, zero in the UK). See note below.

A tuple of two strings: the first is the name of the local non-DST timezone, the
second is the name of the local DST timezone. If no DST timezone is defined,
the second string should not be used. See note below.

Note

For the above Timezone constants (, , ,
and ), the value is determined by the timezone rules in effect
at module load time or the last time is called and may be incorrect
for times in the past. It is recommended to use the and
results from to obtain timezone information.

See also

Module

More object-oriented interface to dates and times.

Module

Internationalization services. The locale setting affects the interpretation
of many format specifiers in and .

Module

General calendar-related functions. is the
inverse of from this module.

Footnotes

The use of is now deprecated, but the escape that expands to the
preferred hour/minute offset is not supported by all ANSI C libraries. Also, a
strict reading of the original 1982 RFC 822 standard calls for a two-digit
year (%y rather than %Y), but practice moved to 4-digit years long before the
year 2000. After that, RFC 822 became obsolete and the 4-digit year has
been first recommended by RFC 1123 and then mandated by RFC 2822.

Best time to go to sleep

Share on PinterestA person’s age can determine the amount of sleep that they require.

In general, the body and brain slow down as it gets dark and start to wake up as the sun rises.

There is some evidence to suggest that early bedtimes are better for people. One study involving 1,197 Japanese workers found that those who went to bed later were more likely to have depressive symptoms. However, sleep duration may have contributed to these symptoms, as the participants who went to bed later often got less sleep.

Another study found that people who stated a preference for going to sleep later also had higher levels of repetitive negative thinking, such as dwelling on problems or bad experiences. Importantly, this also affects how much sleep a person gets.

Методы строк

Строка является объектом в Python. Фактически, все, что есть в Python – является объектом. Если вы хотите узнать больше об Объектно-ориентированном программирование, мы рассмотрим это в другой статье «Классы в Python«. В данный момент достаточно знать, что строки содержат собственные встроенные методы. Например, допустим, у вас есть следующая строка:

Python

my_string = «This is a string!»

1	my_string=»This is a string!»

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

Python

my_string.upper()

1	my_string.upper()

Если вы открыли ваш интерпретатор, вы также можете сделать то же самое:

Python

«This is a string!».upper()

1	«This is a string!».upper()

Существует великое множество других методов строк. Например, если вам нужно, что бы все было в нижнем регистре, вам нужно использовать метод lower(). Если вы хотите удалить все начальные и конечные пробелы, вам понадобится метод strip(). Для получения списка всех методов строк, впишите следующую команду в ваш интерпретатор:

Python

dir(my_string)

1	dir(my_string)

Вы увидите что-то на подобие этого:

Python

1 2 3 4 5 6 7 8 9 10

‘__add__’,‘__class__’,‘__contains__’,‘__delattr__’,‘__doc__’,‘__eq__’,‘__format__’, ‘__ge__’,‘__getattribute__’,‘__getitem__’,‘__getnewargs__’,‘__getslice__’,‘__gt__’, ‘__hash__’,‘__init__’,‘__le__’,‘__len__’,‘__lt__’,‘__mod__’,‘__mul__’,‘__ne__’, ‘__new__’,‘__reduce__’,‘__reduce_ex__’,‘__repr__’,‘__rmod__’,‘__rmul__’,‘__- setattr__’,‘__sizeof__’,‘__str__’,‘__subclasshook__’,‘_formatter_field_name_split’, ‘_formatter_parser’,‘capitalize’,‘center’,‘count’,‘decode’,‘encode’,‘endswith’,‘expandtabs’, ‘find’,‘format’,‘index’,‘isalnum’,‘isalpha’,‘isdigit’,‘islower’,‘isspace’, ‘istitle’,‘isupper’,‘join’,‘ljust’,‘lower’,‘lstrip’,‘partition’,‘replace’,‘rfind’,‘rindex’, ‘rjust’,‘rpartition’,‘rsplit’,‘rstrip’,‘split’,‘splitlines’,‘startswith’,‘strip’,‘swapcase’, ‘title’,‘translate’,‘upper’,‘zfill’

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

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

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

Python

help(my_string.capitalize)

1	help(my_string.capitalize)

Вы получите следующую информацию:

Python

Help on built-in function capitalize:

capitalize(…)
S.capitalize() -> string

Выдача копии строки S только с заглавной буквой.

1 2 3 4 5 6

Help on built-in function capitalize:   capitalize(…)     S.capitalize() -> string   Выдача копии строки S только с заглавной буквой.

Вы только что узнали кое-что о разделе, под названием интроспекция. Python может исследовать все свои объекты, что делает его очень легким в использовании. В основном, интроспекция позволяет вам спрашивать Python о нём. Вам моет быть интересно, как сказать о том, какой тип переменной был использован (другими словами int или string). Вы можете спросить об этом у Python!

Python

type(my_string) # <type ‘str’>

1	type(my_string)# <type ‘str’>

Как вы видите, тип переменной my_string является str!

Ограничение одновременного доступа к ресурсам

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

import logging
import random
import threading
import time

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

class ActivePool(object):
    def __init__(self):
        super(ActivePool, self).__init__()
        self.active = []
        self.lock = threading.Lock()
    def makeActive(self, name):
        with self.lock:
            self.active.append(name)
            logging.debug('Running: %s', self.active)
    def makeInactive(self, name):
        with self.lock:
            self.active.remove(name)
            logging.debug('Running: %s', self.active)

def worker(s, pool):
    logging.debug('Waiting to join the pool')
    with s:
        name = threading.currentThread().getName()
        pool.makeActive(name)
        time.sleep(0.1)
        pool.makeInactive(name)

pool = ActivePool()
s = threading.Semaphore(2)
for i in range(4):
    t = threading.Thread(target=worker, name=str(i), args=(s, pool))
    t.start()

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

$ python threading_semaphore.py

2013-02-21 06:37:53,629 (0 ) Waiting to join the pool
2013-02-21 06:37:53,629 (1 ) Waiting to join the pool
2013-02-21 06:37:53,629 (0 ) Running: 
2013-02-21 06:37:53,629 (2 ) Waiting to join the pool
2013-02-21 06:37:53,630 (3 ) Waiting to join the pool
2013-02-21 06:37:53,630 (1 ) Running: 
2013-02-21 06:37:53,730 (0 ) Running: 
2013-02-21 06:37:53,731 (2 ) Running: 
2013-02-21 06:37:53,731 (1 ) Running: 
2013-02-21 06:37:53,732 (3 ) Running: 
2013-02-21 06:37:53,831 (2 ) Running: 
2013-02-21 06:37:53,833 (3 ) Running: []

Adding a Python sleep() Call With Threads

There are also times when you might want to add a Python 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:

1. Use as before.
2. Use from the module.

Let’s start by looking at .

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

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

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

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

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

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

Нумерация потоков

Можно не сохранять дескрипторы всех потоков-демонов, чтобы убедиться в их завершении до выхода из основного процесса. enumerate() возвращает список активных экземпляров Thread. Список включает в себя текущий поток. Но присоединение к текущему потоку не разрешено (это приводит к ситуации взаимной блокировки), его необходимо пропустить.

import random
import threading
import time
import logging

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

def worker():
    """thread worker function"""
    t = threading.currentThread()
    pause = random.randint(1,5)
    logging.debug('sleeping %s', pause)
    time.sleep(pause)
    logging.debug('ending')
    return

for i in range(3):
    t = threading.Thread(target=worker)
    t.setDaemon(True)
    t.start()

main_thread = threading.currentThread()
for t in threading.enumerate():
    if t is main_thread:
        continue
    logging.debug('joining %s', t.getName())
    t.join()

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

$ python threading_enumerate.py

(Thread-1  ) sleeping 3
(Thread-2  ) sleeping 2
(Thread-3  ) sleeping 5
(MainThread) joining Thread-1
(Thread-2  ) ending
(Thread-1  ) ending
(MainThread) joining Thread-3
(Thread-3  ) ending
(MainThread) joining Thread-2

datetime.date

Python может представлять даты различными способами. Для начала, рассмотрим формат datetime.date, так как это один из самых простых объектов date.

Python

print( datetime.date(2012, 13, 14) )

Traceback (most recent call last):
File «<string>», line 1, in <fragment>
builtins.ValueError: month must be in 1..12

1 2 3 4 5

print(datetime.date(2012,13,14)) Traceback(most recent call last) File»<string>»,line1,in<fragment> builtins.ValueErrormonth must be in1..12

Python

print(datetime.date(2012, 12, 14)) # datetime.date(2012, 12, 14)

1	print(datetime.date(2012,12,14))# datetime.date(2012, 12, 14)

В данном коде показано, как создать простой объект даты. Класс date принимает три аргумента: год, месяц и день. Если вы укажите неправильное значение, вы увидите ошибку ValueError, как в случае выше. В противном случае вы увидите, что объект datetime.date вернулся. Давайте взглянем на еще один пример:

Python

import datetime
d = datetime.date(2012, 12, 14)

print(d.year) # 2012
print(d.day) # 14
print(d.month) # 12

1 2 3 4 5 6

importdatetime d=datetime.date(2012,12,14) print(d.year)# 2012 print(d.day)# 14 print(d.month)# 12

Здесь мы присваиваем объекту date переменную d. Теперь мы можем получить доступ к различным компонентам даты по названиям, таким как d.year или d.month. Давайте посмотрим, какой сейчас день:

Python

import datetime

print(datetime.date.today()) # datetime.date(2017, 4, 5)

1 2 3

importdatetime print(datetime.date.today())# datetime.date(2017, 4, 5)

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

time.sleep

Функция time.sleep дает разработчику возможность приостановить выполнение его скрипта на определенное количество секунд. Это можно сравнить с добавлением функции «Пауза» в вашу программу. Я нашел этот класс особенно полезным, когда мне нужно было подождать несколько секунд, пока закроется файл, или база данных закончит выполнять свою задачу. Давайте взглянем на пример. Откройте новое окно в IDLE и сохраните следующий код:

Python

import time

for x in range(5):
time.sleep(2)
print(«Slept for 2 seconds»)

1 2 3 4 5

importtime forxinrange(5) time.sleep(2) print(«Slept for 2 seconds»)

Теперь запустите этот код в IDLE. Сделав это, вы увидите фразу «Slept for 2 seconds» пять раз, с интервалом в 2 секунды между каждым сообщением. Это очень легко в использовании!

Waiting in a Multi-Threaded Environment

If you’re having multiple threads in your program, you can still use the same logic via to make a particular thread wait for a specific time in Python

Here is an example, which spawns 3 threads, and makes them sleep for a second alternatively, while the other threads keep printing numbers from 1.

We’ll use the module and use the to pool and execute threads, while fetching the results using .

The basic structure of spawning and fetching using threads is as follows:

from concurrent.futures import ThreadPoolExecutor, as_completed

# The threads will call this function
def callback():
    pass

with ThreadPoolExecutor() as thread_executor:
    # Await all results
    await_results = 
    # Fetch them!
    for f in as_completed():
        print(f.result())

Now, let’s write the code for our main program.

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

# Global Variable for the Thread ID Number
tid = 0
# Spawn 4 threads
NUM_THREADS = 4

def func(arg):
    time.sleep(1)
    return arg * arg

if __name__ == '__main__':
    with ThreadPoolExecutor() as thread_executor:
        start_time = time.time()
        # Going to spawn threads
        tid += NUM_THREADS
        # Await all results
        await_results = 
        for f in as_completed():
            print(f.result())
        end_time = time.time()
        print(f"Total Time taken for {NUM_THREADS} threads: {end_time - start_time}")

Output

1
4
9
16
Total Time taken for 4 threads: 1.0037879943847656

As you can see, we spawned 4 threads, who all waited for 1 second before giving the result of the function. This is very close to 1 second, so our output makes sense!

Using threading.Timer() to schedule function calls

However, if you want a particular function to wait for a specific time in Python, we can use the method from the module.

We’ll show a simple example, which schedules a function call every 5 seconds.

from threading import Timer
import time

def func(a, b):
    print("Called function")
    return a * b

# Schedule a timer for 5 seconds
# We pass arguments 3 and 4
t = Timer(5.0, func, )

start_time = time.time()

# Start the timer
t.start()

end_time = time.time()

if end_time - start_time < 5.0:
    print("Timer will wait for sometime before calling the function")
else:
    print("5 seconds already passed. Timer finished calling func()")

Output

Timer will wait for sometime before calling the function
Called function

Here, the main program came to the last line before 5 seconds were up, so Timer makes the program wait until it calls .

After calling , it terminates the program, since there is nothing else to run.

Also notice that the return value of the function cannot be used by the main program.

Hopefully, this gave you some more ideas about scheduling and waiting for intervals.

Обработка и форматирование времени

Функции strptime() и strftime() преобразуют struct_time в строковые представления значений времени и наоборот. Существует длинный список инструкций по форматированию для поддержки ввода и вывода в разных форматах. Полный список указан в документации библиотеки для модуля time.

В приведенном ниже примере использования модуля time Python текущее время преобразуется из строки в экземпляр struct_time и обратно в строку:

time_strptime.py
import time
def show_struct(s):
    print('  tm_year :', s.tm_year)
    print('  tm_mon  :', s.tm_mon)
    print('  tm_mday :', s.tm_mday)
    print('  tm_hour :', s.tm_hour)
    print('  tm_min  :', s.tm_min)
    print('  tm_sec  :', s.tm_sec)
    print('  tm_wday :', s.tm_wday)
    print('  tm_yday :', s.tm_yday)
    print('  tm_isdst:', s.tm_isdst)
now = time.ctime(1483391847.433716)
print('Now:', now)
parsed = time.strptime(now)
print('nParsed:')
show_struct(parsed)
print('nFormatted:',
      time.strftime("%a %b %d %H:%M:%S %Y", parsed))

В примере с time strftime Python строка вывода не такая же, как и входная, так как день месяца имеет префикс с нулем:

$ python3 time_strptime.py

Now: Mon Jan  2 16:17:27 2017

Parsed:
  tm_year : 2017
  tm_mon  : 1
  tm_mday : 2
  tm_hour : 16
  tm_min  : 17
  tm_sec  : 27
  tm_wday : 0
  tm_yday : 2
  tm_isdst: -1

Formatted: Mon Jan 02 16:17:27 2017

The Purpose of Sleep

Sleep serves multiple purposes that are essential to your brain and body. Let’s break down some of the most important ones.

The first purpose of sleep is restoration. Every day, your brain accumulates metabolic waste as it goes about its normal neural activities. While this is completely normal, too much accumulation of these waste products has been linked to neurological disorders such as Alzheimer’s disease.

Alright, so how do we get rid of metabolic waste? Recent research has suggested that sleep plays a crucial role in cleaning out the brain each night. While these toxins can be flushed out during waking hours, researchers have found that clearance during sleep is as much as two-fold faster than during waking hours.

The way this process occurs is fairly remarkable:

During sleep, brain cells actually shrink by 60 percent, allowing the brain’s waste-removal system—called the glymphatic system—to essentially “take out the trash” more easily. The result? Your brain is restored during sleep, and you wake up refreshed and with a clear mind.

The second purpose of sleep is memory consolidation. Sleep is crucial for memory consolidation, which is the process that maintains and strengthens your long-term memories. Insufficient or fragmented sleep can hamper your ability to form both concrete memories (facts and figures) and emotional memories.

Finally, sleep is paramount for metabolic health. Studies have shown that when you sleep 5.5 hours per night instead of 8.5 hours per night, a lower proportion of the energy you burn comes from fat, while more comes from carbohydrate and protein. This can predispose you to fat gain and muscle loss. Additionally, insufficient sleep or abnormal sleep cycles can lead to insulin insensitivity and metabolic syndrome, increasing your risk of diabetes and heart disease.

Don’t see a signup form? Send me a message here and I’ll add you right away.

Работа с часовыми поясами

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

Чтобы изменить часовой пояс, установите переменную среды TZ, затем вызовите tzset(). Часовой пояс можно указать с различными данными, вплоть до времени начала и завершения периода так называемого «летнего» времени. Проще всего использовать название часового пояса, но базовые библиотеки получают и другую информацию.

Приведенная ниже программа без  time sleep python, и задает несколько разных значений для часового пояса и показывает, как изменения влияют на другие настройки в модуле времени:

time_timezone.py
import time
import os
def show_zone_info():
    print('  TZ    :', os.environ.get('TZ', '(not set)'))
    print('  tzname:', time.tzname)
    print('  Zone  : {} ({})'.format(
        time.timezone, (time.timezone / 3600)))
    print('  DST   :', time.daylight)
    print('  Time  :', time.ctime())
    print()
print('Default :')
show_zone_info()
ZONES = [
    'GMT',
    'Europe/Amsterdam',
]
for zone in ZONES:
    os.environ = zone
    time.tzset()
    print(zone, ':')
    show_zone_info()

Часовой пояс по умолчанию для системы, используемой в примерах — US / Eastern. Другие зоны в примере, который позволяет реализовать  модуль time Python изменяют значение tzname, продолжительности светового дня и значение смещения часового пояса:

$ python3 time_timezone.py
Default :
  TZ    : (not set)
  tzname: ('EST', 'EDT')
  Zone  : 18000 (5.0)
  DST   : 1
  Time  : Sun Aug 14 14:10:42 2016
GMT :
  TZ    : GMT
  tzname: ('GMT', 'GMT')
  Zone  : 0 (0.0)
  DST   : 0
  Time  : Sun Aug 14 18:10:42 2016
Europe/Amsterdam :
  TZ    : Europe/Amsterdam
  tzname: ('CET', 'CEST')
  Zone  : -3600 (-1.0)
  DST   : 1
  Time  : Sun Aug 14 20:10:42 2016

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

Python timeit — интерфейс командной строки

Интерфейс командной строки очень похож на интерфейс запуска программы Python.

Вам необходимо импортировать внешний модуль с помощью опции -m и применить его к вашему коду.

python -m timeit 'print("Hello from AskPython")'

Это запустит фрагмент, переданный в виде строки, с использованием .

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

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

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

import timeit

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

execution_time = timeit.timeit(code, number)

Мы можем контролировать количество итераций с помощью параметра .

>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.19053685299877543
>>> timeit.timeit('"-".join()', number=10000)
0.172546762998536
>>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
0.13625987299747067
>>>