多态、魔法函数、和一些方法的实现原理

　　多态

• • 定义
    官方解释: 多个不同类对象可以响应同一个方法,产生不同的结果
    多态不是一种特殊的语法,而是一种状态,特性（既多个不同对象可以响应同一个方法,产生不同的结果 ）​​​是一种状态,
    如果程序具备这种状态,对象的使用者,可以很方便忽略对象之间的差异
  • 好处
    对于使用者而言,大大的降低了使用难度
  • 实现
    我们可以通过鸭子类型来让程序具备多态性

　　两个内置函数

• • isinstance
    • 定义
      判断一个对象是否是某个类的实例
      参数1 要判断的对象
      参数2 要判断的类型​
    • 用法

      def add_num(a,b):
      
          if isinstance(a,int) and isinstance(b,int):
              return a+b
          return None
      
      print(add_num(20,10))
      
      
      '''执行结果
      30
      '''

  • issubclass
    • 定义
      判断一个类是否是另一个类的子类 参数一是子类参数二是父类
    • 用法

      class Animal:
      
          def eat(self):
              print("动物得吃东西...")
      
      class Pig(Animal):
          def  eat(self):
              print("猪得吃 猪食....")
      
      
      class Tree:
          def light(self):
              print("植物光合作用....")
      
      print(issubclass(Pig, Animal))
      print(issubclass(Tree, Animal))
      
      
      '''执行结果
      True
      False
      '''

　　魔法函数

• • str 函数
    • 定义
      __str__  会在对象被转换为字符串时执行,转换的结果就是这个函数的返回值 
      使用场景:我们可以利用该函数 来自定义对象的打印格式
    • 解释
      打印一个实例化对象时，打印的其实时一个对象的地址。​
      而通过__str__()函数就可以帮助我们打印对象中具体的属性值，或者你想得到的东西。
      python中调用print()打印实例化对象时会调用__str__()如果__str__()中有返回值，就会打印其中的返回值。​
    • 用法

      class  Person:
      
          def __init__(self,name,age):
              self.name = name
              self.age = age
      
          def __str__(self):
      
              return "这是一个person对象 name:%s age:%s" % (self.name,self.age)
      
      p = Person("jack",20)
      print(p)
      
      
      '''执行结果
      这是一个person对象 name:jack age:20
      '''

  • del 函数
    • 定义
      执行时机: 手动删除对象时立马执行,或是程序运行结束时也会自动执行 
      使用场景:当你的对象在使用过程中,打开了不属于解释器的资源:例如文件,网络端口 
    • 用法

      class Foo:
      
          def __del__(self):
              print('执行我啦')
      
      f1=Foo()
      del f1
      print('------->')
      
      #输出 执行我啦
      #输出 ------->

      class Foo:
          def __del__(self):
              print('执行我啦')
      
      f1=Foo()
      # del f1
      print('------->')
      #输出 ------->
      #输出 执行我啦

    • 用法解释
      第一个情景是执行删除时，自动执行了__del__方法
      第二个情景是程序执行完毕时，自动执行了__del__方法​
  • call 函数
    • 定义
      执行时机：在调用对象时自动执行,（即对象加括号）
    • 用法

      class A:
      
          def __call__(self, *args, **kwargs):
              print("call run")
              print(args)
              print(kwargs)
      
      a = A()  # 实例化
      a(1,a=100)  # 调用
      
      
      '''执行结果
      call run
      (1,)
      {'a': 100}
      '''

  • slots
    • 定义
      该属性是一个类属性,用于优化对象内存占用
    • 原理
      将原本不固定的属性数量,变得固定了这样的解释器就不会为这个对象创建名称空间,
      所以__dict__也没了  从而达到减少内存开销的效果 
      另外：当类中出现了slots时将导致这个类的对象无法在添加新的属性 
    • 用法

      ass Person:
          __slots__ = ["name"]
          def __init__(self,name):
              self.name = name
              print(self.__dict__)
      p =  Person("jck")
      
      p.age = 20  # dict没有了
      print(p.__dict__)  # 所以打印会报错
      
      
      '''执行结果
      AttributeError: 'Person' object has no attribute '__dict__'
      '''

　　点语法原理

• • 原理
    getattr 用点访问属性时，如果属性不存在时执行
    setattr 用点设置属性时
    delattr 用del 对象.属性  删除属性时 执行
  • 这几个函数反映了 python解释器是如何实现 用点来访问属性 
    
    ​getattribute 该函数也是用来获取属性
    在获取属性时如果存在getattribute则先执行该函数,
    如果没有拿到属性则继续调用 getattr函数,如果拿到了则直接返回
  • 案例

    class A:
    
        def __setattr__(self, key, value):
            # print(key)
            # print(value)
            print("__setattr____")
            self.__dict__[key] = value
            print('<------->')
    
        def __getattr__(self, item):
            print("__getattr____")
            return 1
    
        def __delattr__(self, item):
            print("__delattr____")
            print(item)
            self.__dict__.pop(item)
            print('<------->')
    a = A()
    a.name = "jack"
    del a.name
    print(a.name)
    
    
    '''执行结果
    __setattr____
    <------->
    __delattr____
    name
    <------->
    __getattr____
    1
    '''

　　[]取值原理

• • 原理
    getitem 当你用中括号去获取属性时 执行
    setitem  当你用中括号去设置属性时 执行
    delitem 当你用中括号去删除属性时 执行
  • 案例

    class A:
        def __getitem__(self, item):
            print("__getitem__")
            return self.__dict__[item]
    
        def __setitem__(self, key, value):
            print("__setitem__")
            self.__dict__[key] = value
    
        def __delitem__(self, key):
            del self.__dict__[key]
            print("__delitem__")
    
    a = A()
    a["name"] = "jack"  # a.name = "jack"
    print(a["name"])
    del a["name"]
    
    
    '''执行结果
    __setitem__
    __getitem__
    jack
    __delitem__
    '''

　　运算符重载

• • 定义
    当我们在使用某个符号时,python解释器都会为这个符号定义一个含义,同时调用对应的处理函数, ​
    当我们需要自定义对象的比较规则时,就可在子类中覆盖 大于 等于 等一系列方法....​
    
    另外：案例的代码中,other指的是另一个参与比较的对象,大于和小于只要实现一个即可,
    　　　符号如果不同 解释器会自动交换两个对象的位置
  • 案例

    class Student(object):
        def __init__(self,name,height):
            self.name = name
            self.height = height
    
        def __gt__(self, other):
            return self.height > other.height
    
        def __lt__(self, other):
            return self.height < other.height
    
        def __eq__(self, other):
            if self.name == other.name and  self.height == other.height:
                return True
            return False
    
    stu1 = Student("jack",180)
    stu2 = Student("jack",180)
    print(stu1 < stu2)
    print(stu1 == stu2)
    
    
    '''执行结果
    False
    True
    '''

　　迭代器的两个函数

• • 定义
    迭代器是指具有__iter__和__next__的对象
    我们可以为对象增加这两个方法来让对象变成一个迭代器 
  • 案例（自己写一个range）

    class MyRange:
    
        def __init__(self,start,end,step):
            self.start = start
            self.end = end
            self.step = step
    
        def __iter__(self):
            return self
    
        def __next__(self):
            a = self.start
            self.start += self.step
            if a < self.end:
                return a
            else:
                raise StopIteration
    
    for i in MyRange(1,6,2):
        print(i)
    
    
    '''执行结果
    1
    3
    5
    '''

　　上下文管理

• • 定义
    在python中,上下文可以理解为是一个代码区间,一个范围 ,
    例如with open 打开的文件仅在这个上下文中有效
  • 两个方法
    enter 表示进入上下文,(进入某个场景 了)
    exit 表示退出上下文,(退出某个场景 了)
  • 执行方式
    当执行with 语句时,会先执行enter ,当代码执行完毕后执行exit；
    或者代码遇到了异常会立即执行exit,并传入错误信息
    包含错误的类型.错误的信息.错误的追踪信息
  • 注意
    enter 函数应该返回对象自己 
    
    exit函数 可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文中出现异常有用
    如果为True 则意味着,异常以及被处理了 ；False,异常未被处理,程序将中断报错
  • 案例（自己写一个open）

    class MyOpen(object):
        def __init__(self,path):
            self.path = path
    
        def __enter__(self):
            self.file = open(self.path)
            print("enter.....")
            return self
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            print("exit...")
            # print(exc_type,exc_val,exc_tb)
            self.file.close()
            return True
    with MyOpen("a.txt") as m:
        print(m)
        print(m.file.read())
        # "123"+1
    
    m.file.read()
    
    
    '''执行结果
    enter.....
    <__main__.MyOpen object at 0x00000247FFC85978>
    asasasa
    exit...
    
    Traceback (most recent call last):
      File "上下文管理.py", line 20, in <module>
        m.file.read()
    ValueError: I/O operation on closed file.
    '''