Метод 1: Использование psutil Функция psutil.cpu_percent () показывает текущую загрузку ЦП в системе в процентах. Требуется параметр, который представляет собой временной интервал (секунды). Поскольку загрузка ЦП рассчитывается за определенный период времени, рекомендуется указать временной интервал. Синтаксис:
cpu_percent(time_interval)
Example:
Python
# Importing the library
import psutil
# Calling psutil.cpu_precent() for 4 seconds
print ( «The CPU usage is: » , psutil.cpu_percent( 4 ))
Выход:
Использование ЦП: 2,4
Метод 2: Использование модуля ОС Psutil.getloadavg () предоставляет информацию о загрузке ЦП в виде кортежа. Psutil.getloadavg () работает в фоновом режиме, и результаты обновляются каждые 5 секунд . Os.cpu_count () возвращает количество процессоров в системе. Example:
Python3
import psutil
# Getting loadover15 minutes
load1, load5, load15 = psutil.getloadavg()
cpu_usage = (load15 / os.cpu_count()) * 100
print ( «The CPU usage is : » , cpu_usage)
Выход:
Как узнать время выполнения программы? #python #программирование
The CPU usage is: 13.4
Использование RAM
- total : общая память без подкачки
- доступно : доступная память для процессов
- процент : использование памяти в процентах
- использовано : используемая память
- бесплатно : память не используется и легко доступна
Python
# Importing the library
import psutil
# Getting % usage of virtual_memory ( 3rd field)
print ( «RAM memory % used:» , psutil.virtual_memory()[ 2 ])
Выход:
% Используемой оперативной памяти: 76,9
Метод 2: Использование модуля ОС Модуль os также полезен для расчета использования оперативной памяти в ЦП. Метод os.popen () с флагами в качестве входных данных может предоставить общую, доступную и используемую память. Этот метод открывает канал к команде или от нее. Возвращаемое значение может быть прочитано или записано в зависимости от того, какой режим — «r» или «w». Синтаксис:
os.popen (команда [, режим [, размер буфера]])
Example:
Python3
# Getting all memory using os.popen()
total_memory, used_memory, free_memory = map (
int , os.popen( «free -t -m» ).readlines()[ — 1 ].split()[ 1 :])
# Memory usage
print ( «RAM memory % used:» , round ((used_memory / total_memory) * 100 , 2 ))
Выход:
% Используемой оперативной памяти: 17,55
Примечание. Метод модуля os работает с системой Linux только из-за того, что для системы Linux указан флаг освобождения и системная команда. Внимание компьютерщик! Укрепите свои основы с помощью базового курса программирования Python и изучите основы. Для начала подготовьтесь к собеседованию.
Расширьте свои концепции структур данных с помощью курса Python DS. А чтобы начать свое путешествие по машинному обучению, присоединяйтесь к курсу Машинное обучение — базовый уровень.
Источник: progler.ru
Расчёт времени выполнения программы на python #short
Разработка чрезвычайно быстрых программ на Python
Ненавистники Python всегда говорят, что одной из причин того, что они не хотят использовать этот язык, является то, что Python — это медленно. Но то, что некая программа, независимо от используемого языка программирования, может считаться быстрой или медленной, очень сильно зависит от разработчика, который её написал, от его знаний и от умения создавать оптимизированный и высокопроизводительный код.
Автор статьи, перевод которой мы сегодня публикуем, предлагает доказать то, что те, кто называет Python медленным, неправы. Он хочет рассказать о том, как улучшить производительность Python-программ и сделать их по-настоящему быстрыми.
Измерение времени и профилирование
Прежде чем приступить к оптимизации какого-либо кода, сначала надо выяснить то, какие его части замедляют всю программу. Иногда узкое место программы может быть очевидным, но если программист не знает, где оно находится, он может воспользоваться некоторыми возможностями по его выявлению.
Ниже представлен код программы, который я буду использовать в демонстрационных целях. Он взят из документации к Python. Этот код возводит e в степень x :
# slow_program.py from decimal import * def exp(x): getcontext().prec += 2 i, lasts, s, fact, num = 0, 0, 1, 1, 1 while s != lasts: lasts = s i += 1 fact *= i num *= x s += num / fact getcontext().prec -= 2 return +s exp(Decimal(150)) exp(Decimal(400)) exp(Decimal(3000))
Самый лёгкий способ «профилирования» кода
Для начала рассмотрим самый простой способ профилирования кода. Так сказать, «профилирование для ленивых». Он заключается в использовании команды Unix time :
~ $ time python3.8 slow_program.py real 0m11,058s user 0m11,050s sys 0m0,008s
Такое профилирование вполне может дать программисту некие полезные сведения — в том случае, если ему нужно замерить время выполнения всей программы. Но обычно этого недостаточно.
Самый точный способ профилирования
На другом конце спектра методов профилирования кода лежит инструмент cProfile , который даёт программисту, надо признать, слишком много сведений:
~ $ python3.8 -m cProfile -s time slow_program.py 1297 function calls (1272 primitive calls) in 11.081 seconds Ordered by: internal time ncalls tottime percall cumtime percall filename:lineno(function) 3 11.079 3.693 11.079 3.693 slow_program.py:4(exp) 1 0.000 0.000 0.002 0.002 4/1 0.000 0.000 11.081 11.081 6 0.000 0.000 0.000 0.000 6 0.000 0.000 0.000 0.000 abc.py:132(__new__) 23 0.000 0.000 0.000 0.000 _weakrefset.py:36(__init__) 245 0.000 0.000 0.000 0.000 2 0.000 0.000 0.000 0.000 10 0.000 0.000 0.000 0.000 :1233(find_spec) 8/4 0.000 0.000 0.000 0.000 abc.py:196(__subclasscheck__) 15 0.000 0.000 0.000 0.000 6 0.000 0.000 0.000 0.000 1 0.000 0.000 0.000 0.000 __init__.py:357(namedtuple) 48 0.000 0.000 0.000 0.000 :57(_path_join) 48 0.000 0.000 0.000 0.000 :59() 1 0.000 0.000 11.081 11.081 slow_program.py:1()
Тут мы запускаем исследуемый скрипт с использованием модуля cProfile и применяем аргумент time . В результате строки вывода упорядочены по внутреннему времени ( cumtime ). Это даёт нам очень много информации. На самом деле то, что показано выше, это лишь около 10% вывода cProfile .
Проанализировав эти данные, мы можем увидеть, что причиной медленной работы программы является функция exp (вот уж неожиданность!). После этого мы можем заняться профилированием кода, используя более точные инструменты.
Исследование временных показателей выполнения конкретной функции
Теперь мы знаем о том месте программы, куда нужно направить наше внимание. Поэтому мы можем решить заняться исследованием медленной функции, не профилируя другой код программы. Для этого можно воспользоваться простым декоратором:
Этот декоратор можно применить к функции, которую нужно исследовать:
Теперь после запуска программы мы получим следующие сведения:
~ $ python3.8 slow_program.py module function time __main__ .exp : 0.003267502994276583 __main__ .exp : 0.038535295985639095 __main__ .exp : 11.728486061969306
Тут стоит обратить внимание на то, какое именно время мы планируем измерять.
Соответствующий пакет предоставляет нам такие показатели, как time.perf_counter и time.process_time . Разница между ними заключается в том, что perf_counter возвращает абсолютное значение, в которое входит и то время, в течение которого процесс Python-программы не выполняется. Это значит, что на этот показатель может повлиять нагрузка на компьютер, создаваемая другими программами. Показатель process_time возвращает только пользовательское время (user time). В него не входит системное время (system time). Это даёт нам только сведения о времени выполнения нашего процесса.
Ускорение кода
А теперь переходим к самому интересному. Поработаем над ускорением программы. Я (по большей части) не собираюсь показывать тут всякие хаки, трюки и таинственные фрагменты кода, которые волшебным образом решают проблемы производительности. Я, в основном, хочу поговорить об общих идеях и стратегиях, которые, если ими пользоваться, могут очень сильно повлиять на производительность. В некоторых случаях речь идёт о 30% повышении скорости выполнения кода.
▍Используйте встроенные типы данных
Использование встроенных типов данных — это совершенно очевидный подход к ускорению кода. Встроенные типы данных чрезвычайно быстры, в особенности — если сравнить их с пользовательскими типами, вроде деревьев или связных списков. Дело тут, в основном, в том, что встроенные механизмы языка реализованы средствами C. Если описывать нечто средствами Python — нельзя добиться того же уровня производительности.
▍Применяйте кэширование (мемоизацию) с помощью lru_cache
Кэширование — популярный подход к повышению производительности кода. О нём я уже писал, но полагаю, что о нём стоит рассказать и здесь:
Вышеприведённая функция имитирует сложные вычисления, используя time.sleep . Когда её в первый раз вызывают с параметром 1 — она ждёт 2 секунды и возвращает результат только после этого. Когда же её снова вызывают с тем же параметром, оказывается, что результат её работы уже кэширован. Тело функции в такой ситуации не выполняется, а результат возвращается немедленно. Здесь можно найти примеры применения кэширования, более близкие к реальности.
▍Используйте локальные переменные
Применяя локальные переменные, мы учитываем скорость поиска переменной в каждой области видимости. Я говорю именно о «каждой области видимости», так как тут я имею в виду не только сопоставление скорости работы с локальными и глобальными переменными. На самом деле, разница в работе с переменными наблюдается даже, скажем, между локальными переменными в функции (самая высокая скорость), атрибутами уровня класса (например — self.name , это уже медленнее), и глобальными импортированными сущностями наподобие time.time (самый медленный из этих трёх механизмов).
Улучшить производительность можно, используя следующие подходы к присваиванию значений, которые несведущему человеку могут показаться совершенно ненужными и бесполезными:
# Пример #1 class FastClass: def do_stuff(self): temp = self.value # это ускорит цикл for i in range(10000): . # Выполняем тут некие операции с `temp` # Пример #2 import random def fast_function(): r = random.random for i in range(10000): print(r()) # здесь вызов `r()` быстрее, чем был бы вызов random.random()
▍Оборачивайте код в функции
Этот совет может показаться противоречащим здравому смыслу, так как при вызове функции в стек попадают некие данные и система испытывает дополнительную нагрузку, обрабатывая операцию возврата из функции. Однако эта рекомендация связана с предыдущей. Если вы просто поместите весь свой код в один файл, не оформив в виде функции, он будет выполняться гораздо медленнее из-за использования глобальных переменных. Это значит, что код можно ускорить, просто обернув его в функцию main() и один раз её вызвав:
def main(): . # Весь код, который раньше был глобальным main()
▍Не обращайтесь к атрибутам
Ещё один механизм, способный замедлить программу — это оператор точка ( . ), который используется для доступа к атрибутам объектов. Этот оператор вызывает выполнение процедуры поиска по словарю с использованием __getattribute__ , что создаёт дополнительную нагрузку на систему. Как ограничить влияние этой особенности Python на производительность?
# Медленно: import re def slow_func(): for i in range(10000): re.findall(regex, line) # Медленно! # Быстро: from re import findall def fast_func(): for i in range(10000): findall(regex, line) # Быстрее!
▍Остерегайтесь строк
Операции на строках могут сильно замедлить программу в том случае, если выполняются в циклах. В частности, речь идёт о форматировании строк с использованием %s и .format() . Можно ли их чем-то заменить?
Если взглянуть на недавний твит Раймонда Хеттингера, то можно понять, что единственный механизм, который надо использовать в подобных ситуациях — это f-строки. Это — самый читабельный, лаконичный и самый быстрый метод форматирования строк. Вот, в соответствии с тем твитом, список методов, которые можно использовать для работы со строками — от самого быстрого к самому медленному:
f’ ‘ # Быстро! s + ‘ ‘ + t ‘ ‘.join((s, t)) ‘%s %s’ % (s, t) ‘<> <>’.format(s, t) Template(‘$s $t’).substitute(s=s, t=t) # Медленно!
▍Знайте о том, что и генераторы могут работать быстро
Генераторы — это не те механизмы, которые, по своей природе, являются быстрыми. Дело в том, что они были созданы для выполнения «ленивых» вычислений, что экономит не время, а память.
Однако экономия памяти может привести к тому, что программы будут выполняться быстрее. Как это возможно? Дело в том, что при обработке большого набора данных без использования генераторов (итераторов) данные могут привести к переполнению L1-кэша процессора, что значительно замедлит операции по поиску значений в памяти.
Если речь идёт о производительности, очень важно стремиться к тому, чтобы процессор мог бы быстро обращаться к обрабатываемым им данным, чтобы они находились бы как можно ближе к нему. А это значит, что такие данные должны помещаться в процессорном кэше. Этот вопрос затрагивается в данном выступлении Раймонда Хеттингера.
Итоги
Первое правило оптимизации заключается в том, что оптимизацией заниматься не нужно. Но если без оптимизации никак не обойтись, тогда я надеюсь, что советы, которыми я поделился, вам в этом помогут.
Уважаемые читатели! Как вы подходите к оптимизации производительности своего Python-кода?
Источник: temofeev.ru
Даты, времена и календари в Python
Изменение цен на нефть со временем, изменение температуры за день, уровень цен за месяц, доходы за год — все эти компоненты объединяет время. В Data Science часто приходится сталкиваться с временными рядами. Сегодня мы расскажем о стандартных модулях Python, которые предоставляют интерфейс для дат и времени: time, datetime, calendar.
3 основных модуля
В комплекте стандартных библиотек Python имеются три основных модуля для работы со временем, датами и календарем:
- time предоставляет различные функции для управления значениями времени;
- datetime поможет для работы с датами;
- calendar обеспечит идеализированным григорианским календарем.
Далее мы рассмотрим, как их можно использовать в реальных проектах Data Science и повседневных задачах Python-программиста.
Модуль time для отсчета времени
Время в Python отсчитывается в секундах от начала эпохи. Эпоха может отличаться для разных операционных систем. Для Unix-систем эпоха — это январь 1970 года 00:00:00. Чтобы узнать, какая эпоха на компьютере, используется функция time.gmtime(0) :
>>> import time >>> time.gmtime(0) time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
Возвращается объект time_struct , который имеет атрибуты в виде года, месяца, недели и т.д. Последний атрибут tm_isdst показывает летнее ли время (0 — нет, 1- да).
Считаем время в Python
Чтобы узнать, сколько прошло секунд с эпохи до настоящего времени, в Python используется функция time :
>>> time.time() 1598423943.4023273
Можно получить объект time_struct с нынешним временем в вашем часовом поясе, для этого есть localtime :
>>> time.localtime() time.struct_time(tm_year=2020, tm_mon=8, tm_mday=26, tm_hour=13, tm_min=39, tm_sec=43, tm_wday=2, tm_yday=239, tm_isdst=0)
Получить полный форматированный вариант в читаемом виде поможет функция time.asctime() :
>>> time.asctime() ‘Wed Aug 26 13:51:33 2020’
Более удобный формат времени
Функция asctime возвращает полную информацию о времени в определенном формате. Когда требуется самостоятельно задать формат вывода, в Python можно воспользоваться функцией strftime , которая принимает формат вывода и объект time_struct :
>>> time.strftime(«%a %d %Y», time.localtime()) ‘Wed 26 2020’
Здесь %a означает день недели, %d — день месяца, а %Y — год. Полный список доступен в официальной документации.
Из строки в time_stuct
А вот получить из строки (str) соответствующий объект time_struct можно с помощью функции strptime:
>>> time.strptime(«Wed 26 2020», «%a %d %Y») time.struct_time(tm_year=2020, tm_mon=1, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=26, tm_isdst=-1)
Не стоит путать с strftime , так как они различаются на одну букву.
Засыпаем на некоторое время
Иногда требуется сымитировать действие, которое занимает определенное время. На помощь придет функция sleep, которая аргументом принимает секунды:
>>> def timeit(secs): . start = time.time() . time.sleep(secs) # заснуть на secs . end = time.time( . return end — start . >>> timeit(1) 1.0011100769042969
Работаем с датами
Интерфейс для дат в Python можно найти в модуле datetime . У него есть 3 основных класса: date , time и datetime — для работы с только датами, только временем и с датой и временем, соответственно. Объект date принимает в качестве аргументов год, месяц и день:
>>> from datetime import date, time, datetime >>> date(year=2020, month=1, day=15) datetime.date(2020, 1, 15)
Объект time принимает часы, минуты и секунды:
>>> time(hour=18, minute=45, second=30) datetime.time(18, 45, 30)
Объект datetime принимает все вышеперечисленное:
>>> datetime(year=2020, month=1, day=15, hour=18, minute=45, second=30) datetime.datetime(2020, 1, 15, 18, 45, 30)
Сейчас и сегодня
В Python можно получить сегодняшнюю дату:
>>> date.today() datetime.date(2020, 8, 26)
А также, текущую дату и время:
>>> datetime.today() datetime.datetime(2020, 8, 26, 15, 52, 39, 757438)
Получаем даты из ISO-формата
Помимо прочего, можно получить дату из ISO формат с видом YYYY-MM-DD:
>>> date.fromisoformat(«2020-01-15») datetime.date(2020, 1, 15)
В Python 8 был добавлен метод fromisocalendar , который принимает в качестве аргументов год, неделю, месяц:
>>> date.fromisocalendar(2020, 45, 3) datetime.date(2020, 11, 4)
Формат даты из строки
Как и время из модуля time, объект datetime имеет методы strptime и strftime для получение строки из даты и наоборот:
>>> datetime.strptime(«Wed 26 2020», «%a %d %Y») datetime.datetime(2020, 1, 26, 0, 0) >>> today = datetime.today() >>> today.strftime(«%a %d %Y») ‘Wed 26 2020’
Из секунд в даты
Как уже было сказано, time.time возвращает количество секунд, которые начинаются с эпохи. Эти секунды также можно перевести в дату и время:
>>> now = time.time() >>> datetime.fromtimestamp(now) datetime.datetime(2020, 8, 26, 13, 39, 3, 402327)
Сколько времени прошло
В Python-модуле datetime имеется специальный объект timedelta , который используется для разницы между датами
>>> from datetime import timedelta >>> timedelta(days=10, seconds=25) datetime.timedelta(days=10, seconds=25)
Например, можно получить разницу между сегодняшним и вчерашним днями:
>>> today = datetime.today() >>> yesterday = date(2020, 8, 25) >>> today — yesterday datetime.timedelta(days=1)
Для более точного подсчета можно добавить часы, минуты, секунды.
Работаем с календарем
В Python также можно работать с календарем, который есть в модуле calendar . Объект Calendar позволяет итерировать дни и недели в месяце, в году и т.д. Например, метод monthdatescalendar вернет список дней (объекты datetime ) заданного месяца и года, причем дополнит их так, чтобы начинался с первого дня понедельника прошлого месяца и заканчивался последним воскресенья следующего (для августа 2020 — это 27 июля и 6 сентября):
>>> from calendar import Calendar >>> c = Calendar() >>> c.monthdatescalendar(2020, 8) [datetime.date(2020, 7, 27), datetime.date(2020, 7, 28), . datetime.date(2020, 8, 1), datetime.date(2020, 8, 2), . datetime.date(2020, 8, 31), . datetime.date(2020, 9, 6)]
А вот метод yeardatescalendar вернет список дней заданного года. И в этом случае он будет каждый месяц дополнять днями первого понедельника и последнего воскресенья, поэтому если требуется посчитать количество дней в году лучше использовать функцию max для месяца, а не len .
В Python 3.7 были добавлены методы, которые возвращают не список, а генератор (о них мы писали тут). Поэтому вместо monthdatescalendar можно использовать itermonthdays .
Печатаем календарь на месяц
В Python можно получить календарь в читаемом формате с помощью prmonth:
>>> import calendar >>> calendar.prmonth(2020, 8) August 2020 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Печатаем календарь на год
А вот функция prcal напечатает весь календарь заданного года:
>>> calendar.prcal(2020) January February March Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su 1 2 3 4 5 1 2 1 6 7 8 9 10 11 12 3 4 5 6 7 8 9 2 3 4 5 6 7 8 13 14 15 16 17 18 19 10 11 12 13 14 15 16 9 10 11 12 13 14 15 20 21 22 23 24 25 26 17 18 19 20 21 22 23 16 17 18 19 20 21 22 27 28 29 30 31 24 25 26 27 28 29 23 24 25 26 27 28 29 30 31 . остальные месяцы
Дни недели
Что не перечислять дни недели самостоятельно (Monday, Tuesday и т.д), можно использовать готовые перечисления. Также с функцией weekday можно узнать день недели заданного дня:
>>> calendar.WEDNESDAY 2 >>> calendar.weekday(2020, 8, 26) 2
Еще больше подробностей вы сможете о работе со временем, датами и временными рядами в целом, вы узнаете на наших Python-курсах в лицензированном учебном центре обучения и повышения квалификации IT-специалистов в Москве.
Источник: python-school.ru