Python exec bash command

Executing Shell Commands with Python

A sysadmin would need to execute shell commands in Python scripts. Learn how to execute shell commands in Python.

Python is an excellent scripting language. More and more sysadmins are using Python scripts to automate their work.

Since the sysadmin tasks involve Linux commands all the time, running Linux commands from the Python script is a great help.

In this tutorial, I’ll show you a couple of ways you can run shell commands and get its output in your Python program.

Execute Shell command in Python with os module

Let me create a simple python program that executes a shell command with the os module.

import os myCmd = 'ls -la' os.system(myCmd)

Now, if I run this program, here’s what I see in the output.

python prog.py total 40 drwxr-xr-x 3 abhishek abhishek 4096 Jan 17 15:58 . drwxr-xr-x 49 abhishek abhishek 4096 Jan 17 15:05 .. -r--r--r-- 1 abhishek abhishek 456 Dec 11 21:29 agatha.txt -rw-r--r-- 1 abhishek abhishek 0 Jan 17 12:11 count -rw-r--r-- 1 abhishek abhishek 14 Jan 10 16:12 count1.txt -rw-r--r-- 1 abhishek abhishek 14 Jan 10 16:12 count2.txt --w-r--r-- 1 abhishek abhishek 356 Jan 17 12:10 file1.txt -rw-r--r-- 1 abhishek abhishek 356 Dec 17 09:59 file2.txt -rw-r--r-- 1 abhishek abhishek 44 Jan 17 15:58 prog.py -rw-r--r-- 1 abhishek abhishek 356 Dec 11 21:35 sherlock.txt drwxr-xr-x 3 abhishek abhishek 4096 Jan 4 20:10 target

That’s the content of the directory where prog.py is stored.

If you want to use the output of the shell command, you can store it in a file directly from the shell command:

import os myCmd = 'ls -la > out.txt' os.system(myCmd)

You can also store the output of the shell command in a variable in this way:

import os myCmd = os.popen('ls -la').read() print(myCmd)

If you run the above program, it will print the content of the variable myCmd and it will be the same as the output of the ls command we saw earlier.

Now let’s see another way of running Linux command in Python.

Execute shell command in Python with subprocess module

A slightly better way of running shell commands in Python is using the subprocess module.

If you want to run a shell command without any options and arguments, you can call subprocess like this:

import subprocess subprocess.call("ls")

The call method will execute the shell command. You’ll see the content of the current working directory when you run the program:

python prog.py agatha.txt count1.txt file1.txt prog.py target count count2.txt file2.txt sherlock.txt

If you want to provide the options and the arguments along with the shell command, you’ll have to provide them in a list.

import subprocess subprocess.call(["ls", "-l", "."])

When you run the program, you’ll see the content of the current directory in the list format.

Now that you know how to run shell command with subprocess, the question arises about storing the output of the shell command.

For this, you’ll have to use the Popen function. It outputs to the Popen object which has a communicate() method that can be used to get the standard output and error as a tuple. You can learn more about the subprocess module here.

import subprocess MyOut = subprocess.Popen(['ls', '-l', '.'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) stdout,stderr = MyOut.communicate() print(stdout) print(stderr)

When you run the program, you’ll see the stdout and stderr (which is none in this case).

python prog.py total 32 -r--r--r-- 1 abhishek abhishek 456 Dec 11 21:29 agatha.txt -rw-r--r-- 1 abhishek abhishek 0 Jan 17 12:11 count -rw-r--r-- 1 abhishek abhishek 14 Jan 10 16:12 count1.txt -rw-r--r-- 1 abhishek abhishek 14 Jan 10 16:12 count2.txt --w-r--r-- 1 abhishek abhishek 356 Jan 17 12:10 file1.txt -rw-r--r-- 1 abhishek abhishek 356 Dec 17 09:59 file2.txt -rw-r--r-- 1 abhishek abhishek 212 Jan 17 16:54 prog.py -rw-r--r-- 1 abhishek abhishek 356 Dec 11 21:35 sherlock.txt drwxr-xr-x 3 abhishek abhishek 4096 Jan 4 20:10 target None

I hope this quick tip helped you to execute shell command in Python programs. In a related quick tip, you can learn to write list to file in Python.

If you have questions or suggestions, please feel free to drop a comment below.

Источник

How to Run bash scripts Using Python?

Invicti Web Application Security Scanner – the only solution that delivers automatic verification of vulnerabilities with Proof-Based Scanning™.

If you are using Linux, then you would definitely love the shell commands.

And if you are working with Python, then you may have tried to automate things. That’s a way to save time. You may also have some bash scripts to automate things.

Python is handy to write scripts than bash. And managing Python scripts are easy compared to bash scripts. You will find it difficult to maintain the bash scripts once it’s growing.

But what if you already have bash scripts that you want to run using Python?

Is there any way to execute the bash commands and scripts in Python?

Yeah, Python has a built-in module called subprocess which is used to execute the commands and scripts inside Python scripts. Let’s see how to execute bash commands and scripts in Python scripts in detail.

Executing Bash Commands

As you may have already seen the module subprocess is used to execute the bash commands and scripts. It provides different methods and classes for the same.

There are mainly one method and one class to know about from the subprocess module. They are run and Popen. These two help us to execute the bash commands in Python scripts. Let’s see them one by one.

subprocess.run()

The method subprocess.run() will take a list of strings as a positional argument. This is mandatory as it has the bash command and arguments for it. The first item in the list is the command name and the remaining items are the arguments to the command.

import subprocess subprocess.run(["ls"]) 

The above script list all the items in the current working directory as the script lies. There are no arguments to the command in the above script. We have given only the bash command. We can provide additional arguments to the ls command like -l , -a , -la , etc.

Let’s see a quick example with command arguments.

import subprocess subprocess.run(["ls", "-la"]) 

The above command displays all the files including hidden files along with the permissions. We have provided the argument la which displays files and directories extra information and hidden files.

We may end up making some mistakes while writing the commands. Errors will raise according to the mistakes. What if you want to capture them and use them later? Yeah, we can do that using the keyword argument stderr.

import subprocess result = subprocess.run(["cat", "sample.txt"], stderr=subprocess.PIPE, text=True) print(result.stderr) 

Make sure you don’t have the file with the name sample.txt in the working directory. The value to the keyword argument stderr is PIPE which helps to return the error in an object. We can access it later with the same name. And the keyword argument text helps to tell that the output should be a string.

Similarly, we can capture the output of the command using the stdout keyword argument.

import subprocess result = subprocess.run(["echo", "Hello, World!"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) print(result.stdout) 

subprocess.run() – input

You can give input to the commands using the input keyword argument. We will give inputs in a string format. So, we need to set the keyword argument text to True . By default, it takes it in bytes.

import subprocess subprocess.run(["python3", "add.py"], text=True, input="2 3") 

In the above program, the Python script add.py will take two numbers as input. We have given the input to the Python script using the input keyword argument.

subprocess.Popen()

The class subprocess.Popen() is advanced than the method subprocess.run(). It gives us more options to execute the commands. We will create an instance of the subprocess.Popen() and use it for various things like knowing the status of the command execution, getting output, giving input, etc.

There are several methods of the class subprocess.Popen() that we need to know. Let’s see them one by one along with the code examples.

wait

It is used to wait until the completion of the execution of the command. The next lines of the Python script won’t execute until the completion of the previous command that is written after the wait method. Let’s see the example.

import subprocess process = subprocess.Popen(["ls", "-la"]) print("Completed!") 

Run the above code and observe the output. You will see that the message Completed! is printed before the execution of the command. We can avoid it using the wait method. Let’s wait till the completion of the command.

import subprocess process = subprocess.Popen(["ls", "-la"]) process.wait() print("Completed!") 

If you see the output for the above code, then you will realize that wait is actually working. The print statement is executed after the completion of the command execution.

communicate

The method communicate is used to get the output, error and give input to the command. It returns a tuple containing output and error respectively. Let’s see an example.

import subprocess process = subprocess.Popen(["echo", "Hello, World!"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) result = process.communicate() print(result)

subprocess.Popen() – input

We can’t pass the input to the class Popen directly. We need to use the keyword argument called stdin to give the input to the command. The instance of the class Popen will provide us stdin object. It has a method called write which is used to give the input to the command.

As we discussed earlier, it will take inputs as bytes-like objects by default. So, don’t forget to set the keyword argument text to True while creating the instance of Popen .

import subprocess process = subprocess.Popen(["python3", "add.py"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) process.stdin.write("2 3") process.stdin.close() print(process.stdout.read())

poll

The method poll is used to check whether the execution of the command is completed or not. This method will return None if the command is still executing. Let’s see an example.

import subprocess process = subprocess.Popen(['ping', '-c 5', 'geekflare.com'], stdout=subprocess.PIPE, text=True) while True: output = process.stdout.readline() if output: print(output.strip()) result = process.poll() if result is not None: break 

In the above code, we have used the ping command with 5 requests. There is an infinite loop that iterates until the completion of the command execution. We have used the method poll to check the status of the command execution. If the method poll returns code other than None , then the execution completes. And the infinite loop breaks.

Executing Bash Scripts

We have seen two ways to execute the commands. Now, let’s see how to execute the bash scripts in Python scripts.

The subprocess has a method called call. This method is used to execute the bash scripts. The method returns the exit code from the bash script. The default exit code for the bash scripts is 0. Let’s see an example.

Create a bash script with the name practice.sh as follows.

#!/bin/bash echo "Hello, World!" exit 1 

Now, write a Python script execute the above bash script.

import subprocess exit_code = subprocess.call('./practice.sh') print(exit_code) 

You will get the following output once you run the above Python script.

Conclusion

We have seen how to execute bash commands and scripts in Python. You can use them to automate things more efficiently.

Источник