python中常见的魔法方法 magic method

魔法方法 magic method（类中定义的双下方法）

魔法方法都是父类object有的，在python3中所有的类默认都会继承object。当我们对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法，可以理解为重写这些python的内置函数。到达某种条件自动触发

 _ _ call _ _( **args,*kwargs ) 方法

类加( )触发类的元类的__call__方法 ，当给对象加括号调用的时候，自定触发_ call _方法

高度定制对象的产生过程，可以操作元类里面的__call__

class MyClass(object):
    def __init__(self,name):
        self.name = name
        pass
    def __str__(self):
        # print('__str__方法')
        return '对象:%s'%self.name
    def __call__(self, *args, **kwargs):
        print('__call__')
        print(args)
        print(kwargs)
obj = MyClass('tom')
obj(1,2,name='tom',age=18)

_ _ new _ _(cls)方法 由object基类提供的内置静态方法

__new__方法专门用于产生空对象

当我们创建实例的时候、在内存中为对象分配空间,返回对象引用,python解释器获取对象引用后，并将__new__方法的返回值将传递给__init__方法作为第一个参数，最后__init__给这个实例设置一些参数.(__new__方法在__init__方法之前被调用) 

类产生对象的步骤
	1.产生一个空对象（__new__方法专门用于产生空对象）
	2.自动触发__init__方法实例化对象
	3.返回实例化好的对象

__new__方法专门用于产生空对象				骨架
__init__方法专门用于给对象添加属性		  血肉

_ _init _ _ ( self ) 对象初始化 / 实例化方法

类实例化创建对象时，自动触发

高度定制类的产生过程，可以操作元类里面的__init__

通过类**实例化**创建对象时，自动触发执行，然后设置对象属性的一些初始值，用来为对象初始化自己独有的数据，通常用在初始化一个类实例的时候，是一个实例方法。  

class MyClass(object):
    def __init__(self, name):
        """实例化对象的时候自动触发"""
				self.name = name
        print('__init__方法')
obj = MyClass('tom')

# __init__方法

_ _ str _ _ ( self ) 方法

打印对象会自定触发的函数/方法,返回值必须是字符串类型

str函数或者print函数—>obj.str()
如果想要把一个类的实例变成str，就需要实现特殊方法__str__（self），print打印出来的是个对象，使用了就把对象变成字符串，打印从这个方法中return出来的数据

class MyClass(object):
    def __str__(self):
        """
        对象被执行打印操作的时候会自动触发
            该方法必须返回一个字符串
            返回什么字符串打印对象之后就展示什么字符串
        """
		def __str__(self):
		        print('__str__方法')
		        return ''
obj = MyClass()
print(obj)

_ _ getattr _ _( self, item ) 方法

当对象获取一个不存在的属性名自动触发，存在不触发

• 在对象.__dict__里找不到就会触发

class MyClass(object):
    def __getattr__(self, item):
        """当对象获取一个不存在的属性名 自动触发
            该方法返回什么 对象获取不存在的属性名就会得到什么,不返回默认为None
            形参item就是对象想要获取的不存在的属性名
        """
        print('__getattr__', item)
        return '您想要获取的属性名:%s不存在'%item
obj = MyClass('tom')
print(obj.age) # 获取对象不存在的属性名age

# 只要是查找获取属性最后都会走_ _ getattr _ _方法

_ _ setattr _ _(self, key, value ) 方法

对象无论在哪里 操作（对象.属性 = 属性值）属性值的时候，都会自动触发

class MyClass(object):
    def __init__(self, name):
        """实例化对象的时候自动触发"""
				self.name = name
        print('__init__方法')
    def __setattr__( key, value):
        """对象操作属性值的时候自动触发>>>:  对象.属性名=属性值"""
        print("__setattr__")
        print(key)
        print(value)
        **super().__setattr__(key, value)**  # 属性名（key）=属性值（value）
obj = MyClass('tom')
print(obj.__dict__) # 查看对象名称空间发现打印为空字典{}
# 因为我们定义了一个和父类一模一样的方法名，顶替掉了，重写派生了该方法，且没有将**属性 = 属性值**键的值对塞到对象的名称空间，重新继承父类即可

_ _ del _ _( self ) 方法

删除对象属性的时候，自动触发（主动删除），当所有代码执行完成结束，整个名称空间都要删除，还会自动触发（释放空间，被动删除）

class MyClass(object):
    def __del__(self):
        """对象在被删除(主动 被动)的时候自动触发"""
        print('__del__')
obj = MyClass('tom')

_ _ getattribute _ _ ( self,item ) 方法

对象获取属性值的时候，自动触发，无论这个属性存不存在。当类中既有_ _ getattr _ ，又有 _ getattribute _ ，只会走 _ getattribute _ _

class MyClass(object):
    def __getattribute__(self, item):
        """对象获取属性的时候自动触发 无论这个属性存不存在
            当类中既有__getattr__又有__getattribute__的时候 只会走后者
						形参item就是对象获取的属性名 
        """
        # print('__getattribute__')
        # return super(MyClass, self).__getattribute__(item)  复杂写法
        **return super().__getattribute__(item)  # 简便写法**
obj = MyClass('tom')

_ _ enter _ _( self ) 方法

对象被with语法(上下文管理协议)执行的时候自动触发，该方法返回什么，as关键字后面的变量名就能得到什么

_ _ exit _ _( self,exc_type,exc_val,exc_tb ) 方法

对象被with语法(上下文管理协议)执行并运行完with子代码后自动触发

_ _ setitem _ _ (self,value,key)方法

这个方法会让类按照一定的方法存储和key映射的value