一些面向对象的补充和异常的知识

多重继承

• 在python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类，这个特性是python语言独有的。
• 可以在类名的()后边添加多个类，来实现多重继承
• 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

class A(object):
    def test(self):
        print('我是A')

class B(object):
    def test2(self):
        print('我是B')

class C(A,B):
    pass
# __bases__  可以获取当前所有类的父类  使用C.__bases__
print(C.__bases__)
print(B.__bases__)
print(A.__bases__)
c = C()
c.test()
c.test2()

属性和方法

• 类属性：直接在类中定义的属性 可以通过类或类的实例访问,但类属性只能通过类对象去修改
• 实例属性：通过实例对象添加的属性 只能通过实例对象来访问或修改
• 实例方法：在类中直接定义的，以self为第一个参数开头的都是实例方法。当通过实例对象去调用时实例会自动转化为self，当使用类对象去调用时不会自动转化为self
• 类方法：在创建时需要使用classmethod装饰器，类方法的第一个参数是cls，他也会自动传递，cls就是指当前的类对象。类方法可以通过类或类的实例访问
• 静态方法：在创建时需要使用staticmethod装饰器。静态方法基本上是一个和当前类无关的一个方法，它只是保存在当前类的一个函数。静态方法一般都是一些工具方法，和当前类无关

class A:
    # 类属性
    count = 0

    def __init__(self):
        # 实例属性
        self.name = '老子'

    def test(self):
        print('我是test方法......')

    @classmethod
    def test2(cls):
        print('我是test2方法，我是一个类方法......')

    @staticmethod
    def test3():
        print('我是test3方法，我是一个静态方法......')

a = A()
a.count = 123
A.count = 456
a.name = '庄子'
print(a.count, a.name, A.count)
a.test()
A.test(a)

多态

• 多态是面向对象的三大特性之一。从字面上理解是有多种形态。一个对象可以以不同的形态去呈现
• 一个对象之所以能够通过len()函数获取其长度，这就是多态的体现。多态本质上来说就是不限制对象的具体形态（类型）
• 面向对象的三大属性：
  • 封装 确保对象的安全性
  • 继承 保证了对象的拓展性
  • 多态 保证了程序的灵活性

class A:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name

class B:
    def __init__(self, name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name
class C:
    pass
a = A('老子')
b = B('庄子')
c = C()
# 对于speak这个函数，只要对象中有name属性，它就可以作为参数传递
# 这个函数并不会考虑对象的类型，只要有name属性就可以，那么这个现象就是一个多态的体现
def speak(obj):
    print('你好，我是%s' % obj.name)
# speak(b)
# 在speak2中我们做了一个类型检查，也就是只有o是A类型的对象时，才可以正常使用
# 其他类型的对象无法使用该函数，这个函数就违反了多态
def speak2(o):
    if issubclass(o, A):
        print('你好，我是%s' % o.name)

异常

异常的简介

• 异常：在程序运行当中会不可避免出现一些错误，例如 使用了没有赋值的变量 索引越界，这些错误我们就称之为异常。
• 程序在运行中，出现异常就会立即停止，后面的代码就不会执行了
• 处理异常：程序运行的时候出现异常的目的并不是让我们的程序直接终止，python希望在出现异常的时候，我们编写相应的代码来进行处理。

# try语句
# try：
#   代码（可能出现错误的语句）
# except：
#   代码（出现错误之后处理的方式）
# else：
#   代码（没有出现错误时要执行的语句）

print('嘿嘿')
try:
    print(10/2)
except:
    print('出错了......')
else:
    print('哈哈')
print('哈哈')

异常的传播

• 如果函数中出现了异常，在函数中对异常进行处理了的话异常就不会继续传播
• 如果函数调用处处理了异常，则不再传播异常，如果没有处理则继续向调用处传播。直到传递到全局作用域(主模块)如果依然没有处理，则程序终止，并显示异常信息。
• 当程序运行过程中出现异常以后，所有异常信息会保存到一个异常对象中。而异常传播时，实际上就是异常对象抛给了调用处。这个被我们称之为抛异常。抛异常抛的是异常的对象。

def fn():
    print('hello fn')
    print(10/0)
def fn2():
    print('hello fn2')
    fn()
def fn3():
    print('hello fn3')
    fn2()
fn3()

异常对象

• 当程序运行过程中，出现异常以后，所有的异常信息会保存到一个专门的异常对象当中
• 而异常传播时，实际上就是异常对象抛给了调用处
• 比如 ZeroDivisionError NameError KeyError IndexError…
• except后不跟任何内容，则此时它会捕获所有的异常
• Exception 是所有异常类的父类，所以except后面跟的是Exception 它会捕获所有的异常
• finally语句不管异常十分出现都会执行

print('异常出现前')
try:
    print(10/5)
except Exception as e:
    print('出现异常', e, type(e))
finally:
    print('是否出现异常该语句都会执行')

print('异常出现后')

# try语句
try:
	代码块(可能出现错误的语句)
except 异常类型 as 异常名:
	代码块(出现错误以后的处理⽅式)
except 异常类型 as 异常名:
	代码块(出现错误以后的处理⽅式)
except 异常类型 as 异常名:
	代码块(出现错误以后的处理⽅式)
....
else:
	代码块(没出错时要执⾏的语句)
finally:
	代码块(是否出错该代码块都会执⾏)
# try是必须的 else有没有都可以
# except和finally⾄少有⼀个