Vfrdtyky

This is way easier, but only works on Unix (including Cygwin).

import commands

print commands.getstatusoutput('wc -l file')

it returns a tuple with the (return_value, output)

This only works in python2.7: it is not available on python3. For a solution that works in both, use the subprocess module instead:

import subprocess

output=subprocess.Popen(["date"],stdout=PIPE)

response=output.communicate()

print response

Something like that:

def runProcess(exe):    

    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    while(True):

        # returns None while subprocess is running

        retcode = p.poll() 

        line = p.stdout.readline()

        yield line

        if retcode is not None:

            break

Note, that I'm redirecting stderr to stdout, it might not be exactly what you want, but I want error messages also.

This function yields line by line as they come (normally you'd have to wait for subprocess to finish to get the output as a whole).

For your case the usage would be:

for line in runProcess('mysqladmin create test -uroot -pmysqladmin12'.split()):

    print line,

Vartec's answer doesn't read all lines, so I made a version that did:

def run_command(command):

    p = subprocess.Popen(command,

                         stdout=subprocess.PIPE,

                         stderr=subprocess.STDOUT)

    return iter(p.stdout.readline, b'')

Usage is the same as the accepted answer:

command = 'mysqladmin create test -uroot -pmysqladmin12'.split()

for line in run_command(command):

    print(line)

This is a tricky but super simple solution which works in many situations:

import os

os.system('sample_cmd > tmp')

print open('tmp', 'r').read()

A temporary file(here is tmp) is created with the output of the command and you can read from it your desired output.

Extra note from the comments:
You can remove the tmp file in the case of one-time job. If you need to do this several times, there is no need to delete the tmp.

os.remove('tmp')

In Python 3.5:

import subprocess



output = subprocess.run("ls -l", shell=True, stdout=subprocess.PIPE, 

                        universal_newlines=True)

print(output.stdout)

I had the same problem
But figured out a very simple way of doing this
follow this

import subprocess

output = subprocess.getoutput("ls -l")

print(output)

Hope it helps out

Note: This solution is python3 specific as subprocess.getoutput() don't work in python2

You can use following commands to run any shell command. I have used them on ubuntu.

import os

os.popen('your command here').read()

Modern Python solution (>= 3.1):

 res = subprocess.check_output(lcmd, stderr=subprocess.STDOUT)

Your Mileage May Vary, I attempted @senderle's spin on Vartec's solution in Windows on Python 2.6.5, but I was getting errors, and no other solutions worked. My error was: WindowsError: [Error 6] The handle is invalid.

I found that I had to assign PIPE to every handle to get it to return the output I expected - the following worked for me.

import subprocess



def run_command(cmd):

    """given shell command, returns communication tuple of stdout and stderr"""

    return subprocess.Popen(cmd, 

                            stdout=subprocess.PIPE, 

                            stderr=subprocess.PIPE, 

                            stdin=subprocess.PIPE).communicate()

and call like this, ([0] gets the first element of the tuple, stdout):

run_command('tracert 11.1.0.1')[0]

After learning more, I believe I need these pipe arguments because I'm working on a custom system that uses different handles, so I had to directly control all the std's.

To stop console popups (with Windows), do this:

def run_command(cmd):

    """given shell command, returns communication tuple of stdout and stderr"""

    # instantiate a startupinfo obj:

    startupinfo = subprocess.STARTUPINFO()

    # set the use show window flag, might make conditional on being in Windows:

    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

    # pass as the startupinfo keyword argument:

    return subprocess.Popen(cmd,

                            stdout=subprocess.PIPE, 

                            stderr=subprocess.PIPE, 

                            stdin=subprocess.PIPE, 

                            startupinfo=startupinfo).communicate()



run_command('tracert 11.1.0.1')

I had a slightly different flavor of the same problem with the following requirements:

1. Capture and return STDOUT messages as they accumulate in the STDOUT buffer (i.e. in realtime).
   
   
   
   
   • @vartec solved this Pythonically with his use of generators and the 'yield'
     
     keyword above
   
   
   
   


2. Print all STDOUT lines (even if process exits before STDOUT buffer can be fully read)


3. Don't waste CPU cycles polling the process at high-frequency


4. Check the return code of the subprocess


5. Print STDERR (separate from STDOUT) if we get a non-zero error return code.

I've combined and tweaked previous answers to come up with the following:

import subprocess

from time import sleep



def run_command(command):

    p = subprocess.Popen(command,

                         stdout=subprocess.PIPE,

                         stderr=subprocess.PIPE,

                         shell=True)

    # Read stdout from subprocess until the buffer is empty !

    for line in iter(p.stdout.readline, b''):

        if line: # Don't print blank lines

            yield line

    # This ensures the process has completed, AND sets the 'returncode' attr

    while p.poll() is None:                                                                                                                                        

        sleep(.1) #Don't waste CPU-cycles

    # Empty STDERR buffer

    err = p.stderr.read()

    if p.returncode != 0:

       # The run_command() function is responsible for logging STDERR 

       print("Error: " + str(err))

This code would be executed the same as previous answers:

for line in run_command(cmd):

    print(line)

If you need to run a shell command on multiple files, this did the trick for me.

import os

import subprocess



# Define a function for running commands and capturing stdout line by line

# (Modified from Vartec's solution because it wasn't printing all lines)

def runProcess(exe):    

    p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    return iter(p.stdout.readline, b'')



# Get all filenames in working directory

for filename in os.listdir('./'):

    # This command will be run on each file

    cmd = 'nm ' + filename



    # Run the command and capture the output line by line.

    for line in runProcess(cmd.split()):

        # Eliminate leading and trailing whitespace

        line.strip()

        # Split the output 

        output = line.split()



        # Filter the output and print relevant lines

        if len(output) > 2:

            if ((output[2] == 'set_program_name')):

                print filename

                print line

Edit: Just saw Max Persson's solution with J.F. Sebastian's suggestion. Went ahead and incorporated that.

Splitting the initial command for the subprocess might be tricky and cumbersome.

Use shlex.split to help yourself out.

Sample command

git log -n 5 --since "5 years ago" --until "2 year ago"

The code

from subprocess import check_output

from shlex import split



res = check_output(split('git log -n 5 --since "5 years ago" --until "2 year ago"'))

print(res)

>>> b'commit 7696ab087a163e084d6870bb4e5e4d4198bdc61anAuthor: Artur Barseghyan...'

eg, execute('ls -ahl')
differentiated three/four possible returns and OS platforms:

1. no output, but run successfully


2. output empty line, run successfully


3. run failed


4. output something, run successfully

function below

def execute(cmd, output=True, DEBUG_MODE=False):

"""Executes a bash command.

(cmd, output=True)

output: whether print shell output to screen, only affects screen display, does not affect returned values

return: ...regardless of output=True/False...

        returns shell output as a list with each elment is a line of string (whitespace stripped both sides) from output

        could be 

        , ie, len()=0 --> no output;    

        [''] --> output empty line;     

        None --> error occured, see below



        if error ocurs, returns None (ie, is None), print out the error message to screen

"""

if not DEBUG_MODE:

    print "Command: " + cmd



    # https://stackoverflow.com/a/40139101/2292993

    def _execute_cmd(cmd):

        if os.name == 'nt' or platform.system() == 'Windows':

            # set stdin, out, err all to PIPE to get results (other than None) after run the Popen() instance

            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)

        else:

            # Use bash; the default is sh

            p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, executable="/bin/bash")



        # the Popen() instance starts running once instantiated (??)

        # additionally, communicate(), or poll() and wait process to terminate

        # communicate() accepts optional input as stdin to the pipe (requires setting stdin=subprocess.PIPE above), return out, err as tuple

        # if communicate(), the results are buffered in memory



        # Read stdout from subprocess until the buffer is empty !

        # if error occurs, the stdout is '', which means the below loop is essentially skipped

        # A prefix of 'b' or 'B' is ignored in Python 2; 

        # it indicates that the literal should become a bytes literal in Python 3 

        # (e.g. when code is automatically converted with 2to3).

        # return iter(p.stdout.readline, b'')

        for line in iter(p.stdout.readline, b''):

            # # Windows has rn, Unix has n, Old mac has r

            # if line not in ['','n','r','rn']: # Don't print blank lines

                yield line

        while p.poll() is None:                                                                                                                                        

            sleep(.1) #Don't waste CPU-cycles

        # Empty STDERR buffer

        err = p.stderr.read()

        if p.returncode != 0:

            # responsible for logging STDERR 

            print("Error: " + str(err))

            yield None



    out = 

    for line in _execute_cmd(cmd):

        # error did not occur earlier

        if line is not None:

            # trailing comma to avoid a newline (by print itself) being printed

            if output: print line,

            out.append(line.strip())

        else:

            # error occured earlier

            out = None

    return out

else:

    print "Simulation! The command is " + cmd

    print ""