# Python The module is a natural singleton pattern.
# module_name.py
class MySingleton(object):
    def foo(self):
        print('danli')

my_singleton = MySingleton()

# to use
from .module_name import my_singleton
my_singleton.foo()
print(id(my_singleton))

from .module_name import my_singleton
my_singleton.foo()
print(id(my_singleton))

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


# Python2
# class MyClass:
#     __metaclass__ = Singleton


# Python3
class MyClass(metaclass=Singleton):
    pass


one = MyClass()
two = MyClass()

print(id(one))
print(id(two))
print(one == two)
print(one is two)

6. Prototype

Content: Specify the kind of objects created with prototype instances, and create new objects by copying them.

Use scenarios:

• By dynamic loading;
• To avoid creating a factory class hierarchy parallel to the product class hierarchy;
• When an instance of a class can only have one of several different combinations of states.It may be easier to prototype and clone a corresponding number of them than to manually instantiate the class each time in the appropriate state.

import copy


class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        """Register an object"""
        self._objects[name] = obj

    def unregister_object(self, name):
        """Unregister an object"""
        del self._objects[name]

    def clone(self, name, **attr):
        """Clone a registered object and update inner attributes dictionary"""
        obj = copy.deepcopy(self._objects.get(name))
        obj.__dict__.update(attr)
        return obj


def main():
    class A:
        def __str__(self):
            return "I am A"

    a = A()
    prototype = Prototype()
    prototype.register_object('a', a)
    b = prototype.clone('a', a=1, b=2, c=3)

    print(a)
    print(b.a, b.b, b.c)


if __name__ == '__main__':
    main()

Creative Mode Summary

Designs using abstract factories, prototypes, or builders are even more flexible than those using factory methods, but they are also more complex.Typically, design begins with a Factory Method.And when designers find that they need more flexibility, they think about other creation models.When you weigh design criteria against each other, understanding multiple patterns can give you more choices.

Creative Patterns Dependent on Inheritance: Factory Method Patterns

Creative Patterns Dependent on Combination: Abstract Factory Patterns, Creator Patterns

Structural patterns

1. Adapter mode (Adapter Class/Object)

Content: Convert the interface of one class to another that the client wants.Adapter mode allows classes that would otherwise not work together due to incompatible interfaces to work together.
Roles:

• Target Interface
• Classes to be adapted (Adaptee)
• Adapter

Two implementations:

• Class adapters: use multiple inheritance
• Object adapter: using composition

Scenarios applicable:

• You want to use a class that already exists and its interface does not meet your requirements
• (Object Adapter) wants to use some subclasses that already exist, but it is not possible to subclass each to match their interfaces.An object adapter can adapt to its parent interface.

Class adapter:

• Match the Adaptee and Target with a specific Adapter class.The result is that when we want to match a class and all its subclasses, the class Adaptee will not be competent.
• This allows the Adapter to redefine some of the Adaptee's behavior because the Adapter is a subclass of the Adaptee.
• Introducing only one object does not require additional pointers to indirectly get an Adaptee.

Object Adapter:

• Allows an Adapter to work with multiple Adaptees - that is, the Adaptee itself and all its subclasses, if any.The Adapter can also add functionality to all Adaptees at once.
• This makes it difficult to redefine the behavior of the Adaptee.This wine needs to generate a subclass of the Adaptee and have the Adapter reference this subclass instead of the Adaptee itself.

from abc import abstractmethod, ABCMeta


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


class Alipay(Payment):
    def pay(self, money):
        print("Alipay Payment%s element" % money)


class ApplePay(Payment):
    def pay(self, money):
        print("Apple Payment%s element" % money)


# ------Class to be adapted------

class WechatPay:
    def cost(self, money):
        print("WeChat Payment%s element" % money)


# Class Adapter
class RealWechatPay(WechatPay, Payment):
    def pay(self, money):
        return self.cost(money)


# object adapter

class RealWechatPay2(Payment):
    def __init__(self):
        self.payment = WechatPay()

    def pay(self, money):
        return self.payment.cost(money)


p = RealWechatPay2()
p.pay(111)

2. Composite

Content: Groups objects into a tree structure to represent a "part-whole" hierarchy.Combination mode makes the use of individual and combined objects consistent.
Roles:

• Component
• Leaf Component
• Composite
• Client

Scenarios applicable:

• Represents a "part-whole" hierarchy of objects (especially recursive)
• You want users to ignore the difference between a composite object and a single object and use all objects in the composite structure in a unified way

Advantage:

• A class hierarchy containing basic and composite objects is defined
• Simplify client code, that is, clients can consistently use composite and individual objects
• Easier to add new types of components

Disadvantages:

• It is difficult to limit the components in a combination

from abc import abstractmethod, ABCMeta

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

    @abstractmethod
    def add(self, graphic):
        pass

    def getchildren(self):
        pass

# Primitives

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 "spot(%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 "line segment[%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("------Composite Graphics------")
        for g in self.children:
            g.draw()
        print("------END------")


pic1 = Picture()
point = Point(2,3)
pic1.add(point)
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()
#pic1.draw()
#point.draw()

3. Proxy mode

Content: Provides a proxy for other objects to control access to this object.
Roles:

• Abstract entity (Subject)
• Entity (RealSubject)
• Proxy

Scenarios applicable:

• Remote proxy: Provides proxy for remote objects
• Virtual Agent: Create large objects as needed
• Protection Agent: Controls access to the original object when the object has different access rights

Advantage:

• Remote proxy: You can hide the fact that the object is in a remote address space
• Virtual Agent: Optimizable, such as creating objects on demand
• Protection agent: Allows additional internal processing when accessing an object

from abc import ABCMeta, abstractmethod


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

    def set_content(self, content):
        pass


class RealSubject(Subject):
    def __init__(self, filename):
        self.filename = filename
        print("read%s File Content" % 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)
        self.__content = content
        f.close()


# ---Remote Agent

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

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

    def set_content(self, content):
        return self.subj.set_content(content)


# ---Virtual agent

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()


x = ProxyB('abc.txt')
# print(x.get_content())

# ---Protection Agent

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

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

    def set_content(self, content):
        raise PermissionError

# filename = "abc.txt"
# username = input()
# if username!="alex":
#     p = ProxyC(filename)
# else:
#     p = ProxyA(filename)
#
# print(p.get_content())

Behavior patterns

1. Chain of Responsibility

Content: Enables multiple objects to process requests, thereby avoiding coupling between the sender and receiver of the request.Join these objects into a chain and pass the request along the chain until one object processes it.
Roles:

• Handler
• ConcreteHandler
• Client

Example:

• Leave Department approval: leader - > Department Manager - > General Manager
• Javascript Event Floating Mechanism

Scenarios applicable:

• There are multiple objects that can handle a request, and which one is handled by the runtime
• Submit a request to one of multiple objects without an explicit recipient

Advantage:

• Decrease coupling: An object does not need to know which other object handles its request

Disadvantages:

• Request not guaranteed to be received: end of chain not processed or chain configuration error

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("General Manager Approval%d Day Holiday" % day)
            return True
        else:
            print("Ha-ha")
            return False


class DepartmentManagerHandler(Handler):
    def __init__(self):
        self.successor = GeneralManagerHandler()

    def handle_leave(self, day):
        if day < 7:
            print("Approval by Department Manager%d Day Holiday" % day)
            return True
        else:
            print("Department manager is not authorized to grant leave")
            return self.successor.handle_leave(day)


class ProjectDirectorHandler(Handler):
    def __init__(self):
        self.successor = DepartmentManagerHandler()

    def handle_leave(self, day):
        if day < 3:
            print("Project Supervisor Approval%d Day Holiday" % day)
            return True
        else:
            print("Project Supervisor Has No Right to Leave")
            return self.successor.handle_leave(day)


day = 11
h = ProjectDirectorHandler()
print(h.handle_leave(day))

2. Iterator mode

Content: Provides a way to access elements in an aggregated object sequentially without exposing its internal representation.

Scenarios applicable:

• Access the contents of an aggregated object without exposing its internal representation.
• Supports multiple traversals of aggregated objects.
• Provides a unified interface for traversing different aggregation structures (that is, supports polymorphic iteration)

Implementation method: u iter_u, u next_u

class LinkList:
    """Chain Head Node Preserves Chain List Length"""

    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
        self.head.item += 1

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)

    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)]
lk = LinkList(li)
print(lk)

linked list

3. Observer mode

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):
        self.observers.remove(obs)
        # obs.company_info=None

    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

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

    @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 = "The company is running well"

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

notice.company_info = "The company is going public"

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

notice.detach(wusir)

notice.company_info = "The company is going bankrupt. Run fast"

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

notice.company_info = "The company has gone bankrupt"

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

4. Strategy

Content: Define a series of algorithms, encapsulate them one by one, and make them interchangeable.This mode allows the algorithm to change independently of the users who use it.
Roles:

• Strategy
• ConcreteStrategy
• Context

Scenarios applicable:

• Many related classes simply behave differently
• Different variants requiring the use of an algorithm
• The algorithm uses data that the client does not need to know
• Multiple behaviors in a class exist as multiple conditional statements, which can be encapsulated in different policy classes.

Advantage:

• Defines a series of reusable algorithms and behaviors
• Eliminated some conditional statements
• Different implementations of the same behavior can be provided

Disadvantages:

• Customers must understand different strategies
• Communication overhead between policy and context
• Increased number of objects

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("Quick Sort")
        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("Merge Sort")
        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()

5. Template Method

Content: Defines the skeleton of the algorithm in an operation, delaying some steps to subclasses.Template methods allow subclasses to redefine certain steps of an algorithm without changing its structure.
Roles:

• AbstractClass: Defines an abstract atomic operation (hook operation); implements a template method as the framework of the algorithm.
• ConcreteClass: Implement atomic operations

Scenarios applicable:

• Implement the invariant part of an algorithm at once
• Public behavior in each subclass should be extracted and aggregated into a common parent class to avoid code duplication
• Control Subclass Extension

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):
    def open(self, name):
        self.file = open(name, "w")

    def deal(self, change):
        self.file.write(change)

    def close(self):
        self.file.close()


f = FileHandler()
f.process("abc.txt", "Hello World")

Reference:

Twenty-three design patterns and their python implementation - Li Qiongyu

Posted by artied on Fri, 02 Aug 2019 19:40:21 -0700