Thanks to the comment of @joan:

You can't. A C program (a program in any language) returns an integer status. You want to change the Python program so it gets the stdout (printf) of the C program rather than the status of the C program.

I do this in Python:

>>> from subprocess import check_output
>>> foo = check_output('./th', shell=True)
>>> foo
'17.9 51.0'

// Your C file to be called from python
// To compile :
// gcc -dynamiclib -I/usr/include/python2.7/ -lpython2.7 -o Module.dylib Module.c

#include < Python.h >

static PyObject* py_myFunction(PyObject* self, PyObject* args)
{
    char *s = "Hello from C!";
    return Py_BuildValue("s", s);
}

static PyMethodDef myModule_methods[] = {
    {"myFunction", py_myFunction, METH_VARAGS},
    {NULL, NULL}
};

void initmyModule()
{
    (void) Py_InitModule("myModule", myModule_methods);
}

To call from python:

from Module import *
print "Result from myFunction:", myFunction()

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

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

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"])

You can use a ThreadPool to run many tasks in parallel.

from multiprocessing.pool import ThreadPool
import subprocess
def f(x):
    a, b = x
    res = subprocess.check_output(["./a.out", str(a), str(b)])
    return int(res.strip())
p = ThreadPool()
results = p.map(f, [(2,3), (5,6), (9,10)])

The input to your C code should be taken by scanf.

C code: [test.c]

#include <stdio.h>
int main() {
    int x;
    scanf("%d",&x);
    printf("Value is %d\n",x);
}

Compile:

gcc test.c -o foo

Python code:[test.py]

print (3)

Command :

python test.py | ./foo

Output:

Value is 3

Here standard input of C code gets changed from keyboard to the end of pipe. And standard output of python code gets changed from monitor to beginning of pipe.

In C there are kernel level calls to perform this operation. Read about close() , dup() calls. I hope your concept will be cleared then. Good Luck :)

And you are actually trying to print command line arguments. But look at your command. You are not passing any arguments to myprogram. So, argc = 0.

This is one of the simplest ways to do this:

1. Make your C program print its output on stdout. This is the standard stream which is used by printf().
2. Make your python program read its input from stdin. This is the standard stream which is used by input().

3. Connect both programs on the command line with the pipe symbol | like this:

   c-program | python script.py
   

Note that there are more ways to make two programs communicate. And there are more ways to write to stdout and to read from stdin.

The method described works on all major operating systems.

One of its biggest advantages is that you can develop each part independent from the other and test it on its own. In example, you can pipe the output of the C program into a file to check later. Similarly you can pipe the input of this or any other file into the python script.

The easiest way is getProcessOutput:

from twisted.internet.utils import getProcessOutput
df = getProcessOutput('ls', args=('/home','-lah'))
df.addCallback( printOutput )

Also see http://twistedmatrix.com/documents/current/core/howto/process.html in case you need something more complex.

You could use subprocess.Popen. Sample code:

#include <iostream>

int sum(int a, int b) {
    return a + b;
}


int main ()
{
    int a, b;

    std::cin >> a >> b;
    std::cout << sum(a, b) << std::endl;
    
}

from subprocess import Popen, PIPE

program_path = "/home/user/sum_prog"

p = Popen([program_path], stdout=PIPE, stdin=PIPE)
p.stdin.write(b"1\n")
p.stdin.write(b"2\n")
p.stdin.flush()

result = p.stdout.readline().strip()
assert result == b"3"

One useful way is calling a python function within c, which is that you need instead of execute whole script.

As described in >> here