python面向对象双下划线方法与元类

目录

• 双下划线方法(__)
• 元类简介
• 产生类的两种表现形式
• 元类的基本使用
• 元类进阶操作
• __new__方法

双下划线方法(__)

面向对象中的双下方法也有一些人称之为是魔法方法，有些双下方法不需要刻意调用，到达某个条件会自动触发，就比如我们在对象实例化中学的__init__方法。

__str__：对象被执行打印(print、前端展示)操作的时候自动触发，该方法必须返回字符串类型的数据。

例子：原本应该是打印对象的，但定义了该方法后，打印的值变成了该方法的返回值。

# 没有__str__的情况：
class MyClass1(object):
    pass
obj1 = MyClass1()
print(obj1) # 输出：<__main__.MyClass object at 0x000001D5B350F208>

# 定义了__str__的情况：
class MyClass2(object):
    def __str__(self):
        """这里可以自定义其他操作"""
        return '这里是返回的内容'
obj2 = MyClass2()
print(obj2)  # 输出：这里是返回的内容

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

例子：程序运行结束python会自动删除(回收)定义的名称，所以程序结束MyClass被删除了，就执行了该方法。

class MyClass(object):
    def __del__(self):
        """这里可以自定义其他操作"""
        print("MyClass被删除了")
obj = MyClass()
"""
执行结果：
MyClass被删除了
"""

__call__：对象被加括号调用的时候自动触发。

例子：

class MyClass(object):
    def __call__(self, *args, **kwargs):
        """自定义操作"""
        print(args, kwargs)
        return '执行的返回值'
obj = MyClass()
res = obj('aaa', a=1)  # 输出：('aaa',) {'a': 1}
print(res)  # 输出：执行的返回值

__enter__：对象被执行with上下文管理语法开始自动触发，该方法返回什么as后面的变量名就会得到什么。

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

例子：

class MyClass(object):
    def __enter__(self):
        """自定义操作"""
        print('__enter__方法')
        return '这是给as后面的变量的'

    def __exit__(self, exc_type, exc_val, exc_tb):
        """对象被执行with上下文管理语法结束之后自动触发"""
        print('__exit__方法')

obj = MyClass()
with obj as o:
    print(o)
"""
执行结果：
__enter__方法
这是给as后面的变量的
__exit__方法
"""

__setattr__：对象在执行添加属性操作的时候自动触发。

例子：因为执行了：对象.变量名=变量值的赋值操作，触发了该方法。

class MyClass(object):
    def __setattr__(self, key, value):
        """这里可以自定义其他操作"""
        print('添加键为%s, 值为%s' % (key, value))
obj = MyClass()
obj.name = 'tom'  # 输出：添加键为name, 值为tom

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

例子：查找到名字时按正常流程走，找不到名字执行该方法，并把该方法返回值替换成需要查找的值。

class MyClass(object):
    name = 'tom'
    def __getattr__(self, item):
        """这里可以自定义其他操作"""
        return '不好意思 没有%s这个名字' % item

obj = MyClass()
print(obj.name)  # 输出：tom
print(obj.age)  # 输出：不好意思，没有age这个名字

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

class MyClass(object):
    def __getattribute__(self, item):
        print('不管有没有，我都执行')
        return '这是执行的返回值'

    def __getattr__(self, item):
        return '不好意思 没有%s这个名字' % item

obj = MyClass()
res = obj.name  # 输出：不管有没有，我都执行
print(res)  # 输出：这是执行的返回值

笔试题

1.让字典具备句点符查找值的功能

点击查看答案

# 1.定义一个类继承字典
class MyDict(dict):
    def __getattr__(self, item):
        return self.get(item)

    def __setattr__(self, key, value):
        self[key] = value

'''要区别是名称空间的名字还是数据k:v键值对'''
obj = MyDict({'name': 'jason', 'age': 18})
obj.pwd = 123  # 给字典名称空间添加名字  不是数据k:v
print(obj)

2.补全下列代码 使其运行不报错

class Context:
    pass
with Context() as ctx:
    ctx.do_something()

点击查看答案

class Context:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

    def do_something(self):
        pass
with Context() as ctx:
    ctx.do_something()

元类简介

元类，即产生类的类。

在学类之前，我们都说type()是查看数据类型的方法，但在学了类之后，可以推导出type()查看的其实是当前对象所属的类名称。比如123属于int类、'asd'属于str类、[1,2,3]属于list类等等。

我们来看一段代码：

class MyClass(object):
    pass
obj = MyClass()
print(type(obj))  # 输出：<class '__main__.MyClass'>
print(type(MyClass))  # 输出：<class 'type'>

在上述例子中，用type()方法可以看到obj属于MyClass类，MyClass类属于的是type类，而且obj是MyClass类产生的，所以可以推导出MyClass类是type类产生的。

总结：type就是元类，而且是所有类默认的元类。

学习元类的目的：

元类能够控制类的创建，也就意味着我们可以高度定制类的行为，就好比掌握了物品的生产过程，就可以在过程中做任何的额外操作。

产生类的两种表现形式

产生类有两种方法，但其实本质上都是同一种。

产生类有两种方法：

• class关键字产生类。

• 用type元类产生类。

第一种我们已经熟知了，重点是第二种方法。

用type元类产生类：

书写方式：type(类名, 父类, 类的名称空间)

比如：

MyClass = type('MyClass', (), {'name': 'tom'})
obj = MyClass()
print(obj.name)  # 输出：tom

元类的基本使用

我们都知道，自定义列表的类需要创建一个类去继承list类，自定义元类也是一样，只需要创建一个类去继承type类，但是如果要让一个类去使用自定义元类就需要用关键字赋值的方式。比如：

# 必须是继承了type的类才是自定义元类
class Mymeta(type):
    pass

# 通过metaclass可以指定类的元类
class MyClass(metaclass=Mymeta):
    pass

print(type(MyClass))  # 输出：<class '__main__.Mymeta'>

问题：如何让一个类必须要大写字母开头。

解决：

class MyTypeClass(type):
    # 重写type元类中的方法
    def __init__(cls, cls_name, cls_bases, cls_dict):
        # 如果创建的类是大写，则报错
        if not cls_name.istitle():
            raise Exception("类名的首字母必须大写")
        # 如果创建的类是大写字母开头，则执行元类type中的方法
        super().__init__(cls_name, cls_bases, cls_dict)

class C1(metaclass=MyTypeClass):  # 正常执行
    school = '清华大学'

class a(metaclass=MyTypeClass):  # 在这里报错
    school = '清华大学'

程序执行到在定义a类的时候就会报错。

元类进阶操作

回想：对象加括号会自动执行产生该对象的类里面的__call__，并且该方法返回什么对象加括号就会得到什么。

推导：类加括号会自动执行元类的里面的__call__，并且该方法返回什么类加括号就会得到什么。

证明：

# 自定义元类
class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print('类被调用了')

# 使用自定义元类创建类
class MyClass(metaclass=Mymeta):
    pass

MyClass()  # 输出：类被调用了

进阶：在创建对象的时候需要用类加括号的方式实例化，但是调用类也是用类加括号的方式，那么类里面的__init__方法和元类里面的__call__方法执行的先后顺序是怎么样的？。

# 自定义元类
class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print('类被调用了')

# 使用自定义元类创建类
class MyClass(metaclass=Mymeta):
    def __init__(self):
        print('类被初始化了')

res = MyClass()  # 输出：类被调用了

由上述结果得知：如果同时存在类里面的__init__方法和元类里面的__call__方法，那么它们的执行优先级为：元类里面的__call__优先级更高。

那么该如何用MyClass类创建对象呢？其实只要返回type元类里面的__call__即可

# 自定义元类
class Mymeta(type):
    def __call__(self, *args, **kwargs):
        print('类被调用了')
        return super().__call__(*args, **kwargs)

# 使用自定义元类创建类
class MyClass(metaclass=Mymeta):
    def __init__(self):
        print('类被初始化了')

res = MyClass()
print(res)  # 输出：<__main__.MyClass object at 0x0000019FC14CC198>

由这个我们可以实现类在实例化产生对象的时候，对象的独有数据必须采用关键字参数。

# 自定义元类
class Mymeta(type):
    def __call__(self, *args, **kwargs):
        if args:
            raise Exception('必须全部采用关键字参数')
        return super().__call__(*args, **kwargs)

# 使用自定义元类创建类
class MyClass(metaclass=Mymeta):
    def __init__(self, name):
        self.name = name

obj1 = MyClass(name='tom')  # 正常执行
obj2 = MyClass('tom')  # 程序报错

元类总结：

• 如果你想高度定制类的产生过程，那么编写元类里面的__init__方法
• 如果你想高度定制对象的产生过程，那么编写元类里面的__call__方法

__new__方法

__new__是用于产生空对象用的，它会返回一个空对象。

事实上，__init__和__call__执行的时候都会先产生一个空对象，而这个空对象就是由__new__产生的。

我们来看一个例子：

# 自定义元类
class Mymeta(type):
    def __new__(cls, *args, **kwargs):
        print('__new__ run')
        return super().__new__(cls, *args, **kwargs)
    def __call__(self, *args, **kwargs):
        print('__call__ run')
        return super().__call__(*args, **kwargs)

# 使用自定义元类创建类
class MyClass(metaclass=Mymeta):
    def __init__(self):
        print('__init__ run')

obj1 = MyClass()
"""
执行结果：
__new__ run
__call__ run
__init__ run
"""

我们可以看出__new__方法是最优先的，并且如果__new__方法不返回空对象，程序就会报错，无法执行__init__和__call__。

所以__init__和__call__方法中的self形参其实是从__new__方法获得的。