Python run command and read output

Python run command and read output from file

But there’s indeed a way to use a text stream without loosing the original line endings by means of — therewith we can do this: Solution 1: If you need real-time output from , you could use something like this ( Windows platform according to your last comment): Byte stream : Text stream : The latter code snippet output : Solution 2: Use (On windows platform, use Powershell): By this way, the screen will display the output on PowerShell terminal and the output will also be stored in out . After that you can simple write that output to a file with the standard Python IO functions: File IO in python.

Call an external command in python and output to file

You can use system from os .

import os os.system("ls -l > file.txt") 

Writing the output of a command can be accomplished by «>». If you want to append instead of overwriting the file, you can use «>>».

This will do what you’re asking :

import subprocess with open ('date.txt', 'w') as file : subprocess.Popen ('date', stdout = file) 

Trying to figure out how to save output from a command to a file path, The usual method is to use the Command Prompt or shell to do these things. You could still have a python script doing things, but then you run

Python execute shell command and get output

Python is an excellent scripting language. More and more sysadmins are using Python scripts Duration: 7:26

Running Shell Commands using Python (Detailed Explanation)

In this video, learn how to run shell commands using Python. This is useful when your python
Duration: 29:42

Writing command line output to file

You can redirect standard output to any file using > in command.

$ ls /Users/user/Desktop > out.txt 

os.system('ls /Users/user/Desktop > out.txt') 

However, if you are using python then instead of using ls command you can use os.listdir to list all the files in the directory.

path = '/Users/user/Desktop' files = os.listdir(path) print files 

After skimming the python documentation to run shell command and obtain the output you can use the subprocess module with the check_output method.

After that you can simple write that output to a file with the standard Python IO functions: File IO in python.

To open a file, you can use the f = open(/Path/To/File) command. The syntax is f = open(‘/Path/To/File’, ‘type’) where ‘type’ is r for reading, w for writing, and a for appending. The commands to do this are f.read() and f.write(‘content_to_write’) . To get the output from a command line command, you have to use popen and subprocess instead of os.system() . os.system() doesn’t return a value. You can read more on popen here.

Execute a command by reading contents of a text file, This should work: import subprocess # read in users and strip the newlines with open(‘/tmp/users.txt’) as f: userlist = [line.rstrip() for

How do I stream output (one line at a time) from `subprocess`?

import subprocess p = subprocess.Popen(("ls"), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) for line in p.stdout: print(line.decode("utf-8").rstrip()) p.wait() status = p.poll() print("process terminate with code: %s" % status) 

my-file.txt . process terminate with code: 0 

When the subprocess exit, stdout is closed, which break the loop.

subprocess stdout is a bytes stream. If you need str objects, you should decode it: line.decode(«utf-8») .

But I think this is not the problem. Some command have different output in case of stdout is a terminal or a pipe. Like with wget . I you want a progress bar, you have to parse output and implement your own progress bar.

for line in process.stdout and process.stdout.readline() are not fit for the task because they don’t return before a whole line has ended, i. e. a \n is received, while a progress part only ends with \r . A way to read output independently of any line termination is to use os.read():

from os import read process = Popen(shlex.split(cmd), stdout=PIPE) while buffer := read(process.stdout.fileno(), 4096): print(buffer.decode(), end='') 

As xrisk noted, using text=True would allow lines ending with \r to be read with readline() , but that’s of no use here because therewith all line endings in the output will be converted to ‘\n’ .

But there’s indeed a way to use a text stream without loosing the original line endings by means of io.TextIOWrapper — therewith we can do this:

import io process = Popen(shlex.split(cmd), stdout=PIPE) for line in io.TextIOWrapper(process.stdout, newline=""): print(line, end="") 

Python | Execute and parse Linux commands, We can retrieve the output of a command by using the communicate function. It reads data from stdout and stderr until it reaches the end-of-file

Run external command from Python. Then display the output on screen and get the output simultaneously

If you need real-time output from Popen , you could use something like this ( Windows platform according to your last comment):

Byte stream :

import sys, subprocess out=b'' result = subprocess.Popen(['cmd', '/c', 'dir /B 1*.txt'], stdout=subprocess.PIPE, universal_newlines=False) for s_line in result.stdout: #Parse it the way you want out += s_line print( s_line.decode(sys.stdout.encoding).replace('\r\n','')) # debugging output print(out.decode(sys.stdout.encoding)) 

Text stream :

import subprocess out='' result = subprocess.Popen(['cmd', '/c', 'dir /B 1*.txt'], stdout=subprocess.PIPE, universal_newlines=True) for s_line in result.stdout: #Parse it the way you want out += s_line print( s_line.rstrip()) # debugging output print(out) 

The latter code snippet output :

>>> import subprocess >>> out='' >>> result = subprocess.Popen(['cmd', '/c', 'dir /B 1*.txt'], stdout=subprocess.PIPE, . universal_newlines=True) >>> for s_line in result.stdout: . #Parse it the way you want . out += s_line . print( s_line.rstrip()) . 1.325.txt 1049363a.txt 1049363b.txt 1051416.txt 1207235log.txt >>> print(out) 1.325.txt 1049363a.txt 1049363b.txt 1051416.txt 1207235log.txt >>> 

Use | tee (On windows platform, use Powershell):

import subprocess # Run command in powershell and redirect it by | tee to a file named out.txt result = subprocess.Popen(['powershell', command, '|', 'tee', 'out.txt']) # Get standard output f = open('out.txt') out = f.read() f.close() 

By this way, the screen will display the output on PowerShell terminal and the output will also be stored in out .

Call an external command in python and output to file, Writing the output of a command can be accomplished by «>». If you want to append instead of overwriting the file, you can use «>>». Share.

Источник

Python: execute shell commands (and get the output) with the os package

This article is part of a two-part series related to running shell commands from within Python.

Execute shell commands using the os package

The most straightforward solution to running shell commands via Python is simply by using the system method of the os package. The os package “provides a portable way of using operating system dependent functionality.” The system method executes a string as a command in a subshell, which basically is an independent instance of the command processor of your operating system. For Windows, commands will be run using cmd.exe, for Linux this will be Bash, Mac will use Bash or Z shell.

The following code will open a subshell, run the command, and return the process exit code — a 0 (zero) if the command has run successfully, other numbers mean something has gone wrong (see Linux and Windows).

import os os.system('echo "Hello World!"')

Execute shell commands and get the output using the os package

Sometimes, you’re not only interested in running shell commands, but you’d also like to know what printed output is. The os package also has a solution for this: the popen method. This method opens a pipe into the command, which is used to transfer its output to a Python variable.

The following code will once again open a subshell and run the command, but instead of returning the process exit code, it will return the command output. If you ‘d like to remove the trailing nextline (\n), you can use the strip method

output_stream = os.popen('echo "Hello World!"') output_stream.read()

• If the command passed to the shell generates errors, it will only return two single quotes.
• If you would like to know if a command completed successfully, you can access the process exit code using the close method. Like this:

output_stream = os.popen('non-existing-command') output_stream.close()

The popen method of the os package uses the subprocess module. So instead of using popen, you might as well interface with the subprocess module directly. We discuss this in the next article.

Источник