Python类中方法的调用自己的方法 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 的类，输出正常。