面向对象

面向对象 - 抽象类/多态: 
    1.抽象类:只能被继承 不能被实例化 
        本质:是一个类 功能就是规范子类 基于继承演变而来的 通过抽象类把子类的标准规范起来  
        好处:降低使用者使用复杂度 统一标准 
        import abc  metaclass=abc.ABCBeta   @abc.abstractmethod  子类必须实现父类规定的方法
    
    2.多态:同一类事物有多种形态:
        eg:动物有多种形态  人 狗 猪
           文件有多种形态  文本文件 可执行文件
        多态的好处:
            多态性:指的是可以在不考虑对象的类型的情况下而直接使用对象
                动态多态性: p.run()
                静态多态性: str int list  可相加+  str+str int+int
        多态性的好处:
            1.增加了程序的灵活性  -- 建立在多态的前提下
　   　         以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
            2.增加了程序的扩展性
     　        通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 　　

import abc
class Animal(metaclass=abc.ABCMeta):  # 同一类事物:动物
    all_type='animal'
    @abc.abstractmethod
    def run(self):
        pass

    @abc.abstractmethod
    def eat(self):
        pass

class People(Animal): # 动物的形态之一:人
    s=123
    def run(self):
        print('people is running')

    def eat(self):
        print('people is eatting')

    def func(self):
        print('----------')

class Pig(Animal): #动物的形态之二:狗
    def run(self):
        print('pig is running')

    def eat(self):
        print('pig is eatting')

# ani = Animal() # 不能实例化
p=People()
# p.run()
# p.func()
# print(p.s,p.all_type)
# pig=Pig()
# pig.run()

# p.run()
# pig.run()

# 不考虑对象的类型的情况下而直接使用对象
def func(animal):
    animal.run()

# func(p)
# func(pig)

面向对象 - 鸭子类型:
    python 崇尚鸭子类型
    鸭子类型: 类与类之间不用共同继承父类,只要做的像同一种事物就ok
        好处: 不继承父类 有共同的方法 给使用者带来直观性
        之后: 使用者可以在不考虑对象类型的情况下 直接使用对象 

class Disk:
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Text:
    def read(self):
        print('text read')

    def write(self):
        print('text write')

disk=Disk()
text=Text()

# disk.read()
# text.write()

# eg:有序序列 list str tuple
li = list([1,2,3])
str=str('hello')
t=tuple(('a','b','c'))

# print(len(li))
# print(len(str))
# print(len(t))

def lens(obj):  # 不考虑对象类型的情况下 直接使用对象
    return obj.__len__()

# print(lens(li))
# print(lens(str))
# print(lens(t))