编程

当前位置:永利皇宫463登录 > 编程 > Python底子(十卡塔尔(英语:State of Qatar) __init__与

Python底子(十卡塔尔(英语:State of Qatar) __init__与

来源:http://www.makebuLuo.com 作者:永利皇宫463登录 时间:2019-12-09 04:23

Linux and python学习沟通1,2群已满.

以下摘自《Python主旨编制程序(第二版)》:

Python旧类中的__new____init__

Python的旧类中实际上并从未__new__艺术。因为旧类中的__init__实质上起布局器的意义。所以若是我们定义如下旧类:

class oldStyleClass:
    def __new__(cls):
        print("__new__ is called") # this line will never get called during construction

oldStyleClass()

程序输出结果如下:

<__main__.oldStyleClass instance at 0x109c45518>

可以知道成立及初步化对象的进度并从未调用__new__。实际上,除非显式调用:oldStyleClass.__new__(oldStyleClass),该类中的__new__主意中的内容永世不会被调用。因为旧类构造实例并不会调用__new__方法。

但万大器晚成大家重载__init__方法:

class oldStyleClass:
    def __init__(self):
        print("__init__ is called")

oldStyleClass()

该程序将会输出

__init__ is called
<__main__.oldStyleClass instance at 0x1091992d8>

设若我们在__init__中加上return讲话,将会引致TypeError: __init__() should return None的错误。

class oldStyleClass:
    def __init__(self):
        return 29

oldStyleClass()

前后相继结果如下:

TypeError: __init__() should return None

那象征对于Python的旧类来说,咱们不能够调节__init__函数的重返值。

__new__在python中实际是,在实例化在此之前执行的,这一个通过参数相像能够见到

__new__:创立对象时调用,会回去当前目的的叁个实例

Python新类中的__new____init__

Python的新类允许顾客重载__new____init__措施,且这三个艺术具备分裂的作用。__new__用作布局器,起成立三个类实例的意义。而__init__作为初步化器,起头步化多个已被创建的实例的效能。

如上边代码是所示:

class newStyleClass(object): 
    # In Python2, we need to specify the object as the base.
    # In Python3 it's default.

    def __new__(cls):
        print("__new__ is called")
        return super(newStyleClass, cls).__new__(cls)

    def __init__(self):
        print("__init__ is called")
        print("self is: ", self)

newStyleClass()

结果如下:

__new__ is called
__init__ is called
self is: <__main__.newStyleClass at 0x109290890>
<__main__.newStyleClass at 0x109290890>

创设类实例并开头化的长河中__new____init__被调用的相继也能从地点代码的出口结果中见到:__new__函数首先被调用,结构了二个newStyleClass的实例,接着__init__函数在__new__函数再次来到多个实例的时候被调用,何况这几个实例作为self参数被流传了__init__函数。

此间供给当心的是,假诺__new__函数重回贰个生机勃勃度存在的实例(无论是哪个类的),__init__不会被调用。如上边代码所示:

obj = 12 
# obj can be an object from any class, even object.__new__(object)

class returnExistedObj(object):
    def __new__(cls):
        print("__new__ is called")
        return obj

    def __init(self):
        print("__init__ is called")

returnExistedObj()

实践结果如下:

__new__ is called
12

同期另叁个亟需静心的点是:

假如大家在__new__函数中不回去任何对象,则__init__函数也不会被调用。

如上边代码所示:

class notReturnObj(object):
    def __new__(cls):
        print("__new__ is called")

    def __init__(self):
        print("__init__ is called")

print(notReturnObj())

执行结果如下:

__new__ is called
None

可以知道假设__new__函数不回来对象的话,不会有任何对象被创制,__init__函数也不会被调用来开始化对象。

__init__与__new__区别:

>>> class Data(object):
...     def __new__(self):
...             print "new"
...     def __init__(self):
...             print "init"
... 
>>> data = Data()
new

计算多少个点

  1. __init__无法有重返值

  2. __new__函数直接上能够回来其他类的实例。如下面例子中的returnExistedObj类的__new__函数重返了一个int值。

  3. 只有在__new__回来三个新创设归于此类的实例时当前类的__init__才会被调用。如上面例子所示:

class sample(object):
    def __str__(self):
        print("sample")

class example(object):
    def __new__(cls):
        print("__new__ is called")
        return sample()

    def __init__(self):
        print("__init__ is called")

example()

出口结果为:

__new__ is called
sample
class temp(object):

    def __init__(self,txt):
        self.txt = txt
        print '__init__'


    def __new__(cls,txt):
        print '__new__'
        print txt
        return super(temp,cls).__new__(cls)

temp('what?')
>>> class Data(object):
...     def __init__(cls):
...             cls.x = 2
...             print "init"
...             return cls
... 
>>> data = Data()
init
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() should return None, not 'Data'

>>> class Data(object):
...     def __new__(cls):
...             print "new"
...             cls.x = 1
...             return cls
...     def __init__(self):
...             print "init"
... 
>>> data = Data()
new
>>> data.x =1 
>>> data.x
1

If __new__() returns an instance of cls, then the new instance’s __init__() method will be 
invoked like __init__(self[, ...]), where self is the new instance and the remaining 
arguments are the same as were passed to __new__().

如果__new__返回一个对象的实例,会隐式调用__init__

If __new__() does not return an instance of cls, then the new instance’s __init__() method
 will not be invoked.

如果__new__不返回一个对象的实例,__init__不会被调用

摘要

正文研商了Python中__init____new__方法。

__new____init__抱有分化的效益。並且对于Python的新类和旧类来说意义也不如。

 

1、在类中,如果__new__和__init__还要存在,会预先调用__new__

Python的新类和旧类

Python中的类分为新类和旧类。旧类是Python3事前的类,旧类并不是暗中同意世袭object类,而是继续type类。

Python2中的旧类如上边代码所示:

class oldStyleClass: # inherits from 'type'
    pass

Python第22中学定义叁个新类:

class newStyleClass(object): # explicitly inherits from 'object'
    pass

在Python3中全体的类均暗许世襲object,所以并无需显式地钦点object为基类。

object为基类能够使得所定义的类具有新类所对应的方式(methods)和属性(properties)。

在上面包车型大巴稿子中大家会独家遵照新类和旧类研商__new____init__

 

__init__:创造完对象后调用,对眼下目的的一些实例开首化,无再次回到值

__new____init__意义上的分别

__new____init__的最首要分裂在于:__new__是用来创设一个类的实例的(constructor),而__init__是用来早先化二个实例的(initializer)。

紧凑一些,通过参数会怀有开掘,其实__init__(self卡塔尔 self隐式的将,实例传过来。

__init()__ "构造器"方法:

当类被调用,实例化的首先步是创立实例对象。生机勃勃旦指标创制了,Python 检查是不是贯彻了__init__(卡塔尔国方法。暗许情状下,若无概念(或遮盖)特殊措施__init__(卡塔尔国,对实例不会施加任何特别的操作.任何所需的特定操作,都急需技士实现__init__(卡塔尔国,覆盖它的暗中认可行为。假设__init__(卡塔尔未有贯彻,则赶回它的对象,实例化进度截至。
然而,如果__init__(卡塔尔国已经被达成,那么它将被调用,实例对象作为第一个参数(self卡塔尔被传送步入,像正规措施调用相同。调用类时,传进的任何参数都付出了__init__(卡塔尔(قطر‎。实际中,你可以想像成这样:把创立实例的调用当成是对构造器的调用。
不问可以看见,(a卡塔尔(قطر‎你未有经过调用 new 来成立实例,你也远非定义贰个构造器。是 Python 为您创制了目的; (b卡塔尔国 __init__(卡塔尔国,是在解释器为你成立三个实例后调用的率先个情势,在您从头采用它从前,这一步能够令你做些计划干活。
__init__(卡塔尔(قطر‎是累累为类定义的非常格局之风度翩翩。在那之中风流倜傥部分特别措施是预订义的,缺省气象下,不开展别的操作,比方__init__(卡塔尔国,要定制,就一定要对它进行重载,还会有个别方法,恐怕要按供给去落实。

__new____init__参数的不如

__new__所接到的首先个参数是cls,而__init__所收受的第二个参数是self。那是因为当大家调用__new__的时候,该类的实例还并不设有(也正是self所引述的靶子还不设有),所以须要抽出四个类作为参数,从而发出三个实例。而当大家调用__init__的时候,实例已经存在,由此__init__接受self用作第二个参数并对该实例进行要求的开始化操作。那也表示__init__是在__new__随后被调用的。

C:Python27python.exe D:/weixin/temp/abc.py
__new__
what?
__init__

Process finished with exit code 0

2、__new__方法会重回所组织的指标,__init__则不会。__init__无再次来到值。

不前行,不倒退,截至的事态是未有的.

__new()__ "构造器"方法:

与__init__()相比,__new__(卡塔尔(英语:State of Qatar)方法更像三个确实的结构器。类型和类在本子 2.2 就集结了,Python 客户能够对内建项目进行派生,因而,须求风流罗曼蒂克种门路来实例化不可变对象,比方,派生字符串,数字,等等。
在此种情景下,解释器则调用类的__new__(卡塔尔方法,四个静态方法,况兼传入的参数是在类实例化操作时生成的。__new__(卡塔尔(قطر‎会调用父类的__new__(卡塔尔(英语:State of Qatar)来创造对象(向上代理)。
缘何大家感到__new__()比__init__(卡塔尔(قطر‎更像构造器呢?那是因为__new__(卡塔尔国必需回到贰个官方的实例,那样解释器在调用__init__(卡塔尔国时,就能够把那一个实例作为 self 传给它。调用父类的__new__(卡塔尔来创制对象,正像别的语言中运用 new 关键字同样。
__new__()和__init__(卡塔尔(قطر‎在类创建时,都流传了(相近)参数。13.11.3 节中有个例证使用了__new__()。

<class '__main__.B'>
>>> class A(object):
...     def __new__(Class):
...             object = super(A,Class).__new__(Class)
...             print "in New"
...             return object
...     def __init__(self):
...             print "in init"
... 
>>> A()
in New
in init
<__main__.A object at 0x7fa8bc622d90>
>>> class A(object):
...     def __new__(cls):
...             print "in New"
...             return cls
...     def __init__(self):
...             print "in init"
... 
>>> a = A()      
in New

object.__init__(self[, ...])
Called when the instance is created. The arguments are those passed to the class 
constructor expression. If a base class has an __init__() method, the derived 
class’s __init__() method, if any, must explicitly call it to ensure proper initialization 
of the base class part of the instance; for example: BaseClass.__init__(self, [args...]). 
As a special constraint on constructors, no value may be returned; doing so will cause a
TypeError to be raised at runtime.

在对象的实例创建完成后调用。参数被传给类的构造函数。如果基类有__init__方法,子类必须显示
调用基类的__init__。

从没重回值,不然会再掀起TypeError错误。
原文:https://www.cnblogs.com/gsblog/p/3368304.html

Linux and python学习交换3群新开,迎接参加,一同学习.qq 3群:563227894

 

 

结果:

__new__(cls卡塔尔(英语:State of Qatar),cls是隐式的传递的类对象,并非实例。因为__new__的天职正是,创制类实例并回到实例。

联机前行,与君共勉,

__init__在python,其实是,在实例化之后实践的,用来起头化一些属性,也等于布局函数,不过又不均等

本文由永利皇宫463登录发布于编程,转载请注明出处:Python底子(十卡塔尔(英语:State of Qatar) __init__与

关键词: