多态和绑定方法

多态

1 什么是多态 : 同一种事物的多种形态(通过继承实现)

class Animal:
    pass

class People(Animal):
    pass

class Dog(Animal):
    pass

class Pig(Animal):
    pass

2 为何要有多态=》多态会带来什么样的特性，多态性

多态性指的是可以在不考虑对象具体类型的情况下而直接使用对象

class Animal: # 统一所有子类的方法
    def say(self):
        print('动物基本的发声频率。。。',end=' ')

class People(Animal):
    def say(self):
        super().say()
        print('嘤嘤嘤嘤嘤嘤嘤')

class Dog(Animal):
    def say(self):
        super().say()
        print('汪汪汪')

class Pig(Animal):
    def say(self):
        super().say()
        print('哼哼哼')

obj1=People()
obj2=Dog()
obj3=Pig()

obj1.say()
obj2.say()
obj3.say()

# 定义统一的接口，接收传入的动物对象
# def animal_say(animal):
#     animal.say()
#
# animal_say(obj1)
# animal_say(obj2)
# animal_say(obj3)

Python中一切皆对象,本身就支持多态性

#我们所用的len方法就是一种多态的体现
print('hello'.__len__())
print([1,2,3].__len__())
print({'a':1,'b':2}.__len__())

def my_len(val):
    return val.__len__()

print(my_len('hello'))
print(my_len([1,2,3]))
print(my_len({'a':1,'b':2}))

len('hello')
len([1,2,3])
len({'a':1,'b':2})

3 总结

多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.talk()

class Wolf(Animal): #动物的另外一种形态：狼
     def talk(self):
         print('嗷...')
 
wolf=Wolf() # 实例出一头狼
wolf.talk() # 使用者根本无需关心wolf是什么类型而调用talk
#嗷...

4 了解

多态性的本质在于不同的类中定义有相同的方法名，这样我们就可以不考虑类而统一用一种方式去使用对象，可以通过在父类引入抽象类的概念来硬性限制子类必须有某些方法名

import abc

class Animal(metaclass=abc.ABCMeta): # 统一所有子类的标准
    @abc.abstractmethod
    def say(self):
        pass

# obj=Animal() # 不能实例化抽象类自己

class People(Animal):
    def say(self):
        pass

class Dog(Animal):
    def say(self):
        pass

class Pig(Animal):
    def say(self):
        pass

#
# obj1=People()
# obj2=Dog()
# obj3=Pig()

5 鸭子类型

Python崇尚的“鸭子类型”（duck typing）：“如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度.就是完全可以不依赖于继承，只需要制造出外观和行为相同对象，同样可以实现不考虑对象类型而使用对象

#例如
class Cpu:
    def read(self):
        print('cpu read')

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

class Mem:
    def read(self):
        print('mem read')

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

class Txt:
    def read(self):
        print('txt read')

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

obj1=Cpu()
obj2=Mem()
obj3=Txt()

obj1.read()
obj1.write()

obj2.read()
obj2.write()

obj3.read()
obj3.write()

绑定方法与非绑定方法

1 绑定方法：

​ 特殊之处在于将调用者本身当做第一个参数自动传入

​ 1、绑定给对象的方法：调用者是对象，自动传入的是对象
​ 2、绑定给类的方法：调用者类，自动传入的是类

#settings.py
IP='127.0.0.1'
PORT=3306
#Mysql.py
import settings

class Mysql:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port

    def func(self):
        print('%s:%s' %(self.ip,self.port))

    @classmethod # 将下面的函数装饰成绑定给类的方法
    def from_conf(cls):
        print(cls)
        return cls(settings.IP, settings.PORT)

# obj1=Mysql('1.1.1.1',3306)

obj2=Mysql.from_conf()
print(obj2.__dict__)

2 非绑定方法 : =>静态方法

没有绑定给任何人：调用者可以是类、对象，没有自动传参的效果

class Mysql:
    def __init__(self,ip,port):
        self.nid=self.create_id()
        self.ip=ip
        self.port=port

    @staticmethod # 将下述函数装饰成一个静态方法
    def create_id():
        import uuid
        return uuid.uuid4()

    @classmethod
    def f1(cls):
        pass

    def f2(self):
        pass
obj1=Mysql('1.1.1.1',3306)

print(Mysql.create_id)
print(obj1.create_id)

print(Mysql.create_id)
print(Mysql.f1)
print(obj1.f2)