多态与多态性，鸭子类型，内置方法，反射，异常处理

一、多态与多态性，鸭子类型

多态指的是一类事物有多种形态，比如动物有多种形态：猫、狗、猪

class Animal: #同一类事物:动物
    def talk(self):
        pass
class Cat(Animal): #动物的形态之一:猫
    def talk(self):
        print('喵喵喵')
class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('汪汪汪')
class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('哼哼哼')

#实例化得到三个对象
>>> cat=Cat()
>>> dog=Dog()
>>> pig=Pig()

多态性指的是可以在不用考虑对象具体类型的情况下而直接使用对象，这就需要在设计时，把对象的使用方法统一成一种：例如cat、dog、pig都是动物,但凡是动物肯定有talk方法，于是我们可以不用考虑它们三者的具体是什么类型的动物,而直接使用

>>> cat.talk()
喵喵喵
>>> dog.talk()
汪汪汪
>>> pig.talk()
哼哼哼

更进一步,我们可以定义一个统一的接口来使用

>>> def Talk(animal):
...     animal.talk()
... 
>>> Talk(cat)
喵喵喵
>>> Talk(dog)
汪汪汪
>>> Talk(pig)
哼哼哼

Python中一切皆对象，本身就支持多态性

# 我们可以在不考虑三者类型的情况下直接使用统计三个对象的长度
s.__len__()
l.__len__()
t.__len__()

# Python内置了一个统一的接口
len(s)
len(l)
len(t)

多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.talk()

>>> class Wolf(Animal): #动物的另外一种形态：狼
...     def talk(self):
...         print('嗷...')
... 
>>> wolf=Wolf() # 实例出一头狼
>>> wolf.talk() # 使用者根本无需关心wolf是什么类型而调用talk

综上我们得知，多态性的本质在于不同的类中定义有相同的方法名，这样我们就可以不考虑类而统一用一种方式去使用对象，可以通过在父类引入抽象类的概念来硬性限制子类必须有某些方法名

import abc

# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
    def talk(self): # 抽象方法中无需实现具体的功能
        pass

class Cat(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
    def talk(self):
        pass

cat=Cat() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

多态性的好处：1、增加了程序的灵活性

​ 2、增加了程序额可扩展性

但其实我们完全可以不依赖于继承，只需要制造出外观和行为相同对象，同样可以实现不考虑对象类型而使用对象，这正是Python崇尚的“鸭子类型”（duck typing）：“如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度，如下

#二者看起来都像文件,因而就可以当文件一样去用，然而它们并没有直接的关系
class Txt: #Txt类有两个与文件类型同名的方法，即read和write
    def read(self):
        pass
    def write(self):
        pass

class Disk: #Disk类也有两个与文件类型同名的方法：read和write
    def read(self):
        pass
    def write(self):
        pass

二、内置方法

1、isinstance(obj,cls)

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

>>>: class Foo:
...       pass

>>>: obj = Foo()

print(isinstance(obj,Foo))     # 打印 True
print(isinstance([1,2,3],list))    #  打印 True

2、issubclass(sub,super)

ssubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo:
    pass

obj = Foo()       # foo类是否是object的子类  ？

print(issubclass(Foo,object))   # 打印 True

3、__str__和 _ del _

__str__方法会在对象被打印时自动触发，print功能打印的就是它的返回值，我们通常基于方法来定制对象的打印信息，该方法必须返回字符串类型

>>> class People:
...     def __init__(self,name,age):
...         self.name=name
...         self.age=age
...     def __str__(self):
...         return '<Name:%s Age:%s>' %(self.name,self.age) #返回类型必须是字符串
... 
>>> p=People('lili',18)
>>> print(p) #触发p.__str__()，拿到返回值后进行打印
<Name:lili Age:18>

__del__会在对象被删除时自动触发。由于Python自带的垃圾回收机制会自动清理Python程序的资源，所以当一个对象只占用应用程序级资源时，完全没必要为对象定制__del__方法，但在产生一个对象的同时涉及到申请系统资源（比如系统打开的文件、网络连接等）的情况下，关于系统资源的回收，Python的垃圾回收机制便派不上用场了，需要我们为对象定制该方法，用来在对象被删除时自动触发回收系统资源的操作

class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __del__(self):  # 不是用__del__删对象，是删对象时，删除命令触发这个方法的运行
        print('===>')

obj = People("egon",19)

del obj  # 在对象obj被删除时，自动触发obj.__del__()
print('======?')

三、反射

python是动态语言，而反射(reflection)机制被视为动态语言的关键。

反射机制指的是在程序的运行状态中

对于任意一个类，都可以知道这个类的所有属性和方法；

对于任意一个对象，都能够调用他的任意方法和属性。

这种动态获取程序信息以及动态调用对象的功能称为反射机制。

class People:
    country = "china"
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def tell_info(self):
        print(self.name,self.age)

obj = People('egon',18)

print(hasattr(obj,"country"))  # 按字符串'country'判读有无属性obj.country

res = getattr(obj,'country')
print(res)    # 用getattr 拿 country 的数据属性，

method = getattr(obj,'tell_info')
method()      # 用 getattr 拿 'tell_info'的 属性，和绑定方法

setattr(obj,"xxx",1111)  # 等同于 obj.xxx = 1111
print(obj.xxx)

delattr(obj,"name")
print(obj.name)     # 等同于 del name

四、异常处理

异常是程序发生错误的信号。程序一旦出现错误，便会产生一个异常，若程序中没有处理它，就会抛出该异常，程序的运行也随之终止。在Python中,错误触发的异常如下

错误分为两种： 1、语法错误 2、逻辑错误

>>> if  
  File "<stdin>", line 1
    if
     ^
SyntaxError: invalid syntax  # 语法错误

# TypeError：数字类型无法与字符串类型相加
1+’2’

# ValueError：当字符串包含有非数字的值时，无法转成int类型
num=input(">>: ") #输入hello
int(num)

# NameError：引用了一个不存在的名字x
x

# IndexError： 索引超出列表的限制
l=['egon','aa']
l[3]                                                      # 逻辑错误

# KeyError：引用了一个不存在的key
dic={'name':'egon'}
dic['age']

# AttributeError：引用的属性不存在
class Foo:
    pass
Foo.x

# ZeroDivisionError：除数不能为0
1/0

异常的种类：

AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的

常用异常

如何处理

语法错误--->程序运行前就必须改正确

逻辑错误 --->针对可以控制的逻辑错误，应该直接在代码层面解决 针对不可以控制的逻辑错误，应该采用try...except...

为了保证程序的健壮性与容错性，即在遇到错误时程序不会崩溃，我们需要对异常进行处理，

如果错误发生的条件是可预知的，我们需要用if进行处理：在错误发生之前进行预防

AGE=10
while True:
    age=input('>>: ').strip()
    if age.isdigit(): #只有在age为字符串形式的整数时,下列代码才不会出错,该条件是可预知的
        age=int(age)
        if age == AGE:
            print('you got it')
            break

如果错误发生的条件是不可预知的，则需要用到try...except：在错误发生之后进行处理

try...execpet一种异常产生之后的补救措施
print('start...')
try:
    被监测的代码块1
    被监测的代码块2
    被监测的代码块3
    被监测的代码块4
    被监测的代码块5
except 异常的类型1 as e:
    处理异常的代码
except 异常的类型2 as e:
    处理异常的代码
except 异常的类型3 as e:
    处理异常的代码
except (异常的类型4,异常的类型5,异常的类型6) as e:
    处理异常的代码
except Exception:   # 万能异常，所有异常都能对上
    处理异常的代码
else:
    没有发生异常时要执行的代码
finally:
    无论异常与否,都会执行该代码，通常用来进行回收资源的操作
print('end...')

···#基本语法为                            % 打补丁操作
try:
    被检测的代码块
except 异常类型：
    try中一旦检测到异常，就执行这个位置的逻辑
#举例
try:
    f=open('a.txt')
    g=(line.strip() for line in f)
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
except StopIteration:
    f.close()

断言 （了解）

断言  #测试场景应用，测试后应删掉断言
l = [111,222]
if len(l) != 3:
    raise Exception('必须达到三个值')  #主动抛出异常
    
或者  assert len(l)  == 3  # 如果断言成功，这行代码等于没有
     print('后续代码。。。')  

raise 主动抛出异常

raise IndexError("索引错误") # 应用场景：订规则时或断言时使用

自定义异常

class Permission(BaseException):   # BaseException内置异常
    def __init__(self,msg):
        self.msg = msg

raise Permission("权限错误")