Linux посмотреть процессы python

Обновлено: 04.07.2024

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

Прочитав статью, вы узнаете как:

Использовать функцию run для запуска внешнего процесса.
Получить стандартный вывод процесса и информацию об ошибках.
Проверить код возврата процесса и вызвать исключение в случае сбоя.
Запустить процесс, используя оболочку в качестве посредника.
Установить время ожидания завершения процесса.
Использовать класс Popen напрямую для создания конвейера ( pipe ) между двумя процессами.

Так как модуль subprocess почти всегда используют с Linux все примеры будут касаться Ubuntu. Для пользователей Windows советую скачать терминал Ubuntu 18.04 LTS.

Функция «run»

Функция run была добавлена в модуль subprocess только в относительно последних версиях Python (3.5). Теперь ее использование является рекомендуемым способом создания процессов и должно решать наиболее распространенные задачи. Прежде всего, давайте посмотрим на простейший случай применения функции run .

Предположим, мы хотим запустить команду ls -al ; для этого в оболочке Python нам нужно ввести следующие инструкции:

Вывод внешней команды ls отображается на экране:

Здесь мы просто использовали первый обязательный аргумент функции run , который может быть последовательностью, «описывающей» команду и ее аргументы (как в примере), или строкой, которая должна использоваться при запуске с аргументом shell=True (мы рассмотрим последний случай позже).

Захват вывода команды: stdout и stderr

Что, если мы не хотим, чтобы вывод процесса отображался на экране. Вместо этого, нужно чтобы он сохранялся: на него можно было ссылаться после выхода из процесса? В этом случае нам стоит установить для аргумента функции capture_output значение True :

Как мы можем впоследствии получить вывод ( stdout и stderr ) процесса? Если вы посмотрите на приведенные выше примеры, то увидите, что мы использовали переменную process для ссылки на объект CompletedProcess , возвращаемый функцией run . Этот объект представляет процесс, запущенный функцией, и имеет много полезных свойств. Помимо прочих, stdout и stderr используются для «хранения» соответствующих дескрипторов команды, если, как уже было сказано, для аргумента capture_output установлено значение True . В этом случае, чтобы получить stdout , мы должны использовать:

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

Управление сбоями процесса

Команда, которую мы запускали в предыдущих примерах, была выполнена без ошибок. Однако при написании программы следует принимать во внимание все случаи. Так, что случится, если порожденный процесс даст сбой? По умолчанию ничего «особенного» не происходит. Давайте посмотрим на примере: мы снова запускаем команду ls , пытаясь вывести список содержимого каталога /root, который не доступен для чтения обычным пользователям:

Мы можем узнать, не завершился ли запущенный процесс ошибкой, проверив его код возврата, который хранится в свойстве returncode объекта CompletedProcess :

Видите? В этом случае returncode равен 2 , подтверждая, что процесс столкнулся с ошибкой, связанной с недостаточными правами доступа, и не был успешно завершен. Мы могли бы проверять выходные данные процесса таким образом чтобы при возникновении сбоя возникало исключение. Используйте аргумент check функции run : если для него установлено значение True , то в случае, когда внешний процесс завершается ошибкой, возникает исключение CalledProcessError :

Обработка исключений в Python довольно проста. Поэтому для управления сбоями процесса мы могли бы написать что-то вроде:

Исключение CalledProcessError , как мы уже сказали, возникает, когда код возврата процесса не является 0 . У данного объекта есть такие свойства, как returncode , cmd , stdout , stderr ; то, что они представляют, довольно очевидно. Например, в приведенном выше примере мы просто использовали свойство cmd , чтобы отобразить последовательность, которая использовалась для запуска команды при возникновении исключения.

Выполнение процесса в оболочке

Процессы, запущенные с помощью функции run , выполняются «напрямую», это означает, что для их запуска не используется оболочка: поэтому для процесса не доступны никакие переменные среды и не выполняются раскрытие и подстановка выражений. Давайте посмотрим на пример, который включает использование переменной $HOME :

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

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

Ограничение времени работы процесса

Обычно мы не хотим, чтобы некорректно работающие процессы бесконечно исполнялись в нашей системе после их запуска. Если мы используем параметр timeout функции run , то можем указать количество времени в секундах, в течение которого процесс должен завершиться. Если он не будет завершен за это время, процесс будет остановлен сигналом SIGKILL. Который, как мы знаем, не может быть перехвачен. Давайте продемонстрируем это, запустив длительный процесс и предоставив timeout в секундах:

В приведенном выше примере мы запустили команду ping без указания фиксированного числа пакетов ECHO REQUEST, поэтому она потенциально может работать вечно. Мы также установили время ожидания в 5 секунд с помощью параметра timeout . Как мы видим, ping была запущена, а по истечении 5 секунд возникло исключение TimeoutExpired и процесс был остановлен.

Функции call, check_output и check_call

Как мы уже говорили ранее, функция run является рекомендуемым способом запуска внешнего процесса. Она должна использоваться в большинстве случаев. До того, как она была представлена в Python 3.5, тремя основными функциями API высокого уровня, применяемыми для создания процессов, были call , check_output и check_call ; давайте взглянем на них вкратце.

Прежде всего, функция call : она используется для выполнения команды, описанной параметром args; она ожидает завершения команды; ее результатом является соответствующий код возврата. Это примерно соответствует базовому использованию функции run.

Поведение функции check_call практически не отличается от run , когда для параметра check задано значение True : она запускает указанную команду и ожидает ее завершения. Если код возврата не равен 0 , возникает исключение CalledProcessError .

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

Работа на более низком уровне с классом Popen

До сих пор мы изучали функции API высокого уровня в модуле subprocess, особенно run . Все они под капотом используют класс Popen . Из-за этого в подавляющем большинстве случаев нам не нужно взаимодействовать с ним напрямую. Однако, когда требуется большая гибкость, без создания объектов Popen не обойтись.

Предположим, например, что мы хотим соединить два процесса, воссоздав поведение конвейера (pipe) оболочки. Как мы знаем, когда передаем две команды в оболочку, стандартный вывод той, что находится слева от пайпа «|», используется как стандартный ввод той, которая находится справа. В приведенном ниже примере результат выполнения двух связанных конвейером команд сохраняется в переменной:

Чтобы воссоздать подобное поведение с помощью модуля subprocess без установки параметра shell в значение True , как мы видели ранее, мы должны напрямую использовать класс Popen :

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

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

Список процессов в Linux

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

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

1. Утилита ps

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

Но вряд-ли вас интересует именно это. Чтобы посмотреть все процессы, добавьте опцию -e, а для максимально подробной информации - опцию -F:

Вот значение основных колонок в выводе утилиты:

UID - имя пользователя, от имени которого работает процесс;
PID - идентификатор пользователя;
PPID - идентификатор родительского процесса пользователя;
C - расходование ресурсов процессора, в процентах;
SZ - размер процесса;
RSS - реальный размер процесса в памяти;
PSR - ядро процессора, на котором выполняется процесс;
STIME - время, когда процесс был запущен;
TTY - если процесс привязан к терминалу, то здесь будет выведен его номер;
TIME - общее время выполнения процесса (user + system);
CMD - команда, которой был запущен процесс, если программа не может прочитать аргументы процесса, он будет выведен в квадратных скобках;

Чтобы посмотреть список процессов в виде дерева, и понимать какой процесс имеет какие дочерние процессы, выполните команду:

Для просмотра списка процессов с потоками используйте опцию -L:

Здесь появятся ещё две дополнительных колонки:

LWP - Это сокращение от LightWeight Proccess. Идентификатор потока;
NLWP - количество потоков у этого процесса.

Чтобы посмотреть список процессов определенного пользователя, например, sergiy используйте опцию -u:

Теперь давайте перейдём к другим, более интересным, интерактивным утилитам.

2. Утилита top

Утилита top не поставляется вместе с системой, поэтому вам придется её установить. Для этого в Ubuntu выполните:

sudo apt install top

Программа позволяет интерактивно просматривать список запущенных процессов Linux. Чтобы вывести список процессов Linux выполните команду:

Колонки, которые выводит программа очень похожи на ps:

PID - идентификатор процесса;
USER - имя пользователя, от имени которого выполняется процесс;
PR - приоритет планировщика, установленный для процесса;
NI - рекомендуемый приоритет процесса. Это значение можно менять, может не совпадать с реальным приоритетом планировщика;
VIRT - всё, что находится в памяти, используется или зарезервировано для использования;
RES - всё, что находится в оперативной памяти и относится к процессу. Расшифровывается как Resident Memory Size, указывается в килобайтах;
SHR - часть памяти из RES, которую занимают ресурсы, доступные для использования другим процессам. Расшифровывается - Shared Memory Size.
S - состояние процесса: D - ожидает завершения операции, R - запущен, S - спит, T - остановлен, t - остановлен отладчиком, Z - зомби;
%CPU - процент использования ресурсов процессора;
%MEM - процент использования ресурсов оперативной памяти на основе колонки RES;
TIME - обще процессорное время, которое процесс использовал с момента запуска;
COMAND - команда, с помощью которой был запущен процесс.

Для того чтобы сделать вывод программы цветным, нажмите Z:

Чтобы вывести дерево процессов Linux нажмите сочетание клавиш Shift+V:

Для отображения потоков нажмите Shift + H:

Если вам недостаточно стандартных полей с информацией о процессах, вы можете нажать Shift + F и выбрать дополнительные поля, которые надо отображать. Для выбора или удаления поля используйте пробел:

3. Утилита htop

Это ещё более мощная утилита для просмотра запущенных процессов в Linux. Пользоваться ею намного удобнее. Здесь поддерживаются не только горячие клавиши, но и управление мышью. А ещё она выводит всё в цвете, поэтому смотреть на данные намного приятнее. Для установки программы выполните:

sudo apt install htop

Для того чтобы запустить выполните в терминале:

Колонки, которые вы увидите в выводе программы, аналогичны тем, что доступны в top, поэтому я не буду рассматривать их здесь отдельно. Для настройки выводимых данных нажмите кнопку F2, затем перейдите в раздел Display Options:

Здесь надо отметить Tree view для вывода списка процессов в виде дерева, а также снять отметки с пунктов Hide threads. для отображения потоков. Здесь есть как потоки пространства пользователя userland process threads, так и потоки пространства ядра - kernel threads. Теперь всё это будет отображаться:

Для того чтобы настроить какие колонки будут отображаться используйте пункт меню Columns:

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

4. Программа Gnome Monitor

Вы можете смотреть запущенные процессы не только в терминале, но и в графическом интерфейсе. Для этого можно использовать утилиту Gnome Monitor. У неё намного меньше возможностей, по сравнению даже с ps, но зато у неё есть графический интерфейс. Вы можете запустить программу из главного меню системы:

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

Теперь программа отображает все запущенные процессы Linux в системе. Здесь вы можете выполнять поиск по процессам, завершать их и многое другое. Но потоков и дерева процессов программа не показывает.

5. Утилита atop

Эта программа тоже позволяет посмотреть процессы в Linux , но немного в другом ключе. Утилиту больше интересует сколько тот или иной процесс потребляет ресурсов системы. Утилита даже может показывать потребление процессами пропускной способности диска и сети, но для этого ей необходим специальный патч ядра. Для установки программы в Ubuntu выполните:

sudo apt install atop

Затем запустите её:

Вот основные колонки, которые выводит утилита и их значения:

PID - идентификатор процесса;
CID - идентификатор контейнера, используется для контейнеров Docker;
SYSCPU - время, потраченное процессом на выполнение в пространстве ядра;
USRCPU - время, потраченное процессом на выполнение в пространстве пользователя;
VGROW - увеличение использования памяти колонки VIRT за последний период;
RGROW - увеличение использования памяти колонки RSS за последний период;
ST - статус процесса, N - новый, E - завершенный, S и С - процесс завершен принудительно с помощью сигнала;
EXC - код выхода или код сигнала, которым был завершен процесс;
THR - общее количество потоков в этом процессе;
S - состояние процесса, аналогично описанному для top;
CPUNR - номер ядра процессора, на котором запущен основной поток процесса;
CPU - процент использования ресурсов процессора;
CMD - команда, которой была запущена программа;
MEM - процент использования памяти;

Для того чтобы включить отображение потоков процесса нажмите y:

Для просмотра информации о памяти нажмите m, если хотите вернутся обратно, нажмите g:

Выводы

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

Исследуем модуль platform

Модуль platform из стандартной библиотеке имеет ряд функций, которые позволяют нам получать различную информацию о системе. Давайте запустим интерпретатор Python и изучим некоторые из них, начиная с функции platform.uname():

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

В Python 3, функция возвращает именованный кортеж:

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

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

Функция linux_distribution() возвращает информацию о используемом вами дистрибутиые Linux. Например, в системе Fedora 18, эта команда возвращает следующую информацию:

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

Если ваш дистрибутив Linux не является одним из них (или производным от одного из них), то вы, вероятно, не увидите никакой полезной информации из приведенного выше вызова функции.
Последняя функция из модуля platform, которую мы рассмотрим, это функция architecture(). При вызове этой функции без каких-либо аргументов, она возвращает кортеж, состоящий из разрядности архитектуры системы и формата исполняемого файла Python. Например:

На 32-битной системе Linux, вы увидите:

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

Рекомендуем вам изучить другие функции модуля platform, которые среди прочего, позволят вам найти текущую версию Python. Если вам интересно узнать, как этот модуль получает информацию, вы можете посмотреть файл Lib/platform.py в каталоге с исходным кодом Python.
Модули os и sys, также представляют интерес для извлечения определенной информации о системе, например используемый вашей системой порядок байтов (Endianness). Далее мы выйдем за пределы модулей стандартной библиотеки Python, чтобы изучить некоторые общие подходы к получению доступа к информации о системе Linux, доступной через файловые системы proc и sysfs. Следует отметить, что информация, представлемая через эти файловые системы будет варьироваться между различными аппаратными архитектурами и, следовательно, вы должны иметь это в виду при чтении этой статьи, а также при написание сценариев, которые пытаются извлечь информацию из файлов в этих файловых системах.

Получаем информацию о центральном процессоре

Файл /proc/cpuinfo содержит информацию о процессорах вашей системы. Например, вот Python-версия того, что должна сделать команда cat /proc/cpuinfo:

Выполнив эту программы с помощью Python 2 или Python 3, вы должны увидеть на экране все содержимое файла /proc/cpuinfo (в приведенной выше программе, метод rstrip() удаляет завершающий символ новой строки в конце каждой из строк).
В следующем листинге используется метод startswith() для отображения моделей ваших процессоров:

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

Теперь мы знаем несколько способов определить архитектуру нашей системы. Если быть точным, оба эти подходы фактически определяют архитектуру ядра вашей системы. Так что, если ваш компьютер на самом деле ваша машина является 64-разрядной, но работает под управлением 32-битного ядра, то эти методы будут сообщать о вашей машине, как имеющей 32-разрядную архитектуру. Для того, чтобы найти истинную архитектуру машины, вы можете посмотреть на флаг lm в списке флагов в /proc/cpuinfo. Флаг lm присутствует только на компьютерах с 64-битной архитектурой. Следующая программа иллюстрирует этот подход:

procinfo [ line . split ( ':' ) [ 0 ] . strip ( ) ] = line . split ( ':' ) [ 1 ] . strip ( )

Информация о состоянии памяти

Аналогично /proc/cpuinfo, файл /proc/meminfo содержит информацию об оперативной памяти вашего компьютера. Следующая программа создает dictionary из содержимого этого файла и выводит его на экран:

meminfo [ line . split ( ':' ) [ 0 ] ] = line . split ( ':' ) [ 1 ] . strip ( )

Как и раньше, вы можете также получить доступ к какой-либо конкретной информации, которую вы ищете, используя ее в качестве ключа (как показано в блоке if __name__==__main__ ). При выполнении программы, вы должны увидеть вывод, аналогичный следующему:

Сетевая статистика

device_data [ line [ 0 ] . strip ( ) ] = data ( float ( line [ 1 ] . split ( ) [ 0 ] ) / ( 1024.0 * 1024.0 ) , print ( '<0>: MiB MiB' . format ( dev , netdevs [ dev ] . rx , netdevs [ dev ] . tx ) )

Запустив вышеприведенную программу, мы увидим список сетевых интерфейсов наряду с общим поличество полученных и переданных данных в MiB с момента последней перезагрузки системы, см. ниже:

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

Процессы

Каталог /proc содержит директории для каждого из запущенных в системе процессов. Имена этих каталогов такие же, как идентификаторы процессов для этих процессов. Следовательно, при сканировании каталога /proc, собрать список всех его подкаталогов, имена которых содержат только цифры, вы получите список идентификаторы всех запущенных в системе процессов. Функция process_list() в следующем листинге возвращает список с идентификаторов всех запущенных процессов. Длина этого списка будет равна общему количеству процессов, запущенных в системе. См. следующий листинг:

print ( 'Total number of running processes:: <0>' . format ( len ( pids ) ) )

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

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

Блочные устройства

Следующая программа выводит список всех блочных устройств путем чтения из виртуальной файловой системы sysfs. Блочные устройства в вашей системе можно найти в директории /sys/block. Таким образом, в вашей системы могут быть такие каталоги как /sys/block/sda, /sys/block/sdb и т. д. Для того, чтобы найти все такие устройства, мы выполняем сканирование каталога /sys/block с помощью простого регулярного выражения для выражения.

nr_sectors = open ( device + '/size' ) . read ( ) . rstrip ( '\n' ) sect_size = open ( device + '/queue/hw_sector_size' ) . read ( ) . rstrip ( '\n' ) return ( float ( nr_sectors ) * float ( sect_size ) ) / ( 1024.0 * 1024.0 * 1024.0 ) if re . compile ( pattern ) . match ( os.path . basename ( device ) ) : print ( 'Device:: <0>, Size:: GiB' . format ( device , size ( device ) ) )

Запустив эту программу, вы увидите результат, похожий на следующий:

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

Пишем утилиты командной строки

Utility to play around with users and passwords on a Linux system if user . pw_uid >= uid_min and user . pw_uid <= uid_max : parser = argparse . ArgumentParser ( description = 'User/Password Utility' ) parser . add_argument ( '--no-system' , action = 'store_true' , dest = 'no_system' , default = False , help = 'Specify to omit system users' )

Пример вызова приведенной выше программы выглядит следующим образом:

Главная > Как проверить, работает ли процесс с использованием Python в Linux?

Как проверить, работает ли процесс с использованием Python в Linux?

Единственный хороший способ, который я нашел, это:

( Источник )
Но надежно ли это? Работает ли это с каждым процессом и каждым дистрибутивом?

в linux вы можете заглянуть в каталог / proc / $ PID, чтобы получить информацию об этом процессе. Фактически, если каталог существует, процесс выполняется.

Он должен работать в любой системе POSIX (хотя смотреть на файловую систему /proc , как другие предлагали, проще, если вы знаете, что она там будет).

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

Ответ Марка - путь, в конце концов, поэтому есть файловая система / proc. Для чего-то более копируемого / вставляемого:

Но надежно ли это? Работает ли это с каждым процессом и каждым дистрибутивом?

Да, он должен работать на любом дистрибутиве Linux. Имейте в виду, что / proc нелегко доступен в системах на основе Unix (FreeBSD, OSX).

Вот решение, которое решило его для меня:

Я новичок в Python + Linux, так что это не может быть оптимальным. Это решило мою проблему и, надеюсь, поможет другим людям.

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

Мне кажется, решение на основе PID слишком уязвимо. Если процесс, который вы пытаетесь проверить, был завершен, его PID может быть повторно использован новым процессом. Итак, IMO ShaChris23, новичок в Python + Linux, дал лучшее решение проблемы. Даже это работает только в том случае, если рассматриваемый процесс уникально идентифицируется по его командной строке, или вы уверены, что будет только один запущенный одновременно.

Если вы работаете с некоторыми версиями Linux, число уникальных PID равно 32768, или что-либо еще в / proc / sys / kernel / pid_max, что делает повторный PID маловероятным для коротко работающих программ.

Немного измененная версия скрипта ShaChris23. Проверяет, найдено ли значение proc_name в строке аргументов процесса (например, скрипт Python, выполняемый с python):

У меня были проблемы с версиями выше (например, функция нашла также часть строки и тому подобное . ) поэтому я написал свою модифицированную версию Максима Козленко:

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

Я использую это, чтобы получить процессы и счет процесса с указанным именем

Читайте также: