面向对象(2)__继承多态1

1.简单的继承

class Animal():
    def __init__(self):
        pass
    def run(self):
        print('animal is running')    
class Dog(Animal):
    pass
if __name__ =="__main__":
    dog=Dog()
    dog.run()#输出 animal is running

2.重写父类方法

class Animal():
    def __init__(self):
        pass
    def run(self):
        print('animal is running')    
class Dog(Animal):
    def run(self):
        print('dog is running')
if __name__ =="__main__":
    dog=Dog()
    dog.run()#输出 dog is running

3.多态

要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个 class 的时候，我们实际上就定义了一种数据类型。我们定义的数据类型
和 Python 自带的数据类型，比如 str、list、dict 没什么两样：

a = list() # a 是 list 类型
b = Animal() # b 是 Animal 类型
c = Dog() # c 是 Dog 类型

判断一个变量是否是某个类型可以用 isinstance()判断：

>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True

同时，子类实例也属于父类的类型如：

>>> isinstance(c, Animal)
True

但是，父类实例不属于子类的类型如：

>>> isinstance(b, Dog)
False

多态demo:

class Animal():
    def __init__(self):
        pass
    def run(self):
        print('animal is running')
class Dog(Animal):
    def run(self):
        print('dog is running')

#定义一个函数
def run_twice(animal):
    animal.run()
    animal.run()
if __name__ =="__main__":
    run_twice(Animal()) #传入一个Animal实例  'animal is running'输出两次
    run_twice(Dog())#传入一个Animal子类 Dog实例  'dog is running'输出两次

理解：

接下来可以定义Cat等等各种继承于Animal,不必对 run_twice()做任何修改，任何依赖 Animal 作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态多态的好处就是，当我们需要传入 Dog、Cat、Tortoise……时，我们只需要接收 Animal 类型就可以了，因为 Dog、Cat、Tortoise……都是 Animal类型，然后，按照 Animal 类型进行操作即可。由于 Animal 类型有 run()方法，因此，传入的任意类型，只要是 Animal 类或者子类，就会自动调用实际类型的 run()方法，这就是多态的意思：对于一个变量，我们只需要知道它是 Animal 类型，无需确切地知道它的子类型，就可以放心地调用 run()方法，而具体调用的 run()方法是作用在 Animal、Dog、Cat 还是 Tortoise 对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种 Animal 的子类时，只要确保 run()方法编写正确，不用管原来的代码是如何调用的。

这就是著名的“开闭”原则：

对扩展开放：允许新增 Animal 子类；
对修改封闭：不需要修改依赖 Animal 类型的 run_twice()等函数。

4.动态语言 鸭子类型

动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
在静态语言(如java)中，run_twice(animal)方法中，如果需要传入 Animal 类型的实例，则传入的对象必须是 Animal 类型或者它的子类，否则，将无法调用 run()方法。
但是在动态语言(如python)中，只要我们传入的类型有run()方法,就可以正常调用
举例：我们可以定义一个类

class Animal():
    def __init__(self):
        pass
    def run(self):
        print('animal is running')
class Dog(Animal):
    def run(self):
        print('dog is running')

class TestRun():

  def run(self):

    print('hahhaha')

#定义一个函数
def run_twice(animal):
    animal.run()
    animal.run()
if __name__ =="__main__":
    run_twice(Animal()) #传入一个Animal实例  'animal is running'输出两次
    run_twice(Dog())#传入一个Animal子类 Dog实例  'dog is running'输出两次
　　 run_twice(TestRun())  #只要有run方法  就可以 运行

Python 的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个 read()方法，返回其内容。但是，许多对象，只要有 read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了 read()方法的对象