python 3.3 对象的的特性 -- 多态

1、多态的适用场景 继承耦合的使用 不推荐

什么是   多态？  同一种事务的多种形态。
在代码内怎么反应出来。

多个子类继承了一个父类，动物有多种状态，，人 狗 猪



class Animal():
    def speak(self):

        print('')


class People(Animal):
    pass


class Pig(Animal):
    pass


class Dog(Animal):
    pass

dog1 = Dog()
dog1.speak()
 父类中功能 ，子类一定有，
 子类如果没有就遗传父类的功能和数据
 子类如果有那就用自己的，那就是覆盖的效果了

这就是多态


特性是什么？？
我们可以在不考虑某一个对象具体类型的前提下，直接使用该对象


class Animal():
    def speak(self):
        print('')


class People(Animal):
    pass
    def speak(self):
        print('人。。。。。')


class Pig(Animal):
    pass
    def speak(self):
        print('猪。。。。。')


class Dog(Animal):
    pass
    def speak(self):
        print('狗。。。。。')


peo1 = People()
dog1 = Dog()
pig1 = Pig()

peo1.speak()
dog1.speak()
pig1.speak()



这3个对象，都是继承了动物的功能和数据，那么他们都有了动物的基本功能

通过上面的代码，还可以看出来，如果我在父类中定义标准的规则，那么子类就可以沿用我父类的标准了，不需要在每一个子类中在加额外的代码。


class Animal():
    def speak(self):
        print('')


class People(Animal):
    pass
    def speak(self):
        print('人。。。。。')


class Pig(Animal):
    pass
    def speak(self):
        print('猪。。。。。')


class Dog(Animal):
    pass
    def speak(self):
        print('狗。。。。。')


peo1 = People()
dog1 = Dog()
pig1 = Pig()

def speak(Animal):  #创建一个函数，功能就是叫， 那么他的传参是Animal，
                    # 只要继承了这个animal类名，那么这个类及子类下实现的所有实例都可以传进来
                    # 当做参数，来实现speak的功能，子类有的按照子类的实现方法调用。
                    # 子类没有的，继承父类的speak功能
    Animal.speak()
speak(peo1)


根据上面的例子，我们看到 父类的作用是什么？ 是不是就是定义统一的标准，让子类沿用这个标准。
多态的核心： 定义标准，让一类的功能统一起来。  归一化，  现在是通过继承实现了归一。
总结
1、多态性是指不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数，
2、向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为。

2、解决多态 父类严格限制子类进化的 使用装饰器限制

父类定制的标准希望子类的进行沿用，但是父类是不能限制子类的进化。

class Animal():
    def speak(self):
        print('1111111')


class People(Animal):
    pass
    def jiao(self):  # 子类就是不遵照父类的标准做
        print('人。。。。。')


class Pig(Animal):
    pass
    def heng(self): # 子类就是不遵照父类的标准做
        print('猪。。。。。')


class Dog(Animal):
    pass
    def wang(self): # 子类就是不遵照父类的标准做
        print('狗。。。。。')


peo1 = People()
dog1 = Dog()
pig1 = Pig()



def func(Animal):
    Animal.speak()


peo1.jiao()
dog1.wang()
pig1.heng()
func(peo1) # 因为子类没有沿用父类的标准，所以找到的功能还是父类的

这样的话，同一种事务的类，就不能统一接口的使用， 麻烦了很多。
所以父类的标准无法限制子类的扩展

如何限制子类？ 加上装饰器 约束子类的功能必须有父类的功能

import abc

class Animal(metaclass=abc.ABCMeta): # 抽象鸡肋
    @abc.abstractmethod
    def speak(self):
       pass

    @abc.abstractmethod
    def run(self):
       pass


class People(Animal):

    def speak(self):
        print('23333')
    def run(self):
        print('23333')



class Pig(Animal):
    pass
    def heng(self):
        print('猪。。。。。')


class Dog(Animal):
    pass
    def wang(self):
        print('狗。。。。。')




peo1 = People()


采用这种加装饰器的方式可以实现限制子类的 ，强制让子类 遵循。

继承的亮点是 1、不让代码冗余，2、让子类的沿用父类的规范，
           但是现在 父类没有冗余代码，子类若沿用父类的规范还是使用装饰器，进行约束。
          而且 父类和子类之间继承，还有耦合的问题。

3、解耦合使用多态

解耦合：  不用继承，所有的类进行约定，统一功能命名

1、多态性是指不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数，
2、向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为

class People():

    def speak(self):
        print('哇哇')
    def run(self):
        print('人 跑')



class Pig():
    def speak(self):
        print('哼哼')
    def run(self):
        print('猪 跑')


class Dog():
    def speak(self):
        print('汪汪')
    def run(self):
        print('dog  跑')


per1=People()
pig1 = Pig()
dog1 = Dog()


def speak(self):
    self.speak()

speak(per1)


这就是duck （鸭子）类型

在同一种事务有相同功能的情况，使用鸭子类型，抛弃了父类繁琐的设置，让调用者更加方便的调用功能。




总结 一切皆对象

鸭子类型 类在 Python中随处可见。
比如 列表的概念


x = [1,2,3,4]

list.append(x,5)
x.append(666)
x.index(0)
x.pop()
x.copy()

print(x)

y = [111,222,33333]
y.append(666)
y.index(0)
y.pop()
y.copy()


是不是不同的对象调用不同的功能 不同的数据类型是不是都有几乎相同的功能 ，都能体现了 鸭子类型 class的存在、


print(type(y))
<class 'list'>  列表也是一个class