python鸭制作类代码_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)

这个类就不能被实例化

你可以说他是一个抽象类