python鸭子类型（多态）抽象基类(abc模块)

什么是多态 
多态，按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。 
多态的目的：就是指不同的对象的，同状态下的，做出的不同表现形式 
python中的鸭子类型 
python中没有多态，但是可以用鸭子类型实现多态。 
鸭子类型主要原因：python中参数是无类型的 
init () 是一个最典型的鸭子类型 ( 多态)

class Cat(object):
    def say(self):
        print("i am a cat")

class Dog(object):
    def say(self):
        print("i am a fish")

class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list

    def __getitem__(self, item):
        return self.employee[item]

    def __len__(self):
        return len(self.employee)

company = Company(["tom", "bob", "jane"])

class Duck(object):
    def say(self):
        print("i am a duck")

animal_list = [Cat, Dog, Duck]
for animal in animal_list:
    animal().say()


dog = Dog()
a = ["bobby1", "bobby2"]

b = ["bobby2", "bobby"]
name_tuple = ["bobby3", "bobby4"]
name_set = set()
name_set.add("bobby5")
name_set.add("bobby6")
a.extend()
print(a)

　　

接口类不能被实例化

在python里没有接口类这种数据类型,没有接口类专门的语法
但是 可以通过继承abc模块实现接口的功能

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):  # 接口类
    @abstractmethod
    def pay(self,money):
        pass
class Wechatpay(Payment):         # 根据接口类的规范编程
    def pay(self,money):
        print('微信支付了%s元'%money)
p = Wechatpay()
p.pay(6)

#我们去检查某个类是否有某种方法
class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list

    def __len__(self):
        return len(self.employee)


com = Company(["bobby1","bobby2"])
print(hasattr(com, "__len__"))


class A:
    pass

class B:
    pass

#我们在某些情况之下希望判定某个对象的类型
from collections.abc import Sized
isinstance(com, Sized)

b = B()
print(isinstance(b, A))
# print(len(com))

#我们需要强制某个子类必须实现某些方法
#实现了一个web框架，集成cache(redis, cache, memorychache)
#需要设计一个抽象基类， 指定子类必须实现某些方法

#如何去模拟一个抽象基类

import abc
from collections.abc import *


class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get(self, key):
        pass

    @abc.abstractmethod
    def set(self, key, value):
        pass
# class CacheBase():
#     def get(self, key):
#         raise NotImplementedError
#     def set(self, key, value):
#         raise NotImplementedError
#
class RedisCache(CacheBase):
    def set(self, key, value):
        pass

# redis_cache = RedisCache()
# redis_cache.set("key", "value")

　　

 

二. 接口隔离原则

from abc import ABCMeta,abstractmethod
class FlyAnimal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        print(11111)

class SwimAnimal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self): pass

class WalkAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self): pass

class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
    # 飞
    def fly(self):pass
    # 游泳
    def swim(self):pass
    # 走
    def walk(self):pass

class Qq(SwimAnimal,WalkAnimal):
    def swim(self):pass
    # 走
    def walk(self):pass

class Bird(FlyAnimal,WalkAnimal):
    # 飞
    def fly(self):pass
    # 走
    def walk(self):pass

Swan()

接口隔离原则

　

三. 抽象类

抽象类 规范一个类的类
在python里 抽象类和接口类 没区别

在java里 有区别
java的接口规定里面的方法一定不能实现(一句代码也不能写)
抽象类 单继承

无论接口类 还是抽象类 其实都是一种面向对象编程的开发规范
只是在接口类或者抽象类中 去约束继承它的子类必须实现某些方法
对于java代码来说:如果发生多继承(类似上面接口隔离原则) 那么一定是接口类 且里面的方法都不能实现
如果在方法里有了实现 那么一定是单继承 的抽象类
但是对于python来说 就没有这些约束
因为python没有接口的概念
对于类的继承 没有多继承的限制
实际上abc模块是帮我实现抽象类的方法,只是我们用它来模仿接口类的效果了

在python中,只要metaclass = ABCMeta 定义了抽象方法(@abctractmethod)
这个类就不能被实例化
你可以说他是一个抽象类