Метод exec() в Python

По сути, метод Python exec() выполняет переданный набор кода в виде строки. Это очень полезно, так как практически поддерживает динамическое выполнение. Синтаксис метода приведен ниже.

Здесь object может быть строкой, объектом открытого файла или объектом кода.

• Для строки — строка анализируется как набор операторов Python, который затем выполняется (если не возникает синтаксическая ошибка).
• Для открытого файла — файл анализируется до EOF и выполняется.
• Для объекта кода — просто выполняется.

И два дополнительных аргументов globals и locals должны быть словари , используемые для глобальных и локальных переменных.

Давайте попробуем понять, как он работает, на примере.

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

Работа с методом Python exec()

Теперь давайте сразу перейдем к некоторым примерам, изучающим, как метод exec() работает в Python с параметрами globals и locals и без них.

1 Без глобальных и локальных параметров

В предыдущем примере мы просто выполнили некоторый набор инструкций в Python, передав аргумент объекта методу exec() . Но мы не видели имена в текущей области.

Теперь давайте воспользуемся методом dir(), чтобы получить список текущих методов и имен с включенным math модулем перед вызовом метода exec() .

Как видите, различные методы, включая builtins , а также из math модуля, прямо сейчас находятся в текущей области видимости и доступны для метода exec() .

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

Используя параметры globals и locals мы можем буквально ограничить exec() чтобы выйти за пределы методов, к которым мы хотим получить доступ.

2 С параметром globals

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

В приведенном выше коде мы передали словарь, содержащий методы squareNo() (сопоставленные с настраиваемым именем squareit) и print() .

Обратите внимание: использование любого другого метода из встроенного метода вызовет TypeError .

3 С параметром locals

Когда мы передаем только local параметр (словарь), по умолчанию все встроенные методы также становятся доступными до тех пор, пока мы явно не исключим их.

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

Следовательно, теперь явно исключая встроенные функции.

В приведенном выше коде ограничение метода на использование только переданных (локальных) методов практически делает недоступным метод pow() . Следовательно, при его запуске мы получаем TypeError .

exec() сравнение с eval()

Между методами eval() и exec() есть два основных различия, хотя они выполняют почти одинаковую работу.

1. eval() может выполнять только одно выражение, тогда как exec() может использоваться для выполнения динамически созданного оператора или программы, которая может включать циклы, операторы if-else , определения функций и class ,
2. eval() возвращает значение после выполнения определенного выражения, тогда как exec() в основном ничего не возвращает и просто игнорирует значение.

How to Execute Shell Commands with Python

Python is a wonderful language for scripting and automating workflows and it is packed with useful tools out of the box with the Python Standard Library. A common thing to do, especially for a sysadmin, is to execute shell commands. But what usually will end up in a bash or batch file, can be also done in Python. You’ll learn here how to do just that with the os and subprocess modules.

Using the os Module

The first and the most straight forward approach to run a shell command is by using os.system():

If you save this as a script and run it, you will see the output in the command line. The problem with this approach is in its inflexibility since you can’t even get the resulting output as a variable. You can read more about this function in the documentation.

Note, that if you run this function in Jupyter notebook, you won’t have an output inline. Instead you the inline output will be the return code of the executed programm ( 0 for successful and -1 for unsuccessful). You will find the output in the command line where you have started Jupyter notebook.

Next, the os.popen() command opens a pipe from or to the command line. This means that we can access the stream within Python. This is useful since you can now get the output as a variable:

When you use the .read() function, you will get the whole output as one string. You can also use the .readlines() function, which splits each line (including a trailing \n ). Note, that you can run them only once. It is also possible to write to the stream by using the mode=’w’ argument. To delve deeper into this function, have a look at the documentation.

In this example and in the following examples, you will see that you always have trailing line breaks in the output. To remove them (including blank spaces and tabs in the beginning and end) you can use the .strip() function like with output.strip() . To remove those characters only in the beginning use .lstrip() and for the end .rstrip() .

Using the subprocess Module

The final approach is also the most versatile approach and the recommended module to run external commands in Python:

The subprocess module provides more powerful facilities for spawning new processes and retrieving their results; using that module is preferable to using this function. See the Replacing Older Functions with the subprocess Module section in the subprocess documentation for some helpful recipes. (Source)

The main function you want to keep in mind if you use Python >= 3.5 is subprocess.run(), but before we get there let’s go through the functionality of the subprocess module. The subprocess.Popen() class is responsible for the creation and management of the executed process. In contrast to the previous functions, this class executes only a single command with arguments as a list. This means that you won’t be able to pipe commands:

You’ll notice that we set stdout and stderr to subprocess.PIPE. This is a special value that indicates to subprocess.Popen that a pipe should be opened that you can then read with the .communicate() function. It is also possible to use a file object as with:

Another thing that you’ll notice is that the output is of type bytes. You can solve that by typing stdout.decode(‘utf-8’) or by adding universal_newlines=True when calling subprocess.Popen .

When you run .communicate() , it will wait until the process is complete. However if you have a long program that you want to run and you want to continuously check the status in realtime while doing something else, you can do this like here:

You can use the .poll() function to check the return code of the process. It will return None while the process is still running. To get the output, you can use process.stdout.readline() to read a single line. Conversely, when you use process.stdout.readlines() , it reads all lines and it also waits for the process to finish if it has not finished yet. For more information on the functionionality of subprocess.Popen , have a look at the documentation.

Also note, that you won’t need quotations for arguments with spaces in between like ‘\»More output\»‘ . If you are unsure how to tokenize the arguments from the command, you can use the shlex.split() function:

You have also the subprocess.call() function to your disposal which works like the Popen class, but it waits until the command completes and gives you the return code as in return_code = subprocess.call([‘echo’, ‘Even more output’]) . The recommended way however is to use subprocess.run() which works since Python 3.5. It has been added as a simplification of subprocess.Popen . The function will return a subprocess.CompletedProcess object:

You can now find the resulting output in this variable:

Similar to subprocess.call() and the previous .communicate() function, it will wait untill the process is completed. Finally, here is a more advanced example on how to access a server with ssh and the subprocess module:

Here you can see how to write input to the process. In this case you need to set the bufsize=0 in order to have unbuffered output. After you are finished writing to the stdin , you need to close the connection.

Выполнение shell команд с Python

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

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

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

Использование os.system для запуска команды

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

Давайте начнем с создания нового файла Python с именем echo_adelle.py и введите следующее:

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

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

По мере того, как команды echo выводятся в наш stdout , os.system() также возвращает код завершения команды оболочки. Код 0 означает, что он работает без проблем, а любое другое число означает ошибку.

Давайте создадим новый файл с именем cd_return_codes.py и введите следующее:

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

Первая команда, которая изменяет каталог на домашний каталог, выполняется успешно. Следовательно, os.system() возвращает код ноль, который хранится в home_dir . С другой стороны, unknown_dir сохраняет код завершения неудачной команды bash, чтобы изменить каталог на несуществующую папку.

Функция os.system() выполняет команду, печатает любой вывод команды на консоль и возвращает код завершения команды. Если нам нужно более детальное управление вводом и выводом команды оболочки в Python, мы должны использовать модуль subprocess .

Выполнение команды с подпроцессом

Модуль subprocess — это рекомендуемый Python способ выполнения команд оболочки. Это дает нам гибкость для подавления вывода команд оболочки или цепочки входов и выходов различных команд вместе, в то же время обеспечивая аналогичный опыт os.system() для базовых сценариев использования.

В новом файле с именем list_subprocess.py напишите следующий код:

В первой строке мы импортируем модуль subprocess , который является частью стандартной библиотеки Python. Затем мы используем функцию subprocess.run() для выполнения команды. Также как и команда os.system() , subprocess.run() возвращает код того, что было выполнено.

Обратите внимание, что subprocess.run() принимает список строк в качестве входных данных вместо одной строки. Первым элементом списка является название команды. Остальные пункты списка — это флаги и аргументы команды.

Примечание: Как правило, вам нужно отделить аргументы , основанные на пространстве, например , ls -alh будет [«ls», «-alh»] , а ls -a -l -h , превратится в [«ls», «-a», -«l», «-h»] .

Запустите этот файл, и вывод вашей консоли будет похож на:

Теперь давайте попробуем использовать одну из более продвинутых функций subprocess.run() , а именно игнорирование вывода в stdout . В том же файле list_subprocess.py измените:

Стандартный вывод команды теперь передается на специальное устройство /dev/null , что означает, что вывод не будет отображаться на наших консолях. Запустите файл в вашей оболочке, чтобы увидеть следующий вывод:

Что если мы хотим получить результат команды? subprocess.run() поможет сделать это. Создайте новый файл с именем cat_subprocess.py , набрав следующее:

Мы используем довольно много параметров, давайте рассмотрим их:

1. stdout=subprocess.PIPE говорит Python перенаправить результат выполнения команды в объект, чтобы позже его можно было прочитать вручную
2. text=True возвращает stdout и в stderr виде строк. Тип возвращаемого значения по умолчанию — байты.
3. input=»Hello from the other side» говорит Python добавить строку в качестве ввода в команду cat .

Запуск этого файла приводит к следующему выводу:

Мы также можем бросить Exception без проверки значения возврата. В новом файле false_subprocess.py добавьте код ниже:

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

Используя check=True , мы сообщаем Python, что нужно вызывать любые исключения, если возникает ошибка. Так как мы столкнулись с ошибкой, оператор print в последней строке не был выполнен.

Функция subprocess.run() дает нам огромную гибкость. Эта функция представляет собой упрощенную абстракцию класса subprocess.Popen , которая предоставляет дополнительные функциональные возможности, которые мы можем исследовать.

Выполнение команды с Popen

Класс subprocess.Popen предоставляет больше возможностей для разработчика при взаимодействии с оболочкой. Тем не менее, мы должны быть более точными в получении результатов и ошибок

По умолчанию subprocess.Popen не останавливает обработку программы Python, если ее команда не завершила выполнение. В новом файле с именем list_popen.py введите следующее:

Этот код эквивалентен list_subprocess.py . Он запускает команду с помощью subprocess.Popen и ожидает ее завершения, прежде чем выполнить оставшуюся часть сценария Python.

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

Метод poll() возвращает код завершения, если команда закончит работу, или None если он все еще выполняется. Например, если бы мы хотели проверить, завершено ли list_dir , а не ждать его, у нас была бы следующая строка кода:

Для управления вводом и выводом subprocess.Popen нам нужно использовать метод communicate() .

В новый файл с именем cat_popen.py добавьте следующий фрагмент кода:

Метод communicate() принимает аргумент input , который используется для передачи входных данных команде оболочки. Метод communicate также возвращает stdout и stderr когда они установлены.

Мы рассмотрели три способа запуска команд оболочки в Python с использованием класса subprocess.Popen . Давайте еще раз рассмотрим их характеристики, чтобы узнать, какой метод лучше всего подходит для требований проекта.

Какой из них я должен использовать?

Если вам нужно выполнить одну или несколько простых команд и вам не помешает, если их вывод поступит в консоль, вы можете использовать команду os.system() . Если вы хотите управлять вводом и выводом команды оболочки, используйте subsystem.run() . Если вы хотите выполнить команду и продолжить выполнять другую работу, пока она выполняется, используйте subprocess.Popen .

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