Explication détaillée de la façon dont Python appelle les programmes C

Avant-propos

Tout le monde sait que les avantages de Python sont une efficacité de développement élevée et une facilité d'utilisation, tandis que le C a une efficacité de fonctionnement élevée. Les deux peuvent se compléter, que ce soit. en Python Lorsque vous intégrez du code C dans un projet ou utilisez Python pour implémenter des fonctions périphériques dans un projet C, vous pourriez avoir besoin que Python appelle des modules C. Voici plusieurs méthodes de base pour exporter du code C dans des interfaces Python. .

Exportation originale

L'interpréteur Python est implémenté en C, donc tant que notre structure de données C peut être comprise par Python , en théorie, il peut être appelé directement. Nous implémentons test1.cpp comme suit

#include <Python.h>

int Add(int x, int y)
{
 return x + y;
}

int Del(int x, int y)
{
 return x - y;
}

PyObject* WrappAdd(PyObject* self, PyObject* args)
{
 int x, y;
 if (!PyArg_ParseTuple(args, "ii", &x, &y))
 {
  return NULL;
 }
 return Py_BuildValue("i", Add(x, y));
}

PyObject* WrappDel(PyObject* self, PyObject* args)
{
 int x, y;
 if (!PyArg_ParseTuple(args, "ii", &x, &y))
 {
  return NULL;
 }
 return Py_BuildValue("i", Del(x, y));
}
static PyMethodDef test_methods[] = {
 {"Add", WrappAdd, METH_VARARGS, "something"},
 {"Del", WrappDel, METH_VARARGS, "something"},
 {NULL, NULL}
};

extern "C"
void inittest1()
{
 Py_InitModule("test1", test_methods);
}

La commande de compilation est la suivante

g++ -fPIC -shared test1.cpp -I/usr/include/python2.6 -o test1.so

Exécutez l'interpréteur Python et testez comme suit

>>> import test1
>>> test1.Add(1,2)
3

Il y a quelques points à noter ici

1. Si le nom de la bibliothèque dynamique générée est test1, le fichier source doit avoir la fonction inittest1, et le premier paramètre de Py_InitModule doit être "test1", sinon Python l'importation du module échouera

2. S'il s'agit d'un fichier source cpp, la fonction inittest1 doit être modifiée avec extern "C". S'il s'agit d'un fichier source c, ce n'est pas obligatoire. La raison en est que l'interpréteur Python recherchera des fonctions comme initxxx lors de l'importation de bibliothèques, et C et C encoderont différemment les symboles de fonction. C prendra en compte la longueur de la fonction et le type de paramètre lors de l'encodage des symboles de fonction. Plus précisément, vous pouvez passer nm test1.so Vérifiez le. symboles de fonction. L'outil c filt peut utiliser les symboles pour résoudre inversement le prototype de fonction
   

implémenté par boost

Nous utilisons le même exemple que ci-dessus pour implémenter test2.cpp comme suit

#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
using namespace boost::python;

int Add(const int x, const int y)
{
 return x + y;
}

int Del(const int x, const int y)
{
 return x - y;
}

BOOST_PYTHON_MODULE(test2)
{
 def("Add", Add);
 def("Del", Del);
}

Le paramètre de BOOST_PYTHON_MODULE est le nom du module à exporter

La commande de compilation est la suivante

g++ test2.cpp -fPIC -shared -o test2.so -I/usr/include/python2.6 -I/usr/local/include -L/usr/local/lib -lboost_python

Remarque : Vous devez spécifier le fichier d'en-tête boost et le chemin de la bibliothèque, voici /usr/local/include et /usr/local/lib

ou exporter le module via setup.py

#!/usr/bin/env python
from distutils.core import setup
from distutils.extension import Extension

setup(name="PackageName",
 ext_modules=[
  Extension("test2", ["test2.cpp"],
  libraries = ["boost_python"])
 ])

Le premier paramètre d'Extension est le nom du module et le deuxième paramètre est le nom du fichier

Exécutez la commande suivante

python setup.py build

Le répertoire de construction sera généré à ce moment-là, recherchez test2.so à l'intérieur et entrez dans le répertoire de même niveau. Vérifiez comme suit

>>> import test2
>>> test2.Add(1,2)
3
>>> test2.Del(1,2)
-1

Classe d'exportation

test3.cpp est implémenté comme suit

#include <boost/python.hpp>
using namespace boost::python;

class Test
{
public:
 int Add(const int x, const int y)
 {
  return x + y;
 }

 int Del(const int x, const int y)
 {
  return x - y;
 }
};

BOOST_PYTHON_MODULE(test3)
{
 class_<Test>("Test")
  .def("Add", &Test::Add)
  .def("Del", &Test::Del);
}

Remarque : dans BOOST_PYTHON_MODULE L'utilisation de def est quelque peu similaire à la syntaxe de Python, qui est équivalente à

class_<Test>("Test").def("Add", &Test::Add);
class_<Test>("Test").def("Del", &Test::Del);

La commande de compilation est la suivante

g++ test3.cpp -fPIC -shared -o test3.so -I/usr/include/python2.6 -I/usr/local/include/boost -L/usr/local/lib -lboost_python

Le test est la suivante

>>> import test3
>>> test = test3.Test()
>>> test.Add(1,2)
3
>>> test.Del(1,2)
-1

Fonction d'exportation de paramètre variable

test4.cpp est implémenté comme suit

#include <boost/python.hpp>
using namespace boost::python;

class Test
{
public:
 int Add(const int x, const int y, const int z = 100)
 {
  return x + y + z;
 }
};

int Del(const int x, const int y, const int z = 100)
{
 return x - y - z;
}

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(Add_member_overloads, Add, 2, 3)
BOOST_PYTHON_FUNCTION_OVERLOADS(Del_overloads, Del, 2, 3)

BOOST_PYTHON_MODULE(test4)
{
 class_<Test>("Test")
  .def("Add", &Test::Add, Add_member_overloads(args("x", "y", "z"), "something"));
 def("Del", Del, Del_overloads(args("x", "y", "z"), "something"));
}

Ici, les fonctions Add et Del utilisent toutes deux des paramètres par défaut, Del est une fonction ordinaire et Add est une fonction membre de la classe, différentes macros sont appelées ici respectivement. Les deux derniers paramètres de la macro représentent le. le nombre minimum de paramètres et le nombre maximum de paramètres de la fonction respectivement

La commande de compilation est la suivante

g++ test4.cpp -fPIC -shared -o test4.so -I/usr/include/python2.6 -I/usr/local/include/boost -L/usr/local/lib -lboost_python

Le test est comme suit

>>> import test4
>>> test = test4.Test()
>>> print test.Add(1,2)
103
>>> print test.Add(1,2,z=3)
6
>>> print test4.Del(1,2)
-1
>>> print test4.Del(1,2,z=3)
-1

Interface d'exportation avec des objets Python

Depuis est exporté en tant qu'interface Python, l'appelant utilisera inévitablement des structures de données spécifiques à Python, telles que tuple, list et dict. Étant donné que la méthode écologique d'origine est trop gênante, seule l'utilisation de boost est enregistrée ici. fonction Python suivante

def Square(list_a)
{
 return [x * x for x in list_a]
}

, c'est-à-dire calculer le carré de chaque élément de la liste passée et renvoyer le résultat du type de liste

Le code est le suivant

#include <boost/python.hpp>

boost::python::list Square(boost::python::list& data)
{
 boost::python::list ret;
 for (int i = 0; i < len(data); ++i)
 {
  ret.append(data[i] * data[i]);
 }

 return ret;
}

BOOST_PYTHON_MODULE(test5)
{
 def("Square", Square);
}

La commande de compilation est la suivante

g++ test5.cpp -fPIC -shared -o test5.so -I/usr/include/python2.6 -I/usr/local/include/boost -L/usr/local/lib -lboost_python

Le test est le suivant

>>> import test5
>>> test5.Square([1,2,3])
[1, 4, 9]

boost implémente les types de données

, boost::python::tuple, boost::python::list La méthode d'utilisation. est fondamentalement le même que celui de Python. Les détails sont La méthode peut consister à afficher boost/python/tuple.hpp et d'autres fichiers correspondants dans le fichier d'en-tête boost boost::python::dict

Une autre fonction couramment utilisée est

, et la méthode d'utilisation est la suivante boost::python::make_tuple()

boost::python::tuple(int a, int b, int c)
{
 return boost::python::make_tuple(a, b, c);
}

Pour des explications plus détaillées sur la façon dont Python appelle les programmes C, veuillez faire attention au site Web PHP chinois !