You have to open the subprocess like this:

import subprocess
cmd = subprocess.Popen(['./myprogram'], stdin=subprocess.PIPE)

This means that cmd will have a .stdin you can write to; print by default sends output to your Python script's stdout, which has no connection with the subprocess' stdin. So do that:

cmd.stdin.write('1\n')  # tell myprogram to select 1

and then quite probably you should:

cmd.stdin.flush()  # don't let your input stay in in-memory-buffers

or

cmd.stdin.close()  # if you're done with writing to the subprocess.

PS If your Python script is a long-running process on a *nix system and you notice your subprocess has ended but is still displayed as a Z (zombie) process, please check that answer.

subprocess.run has optional stdout argument, you might give it file handle, so in your case something like

import subprocess
import sys
filestem = sys.argv[1]
with open('outputfile','wb') as f:
    subprocess.run(['/home/dev/executable_file', filestem],stdout=f)

should work. I do not have ability to test it so please run it and write if it does work as intended

I really can't find something that explain this behaviour; can someone help me understanding?

There are at least two issues here:

1. the C program's standard output is to a non-interactive device (a pipe) and therefore the output is fully buffered. The output will be accumulated in memory, only being sent to the output device when (i) the buffer fills, or (ii) it is manually flushed, or (iii) the program terminates normally.

2. the C program runs indefinitely, with no way to make it terminate normally. Not even end-of-file on its standard input will make it stop.

On the Python side, then, the script is waiting for the subprocess's output to be flushed, whereas the subprocess needs to read and echo more data (probably a lot of it) before that will happen. This is a deadlock.

Your best approach depends on how well the example C program models the behavior of the one in which you're really interested.

• If it's faithful in every relevant detail, then the only thing you can reasonably do is keep writing to the subprocess's stdin until something pops out on its stdout. You probably want to do the data pushing in a separate thread, to avoid reproducing exactly the same kind of deadlock you already saw.

• If it recognizes some kind of clean termination signal, such as a "quit" command or EOF on its standard input, then have the Python side send that signal before trying to read the output. Indeed, you already close stdin, so perhaps you don't actually need to do anything to accommodate the real program.

Note well that the first alternative leaves the subprocess running. You will want to ensure that it terminates. By terminate()ing or kill()ing it, if that's what it takes.

Here's minimalistic example of how to call a C++ executable from Python, and communicate with it from Python.

1) Note that you must add \n when writing to input stream (i.e. stdin) of the subprocess (just like you would hit Rtn if running the program manually).

2) Also note the flushing of the streams, so that the receiving program doesn't get stuck waiting for the whole buffer to fill before printing the result.

3) And if running Python 3, be sure to convert the streaming value from string to bytes (see https://stackoverflow.com/a/5471351/1510289).

Python:

from subprocess import Popen, PIPE

p = Popen(['a.out'], shell=True, stdout=PIPE, stdin=PIPE)
for ii in range(10):
    value = str(ii) + '\n'
    #value = bytes(value, 'UTF-8')  # Needed in Python 3.
    p.stdin.write(value)
    p.stdin.flush()
    result = p.stdout.readline().strip()
    print(result)

C++:

#include <iostream>

int main(){
    for( int ii=0; ii<10; ++ii ){
        int input;
        std::cin >> input;
        std::cout << input*2 << std::endl;
        std::cout.flush();
    }
}

Output of running Python:

0
2
4
6
8
10
12
14
16
18

To complement @Jonathan Leffler's and @alastair's helpful answers:

Assuming you control the string you're passing to the shell for execution, I see nothing wrong with using the shell for convenience. ^[1]

subprocess.call() has an optional Boolean shell parameter, which causes the command to be passed to the shell, enabling I/O redirection, referencing environment variables, ...:

subprocess.call("./x <inp.txt", shell = True)

Note how the entire command line is passed as a single string rather than an array of arguments.

^[1] Avoid use of the shell in the following cases:

• If your Python code must run on platforms other than Unix-like ones, such as Windows.
• If performance is paramount.
• If you find yourself "outsourcing" tasks better handled on the Python side.

If you're concerned about lack of predictability of the shell environment (as @alastair is):

• subprocess.call with shell = True always creates non-interactive non-login instances of /bin/sh - note that it is NOT the user's default shell that is used.

• sh does NOT read initialization files for non-interactive non-login shells (neither system-wide nor user-specific ones).

  • Note that even on platforms where sh is bash in disguise, bash will act this way when invoked as sh.

• Every shell instance created with subprocess.call with shell = True is its own world, and its environment is neither influenced by previous shell instances nor does it influence later ones.

• However, the shell instances created do inherit the environment of the python process itself:

  • If you started your Python program from an interactive shell, then that shell's environment is inherited. Note that this only pertains to the current working directory and environment variables, and NOT to aliases, shell functions, and shell variables.

  • Generally, that's a feature, given that Python (CPython) itself is designed to be controllable via environment variables (for 2.x, see https://docs.python.org/2/using/cmdline.html#environment-variables; for 3.x, see https://docs.python.org/3/using/cmdline.html#environment-variables).

  • If needed, you can supply your own environment to the shell via the env parameter; note, however, that you'll have to supply the entire environment in that event, potentially including variables such as USER and HOME, if needed; simple example, defining $PATH explicitly:

    subprocess.call('echo $PATH', shell = True, \
                    env = { 'PATH': '/sbin:/bin:/usr/bin' })
    

You probably need to quote your paramters separately:

call(["ffmpeg", "-i", "infile.avi", "-acodec", "copy", "-vcodec", "copy", "outfile.mp4")

Your syntax is mostly correct.

The error message is quite clear: subprocess.call(), which use subprocess.Popen class as backend, does not accept a keyword argument 'check'

Remove that argument and try again.

If you want CalledProcessError to be raised when the called process return non-zero returncodes, use subprocess.check_call() instead.

There is no such thing as a C script. If you meant a C program you need to compile spa.c and spa.h into an executable before running it.

If you use GCC in Linux or Mac OS X:

$ gcc -Wall spa.c -o spa

Will get you an executable named spa.

After that, you can run spa program from your Python script with:

from subprocess import call
call(["./spa", "args", "to", "spa"])

Currently recommended way of running and controlling executables using Python is subprocess module. You can use different arguments, capture stdout, process it, or just redirect to arbitrary file. Have a look at documentation here https://docs.python.org/3.2/library/subprocess.html#module-subprocess