一、面向对象的魔法方法

魔法方法：类中定义的双下方法都称为魔法方法(以双下划线开头和结尾的方法)，这些方法不允许开发者自己定义

特点是：不需要人为调用，在特定的条件下会自动触发运行

eg: __init__创建空对象完成后自动触发，在对象初始化时给对象添加独有的数据

1.魔法方法介绍

（1）__init__

​ 对象实例化的时候自动触发

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name
        print('__init__')


obj = C('duoduo')  
#  调用类的时候__init__会自动触发，则会打印'__init__'，然后将空对象，以及调用时括号内传入的参数一同传给__init__方法
obj1 = C('qiuqiu')
print(obj.name)
print(obj1.name)
---------------
__init__
__init__
duoduo
qiuqiu

调用类的过程又称之为实例化，发生三件事

1、先产生一个空对象
2、python会自动调用类中的 __ init __方法然后将空对象以及调用类时括号内传入的参数一同传给 _ _init _ _方法
3、返回初始完成的对象

总结 __init __ 方法

1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
2、__init __ 内应该存放的是为对象初始化属性的功能，但是也可以存放任意其他代码，想要在类调用时就立刻执行的代码都可以放在该方法内
3、__init __ 方法必须返回None

（2）__str__

​ 对象被执行打印(print、前端展示)操作的时候自动触发，方法必须返回字符串类型的数据，很多时候用来更加精准的描述对象（通过str方法可以区分打印的是哪个对象）

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name
        print('__init__')

    def __str__(self):
        """
        对象在被执行打印操作的时候自动触发，该方法返回什么打印的结果就是什么
        并且该方法必须要返回一个字符串类型的数据
        """
        # return f'{self}' 在str方法中不能返回对象本身，由于str方法会自动调用，在str中返回对象则会产生递归调用
        return f'返回字符串类型{self.name}'


obj = C('duoduo')
print(obj)  # __str__方法在打印对象的时候自动触发
-----------------
__init__
返回字符串类型duoduo
'''通过str方法可以区分打印的是哪个对象'''

# res = obj(123, 321, name='duoduo')  # (123, 321) {'name': 'duoduo'}
# print(res)

如果类中没有__str__ 方法，打印对象结果会是这个对象的类名，以及对象的内存地址<__main__.C object at 0x102ffaf40>

return f'{self}' 在__str__方法中不能返回对象本身，由于str方法会自动调用，在__str__中返回对象则会产生递归调用

（3）__call__

​ 对象加括号调用的时候自动触发，当类中没有__call__的时候该类产生的对象不可调用

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name

    def __call__(self, *args, **kwargs):
        """
        对象加括号调用的时候自动触发，该方法返回什么对象调用之后的返回值就是什么
        """
        print('__call__')
        print(args, kwargs)
        return 123


obj = C('duoduo')
obj1 = C('qiuqiu')
# 1 调用对象的时候没有传值
res = obj()
print(res)
---------------------
__call__
() {}  # 表示该对象并没有独有的数据和功能
123  # __call__ 的返回值是什么，对象调用后的返回值就是什么

# 2 调用对象的时候给__call__的参数传值
re = obj1(123, 321, name='duoduo')
print(re)
-------------------
(123, 321) {'name': 'duoduo'}
123

print(args, kwargs)中为什么是不加*号的参数？

​ print中没有默认的 name，age参数，但你要print(sep=',',end="\n") 就可以。
​ 一般print（只能打印 1,2,3,4，var， 如果用a=b）,则 a必须是print函数的有名参数。
所以在print中不能用*来打散参数

（4）__getattr__

​ 对象查找不存在名字的时候自动触发

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name

    def __getattr__(self, item):
        """对象在查找无法使用的名字时自动触发，该方法返回什么，点不存在的名字就可以得到什么"""
        print('__getattr__')
        print(item)

obj = C('duoduo')
obj1 = C('qiuqiu')
obj.age
obj1.obj   
-----------------------
__getattr__
age
__getattr__
obj

（5）__getattribute__

​ 只要对象查找名字无论名字是否存在都会执行该方法，如果类中有__getattribute__方法 那么就不会去执行__getattr__方法

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name

    def __getattr__(self, item):
        """对象在查找无法使用的名字时自动触发，该方法返回什么，点不存在的名字就可以得到什么"""
        print('__getattr__')
        print(item)

    # 当__getattribute__存在的时候，__getattr__方法就不会触发了
    def 当__getattribute__存在的时候(self, item):
        """对象在查找名字的时候就会自动触发该方法"""
        print('__getattribute__')
        return '返回值'


obj = C('duoduo')
obj1 = C('qiuqiu')
res = obj.name  # 调用名字后可以用变量名接收__getattribute__的返回值
print(res)  
obj1.name
obj.age
obj1.obj
-----------------------
__getattribute__
返回值  # __getattribute__的返回值
__getattribute__
__getattribute__
__getattribute__

当__getattribute__存在的时候，__getattr__方法就不会触发了
并且只要查找名字就会调用__getattribute__方法

（6）__setattr__

​ 对象在执行添加属性操作的时候自动触发 >>> obj.变量名=变量值

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name

    def __setattr__(self, key, value):
        "当给对象添加数据的时候，或者更改值的时候 也就是执行对象.名字=值的时候就会自动触发"
        print('__setattr__')
        print(key, value)


obj = C('duoduo')  # 在类调用的时候，括号内传参也有赋值语句的产生，也会调用__setattr__方法
obj.name = 'deft'
obj.age = 13
----------------------
__setattr__
name duoduo
__setattr__
name deft
__setattr__
age 13


# 当类中没有赋值语句时，类名加括号内没有填写的参数的时候，就不会调用__setattr__方法
class C(object):
    name = 'duoduo'
    
    def __setattr__(self, key, value):
        "当给对象添加数据的时候，或者更改值的时候 也就是执行对象.名字=值的时候就会自动触发"
        print('__setattr__')
        print(key, value)


obj = C()
obj.name = 'deft'
obj.age = 13
---------------
__setattr__
name deft
__setattr__
age 13

（7）__enter__

​ 当对象被当做with上下文管理操作的开始自动触发，并且该方法返回什么 as后面的变量名就会接收到什么

（8）__exit__

​ 对象被执行with上下文管理语法结束之后自动触发

class C(object):
    def __init__(self, name):
        """类名加括号，给对象添加独有方法"""
        self.name = name

    def __enter__(self):
        """当对象被当作with上下文管理操作的开始自佛难过触发，
        并且该方法返回什么，as后面就会收到什么"""
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):  # AttributeError: __exit__
        """当对象参与的with上下文管理语法运行完毕之后自动触发（子代码结束）"""
        #  __exit__ 方法相当于自动调用了一个f.close方法，用来回收资源，所以当用with方法来管理对象的时候，需要在产生对象的类中有__exit__方法


"with 方法"
with C('duoduo') as f:  
    f.name = 'deft'
    f.age = 13
    print(f.__dict__)
----------------------
{'name': 'deft', 'age': 13}

with方法将类产生的实例用as后面的别名f来接收，可以通过f加.的方法来对这个实例进行添加和更改属性

（9）__del__

​ 对象被执行(被动、主动)删除操作之后自动执行

class A:
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print(f"{self.name}对象被调用")
        return 10

    def __del__(self):
        print(f"{self.name}对象被销毁")


a = A('a')
a2 = A('a2')
a()
a2()
del a  # 会主动执行__del__方法
print('================')
-------------------------
a对象被调用
a2对象被调用
a对象被销毁
================
a2对象被销毁  # 当程序运行结束，要回收整个程序内存空间，相当于资源全部删除，a2对象也会被__del__方法回收 

2.魔法方法笔试题

1）补全下列代码使得运行不报错

（1）有with上下文管理需要有__enter __，as后面的变量名f 接收该返回值

（2）有with上下文管理结束需要有__exit__

（3）添加do_something方法

class Context:  # 1定义一个类
    def do_something(self):  # （3）添加do_something方法
        pass

    def __enter__(self):  # （1）有with上下文管理需要有__enter__
        # as后面的变量名f 接收该返回值
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):  # （2）有with上下文管理结束需要有__exit__
        pass


with Context() as f:  # 2 Context加()产生对象
    f.do_something()  # 3 对象执行do_something方法

2）自定义字典类型并让字典可以用点的方式点出字典的方式

# 2.自定义字典类型并让字典可以用点的方式点出字典的方式
class My_dict(dict):
    def __setattr__(self, key, value):
        """重写了__setattr__方法，在新的字典中添加键值对"""
        self[key] = value

    def __getattr__(self, item):
        """重写了__getattr__方法，在新的字典中通过get方法取得键的值"""
        return self.get(item)


obj = My_dict()
"通过重写的setattr方法，来为自定义字典添加键值对"
obj.name = 'duoduo'
obj.age = 19
obj.gender = 'male'
# print(obj)  # 字典存储的数据 {}
# print(obj.__dict__)  # 字典对象名称空间
"通过重写的__getattr__方法，来为获取自定义字典中键对应的数据值"
print(obj.name)  # duoduo
print(obj.age)  # 19
print(obj.gender)  # male

二、元类

0.元类type

推导步骤1 : 如何查看数据的数据类型

s1 = 'hello world'
l1 = [11, 22, 33, 44]
d1 = {'name': 'duoduo', 'pwd': 123}
t1 = (11, 22, 33, 44)
print(type(s1))  # <class 'str'>
print(type(l1))  # <class 'list'>
print(type(d1))  # <class 'dict'>
print(type(t1))  # <class 'tuple'>
"str方法是一个类"

推导步骤2：其实type方法是用来查看产生对象的类

class Student:
    pass

obj = Student()
print(type(obj))  # <class '__main__.Student'>

推导步骤3：python中一切皆对象，那么type查看类名显示的是什么

class Student:
    pass
obj = Student()
print(type(Student))  # <class 'type'>
print(type(type))  # <class 'type'> type 也是由自身type产生的
"""
结论：我们定义的类其实都是有type类产生的>>>:元类
类本身不过是一个名为 type 类的实例
"""

结论：我们定义的类其实都是有type类产生的>>>type类被称为元类
类本身不过是一个名为 type 类的实例

1.元类定制类的行为

了解元类如何定制类的行为，则可以去对类的行为进行干预，产生出我们想要的类

（1）创建类的两种方法

• 方式1：使用关键字class

class MyClass:
    pass

print(MyClass) 
print(MyClass.__dict__)  
-------------结果-------------
 <class '__main__.MyClass'>
  
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}

• 方式2：利用元类type

​ 通过查看type源码发现元类初始化实例的参数为：type(类名what， 类的父类bases，类的名称空间dict)

# 则可以用变量名来接收元类type初始化实例后的结果，其结果就是一个type元类产生的类
cls = type('Student', (object,), {})
print(cls)  
print(cls.__dict__) 
-----------结果--------------
<class '__main__.Student'> 

{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
# 通过type也可以产生类，并且cls的名称空间中也具有和关键字class所产生的类一样的名字

type产生的类，其名称空间如何产生数据和方法：

1.手动写键值对（定义函数的话很难写）
但是针对绑定方法不好定义
2.内置方法exec可以产生一个名称空间，
编写一个字符串代码，用exec来产生名称空间

（2）元类定制类的产生行为

​ 我们知道，对象由类名加括号(类的调用)所产生，而对象的独特方法由类的__init__方法产生
​ 以此类推，类是由元类加括号产生 ，则类的方法则会由元类的__init__产生，那么我们可以通过定制元类的__init__方法来定制类的方法

​ 比如：**我们想要定制所有类必须首字母大写，否则无法产生 ** –> 定制类的行为，所以要用到元类type

1.自定义元类：继承了type到类也称之为元类
class MyMetaClass(type):
    def __init__(self, what, bases=None, dict=None):
        """what是类名，bases是父类，dict是名称空间
        所以想对类名
        """
        # print('what', what)  # what myclass
        # print('bases', bases)  # bases ()
        # print('dict', dict)  # dict {'__module__': '__main__', '__qualname__': 'myclass'}
        if not what.istitle():
            raise TypeError('类名首字母应该大写')
        super().__init__(what, bases, dict)


2.指定类的元类:利用关键值metaclass指定类的元类
class myclass(metaclass=MyMetaClass):  #  TypeError: 类名首字母应该大写 当首字母没有大写当时候，则会报错
    desc = '你好'

class Myclass(metaclass=MyMetaClass):  # 类名首字母大写则不会报错
    desc = '你好'    

（3）元类定制对象的产生行为

​ 我们知道，对象加括号会执行产生该对象类里面的 __call__
​ 以此类推，类加括号会执行产生该类的类（元类）里面的 __call__，那么我们可以通过定制元类的__call__方法来定制类产生对象的方法

​ 比如：**我们想要定制：给对象添加独有数据的时候，必须采用关键字参数传参 ** –> 定制对象的产生行为，可以通过元类type的__call__方法来定制

class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        """
        当有对象产生的时候，__call__做的事情：
        1。产生一个空对象
        2。调用__init__给对象添加独有的数据
        3。返回创建好的对象
        """
        # print('call')
        # print(args)  # ('duoduo', 18, 'read')
        # print(kwargs)  # {}
        if args:
            raise TypeError('无法位置传参')
        return super().__call__(*args, **kwargs)  # __call__的值必须返回才能获得


class Student(metaclass=MyMetaClass):
    def __init__(self, name, age, hobby):
        print('init')
        self.name = name
        self.age = age
        self.hobby = hobby


obj = Student(name='duoduo', age=18, hobby='read')
print(obj.__dict__)  # {'name': 'duoduo', 'age': 18, 'hobby': 'read'}

三、魔法方法之__new__方法

class MyMetaClass(type):
    def __call__(cls, *args, **kwargs):
        """
        当有对象产生的时候，__call__做的事情：
        1。产生一个空对象
         1>>> __new__方法来产生的一个空对象
        2。调用__init__给对象添加独有的数据
        3。返回创建好的对象
        """
        __obj = cls.__new__(cls, args, kwargs)
        cls.__init__(__obj, *args, **kwargs)
        return __obj
        # return 123 当返回123的时候，对象就是123


class Student(metaclass=MyMetaClass):
    def __init__(self, name):
        print('init')
        self.name = name


obj = Student('duoduo')
# print(obj)  # 123
print(obj.name)  # duoduo

原文地址：http://www.cnblogs.com/DuoDuosg/p/16870752.html