c调用其他类的方法_python基础进阶-类的继承！

一、类的继承

新建一个类 a，使它继承一个类 b 的所有属性和方法，这个过程就是类的继承。类 b 就是类 a 的父类/基类，类 a 就是类 b 的子类。类 a 在拥有类 b 所有的属性和方法的前提下，也可以自定义自己的属性和方法。我们通过实例来了解一下。

# 实例1

class Dog (object):

# 定义一个 Dog 的类，父类是object，object是所有类的基类。

def __init__(self,type,color):

# 强制绑定参数，type、color

self.type=type

self.color=color

# 赋值给type和color

def call(self):

# 定义Dog的一个方法 call

print('{0} barking...'.format(self.type))

class Husky(Dog):

# 定义 Husky(哈士奇)类，并继承了Dog的类

def eat(self):

# 定义 Husky的eat方法

print('many food')

a=Husky('husky','black')

print(a.type)

print(a.color)

a.call()

a.eat()

>>>

husky

black

husky barking...

many food

# 从a.type 和 a.color 、a.call() 调用输出可以看出，Husky继承了Dog所有的属性和方法，并且Husky有自己的方法a.eat()。

当父类Dog也有一个eat的方法时，类Husky会输出哪个呢？

# 实例2，给Dog父类添加一个方法，并重新调用

def eat(self):

# 此时，Dog有一个eat的方法，Husky也有一个eat的方法

print('eating...')

a=Husky('husky','black')

a.eat()

>>> many food

# Husky调用的是自己的eat方法，说明，子类的方法覆盖了父类相同的方法。

那python能一代一代的继承吗？就是爷爷、爸爸、儿子的这种代代相传的类型？

# 实例3，多级继承

class Person(object):

# 首先定义Person类

def __init__(self,name,age):

# 强制绑定参数

self.name=name

self.age=age

def eat(self):

# 定义Person类的eat方法

print('eating...')

class Student(Person):

# 定义Student类，使之继承Person类

def study(self):

# 定义 Student类的study方法

print('studing...')

class MaleStudent(Student):

# 定义MaleStudent类，并使之继承Student类

def game(self):

# 定义MaleStudent类的game方法

print('gaming...')

a=MaleStudent('zhangsan',18)

print(a.name)

# 输出Person的name属性

print(a.age)

# 输出Person的age属性

a.eat()

# 调用Person的eat方法

a.study()

# 调用Student的study方法

a.game()

# 调用MaleStudent的game方法

>>>

zhangsan

18

eating...

studing...

gaming...

# 结果证明，类是可以一级一级的继承下去，越到下级，拥有的属性和方法越多。

二、鸭子类型

什么叫做鸭子类型？通俗的说，就是如果某个对象形状像鸭子，走的像鸭子，叫声像鸭子，那么就可以称这个对象是鸭子。当然这是通俗的解释，python中的鸭子类型也是这个道理，我们用实例解释一下。

# 实例1

class A(object):

# 定义类 A

def run(self):

# 定义 A 的 run 方法

print('AAA is running...')

class B(A):

# 定义类 B，使之父类为 A

def run(self):

# 定义 B 的 run 方法

print('BBB is running...')

class C(object):

# 定义类 C，使之父类为 object

def run(self):

# 定义类 C 的 run 方法

print('CCC is running...')

class D(object):

# 定义类D，使之父类为 object

def p(self):

# 定义类 D 的 p 方法

print('666')

def fun(var):

# 定义函数 fun，调用传入对象的 run 方法

var.run()

fun(A())

fun(B())

fun(C())

fun(D())

>>>

AAA is running...

BBB is running...

CCC is running...

AttributeError: 'D' object has no attribute 'run'

# A 和 B 属于父类和子类的关系，所以，两个类型是一样的。

# C 和 A、B不是一种类型，但是它有 run 方法，正常的输出了字符串，这就是鸭子类型。

# 但是 D 和 A、B不是一种类型，而且没有 run 方法，输出错误。

鸭子类型有什么好处呢？如上面的那个实例，我们可以利用鸭子类型继续添加其他类，而不需要改变函数 fun 的内容。

# 实例2，继续在实例1的基础上加一个类

class E(object):

def run(self):

print('EEE is running...')

fun(E())

>>> EEE is running...

# 我们并没有修改 fun 函数，直接添加一个 E 的类，输出正常。

进群：960410445 即可获取数十套PDF！