python魔术方法

魔术方法

init 初始化魔术方法 触发时机：初始化对象时触发(不是实例化触发，但是和实例化在同一个操作中)
参数：至少有一个self，接收对象
返回值无 作用：初始化对象的成员 注意：使用该方法初始化的成员都是直接写入对象当中，类中无法具有

new 因为每个init前都有一个系统内置的__new__方法，如果我要自己定义new方法，同时让系统那个new正常使用，就用super函数调
super 重写一次系统内置的new，让他正常使用
如果没有return 不会调用init只会执行new super那一行代码的作用是创建一个内存地址 然后return将地址抛出到init的self中，然后后边实例化时p1就可以接到这个new创建的地址

call 调用对象的魔术方法，触发时机 将对象当做函数调用时 触发对象() p=Person() p() 这时候才会调用call
参数：至少一个self接收对象，其余根据调用时参数觉得 作用：可以降复杂的步骤进行合并操作，减少调用的步骤，方便使用

// # __new__  实例化魔术方法

class Preson:
    def __init__(self):
        # self.name=name
        print('-------------->init')
    #每次执行new，会把其他魔术方法覆盖掉

    def __new__(cls, *args, **kwargs):  #new会捣毁init，new会覆盖初始化魔术方法
        print('---------------new')
        #如果想让init继续生效 就用super关键字
        return super(Preson,cls).__new__(cls,*args,**kwargs)  #因为每个init前都有一个系统内置的__new__方法，如果我要自己定义new方法，同时让系统那个new正常使用，就用super函数调
        #super 重写一次系统内置的new，让他正常使用
        #如果没有return 不会调用init只会执行new  super那一行代码的作用是创建一个内存地址  然后return将地址抛出到init的self中

#Preson.__new__()  类都有一个默认的new，如果我要建立一个新new 同时保证系统内置的那个new正常使用，就需要在类中用super调用
# p=Preson('jack')
p1=Preson()

p1.name=53     #创建一个新的属性
print(p1.name)
print(p1)    #p的地址为空 ，init失效
print('\n')

结果为：
---------------new
-------------->init
53
<__main__.Preson object at 0x0000017FA9E798D0>

以下为有参__new__方法

//class Preson:
    def __init__(self,name):
        self.name=name
        print('-------------->init',self.name)
    #每次执行new，会把其他魔术方法覆盖掉

    def __new__(cls, *args, **kwargs):  #new会捣毁init，new会覆盖初始化魔术方法
        print('---------------new')
        #如果想让init继续生效 就用super关键字
        return super(Preson,cls).__new__(cls)   #注意 在py3.6之后 super(Preson,cls).__new__(cls)  最后一个()中不用再写入上边的形参了(*args,**kwargs)

    def __call__(self, *args, **kwargs):     #调用对象的魔术方法，触发时机 将对象当做函数调用时 触发对象()  p=Person() p()  这时候才会调用call
                                             # 参数：至少一个self接收对象，其余根据调用时参数觉得  作用：可以降复杂的步骤进行合并操作，减少调用的步骤，方便使用
        print('----------------call')
        print('执行对象得到的参数是 ',*args,**kwargs)

    

p2=Preson('德玛西亚')
print(p2.name)
print(p2,'\n')
print('-----------调用call，需要在对象函数化时才能被调用-------------')
p2('嘿嘿 我已被函数化')   #只要你想给对象函数化 就会执行call里的函数  对象当成函数使用的情况比较少


结果为：
---------------new
-------------->init 德玛西亚
德玛西亚
<__main__.Preson object at 0x0000017FA9E80E80> 

-----------调用call，需要在对象函数化时才能被调用-------------
----------------call
执行对象得到的参数是  嘿嘿 我已被函数化

上边已介绍完init new call
下边是 __str__方法

str
触发时机 ： 打印对象名，自动触发去调用__str__里面的内容 必须先有对象调用
注意 一定要在str中添加return return后面内容就是打印对象看到的内容

//class Person:
    def __init__(self,name,age,color):
        self.name=name
        self.age=age
        self.color=color
    def __str__(self):
        print('str已被执行')
        return "姓名是:"+self.name+'年龄是:'+str(self.age)+'颜色是'+self.color

p=Person('小明',50,'黄色')
print(p)  #单纯打印对象的名称，出来是一个地址。地址对于开发者来说没有太大的意义
          #如果想在打印对象名时能够给开发者更多一些信息量，就用__str__

结果为：
str已被执行
姓名是:小明年龄是:50颜色是黄色

//"""
总结：
    重点： __init__  构造方法，创建完空间之后调用的第一个方法 

          __str__   
    了解: __new__   开辟空间 
          __del__  没有指针时他会调用 ，基本不用自己重写 因为系统已经默认设置好了
         __call__  想不想给对象当成函数用 如果当成函数用，就可以写call
"""

"""
    大总结 :
    方法 :
        普通方法 (重点)
            def 方法名(self,形参)：
                方法体 内容动作
            对象.方法()
            方法之间的调用
            class A:
                def a(self):
                    pass
                def b(self):
                    #调用a方法:
                    self.a()  #有参传参数，没参就不用管了

        类方法:
            @classmethod   #类方法不可调用普通方法(self cls)
            def 方法名(cls,形参)
                pass
            类名.方法名()
            对象.方法名()
        静态方法:
            @staticmethod
            def 方法名(形参)
                pass
            类名.方法名()
            对象.方法名()
        魔术方法:
            自动执行的方法
            print(p)  __str__ 



"""

重点掌握init 和 str方法