Материал содержит описание функций модуля psutil
с примерами, которые возвращают различные статистические данные об использовании ресурсов операционной системы и программного обеспечения, работающего в ней. Такие как: текущая загрузка ОС и ЦП, количество логических и физических процессоров, частота ЦП, процессорное время и т.д.
psutil.cpu_times()
время работы системного процессора,psutil.cpu_percent()
текущая загрузка ЦП в процентах,psutil.cpu_times_percent()
то же, что psutil.cpu_times(percpu=True)
,psutil.cpu_count()
количество логических и физических процессоров,psutil.cpu_stats()
различная статистика ЦП,psutil.cpu_freq()
частота ЦП,psutil.getloadavg()
средняя загрузка системы,psutil.boot_time()
время загрузки системы.psutil.cpu_times(percpu=False)
:Функция psutil.cpu_times()
возвращает время работы системного процессора в виде именованного кортежа. Каждый атрибут представляет секунды, потраченные процессором в данном режиме.
Когда аргумент percpu
имеет значение True
, то функция возвращает список именованных кортежей для каждого логического процессора в системе. Первый элемент списка относится к первому процессору, второй элемент - ко второму процессору и так далее. Порядок списка одинаков для всех вызовов.
Пример использования psutil.cpu_times()
в Linux:
>>> import psutil >>> psutil.cpu_times() # scputimes(user=17411.7, nice=77.99, system=3797.02, idle=51266.57, # iowait=732.58, irq=0.01, softirq=142.43, steal=0.0, guest=0.0, guest_nice=0.0)
Доступность атрибутов варьируется в зависимости от платформы:
user
: время, затрачиваемое обычными процессами, выполняемыми в пользовательском режиме. В Linux оно также включает гостевое время. system
: время, затрачиваемое процессами, выполняющимися в режиме ядра.idle
: время, потраченное на простой (когда процессор ничего не делает).Поля, специфичные для конкретной платформы:
nice
(UNIX): время, затрачиваемое процессами с приоритетом niced
, выполняющимися в пользовательском режиме. В Linux это также включает время guest_nice
;iowait
(Linux): время, потраченное на ожидание завершения ввода-вывода. Это время не учитывается в счетчике времени простоя;irq
(Linux, BSD): время, затрачиваемое на обслуживание аппаратных прерываний;softirq
(Linux): время, затрачиваемое на обслуживание программных прерываний;steal
(Linux 2.6.11+): время, затрачиваемое другими операционными системами, работающими в виртуализированной среде;guest
(Linux 2.6.24+): время, затрачиваемое на запуск виртуального процессора для гостевых операционных систем под управлением ядра Linux;guest_nice
(Linux 3.2.0+): время, затраченное на запуск niced guest
(виртуальный процессор для гостевых операционных систем под управлением ядра Linux);interrupt
(Windows): время, затрачиваемое на обслуживание аппаратных прерываний (аналогично “irq” в UNIX)dpc
(Windows): время, затрачиваемое на обслуживание вызовов отложенных процедур (DPC). DPC - это прерывания, которые выполняются с более низким приоритетом, чем стандартные прерывания.Предупреждение: процессорное время всегда должно увеличиваться с течением времени или, по крайней мере, оставаться неизменным, потому что время не может идти вспять. Удивительно, но иногда это может быть не так (по крайней мере, в OC Windows и OC Linux).
psutil.cpu_percent(interval=None, percpu=False)
:Функция psutil.cpu_percent()
возвращает число float
, представляющее текущую загрузку ЦП в масштабе всей системы в процентах.
Когда аргумент interval
> 0,0, то сравнивается время системного процессора, прошедшее до и после интервала (блокировка). Когда интервал равен 0,0 или None
, то сравнивается время системного процессора, прошедшее с момента последнего вызова или импорта модуля, с немедленным возвратом значения. Это означает, что при первом вызове он вернет бессмысленное значение 0.0, которое необходимо игнорировать. В этом случае для точности рекомендуется вызывать эту функцию с интервалом не менее 0,1 секунды между вызовами.
Когда аргумент percpu
имеет значение True
, то функция возвращает список чисел float
, представляющий использование в процентах для каждого ЦП. Первый элемент списка относится к первому процессору, второй элемент - ко второму процессору и так далее. Порядок списка одинаков для всех вызовов.
Пример использования psutil.cpu_percent()
:
>>> import psutil # блокирующий вызов >>> psutil.cpu_percent(interval=1) # 2.0 # неблокирующий вызов # (процент с момента последнего вызова) >>> psutil.cpu_percent(interval=None) # 2.9 # блокирующий вызов, загрузка на процессор >>> psutil.cpu_percent(interval=1, percpu=True) # [2.0, 1.0]
Предупреждение: при первом вызове этой функции с интервалом = 0,0 или
None
она вернет бессмысленное значение 0,0, которое нужно проигнорировать.
psutil.cpu_times_percent(interval=None, percpu=False)
:Функция psutil.cpu_times_percent()
возвращает то же, что и функция psutil.cpu_times(percpu=True)
и предоставляет процент использования для каждого конкретного процессорного времени. Аргументы interval
и percpu
имеют то же значение, что и в psutil.cpu_percent()
. В Linux проценты guest
и guest_nice
не учитываются в процентах user
и user_nice
.
Предупреждение: при первом вызове этой функции с интервалом, равным 0,0 или
None
она вернет бессмысленное значение 0,0, которое нужно игнорировать.
psutil.cpu_count(logical=True)
:Функция psutil.cpu_count()
возвращает количество логических процессоров в системе (так же, как os.cpu_count
) или None
, если оно не определено.
"Логические процессоры" означают количество физических ядер, умноженное на количество потоков, которые могут выполняться на каждом ядре (это называется Hyper-Threading). Если для аргумента logical
задано значение False
, то возвращает только количество физических ядер или None
, если оно не определено. В OpenBSD и NetBSD psutil.cpu_count(logical=False)
всегда возвращает None
.
Пример использования psutil.cpu_count()
для системы с 2 ядрами + Hyper Threading:
>>> import psutil >>> psutil.cpu_count() # 4 >>> psutil.cpu_count(logical=False) # 2
Обратите внимание, что psutil.cpu_count()
не обязательно может быть эквивалентно фактическому количеству процессоров, которые может использовать текущий процесс. Число может измениться в случае изменения привязки процессора к процессу, использования контрольных групп Linux или (в случае Windows) в системах, использующих группы процессоров или имеющих более 64 процессоров.
Количество используемых ЦП можно получить с помощью:
>>> len(psutil.Process().cpu_affinity()) # 1
psutil.cpu_stats()
:Функция psutil.cpu_stats()
возвращает различную статистику ЦП в виде именованного кортежа:
ctx_switches
: количество переключений контекста (добровольных + непроизвольных) с момента загрузки.interrupts
: количество прерываний с момента загрузки.soft_interrupts
: количество программных прерываний с момента загрузки. В Windows и SunOS всегда устанавливается значение 0.syscalls
: количество системных вызовов с момента загрузки. В Linux всегда устанавливается в 0.Пример использования psutil.cpu_stats()
для Linux:
>>> import psutil >>> psutil.cpu_stats() # scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
psutil.cpu_freq(percpu=False)
:Функция psutil.cpu_freq()
возвращает частоту ЦП в виде именованного кортежа, включая текущую, минимальную и максимальную частоты, выраженные в МГц.
В Linux текущая частота сообщает значение в реальном времени, на всех других платформах значение представляет собой номинальное "фиксированное" значение (никогда не меняющееся). Если аргумент percpu
имеет значение True
и система поддерживает получение частоты для каждого процессора (только Linux), то возвращается список частот для каждого процессора, если не поддерживает, то возвращается список с одним элементом. Если минимальные и максимальные значения не могут быть определены, то они устанавливаются равными 0,0.
Пример использования psutil.cpu_freq()
для Linux:
>>> import psutil >>> psutil.cpu_freq() # scpufreq(current=931.42925, min=800.0, max=3500.0) >>> psutil.cpu_freq(percpu=True) # [scpufreq(current=2394.945, min=800.0, max=3500.0), # scpufreq(current=2236.812, min=800.0, max=3500.0), # scpufreq(current=1703.609, min=800.0, max=3500.0), # scpufreq(current=1754.289, min=800.0, max=3500.0)]
Доступность: Linux, macOS, Windows, FreeBSD, OpenBSD
psutil.getloadavg()
:Функция psutil.getloadavg()
возвращает среднюю загрузку системы за последние 1, 5 и 15 минут в виде кортежа. "Нагрузка" представляет собой процессы, находящиеся в состоянии готовности к выполнению, либо использующие ЦП, либо ожидающие использования ЦП (например, ожидающие дискового ввода-вывода).
В системах UNIX это зависит от os.getloadavg
. В Windows это эмулируется с помощью Windows API, который порождает поток, который продолжает работать в фоновом режиме и обновляет результаты каждые 5 секунд, имитируя поведение UNIX. Таким образом, в Windows при первом вызове и в течение следующих 5 секунд он будет возвращать бессмысленный кортеж (0.0, 0.0, 0.0)
.
Возвращаемые числа имеют смысл только в том случае, если они связаны с количеством ядер ЦП, установленных в системе. Так, например, значение 3,14 в системе с 10 логическими ЦП означает, что загрузка системы за последние N минут составила 31,4%.
Пример использования psutil.getloadavg()
:
>>> import psutil >>> psutil.getloadavg() # (3.14, 3.89, 4.67) >>> psutil.cpu_count() # 10 # процентное представление загрузки системы >>> [x / psutil.cpu_count() * 100 for x in psutil.getloadavg()] # [31.4, 38.9, 46.7]
Доступность: Unix, Windows
psutil.boot_time()
:Функция psutil.boot_time()
возвращает время загрузки системы, выраженное в секундах с начала эпохи.
Пример использования psutil.boot_time()
:
>>> import psutil, datetime >>> psutil.boot_time() # 1389563460.0 >>> datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") # '2014-01-12 22:51:00'
Обратите внимание, что в Windows эта функция может возвращать время, которое отличается на 1 секунду, если она используется в разных процессах.