多态与反射

一、多态

1.什么是多态

多态指的是同一种类型的事物，不同的形态。

例如，猪，狗，猫都是动物，都有叫声这个技能，但是狗是“汪汪汪”，猪是“哼哼哼”，猫是“喵喵喵”。它们之间的叫声不同，也就有了不同的区分

# 动物类
class Animal:

    # 方法 叫
    def speak(self):
        pass
# 猪类
class Pig(Animal):

    def speak(self):
        print('哼哼哼...')


# 猫类
class Cat(Animal):

    def speak(self):
        print('喵喵喵...')


# 狗类
class Dog(Animal):

    def speak(self):
        print('汪汪汪...')


animal1 = Dog()
animal2 = Pig()
animal3 = Cat()

# 让动物们叫起来
animal1.speak()
animal2.speak()
animal3.speak()

2.多态作用

　　“多态” 也称之为 “多态性”，目的是为了 在不知道对象具体类型的情况下，统一对象调用方法的规范（比如:名字）。

多态的表现 “形式之一” 就是继承:
- 先抽象，再继承

父类: 定制一套统一的规范。（比如: 方法名统一）
子类: 遵循父类的统一的规范。（比如: 子类遵循父类方法名的统一）

二、抽象类

在python中不会强制限制子类必须要遵循父类的规范，所以出现了抽象类

1.什么是抽象类

在python内置的abc模块中，有一个抽象类

2.抽象类的作用

让子类必须遵循父类的编写规范

3.怎么实现抽象类

- 父类需要继承abc模块中，metaclass=abc.ABCMeta
- 在父类的方法中，需要装饰上 abc.abstractmethod

注意: 在python中不推荐使用抽象类。

注意: 子类必须按照父类的方法编写规范，缺一不可。（只要父类中有几个抽象方法，子类就必须要定义几个）

import abc

class Animal(metaclass= abc.ABCMeta):
    @abc.abstractmethod
    def eat(self):
        pass

    @abc.abstractmethod
    def speak(self):
        pass


class Dog(Animal):
    def eat(self):
        print('舔')

    def speak(self):
        print('汪汪汪')


dog_obj = Dog()
dog_obj.speak()

三、鸭子类型

1.什么是鸭子类型

不同的对象，只要长得像鸭子，动作行为像鸭子，那它就是鸭子。鸭子类型是多态的一种表现形式。

2.鸭子类型作用

不同对象，先抽象出相同类型的方法，给他们定制一套统一的规范。所有的类，在定义时都按照统一的规范进行编写。降低程序的耦合度。提升了程序的可扩展性

# 猪类
class Pig:
    def eat(self):
        print('bia唧...')

    def speak(self):
        print('哼哼哼...')


# 猫类
class Cat:
    def eat(self):
        print('咬ji 咬ji....')

    def speak(self):
        print('喵喵喵...')


# 狗类
class Dog:
    def eat(self):
        print('舔 ji 舔ji...')

    def speak(self):
        print('汪汪汪...')


def animal_speak(animal):
    animal.speak()


dog = Dog()
pig = Pig()
cat = Cat()
animal_speak(dog)
animal_speak(pig)
animal_speak(cat)

# 自定义统计长度
def my_len(obj):
    return obj.__len__()

str1 = '123456789'
list1 = [1, 2, 3, 4, 5]
print(my_len(str1))
print(my_len(list1))

小结：

- 多态的三种表现形式:
　　- 继承父类 ：
　　　　- 耦合度高，程序的可扩展性低

　　- 继承抽象类：
　　　　- 耦合度极高，程序的可扩展性极低

　　- 鸭子类型:
　　　　- 耦合度低，程序的可扩展性高

注意: 在python中，强烈推荐使用鸭子类型。

四、classmethod 和 staticmethod

classmethod与staticmethod都是python解释器内置的装饰器

1.classmethod

是一个装饰器，给在类内部定义方法中装饰，将类内部的方法变为 “类的绑定方法”。

# classmethod
class DB:
    __data = 'abc'
    def __init__(self, user, pwd):
        self.user = user
        self.pwd = pwd


    @classmethod
    def check(cls, user, pwd):
        obj = cls(user, pwd)
        if obj.user == 'aaa' and obj.pwd == '123':
            print('验证通过...')
            print(cls.__data)

DB.check('aaa', '123')

2.staticmethod

是一个装饰器，给在类内部定义方法中装饰，将类内部的方法变为 “非绑定方法”。

# staticmethod
class Foo:
    @staticmethod
    def print_info(self):
        print(self)

obj = Foo()

# 对象调用非绑定方法
obj.print_info(123)

# 类调用非绑定方法
Foo.print_info(1234)

小结

- 对象的绑定方法:
　　- 由对象来调用，由谁来调用，会将谁(对象)当做第一个参数传入。

- 类的绑定方法:
　　- 由类来调用，由谁来调用，会将谁(类)当做第一个参数传入。

- 非绑定方法:
　　- 可以由对象或类来调用，谁来调用都是一个普通方法(普通函数)，方法需要传入几个参数，就得传入几个。

五、isinstance 和 issubclass

1.isinstance

判断一个对象是否是另一个类的实例。
- 如果是: True，且这个对象也是该类的父类的一个实例
- 如果不是: False

class Foo:
    pass

class Sub(Foo):
    pass

class Oth:
    pass

o_obj = Oth()
s_obj = Sub()

# isinstance
print(isinstance(s_obj, Sub))   # True
print(isinstance(s_obj, Foo))   # True
print(isinstance(s_obj, Oth))   # False

2.issubclass

判断一个类是否是另一个类的子类。
- 如果是: True
- 如果不是: False

class Foo:
    pass

class Sub(Foo):
    pass

class Oth:
    pass

o_obj = Oth()
s_obj = Sub()

# issubclass
print(issubclass(Sub, Foo))     # True
print(issubclass(Sub, Oth))     # False

六、反射

反射指的是通过 “字符串” 对 对象的属性进行操作。

1.hasattr

通过 “字符串” 判断对象的属性或方法是否存在。

2.getattr

 通过 “字符串” 获取对象的属性或方法。

3.setattr

通过 “字符串” 设置对象的属性或方法。

4.delattr

通过 “字符串” 删除对象的属性或方法。

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y

obj = Foo(10, 20)
print(obj.__dict__)

# hasattr
print(hasattr(obj, 'x'))    # True
print(hasattr(obj, 'z'))    # Flase

# getattr
print(getattr(obj, 'x'))    # 10
# 若属性不存在，则返回默认值
print(getattr(obj, 'z', '不存在返回值'))    # 不存在返回值

# setattr
setattr(obj, 'x', 30)
print(obj.__dict__)     # {'x': 30, 'y': 20}
setattr(obj, 'z', '123')
print(obj.__dict__)     # {'x': 30, 'y': 20, 'z': '123'}

# delattr
delattr(obj, 'z')
print(obj.__dict__)     # {'x': 30, 'y': 20}

# 反射应用
class FileControl:

    def run(self):
        while True:
            cmd = input('输入要进行功能(upload ---> 上传   download ---> 下载)：').strip()
            if hasattr(self, cmd):
                func = getattr(self, cmd)
                func()
            else:
                print('输入不合法')

    @staticmethod
    def upload():
        print('上传数据中...')

    @staticmethod
    def download():
        print('下载数据中...')


obj = FileControl()
obj.run()