Как запустить программу с помощью python

В этом руководстве мы узнаем, как использовать библиотеку pyautogui в Python 3. Она обеспечивает кроссплатформенную поддержку для управления операциями с мышью и клавиатурой с помощью кода, позволяющего автоматизировать задачи. Библиотека pyautogui также доступна для Python 2, однако мы будем использовать Python 3 на протяжении всего этого руководства.

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

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

Установка PyAutoGUI в Python

Процесс установки PyAutoGUI довольно прост для всех операционных систем. Однако существует несколько зависимостей для Mac и Linux, которые необходимо установить перед установкой и использованием библиотеки PyAutoGUI в программах.

Windows

Для Windows PyAutoGUI не имеет зависимостей. Просто запустите следующую команду в командной строке, и установка будет завершена.

$ pip install PyAutoGUI

Mac

Для Mac сначала необходимо последовательно установить модули pyobjc-core и pyobjc. Ниже приведены команды, которые необходимо последовательно запустить в терминале для успешной установки:

$ pip3 install pyobjc-core $ pip3 install pyobjc $ pip3 install pyautogui

Linux

Для Linux единственная зависимость – это python3-xlib (для Python 3). Чтобы установить его, а затем pyautogui, запустите в своем терминале две указанные ниже команды:

$ pip3 install python3-xlib $ pip3 install pyautogui

Общие функции

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

position()

Прежде чем мы сможем использовать функции PyAutoGUI, нам нужно импортировать их в нашу программу:

import pyautogui as pag

Эта функция position() сообщает нам текущее положение мыши на экране:

pag.position()
Point (x = 643, y = 329)

onScreen()

Функция onScreen() сообщает нам, существует ли на экране точка с координатами x и y:

print(pag.onScreen(500, 600)) print(pag.onScreen(0, 10000))
True False

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

size()

Функция size() находит высоту и ширину (разрешение) экрана.

pag.size()
Size (width = 1440, height = 900)

Ваш результат может отличаться и будет зависеть от размера вашего экрана.

Общие операции с мышью

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

Программы на Python | Как отправить SMS на телефон с помощью Python

moveTo()

Синтаксис функции moveTo() следующий:

pag.moveTo(x_coordinate, y_coordinate)

Значение x_coordinate увеличивается слева направо на экране, а значение y_coordinate увеличивается сверху вниз. Значение как x_coordinate, так и y_coordinate в верхнем левом углу экрана равно 0.

Взгляните на следующий скрипт:

pag.moveTo(0, 0) pag.PAUSE = 2 pag.moveTo(100, 500) # pag.PAUSE = 2 pag.moveTo(500, 500)

В приведенном выше коде основное внимание уделяется функции moveTo(), которая перемещает курсор мыши по экрану на основе координат, которые мы предоставляем в качестве параметров. Первый параметр – это координата x, а второй параметр – координата y. Важно отметить, что эти координаты представляют собой абсолютное положение курсора.

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

Другой обходной путь для этого – указать время для каждой операции moveTo() в качестве третьего параметра функции, например moveTo (x, y, time_in_seconds).

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

Traceback (most recent call last): File «a.py», line 5, in pag.moveTo (100, 500) File «/anaconda3/lib/python3.6/site-packages/pyautogui/__init__.py», line 811, in moveTo _failSafeCheck() File «/anaconda3/lib/python3.6/site-packages/pyautogui/__init__.py», line 1241, in _failSafeCheck raise FailSafeException (‘PyAutoGUI fail-safe triggered from mouse moving to a corner of the screen. To disable this fail-safe, set pyautogui.FAILSAFE to False. DISABLING FAIL-SAFE IS NOT RECOMMENDED.’) pyautogui.FailSafeException: PyAutoGUI fail-safe triggered from mouse moving to a corner of the screen. To disable this fail-safe, set pyautogui.FAILSAFE to False. DISABLING FAIL-SAFE IS NOT RECOMMENDED.

Если выполнение функции moveTo() вызывает ошибку, аналогичную показанной выше, это означает, что на вашем компьютере включена функция защиты от сбоев. Чтобы отключить отказоустойчивость, добавьте в начало кода следующую строку:

pag.FAILSAFE = False

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

moveRel()

Координаты функции moveTo() абсолютны. Однако, если вы хотите переместить положение мыши относительно текущего положения мыши, вы можете использовать функцию moveRel().

Это означает, что точкой отсчета для этой функции при перемещении курсора будет не верхняя левая точка на экране (0, 0), а текущая позиция курсора мыши. Итак, если ваш курсор мыши в настоящее время находится в точке (100, 100) на экране и вы вызываете функцию moveRel() с параметрами (100, 100, 2), новая позиция вашего курсора перемещения будет (200, 200) .

Вы можете использовать функцию moveRel(), как показано ниже:

pag.moveRel(100, 100, 2)

Приведенный выше скрипт переместит курсор на 100 пунктов вправо и на 100 пунктов вниз за 2 секунды относительно текущей позиции курсора.

click()

Функция click() используется для имитации операций щелчка мышью. Синтаксис функции click() следующий:

pag.click(x, y, clicks, interval, button)

• x: координата x точки, которую нужно достичь.
• y: координата y точки, которую нужно достичь.
• clicks: количество кликов, которые вы хотели бы сделать, когда курсор достигнет этой точки на экране.
• interval: количество времени в секундах между каждым щелчком мыши, например, если вы выполняете несколько щелчков мышью.
• button: укажите, какую кнопку мыши вы хотите нажать, когда курсор переместится в эту точку на экране. Возможные значения: правое, левое и среднее.

pag.click(100, 100, 5, 2, ‘right’)

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

pag.rightClick(x, y) pag.doubleClick(x, y) pag.tripleClick(x, y) pag.middleClick(x, y)

Здесь x и y представляют координаты x и y, как и в предыдущих функциях.

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

Вот небольшой пример:

pag.mouseDown(x=x, y=y, button=’left’) pag.mouseUp(x=x, y=y, button=’left’)

Приведенный выше код эквивалентен простому вызову pag.click (x, y).

scroll()

Последняя функция мыши, которую мы рассмотрим, – это прокрутка. Как и ожидалось, у него есть два варианта: прокрутка вверх и прокрутка вниз. Синтаксис функции scroll() следующий:

pag.scroll(amount_to_scroll, x=x_movement, y=y_movement)

Для прокрутки вверх укажите положительное значение для параметра amount_to_scroll, а для прокрутки вниз укажите отрицательное значение. Вот пример:

pag.scroll(100, 120, 120)

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

Общие операции с клавиатурой

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

print(pag.KEYBOARD_KEYS)

typewrite()

Функция typewrite() используется для ввода чего-либо в текстовое поле. Синтаксис функции следующий:

pag.typewrite(text, interval)

Здесь текст – это то, что вы хотите ввести в поле, а интервал – это время в секундах между каждым нажатием клавиши. Вот пример:

pag.typewrite(‘Junaid Khalid’, 1)

Выполнение приведенного выше скрипта приведет к вводу текста «Джунаид Халид» в поле, которое в настоящее время выбрано с паузой в 1 секунду между каждым нажатием клавиши.

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

pag.typewrite([‘j’, ‘u’, ‘n’, ‘a’, ‘i’, ‘d’, ‘e’, ‘backspace’, ‘enter’])

В приведенном выше примере будет введен текст junaide с удалением завершающего e. Ввод в текстовое поле будет отправлен нажатием клавиши Enter.

hotkey()

Если вы до сих пор этого не заметили, ключи, которые мы показали выше, не упоминаются для комбинированных операций, таких как Control + C для команды копирования. Если вы думаете, что можете сделать это, передав список [‘ctrl’, ‘c’] функции typewrite(), вы ошибаетесь.

Функция typewrite() будет нажимать обе эти кнопки последовательно, а не одновременно. И, как вы, наверное, уже знаете, чтобы выполнить команду копирования, вам нужно нажать клавишу C, удерживая клавишу ctrl.

Чтобы нажать две или более клавиш одновременно, вы можете использовать функцию hotkey(), как показано здесь:

screenshot()

Если вы хотите сделать снимок экрана в любой момент, функция screenshot() – это именно та функция, которую вы ищете. Давайте посмотрим, как мы можем реализовать это с помощью PyAutoGUI:

scree_shot = pag.screenshot() # to store a PIL object containing the image in a variable

Это сохранит объект PIL, содержащий изображение, в переменной.

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

pag.screenshot(‘ss.png’)

Это сохранит снимок экрана в файле с указанным именем на вашем компьютере.

Функции confirm(), alert() и prompt()

1. Окно подтверждения: отображает информацию и дает вам два варианта: ОК и Отмена.
2. Окно оповещения: отображает некоторую информацию и подтверждает, что вы ее прочитали. Он отображает одну кнопку, т.е. ОК.
3. Поле подсказки: запрашивает некоторую информацию от пользователя, и при входе пользователь должен нажать кнопку ОК.

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

pag.confirm(«Are you ready?») pag.alert(«The program has crashed!») pag.prompt(«Please enter your name: «)

На выходе вы увидите следующую последовательность окон сообщений.

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

Источник: tonais.ru

Как запускать внешние процессы с помощью Python и модуля подпроцесса

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

В этом уроке вы узнаете:

• Как использовать функцию «запустить» для создания внешнего процесса
• Как записать стандартный вывод процесса и стандартную ошибку
• Как проверить существующий статус процесса и вызвать исключение в случае сбоя
• Как выполнить процесс в промежуточной оболочке
• Как установить тайм-аут для процесса
• Как использовать класс Popen напрямую для передачи двух процессов в конвейер

Как запускать внешние процессы с помощью Python и модуля подпроцесса

Требования к программному обеспечению и используемые условные обозначения

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

Функция «запустить»

В запустить добавлена ​​функция подпроцесс только в относительно последних версиях Python (3.5). Теперь его использование является рекомендуемым способом создания процессов и должно охватывать наиболее распространенные варианты использования. Прежде всего, давайте посмотрим на его простейшее использование. Предположим, мы хотим запустить ls -al команда; в оболочке Python мы бы запустили:

>>> импорт подпроцесса. >>> process = subprocess.run ([‘ls’, ‘-l’, ‘-a’])

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

всего 132. drwx. 22 egdoc egdoc 4096 30 ноя, 12:18. drwxr-xr-x. 4 root root 4096 22 ноя, 13:11.. -rw. 1 egdoc egdoc 10438 1 декабря 12:54 .bash_history. -rw-r — r—. 1 egdoc egdoc 18 июля 27, 15:10 .bash_logout. [. ]

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

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

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

>>> process = subprocess.run ([‘ls’, ‘-l’, ‘-a’], capture_output = True)

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

>>> process.stdout.

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

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

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

>>> process = subprocess.run ([‘ls’, ‘-l’, ‘-a’, ‘/ root’])

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

>>> процесс. код возврата. 2.

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

>>> process = subprocess.run ([‘ls’, ‘-l’, ‘-a’, ‘/ root’], check = True) ls: невозможно открыть каталог ‘/ root’: в доступе отказано. Отслеживание (последний вызов последним): Файл «», строка 1, в Файл «/usr/lib64/python3.9/subprocess.py», строка 524, в процессе выполнения вызывает CalledProcessError (retcode, process.args, subprocess. CalledProcessError: команда ‘[‘ ls ‘,’ -l ‘,’ -a ‘,’ / root ‘]’ вернула ненулевой статус выхода 2.

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

>>> попробуйте. process = subprocess.run ([‘ls’, ‘-l’, ‘-a’, ‘/ root’], check = True). кроме подпроцесса. ВызываетсяProcessError как e. # Просто пример, нужно сделать что-то полезное для управления ошибкой. print (f » не удалось!»). ls: невозможно открыть каталог ‘/ root’: в доступе отказано. [‘ls’, ‘-l’, ‘-a’, ‘/ root’] не удалось! >>>

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

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

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

>>> process = subprocess.run ([‘ls’, ‘-al’, ‘$ HOME’]) ls: нет доступа к «$ HOME»: нет такого файла или каталога.

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

>>> process = subprocess.run (‘ls -al $ HOME’, shell = True) всего 136. drwx. 23 egdoc egdoc 4096 3 дек, 09:35. drwxr-xr-x. 4 root root 4096 22 ноя, 13:11.. -rw. 1 egdoc egdoc 11885 3 декабря, 09:35 .bash_history. -rw-r — r—. 1 egdoc egdoc 18 июля 27, 15:10 .bash_logout. [. ]

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

Указание тайм-аута для процесса

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

>>> process = subprocess.run ([‘ping’, ‘google.com’], timeout = 5) PING google.com (216.58.206.46) 56 (84) байт данных. 64 байта из mil07s07-in-f14.1e100.net (216.58.206.46): icmp_seq = 1 ttl = 113 time = 29,3 мс. 64 байта из lhr35s10-in-f14.1e100.net (216.58.206.46): icmp_seq = 2 ttl = 113 time = 28,3 мс. 64 байта из lhr35s10-in-f14.1e100.net (216.58.206.46): icmp_seq = 3 ttl = 113 time = 28,5 мс. 64 байта из lhr35s10-in-f14.1e100.net (216.58.206.46): icmp_seq = 4 ttl = 113 time = 28,5 мс.

64 байта из lhr35s10-in-f14.1e100.net (216.58.206.46): icmp_seq = 5 ttl = 113 time = 28,1 мс. Отслеживание (последний вызов последним): Файл «», строка 1, в Файл «/usr/lib64/python3.9/subprocess.py», строка 503, при запуске stdout, stderr = process.communicate (input, timeout = timeout) Файл «/usr/lib64/python3.9/subprocess.py», строка 1130, в общении stdout, stderr = self._communicate (input, endtime, timeout) Файл «/usr/lib64/python3.9/subprocess.py», строка 2003, в файле _communicate self.wait (timeout = self._remaining_time (endtime)) «/usr/lib64/python3.9/subprocess.py», строка 1185, в ожидании return self._wait (timeout = timeout) Файл «/usr/lib64/python3.9/subprocess.py», строка 1907, в _wait поднять TimeoutExpired (self.args, тайм-аут) подпроцесс.

TimeoutExpired: время ожидания команды ‘[‘ ping ‘,’ google.com ‘]’ истекло через 4,999826977029443 секунды.

В приведенном выше примере мы запустили пинг команда без указания фиксированного количества ЭХО ЗАПРОС пакетов, поэтому он потенциально может работать вечно. Мы также указали тайм-аут 5 секунд через тайм-аут параметр. Как мы видим, программа изначально запускалась, но Истекло время ожидания исключение было вызвано, когда было достигнуто указанное количество секунд, и процесс был остановлен.

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

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

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

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

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

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

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

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

$ output = «$ (dmesg | grep sda)»

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

dmesg = подпроцесс. Popen ([‘dmesg’], stdout = subprocess. ТРУБКА) grep = подпроцесс. Popen ([‘grep’, ‘sda’], stdin = dmesg.stdout) dmesg.stdout.close () output = grep.comunicate () [0]

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

Первое, что мы сделали в приведенном выше фрагменте кода, — это создали Popen объект, представляющий dmesg процесс. Мы устанавливаем стандартный вывод этого процесса подпроцесс. ТРУБКА : это значение указывает, что канал к указанному потоку должен быть открыт.

Затем мы создали еще один экземпляр Popen класс для grep процесс. в Popen конструктор, мы, конечно, указали команду и ее аргументы, но, что важно, мы устанавливаем стандартный вывод dmesg процесс, который будет использоваться в качестве стандартного ввода ( stdin = dmesg.stdout ), поэтому для воссоздания оболочки
поведение трубы.

После создания Popen объект для grep команда, мы закрыли стандартный вывод поток dmesg процесс, используя Закрыть() метод: это, как указано в документации, необходимо для того, чтобы первый процесс мог получить сигнал SIGPIPE. Попробуем объяснить почему. Обычно, когда два процесса соединены конвейером, если один справа от конвейера (grep в нашем примере) завершается раньше, чем тот, что слева (dmesg), последний получает сообщение SIGPIPE
signal (разорванная труба) и по умолчанию завершает работу.

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

Последнее, что мы сделали, это позвонили в общаться() метод на grep объект. Этот метод можно использовать для необязательной передачи ввода процессу; он ожидает завершения процесса и возвращает кортеж, в котором первым членом является процесс стандартный вывод (на который ссылается выход переменная), а вторая — процесс stderr.

Выводы

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

Подпишитесь на новостную рассылку Linux Career Newsletter, чтобы получать последние новости, вакансии, советы по карьере и рекомендуемые руководства по настройке.

LinuxConfig ищет технических писателей, специализирующихся на технологиях GNU / Linux и FLOSS. В ваших статьях будут представлены различные руководства по настройке GNU / Linux и технологии FLOSS, используемые в сочетании с операционной системой GNU / Linux.

Ожидается, что при написании статей вы сможете идти в ногу с технологическим прогрессом в вышеупомянутой технической области. Вы будете работать самостоятельно и сможете выпускать как минимум 2 технических статьи в месяц.

• 09/08/2021
• ПрограммированиеPythonАдминистрацияРазработка

Как сбросить утерянный пароль root в Ubuntu 18.04 Bionic Beaver Linux

ЗадачаЦель состоит в том, чтобы сбросить утерянный пароль root или пользователя в Ubuntu 18.04 Bionic Beaver Linux.Версии операционной системы и программного обеспеченияОперационная система: — Ubuntu 18.04 Bionic BeaverТребованияТребуется физическ.

Как проверить записи MX (почтовый обмен) домена с помощью команды dig в Linux

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

Установите Ubuntu 16.04 MATE или Ubuntu 18.04 на Raspberry Pi

• 08/08/2021
• 18.04UbuntuАдминистрацияРабочий стол

ЗадачаУстановите Ubuntu 16.04 MATE или Ubuntu 18.04 на Raspberry Pi 3РаспределенияВы можете сделать это из любого дистрибутива Linux.ТребованияРабочая установка Linux с привилегиями root, Raspberry Pi 3, совместимое зарядное устройство Pi, карта M.

Источник: wowgold-seller.com

Python с абсолютного нуля. Работаем с ОС, изучаем регулярные выражения и функции

Се­год­ня мы порабо­таем с фай­ловой сис­темой ОС — научим­ся ходить по катало­гам, откры­вать и изме­нять фай­лы. Затем осво­им могущес­твен­ные зак­линания под наз­вани­ем «регуляр­ные выраже­ния», изу­чим тон­кости соз­дания и вызова фун­кций и под конец напишем прос­тень­кий ска­нер SQL-уяз­вимос­тей. И все это в одном нед­линном уро­ке!

От редакции

Эта статья — часть цик­ла «Python с абсо­лют­ного нуля», где мы рас­ска­зыва­ем об азах Python в нашем фир­менном нес­кучном сти­ле. Ты можешь читать их по поряд­ку или выбирать какие‑то области, которые хотел бы под­тянуть.

• Урок 1: Пе­ремен­ные, типы дан­ных, усло­вия и цик­лы
• Урок 2: Стро­ки, фай­лы, исклю­чения и работа с интерне­том

Пер­вые два уро­ка дос­тупны целиком без плат­ной под­писки. Этот — поч­ти целиком: за исклю­чени­ем пос­ледне­го при­мера и домаш­него задания.

Работаем с файлами

Нач­нем, как всег­да, с нес­ложных вещей. В Python есть модуль с лаконич­ным наз­вани­ем os , который (ты не поверишь!) пред­назна­чен для вза­имо­дей­ствия прог­раммы с опе­раци­онной сис­темой, в том чис­ле для управле­ния фай­лами.

Пер­вым делом, конеч­но, нуж­но импорти­ровать его в начале нашего скрип­та:

И теперь нам откры­вают­ся раз­ные инте­рес­ные воз­можнос­ти. К при­меру, мы можем получить путь к текущей пап­ке. Сна­чала она сов­пада­ет с той, в которой ты был при запус­ке скрип­та (даже если сам скрипт находит­ся где‑то в дру­гом мес­те), но по ходу исполне­ния прог­раммы мы можем менять это зна­чение при помощи фун­кции os. chdir( ) .

# Возвращает путь к текущей рабочей папке
pth = os . getcwd ( )
print ( pth )
# Устанавливает путь к текущей рабочей папке, в данном случае это диск D: /
os . chdir ( r’D:/ ‘ )

info

Ес­ли ты работа­ешь в Windows, то в пути к фай­лу или пап­ке перед откры­вающей кавыч­кой ука­зывай бук­ву r (что озна­чает raw) или вмес­то одной косой чер­ты в пути ставь две.

Поп­робу­ем получить спи­сок фай­лов с рас­ширени­ем .py, находя­щих­ся в текущей дирек­тории. Для это­го исполь­зуем модули os и fnmatch.

import fnmatch
# В цикле, с помощью os. listdir( ‘. ‘) получим список файлов
# в текущей директории ( точка в скобках как раз ее и обозначает)
for fname in os . listdir ( ‘. ‘ ) :
# Если у текущего имени файла расширение . py, то печатаем его
if fnmatch . fnmatch ( fname , ‘*. py’ ) :
print ( fname )

Мо­дуль fnmatch поз­воля­ет искать в стро­ках опре­делен­ный текст, под­ходящий по мас­ке к задан­ному шаб­лону:

• * заменя­ет любое количес­тво любых сим­волов;
• ? заменя­ет один любой сим­вол;
• [ seq] заменя­ет любые сим­волы из пос­ледова­тель­нос­ти в квад­ратных скоб­ках;
• [! seq] заменя­ет любые сим­волы, кро­ме тех, что при­сутс­тву­ют в квад­ратных скоб­ках.

Да­вай без­жалос­тно уда­лим какой‑нибудь файл:

( os . remove ( r’D: allmypasswords. txt’ ) )
os . rename ( ‘lamer. txt’ , ‘xakep. txt’ )

А теперь соз­дадим пап­ку по ука­зан­ному пути и сра­зу же уда­лим ее. Для это­го при­годит­ся модуль shutil, где есть фун­кция rmtree( ) , которая уда­ляет пап­ку вмес­те с содер­жимым.

import shutil
os . makedirs ( r’D: secret beer photo’ ) # Создает все папки по указанному пути
shutil . rmtree ( r’D: secret beer photo’ ) # Удаляет папку вместе с ее содержимым

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

warning

Будь осто­рожен — скрипт в таком виде обша­рит весь диск D. Если он у тебя есть и там мно­го хла­ма, то про­цесс может затянуть­ся.

for root , dirs , files in os . walk ( r’D: ‘ ) :
for name in files :
fullname = os . path . join ( root , name )
print ( fullname )
if ( ‘pass’ in fullname ) :
print ( ‘Бинго. ‘ )

Фун­кция walk() модуля os при­нима­ет один обя­затель­ный аргу­мент — имя катало­га. Она пос­ледова­тель­но про­ходит все вло­жен­ные катало­ги и воз­вра­щает объ­ект‑генера­тор, из которо­го получа­ют:

• ад­рес оче­ред­ного катало­га в виде стро­ки;
• спи­сок имен под­катало­гов пер­вого уров­ня вло­жен­ности для дан­ного катало­га;
• спи­сок имен фай­лов дан­ного катало­га.

info

Ге­нера­тор — это объ­ект, который сра­зу при соз­дании не вычис­ляет зна­чения всех сво­их эле­мен­тов. Этим генера­торы отли­чают­ся от спис­ков — те хра­нят в памяти все свои эле­мен­ты, и уда­лить их мож­но толь­ко прог­рам­мно. Вычис­ления с помощью генера­торов называ­ются ленивы­ми, они эко­номят память. Под­робнее мы рас­смот­рим генера­торы в сле­дующих уро­ках.

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

import os. path
# Модуль для преобразования даты в приемлемый формат
from datetime import datetime
path = r’C: Windows notepad. exe’
# Получим размер файла в байтах
size = os . path . getsize ( path )
# А теперь в килобайтах
# Две косые черты — это целочисленное деление
ksize = size / / 1024
atime = os . path . getatime ( path )
# Дата последнего доступа в секундах с начала эпохи
mtime = os . path . getmtime ( path )
# Дата последней модификации в секундах с начала эпохи
print ( ‘Размер: ‘ , ksize , ‘ KB’ )
print ( ‘Дата последнего использования: ‘ , datetime . fromtimestamp ( atime ) )
print ( ‘Дата последнего редактирования: ‘ , datetime . fromtimestamp ( mtime ) )

info

Для опе­раци­онных сис­тем Unix 1 янва­ря 1970, 00:00:00 (UTC) — точ­ка отсче­та вре­мени, или «начало эпо­хи». Чаще все­го вре­мя в компь­юте­ре вычис­ляет­ся в виде про­шед­ших с это­го момен­та секунд и лишь затем перево­дит­ся в удоб­ный для челове­ка вид.

Да­вай пошутим над юзе­ром: соз­дадим какой‑нибудь файл и будем пос­тоян­но его откры­вать с помощью той прог­раммы, которой этот файл обыч­но откры­вает­ся в сис­теме:

# Модуль time понадобится для паузы, чтобы не слишком часто открывалось
import time
# Создаем текстовый файл
f = open ( ‘beer. txt’ , ‘w’ , encoding = ‘UTF-8’ )
f . write ( ‘СРОЧНО НАЛЕЙТЕ ХАКЕРУ ПИВА, ИНАЧЕ ЭТО НЕ ЗАКОНЧИТСЯ!!’ )
while True :
# Открываем файл программой по умолчанию
os . startfile ( ‘beer. txt’ )
# Делаем паузу в одну секунду
time . sleep ( 1 )

Ни­же при­веден спи­сок еще некото­рых полез­ных команд:

• os. path. basename( ‘путь’) — воз­вра­щает наз­вание фай­ла или пап­ки в кон­це пути;
• os. path. dirname( ‘путь’) — воз­вра­щает родитель­ский путь к объ­екту пути;
• os. path. splitext( ‘путь’) — раз­деля­ет путь на путь и рас­ширение фай­ла;
• os. path. exists( ‘путь’) — сущес­тву­ет ли путь до фай­ла или пап­ки;
• os. path. isfile( ‘путь’) — явля­ется ли объ­ект пути фай­лом (сущес­тву­ющим);
• os. path. isdir( ‘путь’) — явля­ется ли объ­ект пути пап­кой (сущес­тву­ющей).

Регулярные выражения

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

www

Под­робнее о регэк­спах ты можешь почитать в до­кумен­тации Python, в Ви­кипе­дии или в кни­ге Джеф­фри Фрид­ла, которая так и называ­ется — «Ре­гуляр­ные выраже­ния».