设计模式

设计模式

1.接口类

接口类的实现主要为了接口化，归一化，统一化，就是每个类的方法都是固定的名称
from abc import abstractmethod, ABCMeta

class Payment(metaclass=ABCMeta):
　　"""父类实现的方法加入子类继承了必须实现，否则报错"""
    @abstractmethod
    def pay(self, money):
        pass

class Alipay(Payment):
    def pay(self, money):
        print("支付宝支付%s元"%money)

class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元"%money)

class WechatPay(Payment):
    def pay(self, money):
        print("微信支付%s元"%money)

payment = Alipay()
payment.pay(100)

2.工厂类

from abc import abstractmethod, ABCMeta

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        raise NotImplementedError

class Alipay(Payment):
    def __init__(self, enable_yuebao=False):   #一个支付软件可以有多种的支付方式
        self.enable_yuebao = enable_yuebao

    def pay(self, money):
        if self.enable_yuebao:
            print("余额宝支付%s元" % money)
        else:
            print("支付宝支付%s元" % money)

class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元" % money)

class PaymentFactory:  # 工厂类 封装了对象创建的细节，封装了所有的支付方式，只是提供给用户一个接口
    def create_payment(self, method):
        if method == "alipay":
            return Alipay()      #调用Alipay()      #模式使用支付宝
        elif method == "applepay":
            return ApplePay()
        elif method == "yuebao":
            return Alipay(True)     #调用Alipay()      采用余额宝功能
        else:
            raise NameError(method)

factory = PaymentFactory()            #实例化工厂函数
payment = factory.create_payment("yuebao")      #调用工厂函数的方法
payment.pay(100)                                #根据用户的选择进行支付

3.工厂类的另一种实现方式

from abc import abstractmethod, ABCMeta

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        raise NotImplementedError

class Alipay(Payment):
    def pay(self, money):
        print("支付宝支付%s元" % money)

class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元"%money)

class PaymentFactory(metaclass=ABCMeta):
    @abstractmethod
    def create_payment(self):
        pass

class AlipayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()

class ApplePayFactory(PaymentFactory):
    def create_payment(self):
        return ApplePay()

# 用户输入
# 支付宝，120

af = AlipayFactory()
ali = af.create_payment()
ali.pay(120)

4.抽象工厂

from abc import abstractmethod, ABCMeta


# ------抽象产品------
class PhoneShell(metaclass=ABCMeta):      #生产手机壳的类
    @abstractmethod
    def show_shell(self):
        pass

class CPU(metaclass=ABCMeta):      #生产CPU的类
    @abstractmethod
    def show_cpu(self):
        pass

class OS(metaclass=ABCMeta):            #制作系统的类
    @abstractmethod
    def show_os(self):
        pass

# ------抽象工厂------
class PhoneFactory(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass


# ------具体产品------
class SmallShell(PhoneShell):        #生产小的手机壳
    def show_shell(self):
        print("普通手机小手机壳")

class BigShell(PhoneShell):       #生产大的手机壳
    def show_shell(self):
        print("普通手机大手机壳")

class AppleShell(PhoneShell):    #生产苹果手机壳
    def show_shell(self):
        print("苹果手机壳")

class SnapDragonCPU(CPU):         #生产骁龙cpu
    def show_cpu(self):
        print("骁龙CPU")

class MediaTekCPU(CPU):         #生产联发科cpu
    def show_cpu(self):
        print("联发科CPU")

class AppleCPU(CPU):            #生产苹果cpu
    def show_cpu(self):
        print("苹果CPU")

class Android(OS):          #生产Android系统
    def show_os(self):
        print("Android系统")

class IOS(OS):
    def show_os(self):    #生产ios系统
        print("iOS系统")

# ------具体工厂------
class MiFactory(PhoneFactory):        #这个工厂生产骁龙cpu
    def make_cpu(self):
        return SnapDragonCPU()

    def make_os(self):     #这个工厂制造安卓系统
        return Android()

    def make_shell(self):    #这个手机制造大的手机壳
        return BigShell()

class HuaweiFactory(PhoneFactory):   #华为工厂
    def make_cpu(self):
        return MediaTekCPU()

    def make_os(self):
        return Android()

    def make_shell(self):
        return SmallShell()

class IPhoneFactory(PhoneFactory): #iPhone工厂
    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return IOS()

    def make_shell(self):
        return AppleShell()

# ------客户端------
class Phone:           #生产好的手机信息
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell

    def show_info(self):
        print("手机信息:")
        self.cpu.show_cpu()
        self.os.show_os()
        self.shell.show_shell()

def make_phone(factory):        #生产手机
    cpu = factory.make_cpu()
    os = factory.make_os()
    shell = factory.make_shell()
    return Phone(cpu, os, shell)

p1 = make_phone(IPhoneFactory())    #生产手机（iPhone制造工厂）
p1.show_info()               #展示制造好的手机

5.建造者模式

import random
from abc import abstractmethod, ABCMeta

#------产品------
class Player:
　　"""生产一个玩具，这个玩具有头，胳膊，身体，腿"""
    def __init__(self, face=None, body=None, arm=None, leg=None):
        self.face = face
        self.arm = arm
        self.leg = leg
        self.body = body

    def __str__(self):    #打印生产出来的人看效果
        return "%s, %s, %s, %s" % (self.face, self.arm, self.body, self.leg)

#------建造者------
class PlayerBuilder(metaclass=ABCMeta):
　　"""负责生产人身体上的每个部件"""

    @abstractmethod
    def build_face(self):
        pass
    @abstractmethod
    def build_arm(self):
        pass
    @abstractmethod
    def build_leg(self):
        pass
    @abstractmethod
    def build_body(self):
        pass
    @abstractmethod
    def get_player(self):
        pass

class BeautifulWomanBuilder(PlayerBuilder):
　　"""生产一个漂亮的小女孩"""
    def __init__(self):
        self.player = Player()    #首先实例化工厂类，之后实现里面的每一个功能
    def build_face(self):
        self.player.face = "漂亮脸蛋"
    def build_arm(self):
        self.player.arm="细胳膊"
    def build_body(self):
        self.player.body="细腰"
    def build_leg(self):
        self.player.leg="长腿"
    def get_player(self):
        return self.player

class RandomPlayerBuilder(PlayerBuilder):
　　"""生产一个即漂亮又难看的人"""
    def __init__(self):
        self.player = Player()
    def build_face(self):
        self.player.face = random.choice(["瓜子脸","西瓜子脸"])
    def build_arm(self):
        self.player.arm=random.choice(["长胳膊","短胳膊"])
    def build_body(self):
        self.player.body=random.choice(["苗条","胖"])
    def build_leg(self):
        self.player.leg=random.choice(["长腿","短腿"])
    def get_player(self):
        return self.player

class PlayerDirector:
    def __init__(self, builder):
        self.builder = builder
    # 控制组装顺序
    def build_player(self):
        self.builder.build_body()
        self.builder.build_face()
        self.builder.build_arm()
        self.builder.build_leg()
        return self.builder.get_player()

pd = PlayerDirector(RandomPlayerBuilder())#随机生产一个人并组装好零件
p = pd.build_player()
print(p)       #可以看到你已经造好了一个玩具人了

6.单利模式

from abc import abstractmethod, ABCMeta

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

class MyClass(Singleton):
    def __init__(self, name=None):
        if name is not None:
            self.name = name

a = MyClass("a")
print(a)
print(a.name)

b = MyClass("b")
print(b)
print(b.name)

print(a)
print(a.name)

7.适配器模式

#适配器主要采用加壳的方式实现
from abc import abstractmethod, ABCMeta

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        raise NotImplementedError

class Alipay(Payment):
    def pay(self, money):
        print("支付宝支付%s元"%money)

class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元"%money)

#------待适配类------
class WechatPay:
    def huaqian(self, a, b):
        print("微信支付%s元"%(a+b))

#------类适配器------
class RealWeChatPay(Payment, WechatPay):
    def pay(self, money):
        return self.huaqian(money, 0)

#------对象适配器------
class PayAdapter(Payment):
    def __init__(self, payment):
        self.payment = payment

    def pay(self, money):
        return self.payment.huaqian(money, 0)

#RealWeChatPay().pay(100)
PayAdapter(WechatPay()).pay(1000)

8.混合模式

from abc import abstractmethod, ABCMeta

class Graphic(metaclass=ABCMeta):
    @abstractmethod
    def draw(self):
        pass

    @abstractmethod
    def add(self, graphic):
        pass

    @abstractmethod
    def getchildren(self):
        pass

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

    def draw(self):
        print(self)

    def add(self, graphic):
        raise TypeError

    def getchildren(self):
        raise TypeError

    def __str__(self):
        return "点(%s, %s)" % (self.x, self.y)

class Line(Graphic):
    def __init__(self, p1, p2):
        self.p1 = p1
        self.p2 = p2

    def draw(self):
        print(self)

    def add(self, graphic):
        raise TypeError

    def getchildren(self):
        raise TypeError

    def __str__(self):
        return "线段[%s, %s]" % (self.p1, self.p2)

class Picture(Graphic):
    def __init__(self):
        self.children = []

    def add(self, graphic):
        self.children.append(graphic)

    def getchildren(self):
        return self.children

    def draw(self):
        print("------复合图形------")
        for g in self.children:
            g.draw()
        print("------END------")

pic1 = Picture()
pic1.add(Point(2,3))
pic1.add(Line(Point(1,2), Point(4,5)))
pic1.add(Line(Point(0,1), Point(2,1)))

pic2 = Picture()
pic2.add(Point(-2,-1))
pic2.add(Line(Point(0,0), Point(1,1)))

pic = Picture()
pic.add(pic1)
pic.add(pic2)

pic.draw()

9.代理模式

from abc import ABCMeta, abstractmethod

class Subject(metaclass=ABCMeta):
    @abstractmethod
    def get_content(self):
        pass

class RealSubject(Subject):
    def __init__(self, filename):
        self.filename = filename
        print("读取%s文件内容"%filename)
        f = open(filename)
        self.content = f.read()
        f.close()

    def get_content(self):
        return self.content

    def set_content(self, content):
        f = open(self.filename, 'w')
        f.write(content)
        f.close()

class ProxyA(Subject):
    def __init__(self, filename):
        self.subj = RealSubject(filename)

    def get_content(self):
        return self.subj.get_content()

class ProxyB(Subject):
    def __init__(self, filename):
        self.filename = filename
        self.subj = None

    def get_content(self):
        if not self.subj:
            self.subj = RealSubject(self.filename)
        return self.subj.get_content()

class ProxyC(Subject):
    def __init__(self, filename):
        self.subj = RealSubject(filename)

    def get_content(self):
        return self.get_content()

    def set_content(self):
        raise PermissionError

    # 写一个set_content

b = ProxyB("abc.txt")
#print(b.get_content())

10.责任链模式

from abc import ABCMeta, abstractmethod
#
# class Handler(metaclass=ABCMeta):
#     @abstractmethod
#     def handle_leave(self, day):
#         pass
#
#
# class GeneralManagerHandler(Handler):
#     def handle_leave(self, day):
#         if day < 10:
#             print("总经理批准%d天假"%day)
#         else:
#             print("呵呵")
#
#
# class DepartmentManagerHandler(Handler):
#     def __init__(self):
#         self.successor = GeneralManagerHandler()
#     def handle_leave(self, day):
#         if day < 7:
#             print("部门经理批准%d天假"%day)
#         else:
#             print("部门经理无权准假")
#             self.successor.handle_leave(day)
#
#
# class ProjectDirectorHandler(Handler):
#     def __init__(self):
#         self.successor = DepartmentManagerHandler()
#     def handle_leave(self, day):
#         if day < 3:
#             print("项目主管批准%d天假")
#         else:
#             print("项目主管无权准假")
#             self.successor.handle_leave(day)
#
#
# day = 4
# h = ProjectDirectorHandler()
# h.handle_leave(day)
#

#--高级例子--模仿js事件处理

class Handler(metaclass=ABCMeta):
    @abstractmethod
    def add_event(self, func):
        pass

    @abstractmethod
    def handle(self):
        pass


class BodyHandler(Handler):
    def __init__(self):
        self.func = None

    def add_event(self, func):
        self.func = func

    def handle(self):
        if self.func:
            return self.func()
        else:
            print("已到最后一级，无法处理")


class ElementHandler(Handler):
    def __init__(self, successor):
        self.func = None
        self.successor = successor

    def add_event(self, func):
        self.func = func

    def handle(self):
        if self.func:
            return self.func()
        else:
            return self.successor.handle()

# 客户端

# <body><div><a>

body = {'type': 'body', 'name': 'body', 'children': [], 'father': None}

div = {'type': 'div', 'name': 'div', 'children': [], 'father': body}

a = {'type': 'a', 'name': 'a', 'children': [], 'father': div}

body['children'].append(div)
div['children'].append(a)

body['event_handler'] = BodyHandler()
div['event_handler'] = ElementHandler(div['father']['event_handler'])
a['event_handler'] = ElementHandler(a['father']['event_handler'])

def attach_event(element, func):
    element['event_handler'].add_event(func)

#test

def func_div():
    print("这是给div的函数")

def func_a():
    print("这是给a的函数")

def func_body():
    print("这是给body的函数")

#attach_event(div, func_div)
#attach_event(a, func_a)
#attach_event(body, func_body)

a['event_handler'].handle()

11.迭代器模式

class LinkList:
    """链表 头结点保存链表的长度"""
    class Node:
        def __init__(self, item=None):
            self.item = item
            self.next = None

    class LinkListIterator:
        def __init__(self, node):
            self.node = node
        def __next__(self):
            if self.node:
                cur_node = self.node
                self.node = cur_node.next
                return cur_node.item
            else:
                raise StopIteration
        def __iter__(self):
            return self

    def __init__(self, iterable=None):
        self.head = LinkList.Node(0)
        self.tail = self.head
        self.extend(iterable)

    def append(self, obj):
        s = LinkList.Node(obj)
        self.tail.next = s
        self.tail = s

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)
        self.head.item += len(iterable)

    def __iter__(self):
        return self.LinkListIterator(self.head.next)

    def __len__(self):
        return self.head.item

    def __str__(self):
        return "<<"+", ".join(map(str, self))+">>"

li = [i for i in range(100)]
print(li)
lk = LinkList(li)
# for i in lk:
#     print(i)

print(lk)
# print(len(lk))

12.观察者模式

from abc import ABCMeta, abstractmethod


class Observer(metaclass=ABCMeta):
    @abstractmethod
    def update(self, notice):
        pass


class Notice:
    def __init__(self):
        self.observers = [] # 记录该主体的观察者（订阅者）

    def attach(self, obs):
        self.observers.append(obs)

    def detach(self, obs):
        obs.company_info = None
        self.observers.remove(obs)

    def notify(self):
        for obj in self.observers:
            obj.update(self)


class ManagerNotice(Notice):
    def __init__(self, company_info=None):
        super().__init__()
        self.__company_info = company_info

    @property
    def company_info(self):
        return self.__company_info

    @company_info.setter
    def company_info(self, info):
        self.__company_info = info
        self.notify()



class Manager(Observer):
    def __init__(self):
        self.company_info = None

    def update(self, noti):
        self.company_info = noti.company_info


notice = ManagerNotice()

alex = Manager()
wusir = Manager()

# print(alex.company_info)
# print(wusir.company_info)

notice.attach(alex)
notice.attach(wusir)
#
notice.company_info="公司运行良好"
#
print(alex.company_info)
print(wusir.company_info)
#
notice.detach(wusir)
#
notice.company_info="公司要破产了"

print(alex.company_info)
print(wusir.company_info)

13.策略模式

from abc import ABCMeta, abstractmethod
import random

class Sort(metaclass=ABCMeta):
    @abstractmethod
    def sort(self, data):
        pass


class QuickSort(Sort):
    def quick_sort(self, data, left, right):
        if left < right:
            mid = self.partition(data, left, right)
            self.quick_sort(data, left, mid - 1)
            self.quick_sort(data, mid + 1, right)

    def partition(self, data, left, right):
        tmp = data[left]
        while left < right:
            while left < right and data[right] >= tmp:
                right -= 1
            data[left] = data[right]
            while left < right and data[left] <= tmp:
                left += 1
            data[right] = data[left]
        data[left] = tmp
        return left

    def sort(self, data):
        print("快速排序")
        return self.quick_sort(data, 0, len(data) - 1)


class MergeSort(Sort):
    def merge(self, data, low, mid, high):
        i = low
        j = mid + 1
        ltmp = []
        while i <= mid and j <= high:
            if data[i] <= data[j]:
                ltmp.append(data[i])
                i += 1
            else:
                ltmp.append(data[j])
                j += 1

        while i <= mid:
            ltmp.append(data[i])
            i += 1

        while j <= high:
            ltmp.append(data[j])
            j += 1

        data[low:high + 1] = ltmp


    def merge_sort(self, data, low, high):
        if low < high:
            mid = (low + high) // 2
            self.merge_sort(data, low, mid)
            self.merge_sort(data, mid + 1, high)
            self.merge(data, low, mid, high)

    def sort(self, data):
        print("归并排序")
        return self.merge_sort(data, 0, len(data) - 1)


class Context:
    def __init__(self, data, strategy=None):
        self.data = data
        self.strategy = strategy

    def set_strategy(self, strategy):
        self.strategy = strategy

    def do_strategy(self):
        if self.strategy:
            self.strategy.sort(self.data)
        else:
            raise TypeError


li = list(range(100000))
random.shuffle(li)

context = Context(li, MergeSort())
context.do_strategy()
#print(context.data)

random.shuffle(context.data)

context.set_strategy(QuickSort())
context.do_strategy()

14.模板模式

from abc import ABCMeta, abstractmethod


class IOHandler(metaclass=ABCMeta):
    @abstractmethod
    def open(self, name):
        pass
    @abstractmethod
    def deal(self, change):
        pass
    @abstractmethod
    def close(self):
        pass
    def process(self, name, change):
        self.open(name)
        self.deal(change)
        self.close()

class FileHandler(IOHandler):

15.接口隔离原则

# 有些东西我有你没有，你有我么有，这是就需要用到接口隔离
# from abc import abstractmethod, ABCMeta
#
# class AnimalOnLand(metaclass=ABCMeta):
#     @abstractmethod
#     def walk(self):
#         pass
#
# class AnimalInSky(metaclass=ABCMeta):
#     @abstractmethod
#     def fly(self):
#         pass
#
# class AnimalInWater(metaclass=ABCMeta):
#     @abstractmethod
#     def swim(self):
#         pass
#
# class Tiger(AnimalOnLand):
#     pass
#
# class Frog(AnimalInWater, AnimalOnLand):
#     pass

class A:
    def test(self):
        pass

class B(A):
    pass

class C:
    def __init__(self):
        self.a = A()
        self.a.test()