Ist es möglich, eine Python-Funktion aus einer Zeichenfolge zu laden und diese Funktion dann mit Argumenten aufzurufen und den Rückgabewert zu erhalten?

Ich verwende die Python-C-API, um Python-Code in meiner C++-Anwendung auszuführen. Ich kann ein Modul aus einer Datei laden mit PyImport_Importerhalten Sie ein Funktionsobjekt davon mit PyObject_GetAttrStringund rufen Sie die Funktion mit auf PyObject_CallObject. Ich möchte das Modul/die Funktion aus einer Zeichenfolge anstelle einer Datei laden. Gibt es etwas Äquivalent zu PyImport_Import was würde es mir ermöglichen, eine Zeichenfolge anstelle einer Datei zu übergeben? Ich muss Argumente an die Funktion übergeben, die ich aufrufe, und ich brauche Zugriff auf den Rückgabewert, also kann ich nicht einfach verwenden PyRun_SimpleString.

Bearbeiten:

Ich fand diese Lösung, nachdem ich eingeschaltet wurde PyRun_String. Ich erstelle ein neues Modul, erhalte sein Wörterbuchobjekt und übergebe es in einem Aufruf an PyRun_String um eine Funktion in meinem neuen Modul zu definieren, dann ein Funktionsobjekt für diese neu erstellte Funktion zu erhalten und es über aufzurufen PyObject_CallObject, meine Argumente übergeben. Folgendes habe ich gefunden, um mein Problem zu lösen:
main.cpp

int main()
{
    PyObject *pName, *pModule, *pArgs, *pValue, *pFunc;
    PyObject *pGlobal = PyDict_New();
    PyObject *pLocal;

    //Create a new module object
    PyObject *pNewMod = PyModule_New("mymod");

    Py_Initialize();
    PyModule_AddStringConstant(pNewMod, "__file__", "");

    //Get the dictionary object from my module so I can pass this to PyRun_String
    pLocal = PyModule_GetDict(pNewMod);

    //Define my function in the newly created module
    pValue = PyRun_String("def blah(x):\n\tprint 5 * x\n\treturn 77\n", Py_file_input, pGlobal, pLocal);
    Py_DECREF(pValue);

    //Get a pointer to the function I just defined
    pFunc = PyObject_GetAttrString(pNewMod, "blah");

    //Build a tuple to hold my arguments (just the number 4 in this case)
    pArgs = PyTuple_New(1);
    pValue = PyInt_FromLong(4);
    PyTuple_SetItem(pArgs, 0, pValue);

    //Call my function, passing it the number four
    pValue = PyObject_CallObject(pFunc, pArgs);
    Py_DECREF(pArgs);
    printf("Returned val: %ld\n", PyInt_AsLong(pValue));
    Py_DECREF(pValue);

    Py_XDECREF(pFunc);
    Py_DECREF(pNewMod);
    Py_Finalize();

    return 0;
}

Hier ist der Rest meines ursprünglichen Beitrags, der der Nachwelt überlassen wurde:

Folgendes habe ich ursprünglich gemacht:
main.cpp:

#include <Python.h>

int main()
{
    PyObject *pName, *pModule, *pArgs, *pValue, *pFunc;

    Py_Initialize();
    PyRun_SimpleString("import sys");
    PyRun_SimpleString("sys.path.append('')");
    pName = PyString_FromString("atest");
    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if(pModule == NULL)
    {
        printf("PMod is null\n");
        PyErr_Print();
        return 1;
    }

    pFunc = PyObject_GetAttrString(pModule, "doStuff");
    pArgs = PyTuple_New(1);
    pValue = PyInt_FromLong(4);
    PyTuple_SetItem(pArgs, 0, pValue);

    pValue = PyObject_CallObject(pFunc, pArgs);
    Py_DECREF(pArgs);
    printf("Returned val: %ld\n", PyInt_AsLong(pValue));
    Py_DECREF(pValue);

    Py_XDECREF(pFunc);
    Py_DECREF(pModule);

    Py_Finalize();

    return 0;
}

Und atest.py:

def doStuff( x):
    print "X is %d\n" % x
    return 2 * x

PyRun_String in der Python-C-API ist wahrscheinlich das, wonach Sie suchen. Sehen: http://docs.python.org/c-api/veryhigh.html

Die in der Frage enthaltene Antwort ist ausgezeichnet, aber ich hatte einige kleine Probleme damit Python 3.5um also zu verhindern, dass andere das tun, was ich getan habe, ist unten eine leicht bearbeitete Version, die zumindest für diese Version von Python gut zu funktionieren scheint:

#include <Python.h>

int main(void)
{
    PyObject *pArgs, *pValue, *pFunc, *pModule, *pGlobal, *pLocal;

    Py_Initialize();

    pGlobal = PyDict_New();

    //Create a new module object
    pModule = PyModule_New("mymod");
    PyModule_AddStringConstant(pModule, "__file__", "");

    //Get the dictionary object from my module so I can pass this to PyRun_String
    pLocal = PyModule_GetDict(pModule);

    //Define my function in the newly created module
    pValue = PyRun_String("def blah(x):\n\ty = x * 5\n\treturn y\n",
        Py_file_input, pGlobal, pLocal);

    //pValue would be null if the Python syntax is wrong, for example
    if (pValue == NULL) {
        if (PyErr_Occurred()) {
            PyErr_Print();
        }
        return 1;
    }

    //pValue is the result of the executing code, 
    //chuck it away because we've only declared a function
    Py_DECREF(pValue);

    //Get a pointer to the function I just defined
    pFunc = PyObject_GetAttrString(pModule, "blah");

    //Double check we have actually found it and it is callable
    if (!pFunc || !PyCallable_Check(pFunc)) {
        if (PyErr_Occurred()) {
            PyErr_Print();
        }
        fprintf(stderr, "Cannot find function \"blah\"\n");
        return 2;
    }

    //Build a tuple to hold my arguments (just the number 4 in this case)
    pArgs = PyTuple_New(1);
    pValue = PyLong_FromLong(4);
    PyTuple_SetItem(pArgs, 0, pValue);

    //Call my function, passing it the number four
    pValue = PyObject_CallObject(pFunc, pArgs);

    fprintf(stdout, "Returned value: %ld\n", PyLong_AsLong(pValue));

    Py_DECREF(pValue);
    Py_XDECREF(pFunc);

    Py_Finalize();

    return 0;
}

Diese Frage ist ziemlich alt, aber wenn jemand immer noch versucht, dies herauszufinden (wie ich), werde ich meine Antwort geben.

Die ursprüngliche Antwort und die aktualisierte Antwort von @kmp funktionieren für einfache Beispiele, wenn jedoch so etwas wie eine import -Anweisung in den Code eingeführt wird, funktioniert dies nicht.

Ich habe hier ein funktionierendes Beispiel gefunden: https://awasu.com/weblog/embedding-python/writing-ac-wrapper-library-part3/

Kurz gesagt (mit Python 3.6 API):

• Lesen Sie eine Python-Datei in:

std::string line, text;
std::ifstream in("the_file.py");
while (std::getline(in, line)) {
  text += line + "\n";
}
const char *data = text.c_str();

• Kompilieren Sie es zu Bytecode:

PyObject *pCodeObj = Py_CompileString(data, "", Py_file_input);

• Erstellen Sie ein Modul, indem Sie den Code ausführen:

pModule = PyImport_ExecCodeModule("the_module", pCodeObj );

Sie können dann fortfahren, indem Sie Funktionen mit abrufen PyObject_GetAttrString und sie wie in den obigen Beispielen aufrufen.