29面向对象双下方法/元类

反射案例（利用字符串操作对象的数据和功能）

# 利用面向对象编写系统终端功能
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()
obj1 = LinuxCmd()
"""反射提供了一种不需要考虑代码的前提下 操作数据和功能"""
def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:')
        if hasattr(obj, cmd):   #如果输入的指令是obj里面的字符串，则执行指令的函数
            func_name = getattr(obj, cmd)
            func_name()
        else:
            print('cmd command not found')   
run(obj1)
run(obj)

面向对象的双下方法

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

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

2._ _del_ _
    对象被执行(被动、主动)删除操作之后自动执行(可以对象用完了，这个函数进行删除（被动）。也可以先运行这个函数删除（主动），在展示对象)

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

4._ _setattr_ _
    对象在执行添加属性操作的时候自动触发    >>>    obj.变量名=变量值，添加新的变量名和变量值键值对的时候才会触发
 
5._ _call_ _
    对象被加括号调用的时候自动触发  （对象往往是不能加括号调用的obj（），因为对象不是函数，但是如果类里面写
了_ _call_ _方法就可以对象加括号调用）

6._ _enter_ _  （进入的意思）
    对象被执行with上下文管理语法开始自动触发   比如with obj as f:  (正常是不可以调用with，但是加了同时调用
_ _enter_ _和_ _exit_ _就可以，
相当于一个是头一个是尾，缺一不可)
      该方法返回什么as后面的变量名就会得到什么
  
7._ _exit_ _ 
    对象被执行with上下文管理语法结束之后自动触发

8._ _getattribute_ _  （相当于这个是_ _getattr_ _的秘书，只要有秘书在，老板不用干活，并且干的活多，无论是否有该对象的名字会执行，如果秘书不在，
老板干活_ _getattr_ _，仅仅针对不存在才触发，存在不管）
    只要对象查找名字无论名字是否存在都会执行该方法
  如果类中有_ _getattribute_ _方法 那么就不会去执行_ _getattr_ _方法

9._ _new_ _
    讲解元类的时候再说！！！

笔试题讲解

1.让字典具备句点符查找值的功能（让字典里面的取值也可以直接用句点符）
    # 1.定义一个类继承字典
  class MyDict(dict):
      def _ _getattr_ _(self, item):  #如果字典里面没有，就执行，obj.name确实是没有值，进行执行，最终得到内部字典里面的值
          return self.get(item)

      def _ _setattr_ _(self, key, value):
          self[key] = value
  '''要区别是名称空间的名字还是数据k:v键值对'''
  obj = MyDict({'name':'jason','age':18})
  # 1.具备句点符取v
  # print(obj.name)
  # print(obj.age)
  # 2.具备句点符设k:v
  # obj['gender'] = 'male'
  obj.pwd = 123  # 给字典名称空间添加名字  不是数据k:v，必须写上_ _setattr_ _最后才能在数据里面添加
  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()

元类简介

# 元类
    即产生类的类
 
# print(type(123))  整型
# print(type([12, 33, 44]))  列表
# print(type({'name':'jason','pwd':123}))  字典
#说白了，整型/列表/字典都是类，类上面是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就是所有类默认的元类!!!'''

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

1.class关键字
    class C1(object):
    pass
    print(C1)  # <class '__main__.C1'>
    
2.type元类
    type(类名,父类,类的名称空间)
      res = type('C1', (), {})
        print(res)  # <class '__main__.C1'>
    
"""
学习元类的目的
    元类能够控制类的创建 也就意味着我们可以高度定制类的行为
        eg:掌握了物品的生产过程 就可以在过程中做任何的额外操作
        
    比如:要求类的名字必须首字母大写
        思考在哪里编写定制化代码
            类的产生过程目前还比较懵       元类里面的__init__方法
            对象的产生过程呢                  类里面的__init__方法
        方法:由已知推未知
"""

元类的基本使用

"""元类是不能通过继承的方式直接指定的"""
    需要通过关键字参数的形式修改
   
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):  #之前的继承直接class C1(MyTypeClass),但是元类的继承需要加关键字
    school = '清华大学'

元类进阶操作

1.回想_ _call_ _方法
    对象加括号会自动执行产生该对象的类里面的_ _call_ _,并且该方法返回什么对象加括号就会得到什么
  推导:类加括号会执行元类的里面的_ _call_ _该方法返回什么其实类加括号就会得到什么
  """类里面的_ _init_ _方法和元类里面的_ _call_ _方法执行的先后顺序"""
     class MyTypeClass(type):  #元类
    def _ _call_ _(self, *args, **kwargs):   ②
        print('_ _call_ _ run')
        super()._ _call_ _(*args, **kwargs)  #这个一定要写，否则不执行后面的类中的_ _init_ _
  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
"""