python之面向对象的继承

面向对象的三大特点：

1、封装 2、继承 3、多态

继承：可以有效的节省代码

示例：

首先定义下面三个子类，把他们的共同特点在定义到一个父类里面，然后每个子类调用父类。

 1 class Animal:
 2     def __init__(self, varieties, sex, color):
 3         self.varieties = varieties
 4         self.sex = sex
 5         self.color = color
 6 
 7 class Cat(Animal):
 8     pass
 9 
10 class Dog(Animal):
11     pass
12 
13 class Pig(Animal):
14     pass
15 
16 cat = Cat('加菲猫', 'male', 'orange')
17 dog = Dog('法国斗牛犬', 'female', 'white')
18 pig = Pig('野猪', 'male', 'black')
19 
20 print(cat.__dict__)
21 # {'varieties': '加菲猫', 'sex': 'male', 'color': 'orange'}
22 
23 print(dog.__dict__)
24 # {'varieties': '法国斗牛犬', 'sex': 'female', 'color': 'white'}
25 
26 print(pig.__dict__)
27 # {'varieties': '野猪', 'sex': 'male', 'color': 'black'}

Animal就是父类

Cat 和Dog以及Pig都属于子类

练习题：把下面相同部分定义一个父类

 1 """
 2 class 猫：
 3     def爬树(self):
 4         print '爬树'
 5 
 6     def 吃(self):
 7         # do something
 8 
 9     def 喝(self):
10         # do something
11 
12     def 拉(self):
13         # do something
14 
15     def 撒(self):
16         # do something
17 
18 class 狗：
19     def 看门(self):
20         print '看门'
21 
22     def 吃(self):
23         # do something
24 
25     def 喝(self):
26         # do something
27 
28     def 拉(self):
29         # do something
30 
31     def 撒(self):
32         # do something
33 """

例子

 1 class livest:
 2     def 吃(self):
 3         print('吃饭')
 4 
 5     def 喝(self):
 6         print('喝水')
 7 
 8     def 拉(self):
 9         print('拉粑粑')
10 
11     def 撒(self):
12         print('撒尿')
13 
14 class 猫(livest):
15     def 爬树(self, name):
16         self.name = name
17         print('%s爬树' % self.name)
18 
19 class 狗(livest):
20     def 看门(self,name):
21         self.name = name
22         print('%s看门' % self.name )
23 
24 cat = 猫()
25 dog = 狗()
26 
27 cat.爬树('阿花')
28 # 阿花爬树
29 
30 print(cat.__dict__)
31 # {'name': '阿花'}
32 
33 cat.吃()
34 # 吃饭
35 
36 cat.喝()
37 # 喝水
38 
39 cat.拉()
40 # 拉粑粑
41 
42 cat.撒()
43 # 撒尿
44 
45 dog.看门('李富贵')
46 # 李富贵看门
47 
48 print(dog.__dict__)
49 # {'name': '李富贵'}
50 
51 dog.吃()
52 # 吃饭
53 
54 dog.喝()
55 # 喝水
56 
57 dog.拉()
58 # 拉粑粑
59 
60 dog.撒()
61 # 撒尿

实现方法

class A:

pass

a = A()

执行结果不报错，为什么呢？？？

因为，在python3.x中，默认的所有类都默认继承一个object的类，又被称为新式类。

在python中，有两种类，新式类和经典类

python2.X中，有经典类和新式类

python3.X中，只有新式类

新式类：遵循广度优先

经典类：遵循深度优先

继承：分为单继承和多继承

继承的执行顺序：如果子类和父类中同时存在了相同的方法，则执行子类里的方法，不会执行父类的方法。

示例：

 1 class Animal:
 2     def __init__(self, varieties, sex, color):
 3         self.varieties = varieties
 4         self.sex = sex
 5         self.color = color
 6     def climb(self):
 7         print('猫会爬树')
 8 
 9 class Cat(Animal):
10     def climb(self):
11         print('阿花在树上')
12 
13 cat1 = Cat('波斯猫', 'male', 'orange')
14 cat1.climb()
15 阿花在树上

如果想同时使用子类和父类相同的方法，则有两种方式：

 1 class Animal:
 2     def __init__(self, varieties, sex, color):
 3         self.varieties = varieties
 4         self.sex = sex
 5         self.color = color
 6     def climb(self):
 7         print('猫会爬树')
 8 
 9 class Cat(Animal):
10     def climb(self):
11         print('阿花在树上')
12 
13 定义一个鸟的类
14 class Bird(Animal):
15     def __init__(self,fly):
16         self.fly = fly
17 
18 cat1 = Cat('波斯猫', 'male', 'orange')
19 b1 = Bird('老鹰', 'female', '黄色', '100KM')  # 这样执行会报错，原因是Bird这个类中只要两个参数，却传了5个参数TypeError: __init__() takes 2 positional arguments but 5 were given，解决办法是在Bird这个类中去将父类中的__init__引用过了

第一种方法：

父类名.方法名(参数)

1 class Bird(Animal):
2     def __init__(self, varieties, sex, color, fly):
3         Animal.__init__(self, varieties, sex, color)
4         self.fly = fly
5 
6 b1 = Bird('老鹰', 'female', '黄色', '100KM/h')
7 print(b1.__dict__) # {'varieties': '老鹰', 'sex': 'female', 'color': '黄色', 'fly': '100KM/h'}

View Code

第二种方法：

super().方法名(参数)

 1 super().方法名(参数)
 2 class Bird(Animal):
 3     def __init__(self, varieties, sex, color, fly):
 4         super().__init__(varieties, sex, color)  # 常用方法
 5         self.fly = fly
 6 
 7 b1 = Bird('老鹰', 'female', '黄色', '100KM/h')
 8 print(b1.__dict__)
 9 {'varieties': '老鹰', 'sex': 'female', 'color': '黄色', 'fly': '100KM/h'}
10 
11 class Cat(Animal):
12     def climb(self):
13         super().climb()
14         print('阿花在树上抓鸟')
15 
16 cat1 = Cat('波斯猫', 'male', 'orange')
17 cat1.climb() # 先执行父类中的‘猫会爬树’ 后执行子类中的‘阿花在树上抓鸟’

View Code

新式类的单继承：

 1 class A:
 2     def test(self):
 3         print('A')
 4 
 5 class B(A):
 6     def test(self):
 7         print('B')
 8 
 9 class C(B):
10     def test(self):
11         print('C')
12 
13 c1 = C()  # 实例化C则先打印C里面的内容，C没有则就去找B，B没有则去找A，如果A还没有的话，则最后找object类
14 print(C.mro())
15 继承顺序：[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

新式类的多继承：

 1 class A:
 2     def test(self):
 3         print('A')
 4 
 5 class B(A):
 6     def test(self):
 7         print('B')
 8 
 9 class C(A):
10     def test(self):
11         print('C')
12 
13 class D(B):
14     def test(self):
15         print('D')
16 
17 class E(C):
18     def test(self):
19         print('E')
20 
21 class F(D,E):
22 
23     def test(self):
24         print('F')
25 
26 print(F.mro())
27 继承顺序：[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

posted on 2018-06-21 18:30 花豆豆阅读(263) 评论(0) 编辑收藏举报