面向对象之多态

一、接口思想

1、接口：建立关联的桥梁，方便管理代码

python中没有接口语法

def jiao(): pass
def chi(): pass
def pao(): pass

# 清晰知道操作的功能，但不明确操作的具体对象
print(len('123'))
# 清晰最大操作的对象，但不明确具体的操作方法
print('123'.__len__())

2、接口类：

用来定义功能的类，为继承它的子类提供功能的，该类的功能方法一般不需要有实现体，实现体有继承它的子类自己去实现

class PetInterface:
    def close_master(self): pass

class WatchInterface:
    def watch_door(self): pass

class Dog(PetInterface, WatchInterface):
    def jiao(self): pass

    def chi(self): pass

    def pao(self): pass

    # 一定要重写接口的方法
    pass

class Cat(PetInterface, WatchInterface): pass

二、抽象类思想

抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类      

抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化)

# python中借助abc来实现抽象父类
import abc  # abstract base class
class Quan(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name
    def run(self):
        print(self.name + 'running')

    # 抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体
    #       -- 抽象父类中的抽象方法实现体就没有意义，实现与不实现都是pass填充
    @abc.abstractmethod
    def chi(self):
        # print(self.name + '肉')
        pass
    @abc.abstractmethod
    def jiao(self):
        # print('汪汪汪')
        pass

    @classmethod
    @abc.abstractmethod
    def fn(cls): pass

class Dog(Quan):
    @classmethod
    def fn(cls): pass

    def kanmen(self):
        print(self.name + '看门')
    def chi(self):
        super().chi()
        print(self.name + '吃狗粮')
    def jiao(self):
        print('汪汪汪')

class Wolf(Quan):
    @classmethod
    def fn(cls): pass

    def bulie(self):
        print(self.name + '捕猎')
    def chi(self):
        print(self.name + '吃肉')
    def jiao(self):
        print('嗷嗷嗷')

dog = Dog('来福')
wolf = Wolf('常委')

dog.jiao()     # 汪汪汪
wolf.jiao()    # 嗷嗷嗷
dog.run()      # 来福running
wolf.run()     # 常委running
dog.chi()      # 来福吃狗粮
wolf.chi()     # 常委吃肉

三、多态

1、定义：对象的多种状态 - 父类对象的多种(子类对象)状态

2、多态的体现：

功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象均可以      

注：一般都是规定需要父类对象，传入子类对象

import abc
class People(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name

    @abc.abstractmethod
    def speak(self): pass

class Chinese(People):
    def speak(self):
        print('说中国话')

class England(People):
    def speak(self):
        print('说英国话')


if __name__ == '__main__':
    # 多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象均可以
    #       注：一般都是规定需要父类对象，传入子类对象
    def ask_someone(obj):
        print('让%s上台演讲' % obj.name)  # 父类提供，自己直接继承
        obj.speak()  # 父类提供，只不过子类重写了

    ch = Chinese('王大锤')
    en = England('Tom')

    ask_someone(ch)     # 让王大锤上台演讲
                        # 说中国话

    ask_someone(en)     # 让Tom上台演讲
                        # 说英国话

四、鸭子类型

1、定义：

①先规定：有什么属性及什么方法的类的类型叫鸭子类型

②这些类实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现

class Test:
    def __init__(self, name):
        self.name = name
    def speak(self):
        print('说鸟语')

if __name__ == '__main__':
    def ask_someone(obj):
        print('让%s上台演讲' % obj.name)      # 需要一个对象，这个对象需要什么特点，有name，有speak，
        obj.speak()                         # 那就制定一个规则，只要有一个对象，它有name属性，speak方法，都叫鸭子
                                            # 规定的规则能随意改变，需要一个什么样的对象，有这样特征的都叫鸭子
    test = Test('鸭子')
                                            # 规定一个对象有什么属性和方法，能提供该属性和方法的对象都叫鸭子
    ask_someone(test)    # 让鸭子上台演讲
                         # 说鸟语

2、例子

# 例：
# 需求：需要一个对象，该对象有name属性及speak方法，就可以作为一种状态的体现被传入
def ask_someone(obj):
    print('让%s上台演讲' % obj.name)
    obj.speak()

# 1.先规定：有什么属性及什么方法的类的类型叫鸭子类型
# 2.这些类实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现
class A:
    # 能有自己特有的属性和方法，可以和B完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
    def __init__(self, name):
        self.name = name

    def speak(self):
        print('说AAAA')

class B:
    # 能有自己特有的属性和方法，可以和A完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
    def __init__(self, name):
        self.name = name

    def speak(self):
        print('说BBBB')

ask_someone(B('B'))           # 让B上台演讲
                              # 说BBBB

五、格式化和析构方法

 1、应用：

class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # ①格式化方法：在外界打印该类对象是被调用
    # 格式化外界直接打印该类对象的字符串表示结果
    def __str__(self):

        return '<name:%s | age:%s>' % (self.name, self.age)

    # ②析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情
    def __del__(self):
        # del会在self代表的对象被消耗的时候被调用
        # 我们可以在析构函数中释放该对象持有的其他资源，
        # 或者将一些持有资源持久化(保存到文件或数据库中)
        del self.name  # 也可以将name存起来

a = A('老王', 88)
print(a, type(a))     # <name:老王 | age:88>   <class '__main__.A'>

import time
time.sleep(3)

print('文件马上执行完毕，a就会被销毁')

2、了解：

class B:
    # 了解：对象.语法的内部实现
    def __setattr__(self, key, value):
        # print(key, value)
        b.__dict__[key] = value
        # b.__dict__[key] = value.lower()
        # b.__dict__['xyz'] = 'XYZ'

    # 了了解：将对象添加属性的方式可以同字典形式
    def __setitem__(self, key, value):
        self.__dict__[key] = value


b = B()
b.name = 'BBB'   # == b.__dict__['name'] = 'BBB'
print(b.name)    # BBB

b['age'] = 18
print(b.age)     # 18  # 访问还是通过.语法访问

六、反射（*****）

1、定义：通过字符串与类和对象的属性(方法)建立关联

2、应用：

class People:
    country = "China"
    
    def __init__(self, name):
        self.name = name

    def tell(self):
        print('%s is aaa' % self.name)

obj = People('egon')

# 1、hasattr(判断'country'是否在People的名称空间里)
print(hasattr(People, 'country'))      # True  # 'country'是否在People的名称空间里
print('country' in People.__dict__)    # True  # 不同的两种方法

print(hasattr(obj, 'name'))            # True
print(hasattr(obj, 'country'))         # True
print(hasattr(obj, 'tell'))            # True

# 2、getattr（查找）
x = getattr(People, 'country')         # China
print(x)
x = getattr(People, 'country1',None)
print(x)                               # None


f = getattr(obj, 'tell', None)
print(f == obj.tell)                 # True
f()                                  # egon is aaa
obj.tell()                           # egon is aaa


# 3、setattr（增值）
People.x = 111
setattr(People, 'x', 111)
print(People.x)                # 111

obj.age = 18
setattr(obj, "age", 18)
print(obj.__dict__)            # {'name': 'egon', 'age': 18}


# 4、delattr（删值）
delattr(People, "country")     # ==del People.country
print(People.__dict__)         # 从People的名称空间中删除了'country'

delattr(obj, "name")           # ==del obj.name
print(obj.__dict__)            # {}   # 删除obj里的’name’后，obj中的名称空间为空

补充：

①__getattr__：在对象获取它没有的属性和方法的时候自动触发 

②__setattr__：在对象点属性设置属性值的时候自动触发

class Demo(object):
    def __init__(self,name):
        self.name = name

    def __getattr__(self, item):
        print('这个对象想获取一个它没有的属性>>>:',item)
        return 123

    def __setattr__(self, key, value):
        print(key, value)

obj = Demo('jason')
obj.password = '123'
print(obj.name)
print(obj.yyy)

# 结果为
# name jason
# password 123
# 这个对象想获取一个它没有的属性>>>: name
# 123
# 这个对象想获取一个它没有的属性>>>: yyy
# 123

3、小练习：

class Foo:
    def run(self):
        while True:
            cmd = input('cmd>>: ').strip()if hasattr(self, cmd):
                func = getattr(self, cmd)
                func()
    def download(self):
        print('download....')

    def upload(self):
        print('upload...')

obj=Foo()
obj.run()
# 结果为
cmd>>: download
download....
cmd>>: upload
upload...

4、总结

# 总结：
# 类的属性用类来操作
# 对象的属性用对象来操作
# 方法建议使用类来操作，得到的方法调用时
#       -- 对象的方法要传入具体的对象
#       -- 类的方法不需要传入参数

class C:
    def fn(self):
        print('fn')

    @classmethod
    def func(cls):
        print('func')

fn = getattr(C, 'fn')
c = C()
fn(c)     # fn

func = getattr(C, 'func')
func()    # func