python 类构造函数
 
In the last tutorial, we learned how to create a class, its instance and how to access class members(variables and functions). In this tutorial, we will try to improve our understanding about classes by learning more about them. So far, it is known that class keyword is used to initiate the definition of a class, followed by the name of the class. After finishing the first line with colon we move to next line and starts defining variables or methods after providing proper indentation.
 
 
 在上一教程中，我们学习了如何创建类，其实例以及如何访问类成员(变量和函数)。 在本教程中，我们将通过学习更多关于类的知识来尝试提高对类的理解。 到目前为止，已知可以使用class关键字来初始化类的定义，然后使用该类的名称。 用冒号结束第一行后，我们移至下一行，并在提供适当的缩进后开始定义变量或方法。 
 
 
 什么是构造函数？ (What is a Constructor?)
 
 
As seen in the last tutorial, we know that there are two ways to declare/define a variable of a class.
 
 
 从上一教程中可以看到，我们知道有两种方法来声明/定义类的变量。 
 
 
First, by simply defining it inside the class and maybe even initialize it with some value, then and there, pretty much like:
 
 
 首先，只需在类中定义它，甚至可以使用一些值对其进行初始化，然后到那里，就像： 
 
 
class Example:
	myVariable = "some value";
 
 
Second way is to declare them inside any function of the class, using the self keyword.
 
 
 第二种方法是使用self关键字在类的任何函数中声明它们。 
 
 
Also, it is possible to assign values to the variables while declaring them but sometimes it may happen that the values of these variables may vary for different objects of the same class. In such cases, you'll have to go for assigning values to the variables after the object creation.
 
 
 同样，可以在声明变量时将其赋值，但有时可能会发生这些变量的值针对同一类的不同对象而变化的情况。 在这种情况下，您必须在创建对象后为变量分配值。 
 
 
Again, this can be done in two ways. First, by calling each variable direct from the object, using the dot . symbol, like:
 
 
 同样，这可以通过两种方式完成。 首先，使用dot直接从对象调用每个变量. 符号，例如： 
 
 
>>> myObject.myVariable = "some other value";
 
 
or we can also ask user for an input:
 
 
 或者我们也可以要求用户输入： 
 
 
>>> myObject.myVariable = input();
 
 
Besides this we can also assign/modify values of our variables inside class functions using the self keyword.
 
 
 除此之外，我们还可以使用self关键字在类函数中分配/修改变量的值。 
 
 
class Example:
	def anotherFunction(self, parameter1):
		self.myVariable = parameter1;
		# or by calling for a user input
		self.myVariable = input();
 
 
If we have such a function defined in our class, then the object's variables can be initialized or re-initialised by calling the anotherFunction() method and passing the desired value as parameter to this method/function.
 
 
 如果我们在类中定义了这样的函数，则可以通过调用anotherFunction()方法并将所需的值作为参数传递给该方法/函数来初始化或重新初始化对象的变量。 
 
 
>>> myObject = Example()
>>> myObject.anotherFunction("Amazing Spiderman")
>>> print (myObject.myVariable)
 
 
 Amazing Spiderman 
 
 
 神奇蜘蛛侠 
 
 
As it can be seen, this was a usual user-defined function inside Example class which is utilising parameters to initialize the variable. The concept is fairly simple here. Although, there exists something better, which uses pretty much the same principle and is a defined standard. It's known as a Constructor.
 
 
 可以看出，这是Example类中通常使用的用户定义函数，它利用参数来初始化变量。 这里的概念非常简单。 虽然，存在更好的东西，它使用几乎相同的原理并且是已定义的标准。 它被称为构造函数 。 
 
 
Constructor is a special type of function that is called automatically whenever an object of that class is created. For example,
 
 
 构造函数是一种特殊的函数类型，每当创建该类的对象时，该函数便会自动调用。 例如， 
 
 
>>> myObject = Example();
 
 
By writing Example() in the code above, we are informing python that myObject is an object of class Example. And that is exactly when the constructor of that class is called.
 
 
 通过在上面的代码中编写Example() ，我们通知python myObject是Example类的对象。 正是在该类的构造函数被调用时。 
 
 
But what will it do? Well, generally, the constructors are used to initialize the variables of the class for an object(instance), although it can perform some other tasks as well, like checking if there are enough resources, if the value used to initialize any variable is valid or not, etc.
 
 
 但是它将做什么？ 好吧，通常，构造函数用于初始化一个对象(实例)的类的变量，尽管它也可以执行其他一些任务，例如检查是否有足够的资源，用于初始化任何变量的值是否有效。是否，等等。 
 
 
 在类中定义构造方法 (Defining Constructor method in a class)
 
 
In python, the object creation part is divided into two parts:
 
 
 在python中，对象创建部分分为两部分： 
 
 
Object Creation
 对象创建 
Object Initialisation
 对象初始化 
 
 对象创建 (Object Creation)
 
 
Object creation is controlled by a static class method with the name __new__. Hence when you call Example(), to create an object of the class Example, then the __new__ method of this class is called. Python defines this function for every class by default, although you can always do that explicitly too, to play around with object creation.
 
 
 对象的创建由名称为__new__的static类方法控制。 因此，当您调用Example()来创建Example类的对象时，将调用该类的__new__方法。 Python默认情况下为每个类都定义了此函数，尽管您也可以始终明确地执行此操作，以进行对象创建。 
 
 
class Example:
    def __new__(self):
        return 'studytonight';

# creating object of the class Example
mutantObj = Example()

# but this will return that our object 
# is of type str
print (type(mutantObj))
 
 
In the example above, we have used the __new__ function to change the tyoe of object returned, just to show you what we can do using this function.
 
 
 在上面的示例中，我们使用了__new__函数来更改返回对象的类型，只是向您展示了我们可以使用该函数做什么。 
 
 
To see how the default __new__ function works, run the code below, and you will see that this time the object created is of the type Example
 
 
 若要查看默认的__new__函数如何工作，请运行以下代码，您将看到这次创建的对象属于Example类型 
 
 
class Example:
	myVariable = "some value";

simpleObj = Example()
print (type(simpleObj))
 
 
 对象初始化 (Object Initialisation)
 
 
Object initialisation is controlled by an instance method with the name __init__ and which is also generally called as a Constructor. Although, both __new__ and __init__ together forms a constructor.
 
 
 对象初始化由一个名为__init__的实例方法控制，该实例方法通常也称为构造函数 。 虽然__new__和__init__共同构成一个构造函数。 
 
 
Once the object is created, you can make sure that every variable in the object is correctly initialised by defining an __init__ method in your class, which pretty much means init-iate.
 
 
 创建对象后，可以通过在类中定义__init__方法来确保正确初始化了对象中的每个变量，这几乎意味着init-iate 。 
 
 
Thus, it doesn't matter what the class name is, if you want to write a constructor(to initialise your object) for that class, it has to be the __init__() method. Within this function, you're free to declare a class variable(using self) or initialize them. Here is a quick example for our Example class with __init__ method:
 
 
 因此，类名是什么都没有关系，如果您想为该类编写一个构造函数(以初始化您的对象)，则必须使用__init__()方法。 在此函数中，您可以自由声明类变量(使用self )或对其进行初始化。 这是一个使用__init__方法的Example类的快速示例： 
 
 
class Example:
	def __init__(self, value1, value2):
	    self.myVariable1 = value1;
		self.myVariable2 = value2;
		print ("All variable initialized")
 
 
Once you define the __init__ method in a class, then while creating an object, when you call Example(), you can provide all the necessary parameters required for the object's variables, because when we call Example(), behind the scene python calls the __init__ function for the created object automatically.
 
 
 一旦在类中定义了__init__方法，然后在创建对象时，调用Example() ，就可以提供对象变量所需的所有必要参数，因为当我们调用Example() ，python在后台调用了__init__函数自动创建的对象。 
 
 
This is how the code will look:
 
 
 代码如下所示： 
 
 
>>> myObj = Example("first variable", "second variable")
 
 
You can use this function in lots of ways for initialization. One is already mentioned above using a parameter, another way could be asking user for input inside the constructor.
 
 
 您可以通过多种方式使用此函数进行初始化。 上面已经提到了使用参数的一种方法，另一种方法是要求用户在构造函数中进行输入。 
 
 
def __init__(self):
	self.myVariable1 = input();
	self.myVariable2 = input();
 
 
Below we have a diagram which summarises it all.
 
 
 在下面，我们有一个图表，总结了这一切。 
 
 

  
 
 

  
翻译自: https://www.studytonight.com/python/constructors-in-python
 
 
python 类构造函数

 
C++和python混合编程
 
零、前言
一、说明
二、测试代码
1、C++代码
2、python代码
   
三、运行结果
 

 
零、前言
 
C++是一门高效率的语言，Python是一门简单易学的脚本语言，现在Python非常火，这两者的强大结合能碰撞出很强大的火花！一起来看看吧！
 
一、说明
 
C++项目中用到python相关的知识，这两天研究了一下C++与python的混合编程，网上有很多这方面的介绍，但是怎么使用python类的构造函数中传参的介绍却没有，这里研究一下，分享出来。(C++和python相互调用的相关接口查询https://docs.python.org/2/index.html)
 
二、测试代码
 
1、C++代码
 
/*=================CplusUsePython.h====================*/
#ifndef CPLUSUSEPYTHON_H
#define CPLUSUSEPYTHON_H
#include <Python.h>
#include <string>
using namespace std;

class CplusUsePython
{
public:
    CplusUsePython();
    ~CplusUsePython();

    static CplusUsePython* instance()
    {
        static CplusUsePython instance;
        return &instance;
    }

    // 初始化相关操作
    int init(const string pyFilePath, const string pyFileNameNoSuffix);
    // C++调用python函数
    int CCallFunction(const string pyFuncName, const string message);
    // C++调用python类中的函数
    int CCallClassFunc(const string pyFuncName, const string name, const int age);

private:
    PyObject *pName;
    PyObject *pModule;
    PyObject *pFunc;
    PyObject *pArgs;
    PyObject *pClass;
    PyObject *pInstance;
};

#endif // CPLUSUSEPYTHON_H

/*=================CplusUsePython.cp====================*/
#include "CplusUsePython.h"
#include <sstream>

CplusUsePython::CplusUsePython()
{

}

CplusUsePython::~CplusUsePython()
{
    if (Py_IsInitialized()) {
        if (pName) Py_DECREF(pName);
        if (pArgs) Py_DECREF(pArgs);
        if (pModule) Py_DECREF(pModule);
        if (pFunc) Py_DECREF(pFunc);
        if (pClass) Py_DECREF(pClass);
        if (pInstance) Py_DECREF(pInstance);
        Py_Finalize();
    }
}

//************************************
// 函数名称: init
// 函数说明：初始化相关操作
// 返 回 值: int
// 参    数: const string pyFilePath
// 参    数: const string pyFileNameNoSuffix
// 作    者：ISmileLi
// 作成日期：2018/11/25
// 修改记录：
//************************************
int CplusUsePython::init(const string pyFilePath, const string pyFileNameNoSuffix)
{
    int ret = 0;
    if (pyFilePath.empty() || pyFileNameNoSuffix.empty())
        return -1;
    Py_Initialize();
    pName = NULL;
    pModule = NULL;
    pFunc = NULL;
    pArgs = NULL;
    pClass = NULL;
    pInstance = NULL;
    // 判断初始化是否成功
    if (!Py_IsInitialized())
        return -2;
    // 调用python中需要使用的模块
    ret = PyRun_SimpleString("import sys");
    if (ret != 0)
    {
        // 导入失败，关闭python调用
        Py_Finalize();
        return -3;
    }
    // 导入python文件的相关操作
    if (ret == 0)
    {
        stringstream strpycmd;
         strpycmd << "sys.path.append('" << pyFilePath << "')";
        ret = PyRun_SimpleString(strpycmd.str().c_str());
    }
    if (ret != 0)
    {
        Py_Finalize();
        return -4;
    }
    pName = PyString_FromString(pyFileNameNoSuffix.c_str());
    if ((pModule = PyImport_Import(pName)) == NULL || pName == NULL)
    {
        Py_Finalize();
        return -5;
    }
    return 0;
}

//************************************
// 函数名称: CCallFunction
// 函数说明：C++调用python中的函数
// 返 回 值: int
// 参    数: const string pyFuncName
// 参    数: const string message
// 作    者：ISmileLi
// 作成日期：2018/11/25
// 修改记录：
//************************************
int CplusUsePython::CCallFunction(const string pyFuncName,const string message)
{
    if (pyFuncName.empty() || message.empty())
    {
        return -1;
    }

    pFunc = PyObject_GetAttrString(pModule, pyFuncName.c_str());
    if(!pFunc)
    {
        return -2;
    }
    // 调用python函数,s表示传入参数是字符串类型
    PyObject *pRet = PyObject_CallFunction(pFunc, "s", (char*)message.c_str());
    if(pRet)
    {
        Py_DECREF(pRet);
    }
    else
    {
        return -3;
    }

    return 0;
}

//************************************
// 函数名称: CCallClassFunc
// 函数说明：C++调用python类中的函数
// 返 回 值: int
// 参    数: const string pyFuncName
// 参    数: const string name
// 参    数: const string age
// 作    者：ISmileLi
// 作成日期：2018/11/25
// 修改记录：
//************************************
int CplusUsePython::CCallClassFunc(const string pyFuncName,const string name, const int age)
{
    if (pyFuncName.empty() || name.empty() || age <= 0)
    {
        return -1;
    }


    // 向Python传参数是以元组（tuple）的方式传递的
    pArgs = PyTuple_New(2);
    //  PyObject* Py_BuildValue(char *format, ...) 将C++的变量转换成一个Python对象
    //  s 表示字符串，i 表示整型变量，f 表示浮点数
    PyTuple_SetItem(pArgs, 0, Py_BuildValue("s", name.c_str()));
    PyTuple_SetItem(pArgs, 1, Py_BuildValue("i", age));

    // 增加支持调用类中方法的操作
    pClass = PyObject_GetAttrString(pModule,"ISmileLi"); // DrawPic为类的名字
    if(!pClass)
    {
        return -2;
    }

    // 传入python构造函数中的两个参数
    pInstance = PyInstance_New(pClass,pArgs,NULL);
    if(!pInstance)
    {
        return -3;
    }
    // 调用类中的函数
    pFunc = PyObject_CallMethod(pInstance,(char*)pyFuncName.c_str(),NULL,NULL);
    if(!pFunc)
    {
        return -4;
    }

    return 0;
}
/*=================main.c================*/
#include <Python.h>
#include <iostream>
#include <string>
#include "CplusUsePython.h"

using namespace std;

int main ()
{
    // C++和python相互调用的相关接口查询https://docs.python.org/2/index.html
    string pyFilePath = "/work/test/testC++/test_C_use_Python";
    int ret = CplusUsePython::instance()->init(pyFilePath,"ISmileLi");
    if(ret != 0)
    {
        cout << "init failure!" << endl;
    }
    ret = CplusUsePython::instance()->CCallFunction("print_message","this is test C++ use python!");

    ret = CplusUsePython::instance()->CCallClassFunc("print_name","LiSa",18);
    ret = CplusUsePython::instance()->CCallClassFunc("print_age","LiSa",18);
    ret = CplusUsePython::instance()->CCallClassFunc("print_name_age","LiSa",18);

    return 0;
}
 
2、python代码
 
#filename: ISmileLi.py
# -*- coding: utf-8 -*-
class ISmileLi:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def print_name(self):
        print("===in function print_name===")
        print("name:",self.name)

    def print_age(self):
        print("===in function print_age===")
        print("age:",self.age)

    def print_name_age(self):
        print("===in function print_name_age===")
        print("name:%s age:%d" % (self.name,self.age))


def print_message(message):
    print("===in function print_message===")
    print("message:",message)
 
三、运行结果
 
 
说明：由于我也不擅长python，如有错误欢迎指正。

python的常用内置方法有以下几种：
 1、init(self)：python在面向对象概念中的构造函数
 2、del(self)
 3、 new(cls,*args,**kwd)
 等等

 
构造函数和构造函数和析构函数都属于python中的特殊方法
 
 
 
 
其中的“__del__”就是一个析构函数了，当使用del 删除对象时，会调用他本身的析构函数，另外当对象在某个作用域中调用完毕，在跳出其作用域的同时析构函数也会被调用一次，这样可以用来释放内存空间
 
转载于:https://www.cnblogs.com/fengyiru6369/p/7003393.html