no message

Author: ydf0509

结构型模式-mvc模式.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/8 0008 21:23
+"""
+MVC 模式代表 Model-View-Controller（模型-视图-控制器） 模式。这种模式用于应用程序的分层开发。
+
+Model（模型） - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。
+View（视图） - 视图代表模型包含的数据的可视化。
+Controller（控制器） - 控制器作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。
+"""
+from monkey_print2 import print
+
+quotes = ('A man is not complete until he is married. Then he is finished.',
+          'As I said before, I never repeat myself.',
+          'Behind a successful man is an exhausted woman.',
+          'Black holes really suck...', 'Facts are stubborn things.')
+
+
+class QuoteModel:
+
+    def get_quote(self, n):
+        try:
+            value = quotes[n]
+        except IndexError as err:
+            value = 'Not found!'
+        return value
+
+
+class QuoteTerminalView:
+
+    def show(self, quote):
+        print('And the quote is: "{}"'.format(quote))
+
+    def error(self, msg):
+        print('Error: {}'.format(msg))
+
+    def select_quote(self):
+        return input('Which quote number would you like to see?')
+
+
+class QuoteTerminalController:
+
+    def __init__(self):
+        self.model = QuoteModel()
+        self.view = QuoteTerminalView()
+
+    def run(self):
+        valid_input = False
+        while not valid_input:
+            n = self.view.select_quote()
+            try:
+                n = int(n)
+            except ValueError as err:
+                self.view.error("Incorrect index '{}'".format(n))
+            else:
+                valid_input = True
+        quote = self.model.get_quote(n)
+        self.view.show(quote)
+
+
+def main():
+    controller = QuoteTerminalController()
+    while True:
+        controller.run()
+
+if __name__ == '__main__':
+    main()

结构型模式-代理模式.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/8 0008 22:40
+
+"""
+在某些应用中，我们想要在访问某个对象之前执行一个或多个重要的操作，例如，访问敏感
+信息——在允许用户访问敏感信息之前，我们希望确保用户具备足够的权限。操作系统中也存在
+类似的情况，用户必须具有管理员权限才能在系统中安装新程序。
+上面提到的重要操作不一定与安全问题相关。延迟初始化
+是另一个案例：我们想要把一个计算成本较高的对象的创建过程延迟到用户首次真正使用它时
+才进行。
+
+
+
+在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
+
+在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
+"""
+
+
+class SensitiveInfo:
+
+    def __init__(self):
+        self.users = ['nick', 'tom', 'ben', 'mike']
+
+    def read(self):
+        print('There are {} users: {}'.format(len(self.users), ' '.join(self.users)))
+
+    def add(self, user):
+        self.users.append(user)
+        print('Added user {}'.format(user))
+
+
+class Info:
+
+    '''SensitiveInfo的保护代理'''
+
+    def __init__(self):
+        self.protected = SensitiveInfo()
+        self.secret = '0xdeadbeef'
+
+    def read(self):
+        self.protected.read()
+
+    def add(self, user):
+        sec = input('what is the secret? ')
+        self.protected.add(user) if sec == self.secret else print("That's wrong!")
+
+
+def main():
+    info = Info()
+    while True:
+        print('1. read list |==| 2. add user |==| 3. quit')
+        key = input('choose option: ')
+        if key == '1':
+            info.read()
+        elif key == '2':
+            name = input('choose username: ')
+            info.add(name)
+        elif key == '3':
+            exit()
+        else:
+            print('unknown option: {}'.format(key))
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 10:39

行为型模式-命令模式.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 9:29
+"""
+命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。
+
+
+现在多数应用都有撤销操作。虽然难以想象，但在很多年里，任何软件中确实都不存在撤销
+操作。撤销操作是在1974年引入的（请参考网页［t.cn/Rqr3N22］），但Fortran和Lisp分别早在1957
+年和1958年就已创建了撤销操作（请参考网页［t.cn/Rqr3067］），这两门语言仍在被人广泛使用。
+在那些年里，我真心不想使用应用软件。犯了一个错误，用户也没什么便捷方式能修正它。
+"""
+import os
+
+verbose = True
+
+
+class RenameFile:
+
+    def __init__(self, path_src, path_dest):
+        self.src, self.dest = path_src, path_dest
+
+    def execute(self):
+        if verbose:
+            print("[renaming '{}' to '{}']".format(self.src, self.dest))
+        os.rename(self.src, self.dest)
+
+    def undo(self):
+        if verbose:
+            print("[renaming '{}' back to '{}']".format(self.dest, self.src))
+        os.rename(self.dest, self.src)
+
+
+class CreateFile:
+
+    def __init__(self, path, txt='hello world\n'):
+        self.path, self.txt = path, txt
+
+    def execute(self):
+        if verbose:
+            print("[creating file '{}']".format(self.path))
+        with open(self.path, mode='w', encoding='utf-8') as out_file:
+            out_file.write(self.txt)
+
+    def undo(self):
+        delete_file(self.path)
+
+
+class ReadFile:
+
+    def __init__(self, path):
+        self.path = path
+
+    def execute(self):
+        if verbose:
+            print("[reading file '{}']".format(self.path))
+        with open(self.path, mode='r', encoding='utf-8') as in_file:
+            print(in_file.read(), end='')
+
+
+def delete_file(path):
+    if verbose:
+        print("deleting file '{}'".format(path))
+    os.remove(path)
+
+
+def main():
+    orig_name, new_name = 'file1', 'file2'
+
+    commands = []
+    for cmd in CreateFile(orig_name), ReadFile(orig_name), RenameFile(orig_name, new_name):
+        commands.append(cmd)
+
+    [c.execute() for c in commands]
+
+    answer = input('reverse the executed commands? [y/n] ')
+
+    if answer not in 'yY':
+        print("the result is {}".format(new_name))
+        exit()
+
+    for c in reversed(commands):
+        try:
+            c.undo()
+        except AttributeError as e:
+            pass
+
+
+if __name__ == '__main__':
+    main()

行为型模式-模板模式.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 10:28
+"""重要程度 ☆☆☆☆☆
+非常简单自然的一种设计模式，说白了就是继承。策略模式说罢了就是组合。
+配合oop 4步转化公式，所向披靡，适用范围广。
+
+1.场景：
+
+                        1.1 当多个算法或类实现类似或相同逻辑的时候。
+
+                        1.2 在子类中实现算法有助于减少重复代码的时候。
+
+                        1.3 可以让子类利用覆盖实现行为来定义多个算法的时候。
+
+2.目的：
+
+                        2.1 使用基本操作定义算法的框架。
+
+                        2.2 重新定义子类的某些操作，而无需修改算法的结构。
+
+                        2.3 实现代码重用并避免重复工作
+
+                        2.4 利用通用接口或实现
+
+"""
+
+from abc import ABCMeta, abstractmethod
+from monkey_print2 import print
+
+
+# 抽象方法 AbstractClass
+class AbstractClass(metaclass=ABCMeta):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def operation1(self):
+        pass
+
+    @abstractmethod
+    def operation2(self):
+        pass
+
+    def operation3(self):
+        print('操作3')
+
+    #  模板方法 tmplate_method()
+    def template_method(self):
+        print("Defining the Algorithm.Operation1 follows Operation2")
+        self.operation2()
+        self.operation1()
+        self.operation3()
+
+
+# 具体类 ConcreteClass
+class ConcreteClass(AbstractClass):
+    def operation1(self):
+        print("My Concrete Operation1")
+
+    def operation2(self):
+        print("Operation 2 remains same")
+
+
+if __name__ == '__main__':
+    concreate = ConcreteClass()
+    concreate.template_method()
+
+    """
+    "D:/coding2/python36patterns/行为型模式-模板模式.py:47"  10:35:10  Defining the Algorithm.Operation1 follows Operation2
+"D:/coding2/python36patterns/行为型模式-模板模式.py:59"  10:35:10  Operation 2 remains same
+"D:/coding2/python36patterns/行为型模式-模板模式.py:56"  10:35:10  My Concrete Operation1
+"D:/coding2/python36patterns/行为型模式-模板模式.py:43"  10:35:10  操作3
+
+    """

行为型模式-状态模式.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 10:08
+"""
+在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。
+
+在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。
+"""
+
+
+class State(object):
+    """Base state. This is to share functionality"""
+
+    def scan(self):
+        """Scan the dial to the next station"""
+        self.pos += 1
+        if self.pos == len(self.stations):
+            self.pos = 0
+        print("Scanning... Station is", self.stations[self.pos], self.name)
+
+
+class AmState(State):
+    def __init__(self, radio):
+        self.radio = radio
+        self.stations = ["1250", "1380", "1510"]
+        self.pos = 0
+        self.name = "AM"
+
+    def toggle_amfm(self):
+        print("Switching to FM")
+        self.radio.state = self.radio.fmstate
+
+
+class FmState(State):
+    def __init__(self, radio):
+        self.radio = radio
+        self.stations = ["81.3", "89.1", "103.9"]
+        self.pos = 0
+        self.name = "FM"
+
+    def toggle_amfm(self):
+        print("Switching to AM")
+        self.radio.state = self.radio.amstate
+
+
+class Radio(object):
+    """A radio.     It has a scan button, and an AM/FM toggle switch."""
+
+    def __init__(self):
+        """We have an AM state and an FM state"""
+        self.amstate = AmState(self)
+        self.fmstate = FmState(self)
+        self.state = self.amstate
+
+    def toggle_amfm(self):
+        self.state.toggle_amfm()
+
+    def scan(self):
+        self.state.scan()
+
+
+# Test our radio out
+if __name__ == '__main__':
+    radio = Radio()
+    actions = [radio.scan] * 2 + [radio.toggle_amfm] + [radio.scan] * 2
+    actions = actions * 2
+
+    for action in actions:
+        action()
+
+    """
+    Scanning... Station is 1380 AM
+    Scanning... Station is 1510 AM
+    Switching to FM
+    Scanning... Station is 89.1 FM
+    Scanning... Station is 103.9 FM
+    Scanning... Station is 81.3 FM
+    Scanning... Station is 89.1 FM
+    Switching to AM
+    Scanning... Station is 1250 AM
+    Scanning... Station is 1380 AM
+    """

行为型模式-策略模式.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 10:12
+"""重要程度 ☆☆☆☆
+
+策略模式（Strategy pattern）鼓励使用多种算法来解决一个问题，其杀手级特性是能够在运
+行时透明地切换算法（客户端代码对变化无感知）。因此，如果你有两种算法，并且知道其中一
+种对少量输入效果更好，另一种对大量输入效果更好，则可以使用策略模式在运行时基于输入数
+据决定使用哪种算法
+
+以下演示策略类。在python中函数也是一等公民。简单情况下的策略模式将函数本身作为另一个函数/方法的入参即可。
+
+"""
+
+from monkey_print2 import print
+
+# 策略模式
+class Strategy():
+    def process(self):
+        pass
+
+
+class FaultStrategy(Strategy):
+    def process(self):
+        print("fault")
+
+
+class NormalStrategy(Strategy):
+    def process(self):
+        print("normal")
+
+
+class Park():
+    def __init__(self, strategy):
+        self.__strategy = strategy
+
+    def geoProcess(self):
+        self.__strategy.process()
+
+
+if __name__ == '__main__':
+    p = Park(NormalStrategy())
+    p.geoProcess()
+    p = Park(FaultStrategy())
+    p.geoProcess()
+
+    """
+    "D:/coding2/python36patterns/行为型模式-策略模式.py:30"  10:23:25  normal
+"D:/coding2/python36patterns/行为型模式-策略模式.py:25"  10:23:25  fault
+    """

行为型模式-观察者模式-重新实现日志系统.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 9:39
+
+"""重要程度 ☆☆☆
+当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。
+有时，我们希望在一个对象的状态改变时更新另外一组对象。
+
+说这么多抽象的概念，说点具体的就是以日志为例，有人把print当做日志用，里面的区别相当大，日志不仅可以有streamhandler和filehandler，还有mailhandler httphandler 等几亿种自定义handler。logger debug时候自动触发各种handler的emit方法。
+用不会日志不理解日志，对logger addHandler各种handler懵逼不知道在干嘛，最主要是不懂观察者模式造成的。
+希望举得例子是接近真实有意义，下面简单使用观察者模式重新模拟实现一个伪日志包。
+"""
+import abc
+from monkey_print2 import print
+
+
+class AbstractHandler(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def emit(self, record):
+        pass
+
+
+class Logger:
+    def __init__(self, logger_name):
+        self.name = logger_name
+        self.handlers = []
+
+    def add_handler(self, handler):
+        self.handlers.append(handler)
+
+    def log(self, record: str):
+        for hr in self.handlers:
+            hr.emit(f'{self.name} -- {record}')
+
+
+class StreamHandler(AbstractHandler):
+    def emit(self, record):
+        print(f' {record}  控制台打印')
+
+
+class FileHandler(AbstractHandler):
+    def emit(self, record):
+        print(f' {record}  文件写入')  # 只是为了演示写入文件，用print模拟的伪实现。希望要搞清楚这里的目的不是print。
+
+
+class MailHandler(AbstractHandler):
+    def emit(self, record):
+        print(f' {record} 发邮件给某人')  # 只是为了演示发邮件，用print模拟的伪实现。希望要搞清楚这里的目的不是print。
+
+
+class DingdingHandler(AbstractHandler):
+    def emit(self, record):
+        print(f' {record} 钉钉机器人将这句话发给群里')  # 只是为了演示发钉钉机器人消息，用print模拟的伪实现。希望要搞清楚这里的目的不是print。
+
+
+if __name__ == '__main__':
+    logger1 = Logger('a')
+    logger1.add_handler(StreamHandler())
+    logger1.add_handler(FileHandler())
+    logger1.add_handler(MailHandler())
+    logger1.log('啦啦啦啦啦啦')
+
+    logger2 = Logger('b')
+    logger2.add_handler(StreamHandler())
+    logger2.add_handler(DingdingHandler())
+    logger2.log('哈哈哈哈哈哈')
+
+    """
+    可以看到日志非常灵活，可以按需选择几个handler，例如日志a会 控制台打印版 写入文件 发邮件，日志b控制台打印 发钉钉消息。
+    "D:/coding2/python36patterns/行为型模式-观察者模式.py:36"  10:00:19   a -- 啦啦啦啦啦啦  控制台打印
+    "D:/coding2/python36patterns/行为型模式-观察者模式.py:40"  10:00:19   a -- 啦啦啦啦啦啦  文件写入
+    "D:/coding2/python36patterns/行为型模式-观察者模式.py:45"  10:00:19   a -- 啦啦啦啦啦啦 发邮件给某人
+    "D:/coding2/python36patterns/行为型模式-观察者模式.py:36"  10:00:19   b -- 哈哈哈哈哈哈  控制台打印
+    "D:/coding2/python36patterns/行为型模式-观察者模式.py:49"  10:00:19   b -- 哈哈哈哈哈哈 钉钉机器人将这句话发给群里
+    """

行为型模式-解释器模式.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 9:35
+"""
+重要程度 ☆☆
+
+解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。
+
+对每个应用来说，至少有以下两种不同的用户分类。
+ 基本用户：这类用户只希望能够凭直觉使用应用。他们不喜欢花太多时间配置或学习应
+用的内部。对他们来说，基本的用法就足够了。
+ 高级用户：这些用户，实际上通常是少数，不介意花费额外的时间学习如何使用应用的
+高级特性。如果知道学会之后能得到以下好处，他们甚至会去学习一种配置（或脚本）
+语言。
+ 能够更好地控制一个应用
+ 以更好的方式表达想法
+ 提高生产力
+解释器（Interpreter）模式仅能引起应用的高级用户的兴趣。这是因为解释器模式背后的主
+要思想是让非初级用户和领域专家使用一门简单的语言来表达想法。然而，什么是一种简单的语
+言？对于我们的需求来说，一种简单的语言就是没编程语言那么复杂的语言
+"""
+from monkey_print2 import print
+
+
+class PlayContext():
+    play_text = None
+
+
+class Expression():
+    def interpret(self, context):
+        if len(context.play_text) == 0:
+            return
+        else:
+            play_segs = context.play_text.split(" ")
+            for play_seg in play_segs:
+                pos = 0
+                for ele in play_seg:
+                    if ele.isalpha():
+                        pos += 1
+                        continue
+                    break
+                play_chord = play_seg[0:pos]
+                play_value = play_seg[pos:]
+                self.execute(play_chord, play_value)
+
+    def execute(self, play_key, play_value):
+        pass
+
+
+class NormGuitar(Expression):
+    def execute(self, key, value):
+        print("Normal Guitar Playing--Chord:%s Play Tune:%s" % (key, value))
+
+
+if __name__ == "__main__":
+    context = PlayContext()
+    context.play_text = "C53231323 Em43231323 F43231323 G63231323"
+    guitar = NormGuitar()
+    guitar.interpret(context)
+    """
+    "D:/coding2/python36patterns/行为型模式-解释器模式.py:29"  09:37:28  Normal Guitar Playing--Chord:C Play Tune:53231323
+    "D:/coding2/python36patterns/行为型模式-解释器模式.py:29"  09:37:28  Normal Guitar Playing--Chord:Em Play Tune:43231323
+    "D:/coding2/python36patterns/行为型模式-解释器模式.py:29"  09:37:28  Normal Guitar Playing--Chord:F Play Tune:43231323
+    "D:/coding2/python36patterns/行为型模式-解释器模式.py:29"  09:37:28  Normal Guitar Playing--Chord:G Play Tune:63231323
+    """

行为型模式-责任链模式.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 9:24
+
+""" 重要程度 ☆☆
+顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
+
+在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
+
+
+"""
+class Event:
+
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return self.name
+
+
+class Widget:
+
+    def __init__(self, parent=None):
+        self.parent = parent
+
+    def handle(self, event):
+        handler = 'handle_{}'.format(event)
+        if hasattr(self, handler):
+            method = getattr(self, handler)
+            method(event)
+        elif self.parent:
+            self.parent.handle(event)
+        elif hasattr(self, 'handle_default'):
+            self.handle_default(event)
+
+
+class MainWindow(Widget):
+
+    def handle_close(self, event):
+        print('MainWindow: {}'.format(event))
+
+    def handle_default(self, event):
+        print('MainWindow Default: {}'.format(event))
+
+
+class SendDialog(Widget):
+
+    def handle_paint(self, event):
+        print('SendDialog: {}'.format(event))
+
+
+class MsgText(Widget):
+
+    def handle_down(self, event):
+        print('MsgText: {}'.format(event))
+
+
+def main():
+    mw = MainWindow()
+    sd = SendDialog(mw)
+    msg = MsgText(sd)
+
+    for e in ('down', 'paint', 'unhandled', 'close'):
+        evt = Event(e)
+        print('\nSending event -{}- to MainWindow'.format(evt))
+        mw.handle(evt)
+        print('Sending event -{}- to SendDialog'.format(evt))
+        sd.handle(evt)
+        print('Sending event -{}- to MsgText'.format(evt))
+        msg.handle(evt)
+
+if __name__ == '__main__':
+    main()