Python design pattern

• Introduced

Design Patterns are a set of reusable, most known, categorized purposes, code design experience Summary. Design patterns are used in order to reuse code, make code easier for others to understand, and ensure code reliability. There is no doubt that design patterns in others in the system are multi-win, design patterns so that code is truly engineering, design patterns are the cornerstone of software engineering, like a block of bricks and tiles in the building. The rational use of design patterns in the project can solve many problems perfectly, each of which has corresponding principles in the present, each of which describes a recurring problem around us, and the core solution of the problem, which is why it can be widely used.

• Classification

The classic "Design pattern" a book summed up 23 design patterns, these 23 models can be classified as, create, structure and behavior of 3 categories,

creation mode: Easy Factory mode (simple Factory), factory method Mode (Factory Method), abstract Factory mode (abstract Factory), Span style= "font-family: ' Microsoft Yahei '; font-size:16px; " > Creator mode (Builder), prototype mode (Prototype), Span style= "font-family: ' Microsoft Yahei '; font-size:16px; " > single case mode (Singleton).

Structural mode: appearance mode (facade), Adapter Mode (Adapter), Agent Mode (proxy), Decorative Mode (Decorator), Bridge Mode (bridges), combination Mode (Composite), enjoy meta mode (Flyweight).

Behavioral Patterns: Template method mode, observer mode (OBSERVER), State mode (states), Policy mode (strategy), responsibility chain mode (Chain of Responsibility), Command mode, visitor mode (Visitor), Mediator mode (mediator), Memo mode (Memento), iterator mode (Iterator), interpreter mode (interpreter).

• Six principles of model design

1. Opening and closing principle (Open Close Principle)
The open and closed principle is to say to the expansion opening, to modify the closure. When the program needs to expand, can not modify the original code, to achieve a hot plug effect. So a nutshell is: In order to make the program good extensibility, easy to maintain and upgrade. To achieve this, we need to use interfaces and abstract classes, which we will refer to later in the specific design.

2. The principle of substitution on the Richter scale (Liskov Substitution Principle)
One of the fundamental principles of object-oriented design of the Richter substitution principle (Liskov Substitution Principle LSP). The Richter substitution principle says that where any base class can appear, subclasses must be able to appear. LSP is the cornerstone of inheritance reuse, only if the derived class can replace the base class, the function of the Software unit is not affected, the base class can be really reused, and the derived class can also add new behavior on the basis of the base class. The principle of substitution on the Richter scale is a supplement to the principle of "open-closed". The key step in implementing the "open-close" principle is abstraction. The inheritance of the base class and subclass is the concrete implementation of abstraction, so the principle of the substitution of the Richter scale is the specification of the concrete steps to realize the abstraction. --from Baidu Encyclopedia
This is the basis of the open and close principle, the specific content: TRUE interface programming, relying on abstraction and not dependent on the specific.

4. Interface Isolation principle (Interface segregation Principle)
This principle means that using multiple isolated interfaces is better than using a single interface. or a reduction of the coupling between the class meaning, from here we see, in fact, the design pattern is a software design ideas, from the large software architecture, in order to upgrade and maintenance convenience. So there are multiple occurrences: reducing dependency and reducing coupling.

5. Dimitri rule (least known principle) (Demeter Principle)
Why is it called the least known principle, that is to say: an entity should be as small as possible interaction with other entities, so that the system function module is relatively independent.

6. Synthesis multiplexing principle (Composite reuse Principle)
The principle is to use composition/aggregation as much as possible, rather than using inheritance.

• Simple Factory model

Code

#!/usr/bin/env python#-*-coding:utf-8-*-class Shape (object):    def draw (self):        raise Notimplementederrorclass Circle (Shape):    def draw (self):        print (' Draw Circle ') class Square (Shape):    def Draw (self):        print (' Draw Square ') class Rectangle (Shape):    def draw (self):        print (' Draw Rectangle ') class Shapefactory (object):    def create (Self, shape):        if shape = = ' Circle ':            return Circle ()        elif shape = = ' Rectangle ':            return Rectangle ()        else:            return Shape () FAC = shapefactory () obj = fac.create (' Circle ') Obj.draw ()

Advantage: The client does not need to modify the code.

Disadvantage: When you need to add a new operation class, not only need to add the Operation class, but also to modify the factory class, violating the open and closed principle.

• Factory Method Model

Python design pattern