Introduction to the python version of the simple factory pattern

This article mainly introduces the Python version of the simple factory pattern in detail, which has certain reference value. Interested friends can refer to it

What is the simple factory pattern

The factory pattern has a very vivid description. The class that creates the object is like a factory, and the objects that need to be created are products; the products are processed in the factory, and the people who use the products do not need to care about the product. How it is produced. From a software development perspective, this effectively reduces the coupling between modules.
The function of a simple factory is to instantiate objects without requiring the client to know which specific subclass the object belongs to. The classes instantiated by a simple factory have the same interface or base class. When the subclass is relatively fixed and does not need to be extended, a simple factory can be used. For example, the database production factory is an application of simple factory
The advantage of using simple factory is that it allows users to obtain corresponding class instances according to parameters, avoiding direct instantiation of classes and reducing coupling; the disadvantage is that instantiable types are It has been determined during compilation that if a new type is added, the factory needs to be modified, which does not comply with the principle of OCP (Open-Closed Principle). A simple factory needs to know all the types to be generated and is not suitable for use when there are too many subclasses or too many levels of subclasses.

Simple Factory Pattern Implementation

Consider an example from "Dahua Design Pattern" below:
Title: Use any object-oriented language to implement A calculator console program. It requires inputting two numbers and operation symbols to get the result.

Question analysis:

The program should be: (1) maintainable; (2) reusable; (3) extensible; (4) flexible.
Maintainable: This means that if the code is changed in one place, it cannot cause a chain reaction and cannot affect other places.
Reusable: Minimize repetitive code.
Extensible: If you want to expand new functions and new businesses, you only need to add new classes, without affecting existing classes and logic. Plug-in applications.
Object-oriented key points:
The three major characteristics of object-oriented: encapsulation, inheritance, and polymorphism.
Reduce program coupling through encapsulation, inheritance, and polymorphism.
Business logic and interface logic are separated.

Class structure diagram:

##Code implementation:

1. First , figure out the parts of the business that are prone to change. In this application, it is required to calculate the operation result of two numbers, so what kind of operation needs to be performed is a part that is prone to change. For example, we only want to implement addition, subtraction, multiplication and division operations now, and later we want to add root root or remainder operations. So how to deal with the changes brought about by this demand. When designing a program, the maintainability, scalability, code reusability, flexibility, etc. of the program should be taken into consideration.

2. For example, this arithmetic unit only has four operations: addition, subtraction, multiplication and division. First, create an Operation class. This class is the parent class of various specific operation classes (addition, subtraction, multiplication, and division). It mainly accepts values ​​entered by users. The class is as follows:

class Operation(): 
  def __init__(self,NumberA=0,NumberB=0): 
    self.NumberA = NumberA 
    self.NumberB = NumberB 
 
  def GetResult(self): 
    pass

3. Then there are the specific operation classes: Add, Sub, Mul, p. They all inherit the Operation class and override the getResult() method. In this way, polymorphism can be used to reduce the coupling of different business logics, and modifications to any one operation class will not affect other operation classes. The code of the specific class is as follows:

class AddOp(Operation): 
  def GetResult(self): 
    return self.NumberB + self.NumberA 
 
class MinusOp(Operation): 
  def GetResult(self): 
    return self.NumberA - self.NumberB 
 
class MultiOp(Operation): 
  def GetResult(self): 
    return self.NumberA * self.NumberB 
 
class pideOp(Operation): 
  def GetResult(self): 
    try: 
      return 1.0*self.NumberA / self.NumberB 
    except ZeropisionError: 
      raise

4. So how do I let the calculator know which operation I want to use? In other words, which specific operation class should be instantiated, Add? Sub? Mul? p? At this time, you should consider using a separate class to do the process of creating specific instances. This class is the factory class. As follows:

class OperationFatory(): 
  def ChooseOperation(self,op): 
    if op == '+': 
      return AddOp() 
    if op == '-': 
      return MinusOp() 
    if op == '*': 
      return MultiOp() 
    if op == '/': 
      return pideOp()

5. In this way, the user only needs to enter the operator, and the factory class can create the appropriate instance, which is returned to the parent class through polymorphism. way to achieve the operation results. The client code is as follows:

if __name__ == '__main__': 
  ch = '' 
  while not ch=='q':  
    NumberA = eval(raw_input('Please input number1: ')) 
    op = str(raw_input('Please input the operation: ')) 
    NumberB = eval(raw_input('Please input number2: ')) 
    OPFactory = OperationFatory() 
    OPType = OPFactory.ChooseOperation(op) 
    OPType.NumberA = NumberA 
    OPType.NumberB = NumberB 
    print 'The result is:',OPType.GetResult() 
    print '\n#-- input q to exit any key to continue' 
    try: 
      ch = str(raw_input()) 
    except: 
      ch = ''

The full version code is as follows:

# -*-coding:UTF-8-*-  
from abc import ABCMeta,abstractmethod 
 
class Operation(): 
  def __init__(self,NumberA=0,NumberB=0): 
    self.NumberA = NumberA 
    self.NumberB = NumberB 
 
  def GetResult(self): 
    pass 
 
class AddOp(Operation): 
  def GetResult(self): 
    return self.NumberB + self.NumberA 
 
class MinusOp(Operation): 
  def GetResult(self): 
    return self.NumberA - self.NumberB 
 
class MultiOp(Operation): 
  def GetResult(self): 
    return self.NumberA * self.NumberB 
 
class pideOp(Operation): 
  def GetResult(self): 
    try: 
      return 1.0*self.NumberA / self.NumberB 
    except ZeropisionError: 
      raise 
 
class OperationFatory(): 
  def ChooseOperation(self,op): 
    if op == '+': 
      return AddOp() 
    if op == '-': 
      return MinusOp() 
    if op == '*': 
      return MultiOp() 
    if op == '/': 
      return pideOp() 
 
if __name__ == '__main__': 
  ch = '' 
  while not ch=='q':  
    NumberA = eval(raw_input('Please input number1: ')) 
    op = str(raw_input('Please input the operation: ')) 
    NumberB = eval(raw_input('Please input number2: ')) 
    OPFactory = OperationFatory() 
    OPType = OPFactory.ChooseOperation(op) 
    OPType.NumberA = NumberA 
    OPType.NumberB = NumberB 
    print 'The result is:',OPType.GetResult() 
    print '\n#-- input q to exit any key to continue' 
    try: 
      ch = str(raw_input()) 
    except: 
      ch = ''

The above is the detailed content of Introduction to the python version of the simple factory pattern. For more information, please follow other related articles on the PHP Chinese website!