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:
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 = ''
# -*-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!