面向对象之多态

多态

一种事物具有多种不同的状态就是多态。

#举个栗子，
import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal):
    def talk(self):
        print('say hello')

class Dog(Animal):
    def talk(self):
        print('say wangwang')

class Pig(Animal):
    def talk(self):
        print('say aoao')
# 人，狗，猪都属于动物，它们就是动物这个类型的多种状态

在python中，多态就是多个不同类的对象可以响应同一个方法，但产生的结果不尽相同。

多态不是一种特殊的语法，但它一种特性，简单的说就是多个对象有相同的使用方法。这个听起来很熟悉的概念其实就是之前学习到的鸭子类型就是最简单的多态实现。

实现多态

class Chicken:
    def speak(self):
        print('gogogogo')
    def spawn(self):
        print('蛋')

class Duck:
    def speak(self):
        print('gagaga')
    def spawn(self):
        print('蛋')

class Goose:
    def speak(self):
        print('eeee')
    def spawn(self):
        print('蛋')

def manage(obj):  # 设计一个接口，共同的调用方法
    obj.spawn()


a = Chicken()
b = Duck()
c = Goose()
a.speak()
b.speak()
c.speak()
manage(a)
manage(b)
manage(c)

多态的好处：1.增加了程序的灵活性，不管对象怎么变，使用者都是同一种形式去调用。

　　　　　　2.增加了程序的额外可扩展性。

 isinstance和issubclass

#isinstance(obj,cls)检查是否obj是否是类 cls 的对象
class Foo(object):
    pass
class Bar(object):
    pass
obj = Foo()
obj1 = Bar()
print(isinstance(obj,Foo))  # True
print(isinstance(obj,Bar))  # False
# 参数一是要判断的对象，参数二是要判断的类型


# issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object):
    pass
class Bar(Foo):
    pass
class Add(object):
    pass
print(issubclass(Bar,Foo))  # True
print(isinstance(Add,Foo))  # False
#参数一是子类，参数二是父类

__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('tom',20)
print(p)  # 这是一只person对象 name:tom age:20
#__str__  会在对象被转换为字符串时,转换的结果就是这个函数的返回值 
#使用场景:我们可以利用该函数来自定义,对象的是打印格式

__del__

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

#del 使用案例
class FileTool:
    def __init__(self,path):
        self.file = open(path,'rt',encoding='utf-8')
        self.a = 100

    def read(self):
        return self.file.read()

    def __del__(self):
        self.file.close()

tool = FileTool('a.txt')
print(tool.read())

__call__

执行时机：在调用对象时自动执行，（既对象加括号）

class A:
    def __call__(self,*args,**kwargs):
        print('call run')
        print(args)
        print(kwargs)

a = A()
a(1,a = 100)

__slots__

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

class Person:

    __slots__ = ['name']
    def __init__(self,name):
        self.name = name

p = Person('jack')
print(p.name)  #  正常输出jack
print(p.__dict__)  # 报错，不能调用__dict__方法
p.age = 18
print(p.age)  # 报错，不能再添加新的属性了

__setattr__,__delattr__,__getattr__

getattr 用点访问属性的时如果属性不存在时执行
setattr 用点设置属性时
delattr 用del 对象.属性 删除属性时 执行

class A:
    def __getattr__(self,item):
        print('__getattr__')

    def __setattr__(self,key,value):
        print('__setattr__')

    def __delattr__(self,item):
        print('__delattr__')

a = A()
a.xx
# __getattr__只有在使用点调用属性且属性不存在的时候才会触发

a.name ='jack'
#__setattr__添加/修改属性会触发它的执行

a.name ='jack'
del a.name
#__delattr__删除属性的时候会触发

运算符重载

当我们在使用某个符号时，python解释器都会为这个符号定义一个含义，同时调用对应的处理函数，当我们需要自定义对象的比较规则时，皆可以在子类中覆盖大于等于等一系列的方法

class Student(object):
    def __init__(self,name,height,age):
        self.name = name
        self.height = height
        self.age = age

    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.age == other .age and self.height == other.height:
            return True
        return False
stu1 = Student('jack',180,28)
stu2 = Student('jack1',175,27)
print(stu1 > stu2)
#上述代码中,other指的是另一个参与比较的对象。

#大于和小于只要实现一个即可,符号如果不同  解释器会自动交换两个对象的位置 

迭代器协议

由之前的学习内容我们知道，迭代器是指具有__iter__和__next__的对象

我们可以为对象增加这两个方法使对象变成一个迭代器。

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,10,1):
    print(i)

上下文管理

上下文context

这个概念属于语言学科，指的是一段话的意义，要参考当前的场景，即上下文内容。

在python中上下文可以理解为是一个代码区间，一个范围。例如with open打开的文件仅在这个上下文中有效。

在这里会用到__enter__和__exit__这两个方法

enter:表示进入上下文（进入某个场景了），当with语句时，会先执行enter

exit:表示退出上下文（退出某个场景了）,当代码执行完毕后执行exit，或者代码遇到异常会立即执行exit，并传入错误信息，包含错误的类型，错误的信息，错误的追踪信息

class Open:
    def __init__(self,name):
        self.name = name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self,exc_type,exc_val,exc_tb):
        print('with中代码块执行完毕时执行的是我')

with Open('a.txt') as f:
    print('====>执行代码块')

__exit__()中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行。

class Open:
    def __init__(self,name):
        self.name = name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self,exc_type,exc_val,exc_tb):
        print('with中代码块执行完毕时执行的是我')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        # return True   #  如果这里加了这一句，,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行


with Open('a.txt') as f:
    print('====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')
print('1'*5)  #  不会执行，如果上面def__exit__的返回值是True则会执行enter 函数应该返回对象自己。 exit函数 可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文中出现异常有用

enter 函数应该返回对象自己
exit函数 可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文中出现异常有用
如果为True 则意味着,异常以及被处理了，False,异常未被处理,程序将中断报错