Подпроцесс это: Глава 10. Процесс. Подпроцесс | Нотация BPMN 2.0 на русском языке

Подпроцесс

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

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

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

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

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

Вкладка «Параметры»

На вкладке Параметры отображаются основные параметры элемента:

• Наименование — название элемента на графической модели процесса. При добавлении подпроцесса его название задается по шаблону. В этом поле название можно изменить;
• Процесс — выбор процесса, который будет вызываться в рамках родительского. Вы можете добавить процесс, который отображается на вкладке Персональные (в расширенном режиме работы) или на вкладке Локальные.

Обмен данными с родительским процессом строится через входящие и исходящие контекстные переменные. Подробнее о них можно прочитать в статье «Контекст процесса».

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

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

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

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

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

Вкладка «Обработчики»

О вкладке Обработчики можно прочитать в статье «Общие принципы настройки активити».

group.html loops.html

Была ли статья полезной?

ДаНет

Выберите вариантРекомендации не помоглиТекст трудно понятьНет ответа на мой вопросСодержание статьи не соответствует заголовкуДругая причина

Нашли опечатку? Выделите текст, нажмите ctrl + enter и оповестите нас

Глава 10.

Процесс. Подпроцесс | Нотация BPMN 2.0 на русском языке

<<предыдущая содержание следующая>>

Подпроцесс представляет собой Действие, заключающее в себе другие Действия, Шлюзы, События и Потоки операций. Графически Подпроцесс изображается в качестве элемента Потока операций Процесса в спецификации BPMN 2.0.

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

Далее будут рассмотрены различные типы Подпроцессов.

Встроенный Подпроцесс (Embedded Sub-Process (Sub-Process))

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

• Подпроцесс представляет собой прямоугольник с закругленным углами, который ДОЛЖЕН БЫТЬ выполнен одинарной тонкой линией.
  • Текст, цвет, размер, а также линии, используемые для изображения Подпроцесса, ДОЛЖНЫ соответствовать правилам, указанным в разделе «Использование Текста, Цвета и Линий в Моделировании Диаграмм». Однако следует учитывать следующее исключение:
    • Одинарная жирная линия в изображении границ Подпроцесса ДОЛЖНА означать использование данного графического элемента в качестве Действия Вызов (Подпроцесс).
    • Пунктирная линия в изображении границ Подпроцесса ДОЛЖНА означать использование данного графического элемента в качестве Событийного Подпроцесса.
    • Двойная линия в изображении границ Подпроцесса ДОЛЖНА означать использование данного графического элемента в качестве Подпроцесса Транзакции.

Подпроцесс может быть свернутым (Collapsed Sub-Process), при этом его детали скрыты (см. фигуру 10.25).

Подпроцесс также может быть развернутым (Expanded Sub-Process), при этом его детали отображаются внутри Процесса, в котором данный Подпроцесс содержится (см. фигуру 10.26). В случае, если Подпроцесс является свернутым, то используется маркер, позволяющий отличить Подпроцесс от Задачи.

• Маркер Подпроцесса ДОЛЖЕН изображаться в виде небольшого квадрата, расположенного в центре нижней части графического элемента и заключающего в себе знак «+».

Фигура 10.25 – Графический элемент Свернутый Подпроцесс

Фигура 10.26 – Графический элемент Развернутый Подпроцесс

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

Развернутый Подпроцесс используется для более компактного отображения группы параллельных Действий с использованием минимума деталей. Как показано на фигуре 10.27, Действия «С» и «D» заключены в безымянном развернутом

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

Фигура 10.27 – Развернутый Подпроцесс, выступающий в роли «параллельного блока».

BPMN различает пять типов стандартных маркеров Свернутого Подпроцесса. Маркер Подпроцесса, изображенный на фигуре 10.25, может сочетаться с оставшимися четырьмя маркерами:

Маркером Цикла (Loop Marker), Многоэкземплярным Маркером (Multiple-Instance Marker), Маркером Компенсации (Compensation Marker) и Маркером Ad Hoc (Ad-Hoc Marker). Свернутый Подпроцесс может содержать от одного до трех вышеуказанных Маркеров. Комбинации Маркеров могут быть любыми, кроме сочетания Маркеров Цикличности и Многоэкземплярного, — эти Маркеры не могут изображаться одновременно (см. фигуру 10. 28).

• Маркер Цикла ДОЛЖЕН БЫТЬ выполнен в виде небольшой стрелки, острие которой загнуто в направлении, противоположном направлению самой стрелки.
  • Маркер Цикла МОЖЕТ сочетаться с любым другим Маркером Подпроцесса, кроме Многоэкземплярного

• Многоэкземплярный Маркер ДОЛЖЕН БЫТЬ выполнен в виде трех параллельных вертикальных линий.
  • Многоэкземплярный Маркер МОЖЕТ сочетаться с любым другим Маркером Подпроцесса, кроме Маркера Цикла.

• Маркер Ad Hoc ДОЛЖЕН БЫТЬ выполнен в виде тильды.
  • Маркер Ad Hoc МОЖЕТ сочетаться с любым другим Маркером Подпроцесса.

• Маркер Компенсации ДОЛЖЕН БЫТЬ выполнен в виде двух треугольников, повернутых влево (как кнопка перемотки назад на проигрывателе).
  • Маркер Компенсации МОЖЕТ сочетаться с любым другим Маркером Подпроцесса.

• Все вышеописанные Маркеры при совместном отображении ДОЛЖНЫ БЫТЬ сгруппированы и располагаться в центре нижней части графического элемента Подпроцесса.

Цикл Многоэкземплярность Компенсация Ad-Hoc Компенсация + Ad—Hoc

Фигура 10.28 – Маркеры Свернутого Подпроцесса

Свернутый Подпроцесс в 

BPMN 2.0 относится к Встроенному Подпроцессу, описанному в BPMN 1.2. Повторно используемый Подпроцесс в BPMN 1.2 относится к Действию типа Вызов, описанному в BPMN2.0. Фигура 10.29 представляет собой диаграмму классов Подпроцесса.

Фигура 10.29 — Диаграмма классов элемента SubProcess

Элемент SubProcess наследует атрибуты и ассоциации элементов Activity (см. таблицу 10.3) и элемента FlowElementContainer (см. таблицу 8.45). Таблица 10.20 содержит информацию о дополнительных атрибутах элемента SubProcess.

Таблица 10.20 – Атрибуты элемента SubProcess

Название атрибута	Описание/использование
triggeredByEvent: boolean = false	Данный атрибут указывает на то, что данный Подпроцесс работает с Событиями. · Значение «false» указывает на то, что Подпроцесс является стандартным. · Значение «true» указывает на то, что Подпроцесс работает с Событиями и является причиной возникновения дополнительных ограничений.
triggeredByEvent: boolean = false	Данный атрибут обусловливает наличие списка Артефактов, хранящихся в Подпроцессе.

ReusableSub—Process (CallActivity) Повторно используемый Подпроцесс (Вызов)

Повторно используемый Подпроцесс, описанный в BPMN 1.2, относится к Действию типа Вызов, используемому для вызова предопределенного Подпроцесса.

Событийный Подпроцесс (Event Sub-Process)

Событийным Подпроцессом называется специфический Подпроцесс, используемый внутри Процесса (Подпроцесса). Такой Подпроцесс имеет атрибут triggeredByEvent с установленным значением «true».

Такой Подпроцесс не является частью Стандартного потока операций, включенного в родительский Процесс, и не имеет входящих или исходящих Потоков операций.

• Событийный Подпроцесс НЕ ДОЛЖЕН иметь входящих или исходящих Потоков операций.

Событийный Подпроцесс МОЖЕТ появляться (один раз или многократно) или НЕ появляться в ходе выполнения родительского Процесса. Отличие такого Подпроцесса от стандартного состоит в том, что стандартный Подпроцесс в качестве триггера использует Поток операций, а Событийный Подпроцесс — Стартовое событие. Всякий раз, когда какое-то Стартовое событие запускается во время выполнения родительского Процесса, запускается и Событийный Подпроцесс.

• Стартовое событие Событийного Подпроцесса ДОЛЖНО иметь определенный триггер.
  • Стартовое событие (EventDefinition) ДОЛЖНО БЫТЬ одного из следующих типов: Сообщение, Ошибка, Эскалация, Компенсация, Условие, Сигнал, Множественный.

• Событийный Подпроцесс ДОЛЖЕН содержать одно или более Стартовое событие.

Такой Подпроцесс изображается в виде прямоугольника с закругленным углами (установленное в BPMN отображение графического элемента Подпроцесс).

• Событийный Подпроцесс представляет собой прямоугольник с закругленным углами, который ДОЛЖЕН БЫТЬ выполнен одинарной тонкой пунктирной линией (см. фигуры 10.30 и 10.31).
  • Текст, цвет, размер, а также линии, используемые для изображения данного Подпроцесса, ДОЛЖНЫ соответствовать правилам, указанным в разделе «Использование Текста, Цвета и Линий в Моделировании Диаграмм». Однако следует учитывать следующее исключение:
    • Если Событийный Подпроцесс является свернутым, то Стартовое событие в таком Подпроцессе будет являться маркером и отображаться в левом верхнем углу фигуры Подпроцесса (см. фигуру 10.30).

Фигура 10. 30 – Графический элемент Свернутый Событийный Подпроцесс

Фигура 10.31 – Графический элемент Развернутый Событийный Подпроцесс

Запуск Событийного Подпроцесса может привести к следующим последствиям в родительском Процессе:

1. Родительский Процесс прерывается.
2. Родительский Процесс продолжает выполняться (не прерывается).

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

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

Фигура 10.32 –Событийные Подпроцессы внутри родительского Подпроцесса

Транзакция (Transaction)

Транзакцией называется специфический тип Подпроцесса, который демонстрирует определенное поведение, контролируемое посредством протокола транзакции (например, WS-Transaction). Граница графического элемента Транзакция выполнена двойной линией (см. фигуру 10.33).

• Транзакция представляет собой прямоугольник с закругленным углами, который ДОЛЖЕН БЫТЬ выполнен двойной тонкой линией.
  • Текст, цвет, размер, а также линии, используемые для изображения данного Подпроцесса, ДОЛЖНЫ соответствовать правилам, указанным в разделе «Использование Текста, Цвета и Линий в Моделировании Диаграмм».

Фигура 10.33 –Подпроцесс Транзакция

Фигура 10. 34 – Свернутый Подпроцесс Транзакция

Элемент TransactionSub-Process наследует атрибуты и ассоциации элемента Activity (см. таблицу 10.3) за счет взаимосвязи с Подпроцессом. Таблица 10.21 содержит информацию о дополнительных атрибутах и ассоциациях элемента TransactionSub-Process.

Таблица 10.21 – Атрибуты и ассоциации элемента TransactionSub-Process

Название атрибута

Описание/использование

method: Transaction- Method

Данный атрибут определяет метод, используемый для совершения Транзакции или её отмены. Для выполняемых процессов данный атрибут ДОЛЖЕН содержать особый URL, например, http://schemas.xmlsoap.org/ws/2004/10/wsat for WS-AtomicTransaction, orhttp://docs.oasis-open. org/ws-tx/wsba/2006/ 06/AtomicOutcome для WS-BusinessActivity. Для сохранения совместимости с BPMN 1.1 данный атрибут также может иметь значения «##compensate», «##store» и «##image».

Использование Транзакции может привести к следующим результатам:

1. Удачное завершение. Отображается в виде Стандартного потока операций, отходящего от Транзакции.
2. Неудачное завершение (с использованием События Отмена). При отказе от выполнения Транзакции Действия, находящиеся внутри данной Транзакции, подвергнуться действиям отмены: например, будет выполнена компенсация определенных Действий, или произойдет возврат к Процессу (для получения более подробной информации о компенсации смотрите соответствующий раздел документа). Обратите внимание, что никакой другой механизм остановки Транзакции (например, использование Событий Ошибка и Таймер или каких-либо Действий, не предусмотренных Транзакцией) не повлечет за собой компенсацию. Промежуточное событие Отмена, соединенное с границей Действия, оказывает влияние на направление хода Процесса после того, как произошел возврат и была выполнена компенсация. Это Событие может быть использовано только в том случае, если оно соединено с границей Подпроцесса Транзакции. Оно не может быть использовано в рамках Стандартного потока операций или не прикрепляется к Подпроцессу, не являющемуся Транзакцией. Существует два механизма, способных сигнализировать об отмене Транзакции:
   • Поток операций Транзакции достигает Промежуточного события Отмена. Это Событие используется только для такого типа Подпроцессов.
   • Сообщение об отмене может быть получено посредством протокола транзакции, поддерживающего выполнение данной Транзакции.
3. Риск (Опасность). Появление Риска означает, что какое-то действие в Транзакции выполняется крайне неверно, и это ведет к тому, что стали невозможны ни удачное завершение, ни отмена. Риски отображаются посредством Промежуточного события Ошибка. При появлении Риска выполнение текущего Действия прекращается без возможности компенсации, а Поток операций возобновляется от Промежуточного события Ошибка.

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

Спонтанный Подпроцесс (Ad-Hoc Sub-Process)

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

Графический элемент Спонтанный Подпроцесс содержит маркер, выполненный в виде знака тильды и располагающийся в центре нижней части фигуры Подпроцесса (см фигуру 10.35 и 10.36).

• Маркер Спонтанного Подпроцесса ДОЛЖЕН БЫТЬ выполнен в виде тильды.
  • Маркер Ad Hoc МОЖЕТ сочетаться с любым другим Маркером Подпроцесса.

Фигура 10.35 – Графический элемент Свернутый Спонтанный Подпроцесс

Фигура 10. 36 – Графический элемент Развернутый Спонтанный Подпроцесс

Элемент Ad-HocSub-Process наследует атрибуты и ассоциации элемента Activity (см. таблицу 10.3) за счет взаимосвязи с Подпроцессом. Таблица 10.22 содержит информацию о дополнительных ассоциациях элемента Ad-HocSub-Process.

Таблица 10.22 – Ассоциации элемента Ad-HocSub-Process

Название атрибута	Описание/использование
completionCondition: Expression	Данный атрибут определяет условия, при которых завершается Процесс. Значение «true» указывает на то, что Процесс будет завершен.
ordering: AdHocOrdering = Parallel { Parallel | Sequential }	Данный атрибут указывает на то, будут ли Действия, включенные в Процесс, выполняться параллельно или НЕОБХОДИМО последовательное их выполнение. Значением по умолчанию является «parallel». Значение «sequential» ограничивает одновременное выполнение нескольких Действий. В данном случае в определенный период времени может быть выполнено лишь одно Действие. Если выбрано значение «parallel», то одновременно может выполняться любое количество Действий, от нуля и более.
cancelRemaining- Instances: boolean = true	Данный атрибут используется только в том случае, если для вышеописанного атрибута ordering установлено значение «parallel». Указывает на то, будут ли отменены запущенные экземпляры Действий, если значение атрибута completionCondition становится «true».

Действия, включенные в состав Спонтанного Подпроцесса, друг с другом, как правило, не соединяются. В ходе выполнения Подпроцесса запущенными МОГУТ одно или несколько Действий. Действия МОГУТ выполняться многократно. То, когда будет запущено Действие, каким будет следующее Действие, а также другие детали выполнения Действий определяются Исполнителем.

Примерами Процессов, входящих в состав Спонтанного Подпроцесса, являются разработка кода (на низком уровне), поддержка клиентов, а также написание главы книги. Рассмотрим, к примеру, написание главы для книги. Мы видим, что данный Процесс включает следующие Действия: поиск темы, составление текста, редактирование текста, создание дизайна, графическое оформление текста, оформление ссылок и т.д. (см. фигуру 10.37). В таком Процессе МОЖЕТ наблюдаться определенная зависимость Задач друг от друга, например, редактирование текста не может происходить раньше его написания. Однако такая корреляция между экземплярами Задачам по написанию и редактированию текста не обязательна. Редактирование может возникать нерегулярно и зависит от текста, полученного в результате выполнения нескольких экземпляров Задачи по написанию текста.

Фигура 10.37 – Спонтанный Подпроцесс написания главы для книги

Хотя в Спонтанном Подпроцессе структура не определена, в его детали все же может быть добавлена информация о последовательности Действий или корреляции данных. К примеру, можно расширить вышеописанный Спонтанный Подпроцесс написания главы для книги путем добавления в него Объектов данных, Ассоциаций или Потоков операций (см. фигуру 10.38).

Однако использование в Спонтанном Подпроцессе элементов потока должно осуществляться со следующими ограничениями, не имеющими отношения к использованию элементов в Подпроцессах других типов:

• В список элементов BPMN, которые ДОЛЖНЫ использоваться в Спонтанном Подпроцессе, входит Действие.
• В список элементов BPMN, которые МОГУТ использоваться в Спонтанном Подпроцессе, входят: Объект данных, Поток операций, Ассоциация, Ассоциация данных, Группа, Поток сообщений (может являться как целью, так и результатом), Шлюз, Промежуточное событие.
• В список элементов BPMN, которые НЕ ДОЛЖНЫ использоваться в Спонтанном Подпроцессе, входят: Стартовое событие, Конечное событие, Переговоры (графически), Соединители переговоров (графически), Действия Хореографии.

Фигура 10.38 – Спонтанный Подпроцесс написания главы для книги с отображением последовательности Действий и зависимых данных

Объект данных, предоставленный для Задач на входе, является дополнительным ограничением для выполнения этих Задач. В данном случае Исполнители, хотя и решают, когда будут выполнены Задачи, уже ограничены в действиях тем, что не могут начать выполнение Задачи без соответствующих данных. Наличие Потока операций между Задачами (например, между разработкой дизайна и оформлением текста в соответствии с дизайном) устанавливает зависимость, согласно которой вторая Задача ДОЛЖНА быть выполнена после выполнения первой. Это не означает, что вторая Задача должна выполняться незамедлительно, но лишь то, что она ДОЛЖНА выполняться после того, как будет завершена первая Задача.

Проблемой для BPM стало отслеживание статуса Спонтанного Подпроцесса. Как правило, Процессы такого типа контролируются при помощи приложений для групповой работы (например, e-mail). BPMN позволяет моделировать Процессы, необязательные для выполнения, хотя определенные механизмы для выполнения процессов, способные отслеживать Спонтанные Подпроцессы, существуют. Исходя из этого, Спонтанный Подпроцесс будет завершен при определенных условиях, которые указываются посредством установки значения для атрибута completionCondition, определяющего, в свою очередь, атрибуты Процесса, корректируемые Действием данного Процесса.

<<предыдущая содержание следующая>>

Данные материалы предназначены исключительно для ознакомления в личных целях.Любое воспроизведение, копирование, а так же коммерческое и некоммерческое использование материалов должно согласовываться с авторами материалов ([email protected]). Допускается использование материалов сайта без уведомления авторов, но с явным указанием источника.

Что такое подпроцессы Python и почему они важны?

• Блог Hubspot
• HubSpot.com

Загрузка

О нет! Мы не смогли найти ничего подобного.

Попробуйте еще раз поискать, и мы постараемся.

Python имеет множество задач и действий, которые выполняются в фоновом режиме; эти задачи называются процессами. И так же, как вид змеи может иметь подвид, процесс Python может иметь подпроцессы. Хотя эта информация может показаться пугающей, правда в том, что она способна сделать нашу работу более управляемой.

Что такое подпроцесс в Python?

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

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

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

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

Исторический факт : Модуль подпроцесса был добавлен в Python 2.4 для повышения эффективности и замены устаревших подходов к управлению данными и памятью. Вскоре после добавления подпроцессов Python добавил многопроцессный модуль, включенный в Python 2.6 и выше. Это добавление многопроцессорного пакета направлено на дальнейшее повышение производительности программного обеспечения на устройствах с большим количеством процессоров.

Как использовать подпроцесс в Python

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

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

Например, чтобы запустить блокнот Windows в качестве подпроцесса для родительского процесса, вы должны передать строку your/path/to/program/notepad.exe, включая его путь. Это укажет подпроцессу найти файл notepad.exe по указанному пути, а затем открыть и запустить файл.

 
 подпроцесс импорта 
 code = subprocess.call("notepad.exe") 
 
 if code == 0: 
 print("Успех!") 
 else: 
 print("Ошибка!") 
 
 Успех! 
 
 

Пример подпроцесса Python

Подпроцесс поставляется не только с методом вызова; он включает метод Popen(). Метод Popen не ожидает завершения подпроцесса перед возвратом информации. Чтобы сделать это с Popen, вы должны использовать метод wait() после Popen. Давайте рассмотрим три примера использования подпроцесса.

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

Использование метода Popen

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

 
 программа = "notepad.exe" 
 subprocess.Popen(program) 
 /*ответ*/ 
  
 
 

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

Использование Popen с методом ожидания

 
 program = "notepad. exe" 
 process = subprocess.Popen(program) 
 code = process.wait() 
 print(code) 
 /*result*/ 
 0 
 
 

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

В некоторых случаях вы не можете использовать метод wait(), так как это может привести к зависанию вашей программы до ее разрешения, особенно при использовании команд stdout/stderr=PIPE. В этих случаях вместо использования wait() вы можете использовать метод Communic(). Давайте посмотрим, как это делается дальше.

 
 args = ["ping", "www.google.com"] 
 process = subprocess.Popen(args, stdout=subprocess.PIPE) 
 data = process.communicate() 
 print(data) 
 

Ради этого поста результат этого действия не имеет отношения к его работе. Но стоит отметить информацию, возвращаемую методом Communic(), что это двухэлементный кортеж, содержащий то, что было в stdout и stderr.

Использование модуля подпроцесса в вашем программном обеспечении

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

• Подпроцессы обеспечивают отличный способ максимизировать эффективность вашего кода.
• Подпроцессы можно вызывать двумя основными способами: с помощью методов call() или Popen().
• Метод wait() необходим для получения полного результата выполнения процесса при использовании метода Popen().
• Метод wait() может вызвать взаимоблокировку при использовании с командами stdout/stderr=PIPE
• Вы можете использовать метод Communicate(), когда метод ожидания не является хорошим выбором.

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

Темы: Что такое питон?

Не забудьте поделиться этим постом!

Связанные статьи

• Откройте для себя лямбда-функцию Python и узнайте, как ее использовать

  27 октября 2022 г.

• Пошаговое руководство по Python Float()

  26 октября 2022 г.

• Узнайте о заявлении Python Pass и о том, что оно может сделать для вашего программного обеспечения

  26 октября 2022 г.

• Литералы Python: что это такое и почему вы должны о них заботиться

  25 октября 2022 г.

• Узнайте, как работают функции Python и как их использовать

  24 октября 2022 г.

• Python API: что это такое и как его использовать

  31 мая 2022 г.

• hubspot.com/website/install-pandas-on-windows»>

  2 простых способа установки Pandas на ваш компьютер с Windows

  13 апр. 2022 г.

• Введение в аргументы командной строки Python

  11 апр. 2022 г.

• Как создать фрейм данных Pandas в Python

  07 апр. 2022 г.

• Понимание основ многопроцессорности в Python

  07 апр. 2022 г.

subprocess — Работа с дополнительными процессами

Назначение:	Создание дополнительных процессов и взаимодействие с ними.
Доступно в:	2.4 и выше

Модуль подпроцесса обеспечивает согласованный интерфейс для создание и работа с дополнительными процессами. Он предлагает интерфейс более высокого уровня, чем у некоторых других доступных модулей, и предназначен для замены таких функций, как os.system(), os.spawn*(), os.popen*(), popen2.*() и команды.*(). Чтобы упростить сравнение подпроцесса с этими другими модулями, многие из приведенных здесь примеров воссоздают те, используется для os и popen.

Модуль подпроцесса определяет один класс Popen и несколько функций-оболочек, использующих этот класс. Конструктор для Popen принимает аргументы для настройки нового процесса, чтобы родительский может общаться с ним через каналы. Он обеспечивает все функциональность других модулей и функций, которые он заменяет, и более. API совместим для всех видов использования, и многие дополнительные шаги необходимых накладных расходов (таких как закрытие дополнительных файловых дескрипторов и обеспечение закрытия труб) «встроены» вместо того, чтобы манипулироваться по коду приложения отдельно.

Примечание

API примерно такой же, но базовая реализация другая. немного отличается между Unix и Windows. Все примеры показанные здесь, были протестированы в Mac OS X. Поведение в ОС, отличной от Unix, будет отличаться.

Запуск внешней команды

Для запуска внешней команды без взаимодействия с ней, например будет делать с os.system() , Используйте call() функция.

 подпроцесс импорта
# Простая команда
subprocess.call(['ls', '-1'], оболочка=Истина)
 

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

 $ python subprocess_os_system.py
__init__.py
index.rst
взаимодействие.py
репитер.py
signal_child.py
signal_parent.py
subprocess_check_call.py
subprocess_check_output.py
subprocess_check_output_error.py
subprocess_check_output_error_trap_output.py
subprocess_os_system.py
subprocess_pipes.py
subprocess_popen2.py
subprocess_popen3.py
subprocess_popen4.py
subprocess_popen_read. py
subprocess_popen_write.py
subprocess_shell_variables.py
subprocess_signal_parent_shell.py
subprocess_signal_setsid.py
 

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

 подпроцесс импорта
# Команда с расширением оболочки
subprocess.call('эхо $HOME', оболочка=Истина)
 

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

 $ Python subprocess_shell_variables.py
/Пользователи/dhellmann
 

Обработка ошибок

Возвращаемое значение функции call() — это код выхода программы. Вызывающий объект отвечает за его интерпретацию для обнаружения ошибок. Функция check_call() работает так же, как call(), за исключением того, что код выхода проверяется, и если он указывает на ошибку, то Возникает исключение CalledProcessError.

 подпроцесс импорта
subprocess.check_call(['false'])
 

Команда false всегда завершается с ненулевым кодом состояния, который check_call() интерпретирует как ошибку.

 $ python subprocess_check_call.py
Traceback (последний последний вызов):
  Файл «subprocess_check_call.py», строка 11, в 
    subprocess.check_call(['false'])
  Файл "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.
7/subprocess.py", строка 511, в check_call
    поднять CalledProcessError (реткод, cmd)
subprocess.CalledProcessError: команда '['false']' вернула ненулевое значение
выйти из статуса 1
 

Захват вывода

Стандартные каналы ввода и вывода для процесса, запущенного call() привязаны к вводу и выводу родителя. Это означает вызывающая программа не может захватить вывод команды. Использовать check_output() для захвата вывода для последующей обработки.

 подпроцесс импорта
вывод = subprocess.check_output(['ls', '-1'])
print 'На выходе %d байт' % len(output)
вывод на печать
                                  
 

Команда ls -1 выполняется успешно, поэтому текст, который она печатает, стандартный вывод захватывается и возвращается.

 $ python subprocess_check_output.py
Иметь 462 байта на выходе
__init__.py
index.rst
взаимодействие.py
репитер.py
signal_child.py
signal_parent.py
subprocess_check_call.py
subprocess_check_output.py
subprocess_check_output_error.py
subprocess_check_output_error_trap_output.py
subprocess_os_system.py
subprocess_pipes.py
subprocess_popen2.py
subprocess_popen3.py
subprocess_popen4.py
subprocess_popen_read.py
subprocess_popen_write.py
subprocess_shell_variables.py
subprocess_signal_parent_shell.py
subprocess_signal_setsid.py
 

Этот сценарий запускает серию команд в подоболочке. Сообщения отправляется на стандартный вывод и стандартную ошибку перед выходом команд с кодом ошибки.

 подпроцесс импорта
вывод = подпроцесс.check_output(
    'эхо на стандартный вывод; эхо на стандартный вывод 1>&2; выход 1',
    оболочка = Верно,
    )
print 'На выходе %d байт' % len(output)
вывод на печать
                                  
 

Сообщение о стандартной ошибке выводится на консоль, но сообщение на стандартный вывод скрыто.

 $ python subprocess_check_output_error.py
стдерр
Traceback (последний последний вызов):
  Файл "subprocess_check_output_error.py", строка 14, в 
    оболочка = Верно,
  Файл "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.
7/subprocess.py", строка 544, в check_output
    поднять CalledProcessError (реткод, cmd, вывод = вывод)
subprocess.CalledProcessError: команда 'echo to stdout; эхо в стандартный вывод
 1>&2; exit 1 'вернул ненулевой статус выхода 1
 

Чтобы предотвратить появление сообщений об ошибках при выполнении команд check_output() от записи в консоль, установите stderr в константу STDOUT.

 подпроцесс импорта
вывод = подпроцесс.check_output(
    'эхо на стандартный вывод; эхо на стандартный вывод 1>&2; выход 1',
    оболочка = Верно,
    stderr=подпроцесс.STDOUT,
    )
print 'На выходе %d байт' % len(output)
вывод на печать
                                  
 

Теперь каналы ошибок и стандартный вывод объединены, так что если команда выводит сообщения об ошибках, они перехватываются и не отправляются консоль.

 $ Python subprocess_check_output_error_trap_output.py
Traceback (последний последний вызов):
  Файл "subprocess_check_output_error_trap_output.py", строка 15, в 
    stderr=подпроцесс.STDOUT,
  Файл "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.
7/subprocess.py", строка 544, в check_output
    поднять CalledProcessError (реткод, cmd, вывод = вывод)
subprocess.CalledProcessError: команда 'echo to stdout; эхо в стандартный вывод
 1>&2; exit 1 'вернул ненулевой статус выхода 1
 

Непосредственная работа с каналами

Путем передачи различных аргументов для stdin , stdout и stderr it можно имитировать варианты os.popen().

popen

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

 подпроцесс импорта
напечатать '\nпрочитать:'
proc = subprocess.Popen(['echo', '"на стандартный вывод"'],
                        стандартный вывод=подпроцесс. PIPE,
                        )
stdout_value = proc.communicate()[0]
распечатать '\ tstdout:', repr (stdout_value)
 

Это похоже на то, как работает popen(), за исключением того, что чтение управляется внутри экземпляра Popen.

 $ Python subprocess_popen_read.py
читать:
        стандартный вывод: '"на стандартный вывод"\n'
 

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

 подпроцесс импорта
распечатать '\nнаписать:'
proc = subprocess.Popen(['cat', '-'],
                        стандартный ввод=подпроцесс.PIPE,
                        )
proc.communicate('\tstdin: на стандартный ввод\n')
 

Чтобы отправить данные на стандартный входной канал процесса один раз, передать данные для связи(). Это похоже на использование popen() с режимом ‘w’.

 $ python -u subprocess_popen_write.py
записывать:
        стандартный ввод: на стандартный ввод
 

popen2

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

 подпроцесс импорта
напечатайте '\npopen2:'
proc = subprocess.Popen(['cat', '-'],
                        стандартный ввод=подпроцесс.PIPE,
                        стандартный вывод=подпроцесс.PIPE,
                        )
stdout_value = proc.communicate('через стандартный ввод в стандартный вывод')[0]
print '\tpass through:', repr(stdout_value)
 

Это настраивает канал для имитации popen2().

 $ python -u subprocess_popen2.py
попэн2:
        пройти через: 'через стандартный ввод на стандартный вывод'
 

popen3

Также можно смотреть оба потока для stdout и stderr, как с popen3().

 подпроцесс импорта
распечатать '\npopen3:'
proc = subprocess.Popen('cat -; echo "to stderr" 1>&2',
                        оболочка = Верно,
                        стандартный ввод=подпроцесс.PIPE,
                        стандартный вывод=подпроцесс.PIPE,
                        stderr=подпроцесс.PIPE,
                        )
stdout_value, stderr_value = proc. communicate('через stdin на stdout')
print '\tpass through:', repr(stdout_value)
напечатать '\tstderr :', repr(stderr_value)
 

Чтение из stderr работает так же, как и из stdout. Прохождение PIPE говорит Popen подключиться к каналу, и Communication() считывает из него все данные перед возвратом.

 $ python -u subprocess_popen3.py
попэн3:
        пройти через: 'через стандартный ввод на стандартный вывод'
        stderr : 'в stderr\n'
 

popen4

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

 подпроцесс импорта
распечатать '\npopen4:'
proc = subprocess.Popen('cat -; echo "to stderr" 1>&2',
                        оболочка = Верно,
                        стандартный ввод=подпроцесс.PIPE,
                        стандартный вывод=подпроцесс.PIPE,
                        stderr=подпроцесс.STDOUT,
                        )
stdout_value, stderr_value = proc.communicate('через stdin на stdout\n')
print '\tcombined output:', repr(stdout_value)
напечатать '\значение tstderr:', repr(stderr_value)
 

Объединение вывода таким образом похоже на то, как popen4() работает.

 $ python -u subprocess_popen4.py
попэн4:
        комбинированный вывод: 'через stdin на stdout\nto stderr\n'
        стандартное значение: нет
 

Соединение сегментов трубы

Несколько команд могут быть подключены к конвейеру , аналогично как работает оболочка Unix, создавая отдельный Popen экземпляров и объединение их входов и выходов вместе. Атрибут stdout одного экземпляра Popen используется как stdin аргумент для следующего в конвейере вместо константы ТРУБКА. Вывод считывается из дескриптора stdout для последняя команда в конвейере.

 подпроцесс импорта
cat = subprocess.Popen(['cat', 'index.rst'],
                        стандартный вывод=подпроцесс.PIPE,
                        )
grep = subprocess.Popen(['grep', '.. include::'],
                        стандартный ввод=cat.stdout,
                        стандартный вывод=подпроцесс.PIPE,
                        )
cut = subprocess.Popen(['cut', '-f', '3', '-d:'],
                        стандартный ввод = grep. stdout,
                        стандартный вывод=подпроцесс.PIPE,
                        )
end_of_pipe = cut.stdout
print 'Включенные файлы:'
для строки в end_of_pipe:
    напечатать '\t', line.strip()
 

В этом примере воспроизводится командная строка cat index.rst | grep «.. включить» | cut -f 3 -d:, который читает источник reStructuredText файл для этого раздела и находит все строки, которые включают другие файлов, затем печатает только имена файлов.

 $ python -u subprocess_pipes.py
Включенные файлы:
        subprocess_os_system.py
        subprocess_shell_variables.py
        subprocess_check_call.py
        subprocess_check_output.py
        subprocess_check_output_error.py
        subprocess_check_output_error_trap_output.py
        subprocess_popen_read.py
        subprocess_popen_write.py
        subprocess_popen2.py
        subprocess_popen3.py
        subprocess_popen4.py
        subprocess_pipes.py
        репитер.py
        взаимодействие.py
        signal_child. py
        signal_parent.py
        subprocess_signal_parent_shell.py
        subprocess_signal_setsid.py
 

Взаимодействие с другой командой

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

 import sys
sys.stderr.write('repeater.py: запуск\n')
sys.stderr.flush()
пока верно:
    следующая_строка = sys.stdin.readline()
    если не следующая_строка:
        ломать
    sys.stdout.write(следующая_строка)
    sys.stdout.flush()
sys.stderr.write('repeater.py: выход\n')
sys.stderr.flush()
 

Сценарий repeater.py записывает в stderr при запуске и останавливается. Эта информация может быть использована для отображения продолжительности жизни ребенка. процесс.

В следующем примере взаимодействия используются дескрипторы файлов stdin и stdout принадлежат экземпляру Popen по-разному. Во-первых например, в стандартный ввод процесса записывается последовательность из 10 чисел, и после каждой записи считывается следующая строка вывода. в второй пример, те же 10 чисел записываются, но вывод читается все сразу, используя коммуникацию().

 подпроцесс импорта
print 'По одной строке за раз:'
proc = subprocess.Popen('python Repeater.py',
 оболочка = Верно,
 стандартный ввод=подпроцесс.PIPE,
 стандартный вывод=подпроцесс.PIPE,
 )
для я в диапазоне (10):
 proc.stdin.write('%d\n' % я)
 вывод = proc.stdout.readline()
 распечатать output.rstrip()
остаток = proc.connect()[0]
распечатать остаток
Распечатать
print 'Весь вывод сразу:'
proc = subprocess.Popen('python Repeater.py',
 оболочка = Верно,
 стандартный ввод=подпроцесс.