C调用python

#! python
# FileName: pytest.py

s = "yanhuangzixun";

def num(a,b):
    c = a + b;
    print "python return the value is ",c;
    return c;

class url:
    def __init__(self,name,age):
        self.name = name;
        self.age = age;
    def GetMsg(self):
        mytuple = (self.name,self.age);
        return mytuple;
    def GetKeyValue(self):
        mydict = {};
        mydict[self.name]=self.age;
        return mydict;
    def GetSequence(self):
        mysequence = [self.name,self.age];
        return mysequence;
   
if __name__ == "__main__":
    u = url("huangser","23");
    #s = u.GetMsg();     
    #print s;
   # mydict = u.GetKeyValue();
   # print mydict;
    mysequence = u.GetSequence();
    print mysequence;

 

 

**********************************************************************************

#include <iostream>
using namespace std;

#define ERRMSG(s) /
 printf("err %s :in fun: %s ,line: %d /n",s,__FUNCTION__,__LINE__);

#include <Python.h>
#pragma comment(lib,"python26.lib")

void printDict(PyObject* obj);
int FuncTest(PyObject *pDict);
int classTest(PyObject *pDict);

int main(int argc,char** argv)
{
 //Initialize python explain
 Py_Initialize(); 
 if( !Py_IsInitialized()){
  ERRMSG("Initialize failed");
  return -1;
 }
 PyObject *pName =NULL,*pModule = NULL,*pDict= NULL;
 //get module name
 do
 {
  pName = PyString_FromString("pytest");  
  if(pName == NULL){
   ERRMSG("PyString_FromString");  
   break;
  }

  pModule = PyImport_Import(pName);
  if(pModule == NULL){
   ERRMSG("PyImport_Import");
   break;
  }

  pDict = PyModule_GetDict(pModule);
  if(pDict == NULL){
   ERRMSG("PyModule_GetDict");  
   break;
  }
  printDict(pDict);

  //func test
  printf("/n----------------func test----------------/n");
  if( FuncTest(pDict) > 0 ){
   cout<<"call fun success /n";
  }else{
   ERRMSG("call fun failed ");
  }
  printf("/n----------------class test----------------/n");
  //class test
  if(classTest(pDict) > 0 ){
   cout<<"call classTest success /n";
  }else{
   ERRMSG("call classTest failed ");
  }

 } while (false); 

 //desdroyed python explain 

 if(pDict != NULL)
  Py_DECREF(pDict);

 if(pModule != NULL)
  Py_DECREF(pModule); 

 if(pName != NULL)
  Py_DECREF(pName);

 Py_Finalize();

 return 0;
};

int FuncTest(PyObject *pDict= NULL)
{
 int nRet = -1;
 if(pDict== NULL)
  return nRet;

 PyObject *pFunc= NULL,*pArgs= NULL;
 do
 {
  pFunc = PyDict_GetItemString(pDict,"num");
  if(pFunc == NULL || !PyCallable_Check(pFunc)){
   ERRMSG("PyDict_GetItemString");  
   break;
  }
  //paramenter
  pArgs = PyTuple_New(2);
  if(pArgs == NULL){
   ERRMSG("PyTuple_New");
   break;
  }
  PyTuple_SetItem(pArgs,0,Py_BuildValue("i",2));
  PyTuple_SetItem(pArgs,1,Py_BuildValue("i",3));

  PyObject *pRet = PyObject_CallObject(pFunc,pArgs);
  if(pRet != NULL)
  {
   int result = PyInt_AsLong(pRet);
   cout<<"result = "<<result<<endl;
   nRet = 1;
  }
 } while (false);

 if(pArgs != NULL)
  Py_DECREF(pArgs);

 if(pFunc != NULL)
  Py_DECREF(pFunc);

 return nRet;
}
int classTest(PyObject *pDict )
{
 int nRet = -1;
 if(pDict == NULL)
  return nRet;

 PyObject *pClassurl = NULL;
 PyObject *purlInstance = NULL;
 PyObject *pArgs = NULL;
 do
 {
  pClassurl = PyDict_GetItemString(pDict,"url");
  if(pClassurl == NULL || !PyClass_Check(pClassurl)){
   ERRMSG("PyDict_GetItemString");
   break;
  }
  //class construct param
  //name , age
  pArgs = PyTuple_New(2);
  if(pArgs == NULL){
   ERRMSG("PyTuple_New");
   break;
  }

  PyTuple_SetItem(pArgs,0,Py_BuildValue("s","huang"));
  PyTuple_SetItem(pArgs,1,Py_BuildValue("s","yang"));

  purlInstance = PyInstance_New(pClassurl,pArgs,NULL);
  if(purlInstance == NULL || !PyInstance_Check(purlInstance)){
   ERRMSG("PyInstance_New");
   break;
  }

  printf("/n-------------tuple---------------/n");
  //GetMsg() return a tuple
  
  PyObject *pResult = PyObject_CallMethod(pClassurl,"GetMsg","O",purlInstance);
  if(pResult != NULL)
  {
   nRet = 0;
   int size = (int)PyTuple_Size(pResult);
   PyObject *pItem = NULL;
   for(int i =0; i < size; i++){
    pItem = PyTuple_GetItem(pResult,i);
    printf("item1 : %s/n",PyString_AsString(pItem));
    nRet++;
   }
   if(pItem != NULL){
    Py_DECREF(pItem);
    pItem = NULL;
   }
   Py_DECREF(pResult);
  }
  else{
   ERRMSG("PyObject_CallMethod");
  }
  
  printf("/n-------------dict-------------------/n");

  //GetKeyValue() return a dict
  PyObject *pMyDict = PyObject_CallMethod(pClassurl,"GetKeyValue","O",purlInstance);
  if(pMyDict != NULL)
  {
   nRet = 0;   
   PyObject *keys = NULL,*key = NULL;
   PyObject *values = NULL,*value = NULL;
   keys = PyDict_Keys(pMyDict);
   values = PyDict_Values(pMyDict);
   int size = PyDict_Size(pMyDict);
   for(int i = 0; i < size; i++){
    key = PyList_GET_ITEM(keys,i);
    value = PyList_GET_ITEM(values,i);
    printf("key: %s ,value:%s /n",PyString_AsString(key),PyString_AsString(value));
    nRet++;
   }
   if(key != NULL)
    Py_DECREF(key);
   if(keys != NULL)
    Py_DECREF(keys);
   if(value != NULL)
    Py_DECREF(value);   
   if(values != NULL)
    Py_DECREF(values);

   Py_DECREF(pMyDict);
  }  
  else{
   ERRMSG("PyObject_CallMethod");
  }

  printf("/n--------------sequence------------------/n");

  //GetSequence() return a sequence
  PyObject *pMySequence = PyObject_CallMethod(pClassurl,"GetSequence","O",purlInstance);
  if(pMySequence != NULL)
  {
   nRet = 0;
   int size = PySequence_Size(pMySequence);
   PyObject *sequence = NULL;
   for(int i = 0 ; i < size; i++){
    sequence = PySequence_GetItem(pMySequence,i);
    printf("item %d: %s /n",i,PyString_AsString(sequence));
    nRet++;
   }
   Py_DECREF(pMySequence);
  }else{
   ERRMSG("PyObject_CallMethod");
  }

 } while (false);

 if(pClassurl != NULL)
  Py_DECREF(pClassurl);
 if(purlInstance != NULL)
  Py_DECREF(purlInstance);

 return nRet;
}

 

void printDict(PyObject* obj)
{
 if( !PyDict_Check(obj))
  return;
 PyObject *k,*keys;
 keys = PyDict_Keys(obj);
 for(int i = 0; i < PyList_GET_SIZE(keys); i++)
 {
  k = PyList_GET_ITEM(keys, i);
  char* c_name = PyString_AsString(k);
  printf("%s/n",c_name);
 }
 Py_DECREF(k);
 Py_DECREF(keys);
}

 

 

///

//

Python使用引用计数机制对内存进行管理，实现自动垃圾回收。在C/C++中使用Python对象时，应正确地处理引用计数，否则容易导致内存泄漏。在Python/C API中提供了Py_CLEAR()、Py_DECREF()等宏来对引用计数进行操作。

当使用Python/C API中的函数创建列表、元组、字典等后，就在内存中生成了这些对象的引用计数。在对其完成操作后应该使用Py_CLEAR()、Py_DECREF()等宏来销毁这些对象。其原型分别如下所示。

void Py_CLEAR( PyObject *o)

void Py_DECREF( PyObject *o)

其参数含义如下。

·     o：要进行操作的对象。

对于Py_CLEAR()其参数可以为NULL指针，此时，Py_CLEAR()不进行任何操作。而对于Py_DECREF()其参数不能为NULL指针，否则将导致错误。