目录

• 反射实际案例

• 面向对象的双下方法

• 元类

内容

1.反射实际案例

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

class WinCmd(object):
    def ls(self):
        print('')
    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()
obj1 = LinuxCmd()

反射提供了一种不需要考虑代码的前提下 操作数据和功能

def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:')
        if hasattr(obj, cmd):
            func_name = getattr(obj, cmd)
            func_name()
        else:
            print('cmd command not found')   
run(obj1)
run(obj)

面向对象的双下方法

1.__str__

对象被执行打印（print，前端展示）操作的时候会自动触发

该方法必须返回字符串类型的数据

很多时候用来更加精准的描述对象

2.__del__

对象被执行（被动，主动）删除操作之后自动执行

3.__getattr__

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

4.__setattr__

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

5.__call__

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

6.__enter__ , __exit__

被执行with语法自动触发 绑定在一起

7.__getattribute__

只要对象查找名字无论名字是否存在都会执行该方法

如果类中有__getattribute__方法，那么就不会执行__getattr__方法

8.__new__

下面将元类会提及

面试题实战

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

class MyDict(dict):
      def __getattr__(self, item):
          return self.get(item)

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

obj = MyDict({'name':'zhou','age':18})

具备句点符取v

print(obj.name) # zhou
print(obj.age) # 18

句点符设k:v

obj['gender'] = 'male'
obj.pwd = 123
print(obj) # {'name': 'jason', 'age': 18, 'gender': 'male', 'pwd': 123}

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 知识点：

print(type(123)) # 
print(type([12, 33, 44])) # 
print(type({'name':'zhou','pwd':123})) # 

这是我们注意到：class

type查看的其实是当前对象所属的类名称

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

class Student:
    pass
print(type(Student))  # 

class Teacher(MyClass):
    pass
print(type(Teacher))  # 

再结合元类的概念可得知：

type 就是所有类默认的元类！！！

产生类的两种表现形式（本质是一种）

1.class关键字

class C1(object):
    pass
    print(C1)  # 

2.type元类

type(类名,父类,类的名称空间)
res = type('C1', (), {})
    print(res)  # 

学习元类的目的：元类能够控制类的创建 也就意味着我们可以高度定制类的行为

eg:掌握了物品的生产过程 就可以在过程中做任何的额外操作

元类的基本使用

元类是不能通过继承的方式直接指定的 需要通过关键字参数的形式修改

class MyTypeClass(type):
    pass
class C1(MyTypeClass):
    pass
print(C1) # 
print(type(C1)) # 

直接继承打印结果是没有反应的

而这里需要的关键字参数就是：metaclass

class MyTypeClass(type):
    pass
class C1(metaclass=MyTypeClass):
    pass
print(type(C1)) # 

class MyTypeClass(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):
        # print(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):
    school = '清华大学'

元类进阶操作

回想__call__方法

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

推导:类加括号会执行元类的里面的__call__该方法返回什么其实类加括号就会得到什么

类里面的__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')

定制对象的产生过程

class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        # print('__call__ run')
        # print(args,kwargs)
        if args:
            raise Exception('必须全部采用关键字参数')
        super().__call__(*args, **kwargs)

class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        # print('__init__ run')
        self.name = name

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

obj1 = MyClass('jason')
obj2 = MyClass(name='jason')

如果你想高度定制类的产生过程：编写元类里面的__init__方法

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

双下new方法

__new__用于产生空对象(类)     骨架  

__init__用于实例化对象(类)       血肉

注意:并不是所有的地方都可以直接调用__new__ 该方法过于底层

如果是在元类的__new__里面 可以直接调用

class Meta(type):
      def __new__(cls, *args, **kwargs):
          obj = type.__new__(cls,*args,**kwargs)
          return obj
    如果是在元类的__call__里面 需要间接调用
        class Mate(type):
      def __call__(self, *args, **kwargs):
          obj = object.__new__(self) # 创建一个空对象
          self.__init__(obj,*args,**kwargs) # 让对象去初始化
          return obj