python工厂模式应用场景,python工厂模式和单例模式
本文主要介绍Python设计模式中的创造性工厂模式。工厂模式是创建对象的最佳方式。下面小编介绍Python工厂模式的相关信息，有需要的朋友可以参考一下。
00-1010 1.工厂模式2。应用场景3。编码示例1。工厂方法模式2。工厂方法模式3。抽象工厂
目录
工厂模式提供了实例化(创建)对象的最佳方式。
在工厂模式中，首先定义一个抽象类工厂，在这个类中定义一个实例化对象的通用接口函数。然后，当客户端要实例化一个特定类的对象时，只需要告诉工厂类需求，工厂类就会根据需求实例化并返回对象。客户端作为调用方，不需要知道对象实例化的任何细节，也就是说任何客户端都不需要考虑根据对象实例化的细节来调整自己的代码。
当我们需要在例如：,购买一批电脑的时候只要把我们的需求告诉电脑厂，电脑厂就会帮我们把这些电脑做好，而不是自己去做这台电脑，或者自己去了解这台电脑是怎么做出来的。这是工厂模式。
模式带来的好处是帮助我们提取对象的实例化部分，从而降低系统中的代码耦合度，增强系统的可扩展性。是一种脱钩思想的实践。
一、工厂模式（Factory Pattern）
多驱动程序(多驱动程序架构)
二、应用场景
三、编码示例
工厂方法模式，只是简单的一层封装，把不同对象的实例化操作分别放到一个工厂类中。
当我们需要实例化一个对象的时候，我们只需要告诉简单工厂类我们的要求，然后简单工厂类就可以根据我们的要求创建相应的对象。适合简单的业务场景。
优点：可以根据用户需求动态生成用户所需类的对象，用户不必知道如何创建对象，使得各个模块各司其职，降低了系统的耦合性。
缺点： s扩展性差违背了开放封闭原则(开放封闭原则是指软件实现应该对扩展开放，对修改封闭)。添加新产品时，需要修改简单工厂类的代码。
实体角色：
产品抽象类、具体产品子类、简单工厂类导入abc
#产品的抽象类别
class Productor(元类=abc。ABCMeta):
@abc.abstractmethod
定义产品(自身、汽车):
及格
#更具体的产品类是产品抽象类的子类。
小米类(Productor):
小米手机
定义产品(自身，价格):
返回用{price}元做一个小米手机
def __repr__(self):
返回f 小米，{id(self)}
#更具体的产品类是产品抽象类的子类。
华为：级(产品)
华为手机
定义产品(自身，价格):
返回“用{price}元做一部华为手机”
def __repr__(self):
返回f 华为，{id(self)}
#简单工厂类
类别电话品牌工厂：
简单工厂
def create_productor(自己，品牌):
如果brand==小米 :
浸水使柔软
urn Xiaomi()
if brand == "Huawei":
return Huawei()
else:
raise TypeError(f"没有名为{brand}的手机生产商。")
if __name__ == "__main__":
# 通过简单工厂类提供的接口函数来获得某个具体的产品类的对象
Xiaomi = PhoneBrandFactory().create_productor("Xiaomi")
Huawei = PhoneBrandFactory().create_productor("Huawei")
print(Xiaomi)
print(Huawei)
print(Xiaomi.product(2999))
print(Huawei.product(5999))
2、工厂方法模式
工厂方法模式，工厂类派生了任意个子工厂类，每个子工厂类对应一个具体的产品类，则某个产品类的对象的实例化就交由这个子工厂类来完成。
工厂方法模式是简单工厂模式的改进，当我们需要扩展一个新产品时，只需要扩展一个新的子工厂类即可，而不用去修改工厂类原有的代码，这样就符合了开闭原则。
优点： 扩展性好，符合了开闭原则。新增一种产品时，只需增加改对应的产品类和对应的工厂子类即可。同时，也使得每个产品类和对应的工厂子类符合了单一职责原则，每个工厂只负责一种产品，而不是由一个工厂去生成所有商品。
缺点： 当我们新增产品时，还需要提供对应的工厂类，系统中类的个数将会成倍增加，相当于增加了系统的复杂性。
实体角色：
- 产品的抽象类
- 具体的产品子类
- 工厂类
- 具体的工厂子类
import abc# 产品的抽象类
class Productor(metaclass=abc.ABCMeta):
@abc.abstractmethod
def product(self, car):
pass
# 更具体的某个产品类，是产品抽象类的子类
class Xiaomi(Productor):
"""
小米手机
"""
def product(self, price):
return f"制造一部小米手机，售价{price}元"
def __repr__(self):
return f"Xiaomi，{id(self)}"
# 更具体的某个产品类，是产品抽象类的子类
class Huawei(Productor):
"""
华为手机
"""
def product(self, price):
return f"制造一部华为手机，售价{price}元"
def __repr__(self):
return f"Huawei，{id(self)}"
# 工厂类
class PhoneBrandFactory(metaclass=abc.ABCMeta):
"""
抽象工厂
"""
@abc.abstractmethod
def create_productor(self, brand):
pass
# 具体产品对应的子工厂类
class XiaomiFactory(PhoneBrandFactory):
def create_productor(self):
return Xiaomi()
# 具体产品对应的子工厂类
class HuaweiFactory(PhoneBrandFactory):
def create_productor(self):
return Huawei()
if __name__ == "__main__":
# 由这个子工厂类来完成对应的某个产品类的对象实例化
Xiaomi = XiaomiFactory().create_productor()
Huawei = HuaweiFactory().create_productor()
print(Xiaomi)
print(Huawei)
print(Xiaomi.product(2999))
print(Huawei.product(5999))
3、抽象工厂模式
抽象工厂模式，又是工厂方法模式的改进。工厂方法模式解决的是生产不同品牌的同一类型的电脑，而抽象工厂模式解决的是生产不同品牌的多种类型的电脑。
比如，工厂方法模式中的电脑工厂只能生产老式的台式电脑，而如果现在需要生产台式电脑，笔记本电脑，平板电脑等多个种类的电脑的话，那么工厂方法模式就不太方便了。而抽象工厂模式可以解决电脑工厂生产多个种类电脑的问题，也就是解决一个工厂生产多种类型的产品的问题。
如果我们需要台式电脑，又需要笔记本电脑，要多种产品时，工厂方法模式无法满足我们的需求；而抽象方法模式，提前在抽象工厂中，定义好了可能需要的多种产品，比如：台式电脑，笔记本电脑，平板电脑等，当有需求的时候，我们只需要创建相关子类和相关子工厂类即可。
优点： 抽象工厂类创建了多个类型的产品，当有需求时，可以创建相关子产品类和子工厂类来获取。也就是可以满足生产不同品牌的不同类型的电脑。
缺点： 扩展新种类产品时困难。抽象工厂模式需要我们在工厂抽象类中提前确定了可能需要的产品种类，以满足不同品牌的多种产品的需求。但是如果我们需要的产品种类并没有在工厂抽象类中提前确定，那我们就需要去修改工厂抽象类了，而一旦修改了工厂抽象类，那么所有的工厂子类也需要修改，这样显然扩展不方便。
实体角色：
- 产品功能特性抽象类
- 具体的产品功能特性子类
- 产品的抽象类
- 具体的产品子类
- 抽象工厂类
import abc# 产品功能特性抽象类
class PhoneShell(metaclass=abc.ABCMeta):
@abc.abstractmethod
def shell(self):
pass
class Cpu(metaclass=abc.ABCMeta):
@abc.abstractmethod
def cpu(self):
pass
class OS(metaclass=abc.ABCMeta):
@abc.abstractmethod
def system(self):
pass
# 具体的产品功能特性类
class SmallShell(PhoneShell):
@property
def shell(self):
return "小屏幕"
class BigShell(PhoneShell):
@property
def shell(self):
return "大屏幕"
class SnapDragonCpu(Cpu):
@property
def cpu(self):
return "骁龙cpu"
class AppleCpu(Cpu):
@property
def cpu(self):
return "苹果cpu"
class Android(OS):
@property
def system(self):
return "安卓系统"
class IOS(OS):
@property
def system(self):
return "IOS系统"
# 产品的抽象类
class ProductPhone:
def __init__(self, factory):
self.factory = factory()
def product(self):
self.shell = self.factory.product_shell()
self.cpu = self.factory.product_cpu()
self.OS = self.factory.product_system()
def show_info(self):
print(f"{self.factory}", f"配置信息：{self.shell.shell}, {self.cpu.cpu}, {self.OS.system}")
# 具体的产品子类
class XiaomiFactory(PhoneFactory):
def product_shell(self):
return BigShell()
def product_cpu(self):
return SnapDragonCpu()
def product_system(self):
return Android()
def __repr__(self):
return "小米手机，售价2999！"
class IphoneFactory(PhoneFactory):
def product_shell(self):
return SmallShell()
def product_cpu(self):
return AppleCpu()
def product_system(self):
return IOS()
def __repr__(self):
return "苹果手机，售价8999！"
# 抽象工厂类
class PhoneFactory(metaclass=abc.ABCMeta):
@abc.abstractmethod
def product_shell(self):
pass
@abc.abstractmethod
def product_cpu(self):
pass
@abc.abstractmethod
def product_system(self):
pass
if __name__ == "__main__":
xiaomi = ProductPhone(XiaomiFactory)
xiaomi.product()
xiaomi.show_info()
iphone = ProductPhone(IphoneFactory)
iphone.product()
iphone.show_info()
到此这篇关于Python设计模式中的创建型工厂模式的文章就介绍到这了,更多相关Python工厂模式内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。