Python设计模式中的创建型工厂模式

目录
  • 一、工厂模式(Factory Pattern)
  • 二、应用场景
  • 三、编码示例
    • 1、简单工厂模式
    • 2、工厂方法模式
    • 3、抽象工厂模式

一、工厂模式(Factory Pattern)

工厂模式(Factory Pattern),提供了一种实例化(创建)对象的最佳方式。

在工厂模式中,首先定义了一个抽象的工厂类(class Factory),并且在该工厂类中定义了提供了一个通用的、用于实例化对象的 Interface(接口)函数。然后当 Client 想要实例化某个具体的类的对象时,只需要将需求告诉工厂类即可,由工厂类按需求去完成对象的实例化并返回。而 Client 作为调用者,则无需知道对象实例化的任何细节,这意味着任意的 Client 都无需要考虑根据对象的实例化细节来调整自身的代码。

例如:当我们需要购买一批电脑,只要把我们的需求告诉电脑工厂,电脑工厂就会帮我们把这批电脑做好,而不用我们自己去做这个电脑的,也不用我们自己去知道这个电脑是怎么做出来的,这就是工厂模式。

工厂模式带来的好处就是帮助我们把对象的实例化部分抽取了出来,目的是降低系统中代码耦合度,并且增强了系统的扩展性。是一种解耦思想的实践。

二、应用场景

  • Multi-Drivers(多驱动架构)

三、编码示例

1、简单工厂模式

简单工厂模式,只是做了一层简单的封装,将不同对象的实例化操作都单独放到了一个工厂类中。

当我们需要实例化某个对象时,只需把我们的需求告诉简单工厂类,然后由这个简单工厂类根据我们的需求去创建对应的对象即可。适用于简单的业务场景。

优点: 简单工厂模式可以根据需求,动态生成使用者所需类的对象,而使用者不用去知道怎么创建对象,使得各个模块各司其职,降低了系统的耦合性。

缺点: 扩展性差,违背了开闭原则(开闭原则指的是:软件实现应该对扩展开放,对修改关闭)。新增产品时,需要修改简单工厂类的代码。

实体角色:

  • 产品的抽象类
  • 具体的产品子类
  • 简单工厂类
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:
    """
    简单工厂
    """
    def create_productor(self, brand):
        if brand == "Xiaomi":
            return 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工厂模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python设计模式之抽象工厂模式

    python面向对象编程入门,我们需要不断学习进步 """抽象工厂模式的实现""" import random class PetShop: """宠物商店""" def __init__(self, animal_factory=None): """宠物工厂是我们的抽象工厂.我们可以随意设置.""" self.pet_fact

  • Python设计模式之工厂方法模式实例详解

    本文实例讲述了Python设计模式之工厂方法模式.分享给大家供大家参考,具体如下: 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延时到其子类. #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' """ 大话设计模式 设计模式--工厂方法模式 工厂方法模式(Factory Method Pattern):

  • Python设计模式之简单工厂模式实例详解

    本文实例讲述了Python设计模式之简单工厂模式.分享给大家供大家参考,具体如下: 简单工厂模式(Simple Factory Pattern):是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类. 下面使用简单工厂模式实现一个简单的四则运算 #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' ''' 大话设计模式 用任意一种面向对象语言实现一个计算器控制台程序.要求输入两个数和运算符号,得到

  • Python设计模式之工厂模式简单示例

    本文实例讲述了Python设计模式之工厂模式.分享给大家供大家参考,具体如下: 工厂模式是一个在软件开发中用来创建对象的设计模式. 工厂模式包涵一个超类.这个超类提供一个抽象化的接口来创建一个特定类型的对象,而不是决定哪个对象可以被创建. 为了实现此方法,需要创建一个工厂类创建并返回. 当程序运行输入一个"类型"的时候,需要创建于此相应的对象.这就用到了工厂模式.在如此情形中,实现代码基于工厂模式,可以达到可扩展,可维护的代码.当增加一个新的类型,不在需要修改已存在的类,只增加能够产生

  • python设计模式之抽象工厂模式详解

    抽象工厂模式(Abstract Factory Pattern):属于创建型模式,它提供了一种创建对象的最佳方式.在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类,每个生成的工厂都能按照工厂模式提供对象. 意图: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 主要解决: 主要解决接口选择的问题. 何时使用: 系统的产品有多于一个的产品族,而系统只消费其中某一族的产品. 如何解决: 在一个产品族里面,定义多个产品. 关键代码: 在一个工厂里聚合多个

  • Python设计模式之抽象工厂模式原理与用法详解

    本文实例讲述了Python设计模式之抽象工厂模式原理与用法.分享给大家供大家参考,具体如下: 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的类 下面是一个抽象工厂的demo: #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' """ 大话设计模式 设计模式--抽象工厂模式 抽象工厂模式(Abstract Factory

  • python3设计模式之简单工厂模式

    在Python3环境下,调试实现了<大话设计模式>中简单工厂模式,通过定义单独的工厂类,完成对具体的产品的实例化,参考链接 具体实现见代码: #!/usr/bin/env python # -*- coding: utf-8 -*- # Date : 2017-10-15 21:46:28 # Author : John # Version : V1.001 # Func : class Operator(object): """docstring for Ope

  • Python设计模式中的创建型工厂模式

    目录 一.工厂模式(Factory Pattern) 二.应用场景 三.编码示例 1.简单工厂模式 2.工厂方法模式 3.抽象工厂模式 一.工厂模式(Factory Pattern) 工厂模式(Factory Pattern),提供了一种实例化(创建)对象的最佳方式. 在工厂模式中,首先定义了一个抽象的工厂类(class Factory),并且在该工厂类中定义了提供了一个通用的.用于实例化对象的 Interface(接口)函数.然后当 Client 想要实例化某个具体的类的对象时,只需要将需求告

  • Python 设计模式中的创建型建造者模式

    目录 一.建造者模式 二.代码示例 一.建造者模式 建造者模式,顾名思义类似于建筑工人,他们按照有条理的施工顺序(e.g. 打桩 => 浇筑框架 => 砌墙 => 装修)来进行建筑的修建.对于千差万别的建筑,都可以复用同样的施工流程.因为不同的材料.不同设计,可以有不同的表现. 建造者模式,与抽象工厂模式同样用于实例化复杂的对象,主要区别在于: 抽象工厂模式侧重于实例化多个系列的复杂对象. 建造者模式侧重于一步步有序地构造一个复杂对象. 二.代码示例 按照有序的步骤来组装(建造)一个复杂

  • Python设计模式中的行为型策略模式

    目录 一.策略模式 二.应用场景 三.代码示例 一.策略模式 策略模式中,首先定义了一系列不同的算法,并把它们一一封装起来,然后在策略类中,使这些算法可以相互替换.这意味着,让一个类的行为(算法)可以在类的实例化对象运行时进行更改. 优点: 定义了一系列可重用的算法和行为. 消除了一些条件语句. 可以提供相同行为的不同实现. 缺点: Client 必须了解不同的策略行为细节. 二.应用场景 根据不同的客户属性,采用不同的折扣策略来计算订单中的商品价格: 有 1000 或以上积分的客户,每个订单享

  • Python设计模式中的结构型桥接模式

    目录 一.桥接模式 二.应用场景 三.代码示例 一.桥接模式 桥接模式,希望能够将一个事物的两个维度分离(解耦),使其都可以独立地变化,并通过桥梁连接起来. (类)抽象部分(Abstraction):存在于多个实体中的共同的概念性联系,就是抽象化.作为一个过程,抽象化就是忽略一些信息,从而把不同的实体当做同样的实体对待. (对象)实体部分(Implementation):抽象化给出的具体实现,就是实现化. 简而言之,桥接模式就是指在一个软件系统的抽象化和实现化之间,使用组合/聚合关系而不是继承关

  • Python设计模式创建型原型模式

    目录 一.原型模式 二.应用场景 三.代码示例 一.原型模式 原型是相对于复制.克隆而言的,但是不同于模板,模板创造出的东西是一模一样,而原型创造出的东西是允许存在差异化和个性化的. 原型模式的实现思路是:“深拷贝” 和 “属性更新”.定义一个原型,设计一个拷贝接口,不需要频繁实例化类,只需要拷贝. 优点: 减少因为对象实例化而产生的损耗,并实行动态装载. 二.应用场景 三.代码示例 要实现多个人的自我介绍,一般方法是每个人都创建一个对象,但是使用原型模式之后,只需要实例化一个对象(标准人),后

  • Python 设计模式中命令模式

    目录 1.命令模式 2.应用场景 3.代码示例 1.命令模式 命令模式的目的是解耦调用操作的对象(调用者)和提供实现的对象(接收者). 命令模式的思路是在调用者和接收者之间插入一个命令类(Command),该命令类定义了一个 execute 接口,并且该接口实际上是调用了接收者中的具体方法来执行具体命令,以此可以通过扩展命令子类来扩展多个不同的接收者. 这样调用此命令的调用者就和命令接收者之间解耦了. 优势: 封装性好,每个命令都被封装起来,对于客户端来说,需要什么功能就去调用相应的命令,而无需

  • 23种设计模式(2) java工厂模式

    23种设计模式第二篇:java工厂模式 定义: 工厂模式是 Java 中最常用的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的. 工厂模式根据抽象程度的不同分为三种: 简单工厂模式(也叫静态工厂模式) 工厂方法模式(也叫多形性工厂) 抽象工厂模式(也叫工具箱) 简单工厂模式 实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接

  • Java结构型设计模式中的适配器模式与桥接模式解析

    适配器模式 定义 适配器模式(英语:adapter pattern)有时候也称包装样式或者包装.将一个类的接口转接成用户所期待的.一个适配使得因接口不兼容而不能在一起工作的类工作在一起. 有两类适配器模式: 1. 对象适配器模式 - 对象适配器通过关联满足用户期待接口,还降低了代码间的不良耦合.在工作中推荐使用"对象适配". 2. 类适配器模式 - 这种适配器模式下,适配器继承自已实现的类(一般多重继承),java中没有多重继承,所以这里不做介绍. 实现 1. Target - 定义C

  • Python设计模式中的结构型适配器模式

    目录 一.适配器模式 二.应用场景 三.代码示例 方式一 方式二 一.适配器模式 适配器,顾名思义是一种万能的接口,达到万能转换的效果. 适配器模式,定义一个适配器类,并且在该类中定义了适配器接口,这些适配接口能够将原来由于接口不兼容而不能在一起工作的多种类型进行适配,使得它们能够一同工作. 二.应用场景 三.代码示例 实体角色: 目标接口(Target):定义提供给 Client 访问的接口,可以是一个抽象类或接口,也可以是具体类.待适配的类 / 适配者类(Adaptee):被适配的角色,它们

  • 简介Python设计模式中的代理模式与模板方法模式编程

    代理模式 Proxy模式是一种常用的设计模式,它主要用来通过一个对象(比如B)给一个对象(比如A) 提供'代理'的方式方式访问.比如一个对象不方便直接引用,代理就在这个对象和访问者之间做了中介 python的例子 你先设想:一个对象提供rgb三种颜色值,我想获得一个对象的rgb三种颜色,但是我不想让你获得蓝色属性,怎么办? class Proxy(object): def __init__(self, subject): self.__subject = subject # 代理其实本质上就是属

随机推荐