no message

Author: ydf0509

行为型模式-中介者模式.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 11:13
+
+"""
+中介者模式(Mediator Pattern):用一个对象来封装一系列的对象交互，中介者使各对象不需要显示地相互引用，从而使耦合松散，而且可以独立地改变它们之间的交互.
+"""
+from monkey_print2 import print
+class ChatRoom:
+    @staticmethod
+    def show_message(user,msg):
+        print(f'{user.name} 说： {msg}')
+
+class User:
+    def __init__(self,name):
+        self.name = name
+
+    def send_msg(self,msg):
+        ChatRoom.show_message(self,msg)
+
+if __name__ == '__main__':
+    user1 = User('小明')
+    user2 = User('小红')
+    user1.send_msg('早上好')
+    user2.send_msg('晚上好')
+
+    """
+    "D:/coding2/python36patterns/行为型模式-中介者模式.py:12"  11:21:04  小明 说： 早上好
+"D:/coding2/python36patterns/行为型模式-中介者模式.py:12"  11:21:04  小红 说： 晚上好
+    """

行为型模式-发布订阅模式.py

@@ -1,3 +1,80 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2019/10/9 0009 10:39
+
+"""重要程度 ☆☆☆
+订阅-发布模式和观察者模式概念相似，但在订阅-发布模式中，订阅者和发布者之间多了一层中间件：一个被抽象出来的信息调度中心。
+
+但其实没有必要太深究 2 者区别，因为《Head First 设计模式》这本经典书都写了：发布+订阅=观察者模式。其核心思想是状态改变和发布通知。在此基础上，根据语言特性，进行实现即可。
+
+对比观察者模式看。23种经典设计模式里面不包括发布订阅设计模式，区别太小。
+"""
+
+class Event:
+    def __init__(self):
+        self.client_list = {}
+
+    def listen(self, key, fn):
+        if key not in self.client_list:
+            self.client_list[key] = []
+        self.client_list[key].append(fn)
+
+    def trigger(self, *args, **kwargs):
+        fns = self.client_list[args[0]]
+
+        length = len(fns)
+        if not fns or length == 0:
+            return False
+
+        for fn in fns:
+            fn(*args[1:], **kwargs)
+
+        return False
+
+    def remove(self, key, fn):
+        if key not in self.client_list or not fn:
+            return False
+
+        fns = self.client_list[key]
+        length = len(fns)
+
+        for _fn in fns:
+            if _fn == fn:
+                fns.remove(_fn)
+
+        return True
+
+
+# 借助继承为对象安装 发布-订阅 功能
+class SalesOffice(Event):
+    def __init__(self):
+        super().__init__()
+
+
+# 根据自己需求定义一个函数：供事件处理完后调用
+def handle_event(event_name):
+    def _handle_event(*args, **kwargs):
+        print("Price is", *args, "at", event_name)
+
+    return _handle_event
+
+
+if __name__ == "__main__":
+    # 创建2个回调函数
+    fn1 = handle_event("event01")
+    fn2 = handle_event("event02")
+
+    sales_office = SalesOffice()
+
+    # 订阅event01 和 event02 这2个事件，并且绑定相关的 完成后的函数
+    sales_office.listen("event01", fn1)
+    sales_office.listen("event02", fn2)
+
+    # 当两个事件完成时候，触发前几行绑定的相关函数
+    sales_office.trigger("event01", 1000)
+    sales_office.trigger("event02", 2000)
+
+    sales_office.remove("event01", fn1)
+
+    # 打印：False
+    print(sales_office.trigger("event01", 1000))

行为型模式-备忘录模式.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 11:22
+
+"""
+备忘录模式
+备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。
+
+介绍
+意图：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
+
+主要解决：所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。
+
+何时使用：很多时候我们总是需要记录一个对象的内部状态，这样做的目的就是为了允许用户取消不确定或者错误的操作，能够恢复到他原先的状态，使得他有"后悔药"可吃。
+
+如何解决：通过一个备忘录类专门存储对象状态。
+
+关键代码：客户不与备忘录类耦合，与备忘录管理类耦合。
+
+应用实例： 1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri + z。 4、IE 中的后退。 4、数据库的事务管理。
+
+优点： 1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。 2、实现了信息的封装，使得用户不需要关心状态的保存细节。
+
+缺点：消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。
+
+使用场景： 1、需要保存/恢复数据的相关状态场景。 2、提供一个可回滚的操作。
+
+注意事项： 1、为了符合迪米特原则，还要增加一个管理备忘录的类。 2、为了节约内存，可使用原型模式+备忘录模式。
+"""
+from monkey_print2 import print
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+
+__author__ = 'Andy'
+"""
+大话设计模式
+设计模式——备忘录模式
+备忘录模式(Memento Pattern):不破坏封装性的前提下捕获一个对象的内部状态，并在该对象之外保存这个状态,这样已经后就可将该对象恢复到原先保存的状态
+"""
+from monkey_print2 import print
+# 发起人类
+class Originator(object):
+
+    def __init__(self, state):
+        self.state = state
+
+    def create_memento(self):
+        return Memento(self.state)
+
+    def set_memento(self, memento):
+        self.state = memento.state
+
+    def show(self):
+        print("当前状态 ", self.state)
+
+# 备忘录类
+class Memento(object):
+
+    def __init__(self, state):
+        self.state = state
+
+# 管理者类
+class Caretaker(object):
+
+    def __init__(self,memento):
+        self.memento = memento
+
+
+
+if __name__ == "__main__":
+    # 初始状态
+    originator = Originator(state='On')
+    originator.show()
+    # 备忘录
+    caretaker = Caretaker(originator.create_memento())
+    # 修改状态
+    originator.state = 'Off'
+    originator.show()
+    # 复原状态
+    originator.set_memento(caretaker.memento)
+    originator.show()

行为型模式-访问者模式.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 11:31
+
+"""
+1。为什么要使用设计模式？
+从理论上来说，设计模式是对程序问题比较好的解决方案。无数的程序员都曾经遇到过这些问题，并且他们使用这些解决方案去处理这些问题。所以当你遇到同样的问题，为什么要去想着创建一个解决方案而不是用现成的并且被证明是有效的呢？
+
+
+
+2。访问者模式解决了什么问题？
+1)对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。
+2)需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作”污染”这些对象的类，也不希望在增加新操作时修改这些类。
+
+
+
+3。访问者模式使用场景
+1)对象结构比较稳定，但经常需要在此对象结构上定义新的操作
+
+2)需要对一个对象结构中的对象进行很多不同的且不相关的操作，而需要避免这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。
+
+比如：访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。
+
+
+
+数据类只提供一个数据处理的接口，而数据类的处理方法我们叫它访问者
+
+下面例子可以实现：安排不同年份的财务报表给不同的角色分析，这就是访问者模式的魅力；访问者模式的核心是在保持原有数据结构的基础上，实现多种数据的处理方法，该方法的角色就是访问者。
+
+
+
+4。访问者模式优点
+1)使得数据结构和作用于结构上的操作解耦，使得操作集合可以独立变化。
+
+2)添加新的操作或者说访问者会非常容易。
+
+3)将对各个元素的一组操作集中在一个访问者类当中。
+
+4)使得类层次结构不改变的情况下，可以针对各个层次做出不同的操作，而不影响类层次结构的完整性。
+
+5)可以跨越类层次结构，访问不同层次的元素类，做出相应的操作。
+6)如果操作的逻辑改变，我们只需要改变访问者的实现就够了，而不用去修改其他所有的商品类。
+
+7)添加新类别的商品到系统变得容易。只需要改变一下访问者接口以及其实现。已经存在的商品类别不会被干扰影响。
+
+
+
+5。访问者模式缺点
+1)增加新的元素会非常困难。
+
+2)实现起来比较复杂，会增加系统的复杂性。
+
+3)破坏封装，如果将访问行为放在各个元素中，则可以不暴露元素的内部结构和状态，但使用访问者模式的时候，为了让访问者能获取到所关心的信息，元素类不得不暴露出一些内部的状态和结构，就像收入和支出类必须提供访问金额和单子的项目的方法一样。
+
+4)visit()方法的返回值的类型在设计系统式就需要明确。不然，就需要修改访问者的接口以及所有接口实现。另外如果访问者接口的实现太多，系统的扩展性就会下降。
+
+"""
+
+
+class Finance:
+    def __init__(self):
+        self.salesvolume = None  # 销售额
+        self.cost = None  # 成本
+        self.history_salesvolume = None  # 历史销售额
+        self.history_cost = None  # 历史成本
+
+    def set_salesvolume(self, value):
+        self.salesvolume = value
+
+    def set_cost(self, value):
+        self.cost = value
+
+    def set_history_salesvolume(self, value):
+        self.history_salesvolume = value
+
+    def set_history_cost(self, value):
+        self.history_cost = value
+
+    def accept(self, visitor):
+        pass
+
+
+# 2018年的财务情况
+class Finance_year(Finance):
+    def __init__(self, year):
+        Finance.__init__(self)
+        self.analyst = []
+        self.year = year
+
+    def add_analyst(self, worker):  # 有哪些分析师来分析数据
+        self.analyst.append(worker)
+
+    def accept(self):  # 分析师列表里面的人去分析数据
+        for v in self.analyst:
+            v.visit(self)
+
+
+# 会计
+class Accounting:
+    def __init__(self):
+        self.id = '会计'
+        self.Duty = '计算报表'
+
+    def visit(self, year_data):
+        print('我现在分析的是{}年的数据'.format(year_data.year))
+        print('我的身份是:{}，职责：'.format(self.id, self.Duty))
+        print('本年度纯利润:{}'.format(year_data.salesvolume - year_data.cost))
+        print('---------------------------------------')
+
+
+# 财务总监
+class Audit:
+    def __init__(self):
+        self.id = '财务总监'
+        self.Duty = '分析业绩'
+
+    def visit(self, year_data):  # 要把具体哪一年的数据传给分析师，让分析师去分析
+        print('我现在分析的是{}年的数据'.format(year_data.year))
+        print('我的身份是:{}，职责：'.format(self.id, self.Duty))
+        if year_data.salesvolume - year_data.cost > year_data.history_salesvolume - year_data.history_cost:
+            msg = '较同期上涨'
+        else:
+            msg = '较同期下跌'
+        print('本年度公司业绩:{}'.format(msg))
+        print('---------------------------------')
+
+
+# 战略顾问
+class Advisor:
+    def __init__(self):
+        self.id = '战略顾问'
+        self.Duty = '制定明年策略'
+
+    def visit(self, year_data):
+        print('我现在分析的是{}年的数据'.format(year_data.year))
+        print('我的身份是:{}，职责：'.format(self.id, self.Duty))
+        if year_data.salesvolume > year_data.history_salesvolume:
+            msg = '行业上涨，扩大规模'
+        else:
+            msg = '行业下跌，减少规模'
+        print('本年度公司业绩:{}'.format(msg))
+        print('------------------------------')
+
+
+# 执行分析
+class AnalyseData:
+    def __init__(self):
+        self.datalist = []  # 需要处理的数据列表,
+
+    def add_data(self, year_data):
+        self.datalist.append(year_data)
+
+    def remove_data(self, year_data):
+        self.datalist.remove(year_data)
+
+    def visit(self):
+        for d in self.datalist:
+            d.accept()
+
+
+if __name__ == '__main__':
+    w = AnalyseData()  # 计划安排财务，总监，顾问对2018年数据处理
+    finance_2018 = Finance_year(2018)  # 2018年的财务数据
+    finance_2018.set_salesvolume(200)
+    finance_2018.set_cost(90)
+    finance_2018.set_history_salesvolume(190)
+    finance_2018.set_history_cost(80)
+
+    accounting = Accounting()
+    audit = Audit()
+    advisor = Advisor()
+
+    finance_2018.add_analyst(accounting)  # 会计参与2018年的数据分析，然后执行了自己的visit方法
+    finance_2018.add_analyst(audit)
+    finance_2018.add_analyst(advisor)
+
+    # finance_2018.accept()   #也可以直接这样调用
+    w.add_data(finance_2018)
+    w.visit()

行为型模式-迭代器模式-使用类.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 11:49
+
+class AccountIterator():
+    def __init__(self, accounts):
+        self.accounts = accounts  # 账户集合
+        self.index = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.index >= len(self.accounts):
+            raise StopIteration("到头了...")
+        else:
+            self.index += 1
+            return self.accounts[self.index - 1]
+
+
+if __name__ == '__main__':
+    account_iter = AccountIterator(['a','b','c','d'])
+    print(next(account_iter))
+    print('----')
+    for a in account_iter:
+        print(a)

行为型模式-迭代器模式.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 11:39
+"""
+迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。
+
+迭代器模式属于行为型模式。
+
+介绍
+意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。
+
+主要解决：不同的方式来遍历整个整合对象。
+
+何时使用：遍历一个聚合对象。
+
+如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。
+
+关键代码：定义接口：hasNext, next。
+
+应用实例：JAVA 中的 iterator。
+
+优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
+
+缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
+
+使用场景： 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。
+
+注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。
+
+python有更pythonic的方式。
+"""
+
+from abc import ABCMeta, abstractmethod
+
+class Iterator(metaclass=ABCMeta):
+
+    @abstractmethod
+    def hasNext(self):
+        pass
+
+    @abstractmethod
+    def next(self):
+        pass
+
+class ConcreteIterator(Iterator):
+
+    def __init__(self, alist):
+        self.alist = alist
+
+    def hasNext(self):
+        '''是否还有下一个元素'''
+        return self.alist != []
+
+    def next(self):
+        '''返回下一个元素'''
+        return self.alist.pop(0)
+
+
+class Aggregate(object):
+
+    def iterator(self):
+        pass
+
+class ConcreteAggregate(Aggregate):
+
+    def __init__(self, alist):
+        self.alist = alist
+
+    def iterator(self):
+        '''返回迭代器对象'''
+        return ConcreteIterator(self.alist)
+
+
+if __name__ == "__main__":
+    concreteAggregate = ConcreteAggregate([1, 2, 3])
+    concreteIterator = concreteAggregate.iterator()
+    while concreteIterator.hasNext():
+        print (concreteIterator.next())

行为型模式-迭代器模式3.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 11:56
+
+from __future__ import print_function
+
+
+def count_to(count):
+    """Counts by word numbers, up to a maximum of five"""
+    numbers = ["one", "two", "three", "four", "five"]
+    for number in numbers[:count]:
+        yield number
+
+
+# Test the generator
+count_to_two = lambda: count_to(2)
+count_to_five = lambda: count_to(5)
+
+
+if __name__ == "__main__":
+    for number in count_to_two():
+        print(number)
+
+
+    for number in count_to_five():
+      print(number)