多重继承、多态、属性和方法、异常的简介、异常的传播、异常对象

1、多重继承

我使用的是python版本是python3.8,在Python中是支持多重继承的，也就是可以为一个类同时指定多个父亲。

• 可以在类命的（）后边添加多个类，来实现多重继承
• 多重继承会使子类同时拥有多个父类，并且会获取到所有父类中的方法
• 类命.__bases__这个属性可以用来获取当前类的所有父类。

class A:
    def test(self):
        print('我是A类的方法')

class B:
    def test(self):
        print('我是B类的方法')

class C(A,B):
    pass

c=C()
print(C.__base__)
c.test()

#<class '__main__.A'>
#我是A类的方法

拓展：深入了解多重继承

学习的时候本以为多重继承很简单，但网上搜寻资料后发现并不是那么简单，还是挺复杂的。如果要深入了解多重继承要先了解两个原则：
1、深度优先搜索DFS
2、广度优先搜索BFS
话不多说，直接拿出代码：

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

class B(A):
    pass

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

class D(B,C):
    pass

d=D()
print(D.__base__)
d.test()

# <class '__main__.B'>
# 我是C

• D的实例对象d在调用test方法的时候，根据广义优先搜索原则，调用的C类里面方法,所有输出的我是C。
• 如果多个父类中有同名的方法，则会现在第一个父类中寻找，然后找第二个，然后找第三个…，前边会覆盖后边的。

2、多态

2.1、概念：

多态指的是一类事物有多种形态，

2.2、作用

让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。

2.3、特点

• 只关心对象的实例方法是否同名，不关心对象所属的类型；
• 对象所属的类之间，继承关系可有可无；
• 多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；
• 多态是调用方法的技巧，不会影响到类的内部设计。

class A:
    def __init__(self,name):
        self.__name = name
        self.__aaa = 534

    @property
    def name(self):
        return self.__name

 class B(A):
    pass

a=A('ming') #实例化A类
b=B('xiao') #实例化B类

def speak(o):  
'''这个函数并不会考虑对象的类型，只要有name属性就可以，那么这个现象就是一个多态的体现'''
	print('我是%s'%o.name)

speak(a)
speak(b) 

#我是ming
#我是xiao

len()函数之所以一个对象可以通过它获取长度，是因为多态的体现。

3、属性和方法

3.1、类属性

• 类属性，直接在类中定义的属性就是类属性
• 类属性可以通过类或类的实例访问
• 类属性只能通过类对象去修改，无法通过实例对象去修改

class A(onject):
	count = 0 #变量count就是A类的属性

3.2、实例属性

• 实例属性 通过实例对象添加的属性是实例属性
• 实例属性只能通过实例对象来访问和修改，类对象无法访问和修改

class A(object):
	count = 0 #类属性
	def __init__(self):
		self.name = '鸽子' #self.name是实例属性

3.3、实例方法

• 实例方法是在我们类中直接定义的，以self为第一个参数开头的都是实例方法
• 当通过实例对象去调用时，会自动将当前对象作为self传入
• 当通过类调用时，不会自动传递self

class A(object):
	count = 0 #类属性
	
	def __init__(self):
		self.name = '鸽子' #self.name是实例属性
	
	def run(self): #实例方法
		print('%s会飞' %self.name)
		return self.name

3.4、类方法

• 类方法的第一个参数是cls 它也会自动传递，cls就是指当期的类对象
• 类方法可以通过类或类的实例访问

class A(object):
	count = 0 #类属性
	
	def __init__(self):
		self.name = '鸽子' #self.name是实例属性
	
	def run(self): #实例方法
		print('%s会飞' %self.name)
		rerurn self.name
	
	@classmethod
    def test2(cls):
        print('test2方法，类方法')
        return cls.count

a=A()
a.test2()
s=A.test2()
print(s)

#test2方法，类方法
#test2方法，类方法
#0

3.5、静态方法

• 静态方法，通过类直接调用，不需要创建对象，不会隐式传递self。
• 静态方法基本上是一个和当前类无关的一个方法，它只是保存在当前类的一个函数.
• 静态方法一般都是一些工具方法，和当前类无关.

class A:
    count = 20
    name = '狗子'

    def __init__(self):

        self.name = '鸽子'

    def test(self):
        print('%s会飞翔' %self.name)
        return self.name

    @classmethod
    def test2(cls):
        print('test2方法，类方法')
        return cls.count

    @staticmethod
    def test3():
        print('test3方法，也是静态方法')

a=A()
a.test3()
A.test3()

# test3方法，也是静态方法
# test3方法，也是静态方法

3.6、dir()函数

返回模块的属性列表

class A:
    count = 20
    name = '狗子'

    def __init__(self):

        self.name = '鸽子'

    def test(self):
        print('%s会飞翔' %self.name)
        return self.name

print(dir(A))

#['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'count', 'name', 'test']

4、面向对象三大特性

• 封装 确保对象中数据的安全
• 继承 保证了对象的扩展性
• 多态 保证了程序的灵活性

5、异常的简介

在程序运行的过程中会不可避免出现一些错误，这些错误我们就称之为异常。程序在运行过程中，一旦出现异常会导致程序立即终止.在异常后面的代码就不会执行了。

5.1、处理异常

• 程序运行的时候出现异常目的并不是让我们的程序直接终止；Python希望在出现异常的时候，我们编写相应的代码来进行处理。

'''
try:
	代码块(可能出现错误的语句)
except 异常类型 as 异常名:
	代码块(出现错误后处理方式)
except 异常类型 as 异常名:
	代码块(出现错误后处理方式)
...
else:
	代码块(没有出现错误的时要执行的语句)
finlly:
	代码块(该代码块需要执行)
'''
try:
    print(10/0)
except :
    print('出现错误了')
finally:
    print('程序执行完毕')

6、异常的传播

当在函数中出现异常时，如果在函数中对异常进行了处理，则异常不会在进行传播。如果函数中没有对异常进行处理，则异常会继续向函数调用传播。如果函数调用处处理了异常，则不再传播异常，如果没有处理则继续向调用处传播。直到传递到全局作用域(主模块)如果依然没有处理，则程序终止，并显示异常信息。

def fn():
    print(10/0)

def fn1():
    fn()

def fn2():
    fn1()

def fn3():
    fn2()

fn3()

Traceback (most recent call last):
  File "D:/python/mytest/error_example.py", line 19, in <module>
    fn3()
  File "D:/python/mytest/error_example.py", line 17, in fn3
    fn2()
  File "D:/python/mytest/error_example.py", line 14, in fn2
    fn1()
  File "D:/python/mytest/error_example.py", line 11, in fn1
    fn()
  File "D:/python/mytest/error_example.py", line 8, in fn
    print(10/0)

7、异常的对象

当程序运行过程中，出现异常以后，所有的异常信息会保存到一个专门的异常对象当中,而异常传播时，实际上就是异常对象抛给了调用处.

def fn():
    print(10/0)

def fn1():
    fn()

def fn2():
    fn1()

def fn3():
    fn2()

try:
    fn3()
except Exception as e:
    print(e)
   
  #division by zero