面向对象编程：双下方法、元类、双下new方法

2022.4.11面向对象双下方法及元类

• 反射实际案例
• 面向对象双下方法
• 元类
• 双下new方法

一、反射实际案例

利用面向对象编写终端功能

class WinCmd(object):
    def ls(self):
        print('windows系统正在执行ls命令')
    def dir(self):
        print('windows系统正在执行dir命令')
    def cd(self):
        print('windows系统正在执行cd命令')

class LinuxCmd(object):
    def ls(self):
        print('Linux系统正在执行ls命令')
    def dir(self):
        print('Linux系统正在执行dir命令')
    def cd(self):
        print('Linux系统正在执行cd命令')

obj = WinCmd()  # 获取对象obj操作win
obj1 = LinuxCmd()  # 获取对象obj2操作linux
然后就可以使用对象利用反射方法操作数据和功能
def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:')
        if hasattr(obj,cmd):  # 判断对象有没有cmd的命令
            func_name = getattr(obj,cmd)  # 获取cmd对应的值
            func_name()  # 加括号执行函数
        else:
            print('cmd command not found')
run(obj)  
run(obj1)

二、面向对象的双下方法

面向对象中的双下方法也有一些人称之为是魔法方法
有些双下方法不需要刻意调用 到达某个条件会自动触发
eg：双下init， 对象实例化的时候自动触发

1.__str__
	对象被执行打印(print、前端展示)操作的时候自动触发
注意：该方法必须返回字符串类型的数据,很多时候用来更加精准的描述对象

2.__del__
	对象被执行(被动、主动)删除操作之后自动执行
#主动：代码删除
#被动：垃圾回收

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

4.__setattr__
	对象在执行添加属性操作的时候自动触发	>>>	obj.变量名=变量值
 
5.__call__
	对象被加括号调用的时候自动触发

6.__enter__
	对象被执行with上下文管理语法开始自动触发 
  	该方法返回什么as后面的变量名就会得到什么
  
7.__exit__
	对象被执行with上下文管理语法结束之后自动触发

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

笔试题讲解

1、需求：让字典具备句点符查找值的功能

# 定义一个类继承字典
class MyDict(dict):
    def __getattr__(self,item)  # 查不到名字执行的代码
    	return sef.get(item)
    def __serattr__(self,key.value):  # 添加数据时执行的代码
        self[key] = value
        
obj = MyDict({'name':'jason','age':18})
obj.pwd = 123  # 类中没有这个数据，则走__setattr__,返回值是添加键值对
print(obj.name)  # 类中没有这个数据则走__getattr__，返回值是获取字典v值

2、需求：补全下列代码，使其运行不报错

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

分析这几行代码，首先是定义了类Context，然后使用with语句，这里as后面的ctx就是类Context中的双下enter的返回值，这样我们就可以想到在类中补全这个函数

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()

三、元类

1、元类简介

概念：即产生类的类

引入：type(123)的底层原理

print(type(123))  # <class 'int'>
print(type([12, 33, 44]))  # <class 'list'>
print(type({'name':'jason','pwd':123}))  # <class 'dict'>
type查看的其实是当前对象所属的类名称
    # 为什么type可以识别不同数据类型呢，其实type底层是一个类，且这个类称为元类，因此 他可以识别不同的数据类型数据什么类，这些内置的方法就是提前定义好的类

class MyClass(object):
    pass
obj = MyClass()
print(type(obj))
print(type(MyClass))  # <class 'type'>

class Student:
    pass
print(type(Student))  # <class 'type'>

class Teacher(MyClass):
    pass
print(type(Teacher))  # <class 'type'>
'''type就是所有类默认的元类!!!'''

2、产生类的两种表现形式(本质是一种)

（1）class关键字

class C1(object):
	pass
print(C1)  # <class '__main__.C1'>

（2）type元类

type(类名,父类,类的名称空间)

res = type('C1', (), {})  # 定义；类C1，没有父类，名称空间为空
print(res)  # <class '__main__.C1'>

学习元类的目的：

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

3、元类基本使用

"""元类是不能通过继承的方式直接指定的"""
	需要通过关键字参数的形式修改
class C1(metaclass=MyTypeClass):
	pass

需求比如:要求类的名字必须首字母大写
思考在哪里编写定制化代码？

首先要知道类名是元类type的哪里产生的，即双下init，因此我们就需要修改双下init的产生过程，如下

class MyTypeClass(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):  # 括号里参数分别是：类名、父类、名称空间
        if not cls_name.istitle():
            raise Exception("类名的首字母必须大写 你个SD")
        super().__init__(cls_name, cls_bases, cls_dict)
    
class C1(metaclass=MyTypeClass):  
    school = '清华大学'

class a(metaclass=MyTypeClass):  # 类名的首字母必须大写 你个SD
    school = '清华大学'

4、元类进阶操作

（1）类里面的__init__方法和元类里面的__call__方法执行的先后顺序

class MyTypeClass(type):  # 自定义元类
    def __call__(self, *args, **kwargs):
        print('__call__ run')
        super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):  # 继承自定义元类
      def __init__(self, name):
          print('__init__ run')
          self.name = name
obj = MyClass('jason')  # __call__ run

我们知道双下call的作用是对象加括号调用时才会执行的代码，那么这里自定义的元类就是重写双下call，可见在加括号生成对象的时候是先执行元类中的双下call，

这样看来，我们是否可以通过重写元类，在元的生产过程做修改来操作产生什么样的类呢？

（2）定制对象的产生过程

需求：

强制规定:类在实例化产生对象的时候 对象的独有数据必须采用关键字参数

class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        if args:  # args不为空主动报错，因为args属于位置参数
            raise Exception('必须全部采用关键字参数')
        super().__call__(*args, **kwargs)

class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        self.name = name
        
obj1 = MyClass('jason')  # 报错：必须全部采用关键字参数
obj2 = MyClass(name='jason')

因此，从这个例子可以看出来，

如果需要高度定制类的生产过程，那么就可以重新编写元类里面的：双下init方法

同理，如果想高度定制对象的产生过程，可以重新编写元类里面的：双下call方法

四、双下new方法

引入：

__new__用于产生空对象(类)		骨架
__init__用于实例化对象(类)		血肉

"""
注意:并不是所有的地方都可以直接调用__new__ 该方法过于底层
	(1)如果是在元类的__new__里面 可以直接调用
class Meta(type):
    def __new__(cls, *args, **kwargs):
        obj = type.__new__(cls,*args,**kwargs)
        return obj
	(2)如果是在元类的__call__里面 需要间接调用
class Mate(type):
    def __call__(self, *args, **kwargs):
        obj = object.__new__(self) # 创建一个空对象
        self.__init__(obj,*args,**kwargs) # 让对象去初始化
        return obj
"""

五、双下方法大全

魔法方法	含义
	基本的魔法方法
_new_(cls[, ...])	1. new 是在一个对象实例化的时候所调用的第一个方法 2. 它的第一个参数是这个类，其他的参数是用来直接传递给 init 方法 3. new 决定是否要使用该 init 方法，因为 new 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 new 没有返回实例对象，则 init 不会被调用 4. new 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
_init_(self[, ...])	构造器，当一个实例被创建的时候调用的初始化方法
_del_(self)	析构器，当一个实例被销毁的时候调用的方法
_call_(self[, args...])	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.call(a, b)
_len_(self)	定义当被 len() 调用时的行为
_repr_(self)	定义当被 repr() 调用时的行为
_str_(self)	定义当被 str() 调用时的行为
_bytes_(self)	定义当被 bytes() 调用时的行为
_hash_(self)	定义当被 hash() 调用时的行为
_bool_(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
_format_(self, format_spec)	定义当被 format() 调用时的行为
	有关属性
_getattr_(self, name)	定义当用户试图获取一个不存在的属性时的行为
_getattribute_(self, name)	定义当该类的属性被访问时的行为
_setattr_(self, name, value)	定义当一个属性被设置时的行为
_delattr_(self, name)	定义当一个属性被删除时的行为
_dir_(self)	定义当 dir() 被调用时的行为
_get_(self, instance, owner)	定义当描述符的值被取得时的行为
_set_(self, instance, value)	定义当描述符的值被改变时的行为
_delete_(self, instance)	定义当描述符的值被删除时的行为
	比较操作符
_lt_(self, other)	定义小于号的行为：x < y 调用 x.lt(y)
_le_(self, other)	定义小于等于号的行为：x <= y 调用 x.le(y)
_eq_(self, other)	定义等于号的行为：x == y 调用 x.eq(y)
_ne_(self, other)	定义不等号的行为：x != y 调用 x.ne(y)
_gt_(self, other)	定义大于号的行为：x > y 调用 x.gt(y)
_ge_(self, other)	定义大于等于号的行为：x >= y 调用 x.ge(y)
	算数运算符
_add_(self, other)	定义加法的行为：+
_sub_(self, other)	定义减法的行为：-
_mul_(self, other)	定义乘法的行为：*
_truediv_(self, other)	定义真除法的行为：/
_floordiv_(self, other)	定义整数除法的行为：//
_mod_(self, other)	定义取模算法的行为：%
_divmod_(self, other)	定义当被 divmod() 调用时的行为
_pow_(self, other[, modulo])	定义当被 power() 调用或 ** 运算时的行为
_lshift_(self, other)	定义按位左移位的行为：<<
_rshift_(self, other)	定义按位右移位的行为：>>
_and_(self, other)	定义按位与操作的行为：&
_xor_(self, other)	定义按位异或操作的行为：^
_or_(self, other)	定义按位或操作的行为：|
	反运算
_radd_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rsub_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rmul_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rtruediv_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rfloordiv_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rmod_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rdivmod_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rpow_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rlshift_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rrshift_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_rxor_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
_ror_(self, other)	（与上方相同，当左操作数不支持相应的操作时被调用）
	增量赋值运算
_iadd_(self, other)	定义赋值加法的行为：+=
_isub_(self, other)	定义赋值减法的行为：-=
_imul_(self, other)	定义赋值乘法的行为：*=
_itruediv_(self, other)	定义赋值真除法的行为：/=
_ifloordiv_(self, other)	定义赋值整数除法的行为：//=
_imod_(self, other)	定义赋值取模算法的行为：%=
_ipow_(self, other[, modulo])	定义赋值幂运算的行为：**=
_ilshift_(self, other)	定义赋值按位左移位的行为：<<=
_irshift_(self, other)	定义赋值按位右移位的行为：>>=
_iand_(self, other)	定义赋值按位与操作的行为：&=
_ixor_(self, other)	定义赋值按位异或操作的行为：^=
_ior_(self, other)	定义赋值按位或操作的行为：|=
	一元操作符
_neg_(self)	定义正号的行为：+x
_pos_(self)	定义负号的行为：-x
_abs_(self)	定义当被 abs() 调用时的行为
_invert_(self)	定义按位求反的行为：~x
	类型转换
_complex_(self)	定义当被 complex() 调用时的行为（需要返回恰当的值）
_int_(self)	定义当被 int() 调用时的行为（需要返回恰当的值）
_float_(self)	定义当被 float() 调用时的行为（需要返回恰当的值）
_round_(self[, n])	定义当被 round() 调用时的行为（需要返回恰当的值）
_index_(self)	1. 当对象是被应用在切片表达式中时，实现整形强制转换 2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 index 3. 如果 index 被定义，则 int 也需要被定义，且返回相同的值
	上下文管理（with 语句）
_enter_(self)	1. 定义当使用 with 语句时的初始化行为 2. enter 的返回值被 with 语句的目标或者 as 后的名字绑定
_exit_(self, exc_type, exc_value, traceback)	1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么 2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作
	容器类型
_len_(self)	定义当被 len() 调用时的行为（返回容器中元素的个数）
_getitem_(self, key)	定义获取容器中指定元素的行为，相当于 self[key]
_setitem_(self, key, value)	定义设置容器中指定元素的行为，相当于 self[key] = value
_delitem_(self, key)	定义删除容器中指定元素的行为，相当于 del self[key]
_iter_(self)	定义当迭代容器中的元素的行为
_reversed_(self)	定义当被 reversed() 调用时的行为
_contains_(self, item)	定义当使用成员测试运算符（in 或 not in）时的行为/