• python 类 构造函数 Python构造函数创建类对象 (Python Constructors to create a Class Object) In the last tutorial, we learned how to create a class, its instance and how to access class members...

    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.


    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.


    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.


    >>> 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 myObjectExample类的对象。 正是在该类的构造函数被调用时。

    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:


    1. Object Creation


    2. 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.


    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


    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.


    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.


    Concept of constructor in python

    翻译自: https://www.studytonight.com/python/constructors-in-python

    python 类构造函数

  • 一、说明:C++项目中用到python相关的知识,这两天研究了一下C++与python的混合编程,网上有很多这方面的介绍,但是怎么使用python类的构造函数中传参的介绍却没有,这里研究一下,分享出来。(C++和python相互调用的...







    #include <Python.h>
    #include <string>
    using namespace std;
    class 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);
        PyObject *pName;
        PyObject *pModule;
        PyObject *pFunc;
        PyObject *pArgs;
        PyObject *pClass;
        PyObject *pInstance;
    #endif // CPLUSUSEPYTHON_H
    #include "CplusUsePython.h"
    #include <sstream>
        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);
    // 函数名称: 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;
        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调用
            return -3;
        // 导入python文件的相关操作
        if (ret == 0)
            stringstream strpycmd;
             strpycmd << "sys.path.append('" << pyFilePath << "')";
            ret = PyRun_SimpleString(strpycmd.str().c_str());
        if (ret != 0)
            return -4;
        pName = PyString_FromString(pyFileNameNoSuffix.c_str());
        if ((pModule = PyImport_Import(pName)) == NULL || pName == NULL)
            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());
            return -2;
        // 调用python函数,s表示传入参数是字符串类型
        PyObject *pRet = PyObject_CallFunction(pFunc, "s", (char*)message.c_str());
            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为类的名字
            return -2;
        // 传入python构造函数中的两个参数
        pInstance = PyInstance_New(pClass,pArgs,NULL);
            return -3;
        // 调用类中的函数
        pFunc = PyObject_CallMethod(pInstance,(char*)pyFuncName.c_str(),NULL,NULL);
            return -4;
        return 0;
    #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;


    #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===")
        def print_age(self):
            print("===in function print_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===")




  • python构造函数

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

    3、 new(cls,*args,**kwd)

  • 构造函数构造函数和析构函数都属于python中的特殊方法 其中的“__del__”就是一个析构函数了,当使用del 删除对象时,会调用他本身的析构函数,另外当对象某个作用域调用完毕,跳出其作用域的同时析构...


    其中的“__del__”就是一个析构函数了,当使用del 删除对象时,会调用他本身的析构函数,另外当对象在某个作用域中调用完毕,在跳出其作用域的同时析构函数也会被调用一次,这样可以用来释放内存空间


  • 这篇文章主要介绍了python构造函数init实例方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一、创建对象,我们需要定义构造函数__init__()方法。构造...
  • 在python定义多个构造函数

    万次阅读 2018-09-20 23:56:33
    &nbsp;&...这个时候,就需要我们创建多个构造函数了。 &nbsp;&nbsp;&nbsp;&nbsp;下面是一个简单的实例: import time class Date: #主构造函数 def __init__(self...
  • python 构造函数作用

    千次阅读 2019-09-27 01:10:06
  • 构造函数主要用来创建对象时完成对对象属性的一些初始化等操作, 当创建 对象时, 对象会自动调用它的构造函数。实例化对象时是可以传入参数的,这些参数会自动传入__init__()方法,可以通过重写这个方法来自定义...
  • python构造函数和析构函数

    千次阅读 2018-05-02 14:54:24
    构造函数和析构函数 1、构造方法的使用 ​ 很多类都倾向于将对象创建有初始化状态.因此类可以定义一个名init()的特殊方法(构造方法)来实例化一个对象。 构造方法也叫做构造器,是指当实例化一个对象(创建一...
  • 1.Python像其他的OOP语言一样类里面会有构造和析构函数... ...他们只是这个对象...构造函数: __init__ 这个函数用代码生成一个对象的实例的时候就会被调用 析构函数: __del__ 这个函数一般很难知道哪里会被调用
  • 子类继承父类后,可以选择是否调用父类的构造函数(即__init__函数)。 1. 不调用父类构造函数 如果子类不想调用父类的构造函数,就需要写出自己的构造函数: class Parent(object): def __init__(self, number): ...
  • 构造函数__inti__() new()方法:用于创建对象,但一般无需重定义该方法。 init()方法:初始化创建好的对象,初始化指的是:“给实例属性赋值”。 一个python对象包含: 1.id:(identity)标识符 2.type:(对象类型...
  • 1.Python像其他的OOP语言一样类里面会有构造和析构函数... ...他们只是这个对象生成和销毁的...构造函数: __init__ 这个函数用代码生成一个对象的实例的时候就会被调用 析构函数: __del__ 这个函数一般很难知
  • Python笔记之构造函数__init__

    千次阅读 2018-10-21 20:33:35
    构造函数 __init__初学者看着很吓人,...在Python中,创建构造函数很简单,只需要将方法init的名称从普通的init改成魔法版的__init__即可。如示例1 #示例1 &gt;&gt;&gt; class My: ... def __init__(...
  • python的构造和析构函数固定的名字。 构造函数--------------------- __init__( self ) 析构函数-------------------...并且在python中构造函数和析构函数可以省略。先看简单的例子: class Simple:   
  • Python 子类继承父类构造函数说明

    千次阅读 多人点赞 2018-12-29 17:41:49
    (1) 如果子类需要的构造方法就需要显示的调用父类的构造方法,或者不重写父类的构造方法。 子类不重写__init__,实例化子类时,会自动调用父类定义的__init__。 实例: class Father(object): def __init...
  • python def 函数构造

    千次阅读 2019-04-22 19:55:00
    def 函数构造: 1、def 是一个声明: 格式: def Xxname_XXtype(位置参数,关键字参数): 2、def 声明的作用: 给下面的“代码块”命一个名。随后调用该声明名称时 复制“代码块”到调用位置。 3、def 声明...
  • python构造/析构函数

    千次阅读 2011-06-27 16:37:00
    python用__init__ 和 __del__ 作为构造和析构函数,标新立异? Python中所有的类成员(包括数据成员)都是 公共的 ,所有的方法都是 有效的 。只有一个例外:如果你使用的数据成员名称以 双下划线前缀 比如__...
  • Python内置函数

    千次阅读 多人点赞 2019-05-10 15:10:36
    Python内置函数Python abs()函数Python all() 函数Python any() 函数Python basestring() 函数Python bin() 函数Python bool() 函数Python bytearray() 函数Python callable() 函数Python chr() 函数Python ...
  • 定义类创建实例 举个例子, class Foo(object): ...对Foo的调用到底调用了什么函数或方法? 第一反应肯定是__init__方法,但仔细想想并不是正确答案,因为它没有返回一个对象,但是调用Foo(1,y=2)确...
  • python中函数调用

    千次阅读 2019-10-30 23:03:32
    #类及函数的定义 ... #构造函数: def __init__(self,var1,var2): self.var1 = var1 self.var2 = var2 def b(self,var1,var2): return var1+var2 #类内函数调用: var1=1 var2=2 #创建对象:...
  • 两种方式如下: super 关键字: super(子类,self).__init__(参数1,参数2,....) 经典写法: 父类名称.__init__(self,参数1,参数2,...)
  • 有时候需要定义一个枚举类型,但不想创建一个新类来继承创建,就可以直接使用它的构造函数来创建一个枚举类型,如下面的例子:#python 3.6 #蔡军生 #http://blog.csdn.net/caimouse/article/details/51749579 # ...
  • 可爱的 PythonPython 函数编程

    千次阅读 2004-11-23 16:04:00
    本文讨论了函数编程的常规概念,并说明了 Python 实现函数技术的方法。我们最好从最难的问题开始:“到底什么是函数编程 (FP)?”一个答案可能会说 FP 就是您使用例如 Lisp、Scheme、Haskell、ML、OCAML、...
  • python3之函数

    2018-01-17 09:52:16
    python基础回顾——函数篇 前言 模块化思想是开发编程很重要的一种思想,对于代码管理和开发带来不少便利,且可以重复使用,函数的使用会使得代码的美观度和可读性增强。 函数基本构造 函数由声明定义、...
  • 内建函数,一般都是因为使用频率比较频繁或是是元操作,所以通过内置函数的形式提供出来,通过对python的内置函数分类分析可以看出来:基本的数据操作基本都是一些数学运算(当然除了加减乘除)、逻辑操作、集合操作...
  • Python 内置函数详解

    万次阅读 多人点赞 2019-11-13 17:21:35
    不过,大家公认的所谓内置函数里面,有很多并不是真的函数,而是内置类,只是因为使用起来和真正的函数没有什么不同,所以也就约定俗成地统称内置函数了。比如,我们常说的类型转换函数 int()、str()、float() ...
  • 一般用小写字母和单下划线、数字等组合,有人习惯用aabb的样式,但我不推荐def是定义函数的关键词,这个简写来自英文单词define函数名后面是圆括号,括号里面,可以有参数列表,也可以没有参数千万不要忘记了括号...
  • Python 内建函数大全

    千次阅读 2018-05-21 15:30:28
    Python 解释器内置了许多函数和类型,列表如下(按字母排序)(省略了几个我没用过或者不常用的)。 - - 内建函数表 - - abs() delattr() hash() memoryview() set() all() dict() ...
  • Python学习笔记3.2-python内置函数大全

    万次阅读 2016-11-22 22:28:09



1 2 3 4 5 ... 20
收藏数 55,095
精华内容 22,038


python 订阅