Python設(shè)計模式中的創(chuàng)建型工廠模式怎么用

這篇文章主要介紹Python設(shè)計模式中的創(chuàng)建型工廠模式怎么用，文中介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們一定要看完！

一、工廠模式（Factory Pattern）

工廠模式（Factory Pattern），提供了一種實例化（創(chuàng)建）對象的最佳方式。

在工廠模式中，首先定義了一個抽象的工廠類（class Factory），并且在該工廠類中定義了提供了一個通用的、用于實例化對象的 Interface（接口）函數(shù)。然后當(dāng) Client 想要實例化某個具體的類的對象時，只需要將需求告訴工廠類即可，由工廠類按需求去完成對象的實例化并返回。而 Client 作為調(diào)用者，則無需知道對象實例化的任何細(xì)節(jié)，這意味著任意的 Client 都無需要考慮根據(jù)對象的實例化細(xì)節(jié)來調(diào)整自身的代碼。

例如：當(dāng)我們需要購買一批電腦，只要把我們的需求告訴電腦工廠，電腦工廠就會幫我們把這批電腦做好，而不用我們自己去做這個電腦的，也不用我們自己去知道這個電腦是怎么做出來的，這就是工廠模式。

工廠模式帶來的好處就是幫助我們把對象的實例化部分抽取了出來，目的是降低系統(tǒng)中代碼耦合度，并且增強(qiáng)了系統(tǒng)的擴(kuò)展性。是一種解耦思想的實踐。

二、應(yīng)用場景

• Multi-Drivers（多驅(qū)動架構(gòu)）

三、編碼示例

1、簡單工廠模式

簡單工廠模式，只是做了一層簡單的封裝，將不同對象的實例化操作都單獨放到了一個工廠類中。

當(dāng)我們需要實例化某個對象時，只需把我們的需求告訴簡單工廠類，然后由這個簡單工廠類根據(jù)我們的需求去創(chuàng)建對應(yīng)的對象即可。適用于簡單的業(yè)務(wù)場景。

優(yōu)點： 簡單工廠模式可以根據(jù)需求，動態(tài)生成使用者所需類的對象，而使用者不用去知道怎么創(chuàng)建對象，使得各個模塊各司其職，降低了系統(tǒng)的耦合性。

缺點： 擴(kuò)展性差，違背了開閉原則（開閉原則指的是：軟件實現(xiàn)應(yīng)該對擴(kuò)展開放，對修改關(guān)閉）。新增產(chǎn)品時，需要修改簡單工廠類的代碼。

實體角色：

• 產(chǎn)品的抽象類

• 具體的產(chǎn)品子類

• 簡單工廠類

import abc

# 產(chǎn)品的抽象類
class Productor(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def product(self, car):
        pass
        
# 更具體的某個產(chǎn)品類，是產(chǎn)品抽象類的子類
class Xiaomi(Productor):
    """
    小米手機(jī)
    """
    def product(self, price):
        return f"制造一部小米手機(jī)，售價{price}元"
        
    def __repr__(self):
        return f"Xiaomi，{id(self)}" 
    
# 更具體的某個產(chǎn)品類，是產(chǎn)品抽象類的子類
class Huawei(Productor):
    """
    華為手機(jī)
    """
    def product(self, price):
        return f"制造一部華為手機(jī)，售價{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}的手機(jī)生產(chǎn)商。")
        

if __name__ == "__main__":
    # 通過簡單工廠類提供的接口函數(shù)來獲得某個具體的產(chǎn)品類的對象
    Xiaomi = PhoneBrandFactory().create_productor("Xiaomi")
    Huawei = PhoneBrandFactory().create_productor("Huawei")
    print(Xiaomi)
    print(Huawei)
    print(Xiaomi.product(2999))
    print(Huawei.product(5999))

2、工廠方法模式

工廠方法模式，工廠類派生了任意個子工廠類，每個子工廠類對應(yīng)一個具體的產(chǎn)品類，則某個產(chǎn)品類的對象的實例化就交由這個子工廠類來完成。

工廠方法模式是簡單工廠模式的改進(jìn)，當(dāng)我們需要擴(kuò)展一個新產(chǎn)品時，只需要擴(kuò)展一個新的子工廠類即可，而不用去修改工廠類原有的代碼，這樣就符合了開閉原則。

優(yōu)點： 擴(kuò)展性好，符合了開閉原則。新增一種產(chǎn)品時，只需增加改對應(yīng)的產(chǎn)品類和對應(yīng)的工廠子類即可。同時，也使得每個產(chǎn)品類和對應(yīng)的工廠子類符合了單一職責(zé)原則，每個工廠只負(fù)責(zé)一種產(chǎn)品，而不是由一個工廠去生成所有商品。

缺點： 當(dāng)我們新增產(chǎn)品時，還需要提供對應(yīng)的工廠類，系統(tǒng)中類的個數(shù)將會成倍增加，相當(dāng)于增加了系統(tǒng)的復(fù)雜性。

實體角色：

• 產(chǎn)品的抽象類

• 具體的產(chǎn)品子類

• 工廠類

• 具體的工廠子類

import abc

# 產(chǎn)品的抽象類
class Productor(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def product(self, car):
        pass
        
# 更具體的某個產(chǎn)品類，是產(chǎn)品抽象類的子類
class Xiaomi(Productor):
    """
    小米手機(jī)
    """
    def product(self, price):
        return f"制造一部小米手機(jī)，售價{price}元"
        
    def __repr__(self):
        return f"Xiaomi，{id(self)}" 
    
# 更具體的某個產(chǎn)品類，是產(chǎn)品抽象類的子類
class Huawei(Productor):
    """
    華為手機(jī)
    """
    def product(self, price):
        return f"制造一部華為手機(jī)，售價{price}元"
        
    def __repr__(self):
        return f"Huawei，{id(self)}" 
    
# 工廠類
class PhoneBrandFactory(metaclass=abc.ABCMeta):
    """
    抽象工廠
    """
    @abc.abstractmethod
    def create_productor(self, brand):
        pass
    
# 具體產(chǎn)品對應(yīng)的子工廠類
class XiaomiFactory(PhoneBrandFactory):
    def create_productor(self):
        return Xiaomi()
    
# 具體產(chǎn)品對應(yīng)的子工廠類
class HuaweiFactory(PhoneBrandFactory):
    def create_productor(self):
        return Huawei()


if __name__ == "__main__":
    # 由這個子工廠類來完成對應(yīng)的某個產(chǎn)品類的對象實例化
    Xiaomi = XiaomiFactory().create_productor()
    Huawei = HuaweiFactory().create_productor()
    print(Xiaomi)
    print(Huawei)
    print(Xiaomi.product(2999))
    print(Huawei.product(5999))

3、抽象工廠模式

抽象工廠模式，又是工廠方法模式的改進(jìn)。工廠方法模式解決的是生產(chǎn)不同品牌的同一類型的電腦，而抽象工廠模式解決的是生產(chǎn)不同品牌的多種類型的電腦。

比如，工廠方法模式中的電腦工廠只能生產(chǎn)老式的臺式電腦，而如果現(xiàn)在需要生產(chǎn)臺式電腦，筆記本電腦，平板電腦等多個種類的電腦的話，那么工廠方法模式就不太方便了。而抽象工廠模式可以解決電腦工廠生產(chǎn)多個種類電腦的問題，也就是解決一個工廠生產(chǎn)多種類型的產(chǎn)品的問題。

如果我們需要臺式電腦，又需要筆記本電腦，要多種產(chǎn)品時，工廠方法模式無法滿足我們的需求；而抽象方法模式，提前在抽象工廠中，定義好了可能需要的多種產(chǎn)品，比如：臺式電腦，筆記本電腦，平板電腦等，當(dāng)有需求的時候，我們只需要創(chuàng)建相關(guān)子類和相關(guān)子工廠類即可。

優(yōu)點： 抽象工廠類創(chuàng)建了多個類型的產(chǎn)品，當(dāng)有需求時，可以創(chuàng)建相關(guān)子產(chǎn)品類和子工廠類來獲取。也就是可以滿足生產(chǎn)不同品牌的不同類型的電腦。

缺點： 擴(kuò)展新種類產(chǎn)品時困難。抽象工廠模式需要我們在工廠抽象類中提前確定了可能需要的產(chǎn)品種類，以滿足不同品牌的多種產(chǎn)品的需求。但是如果我們需要的產(chǎn)品種類并沒有在工廠抽象類中提前確定，那我們就需要去修改工廠抽象類了，而一旦修改了工廠抽象類，那么所有的工廠子類也需要修改，這樣顯然擴(kuò)展不方便。

實體角色：

• 產(chǎn)品功能特性抽象類

• 具體的產(chǎn)品功能特性子類

• 產(chǎn)品的抽象類

• 具體的產(chǎn)品子類

• 抽象工廠類

import abc

# 產(chǎn)品功能特性抽象類
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
    
# 具體的產(chǎn)品功能特性類
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 "安卓系統(tǒng)"    
    
class IOS(OS):
    @property
    def system(self):
        return "IOS系統(tǒng)"
    
# 產(chǎn)品的抽象類
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}")
            
# 具體的產(chǎn)品子類
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 "小米手機(jī)，售價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 "蘋果手機(jī)，售價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設(shè)計模式中的創(chuàng)建型工廠模式怎么用”這篇文章的所有內(nèi)容，感謝各位的閱讀！希望分享的內(nèi)容對大家有幫助，更多相關(guān)知識，歡迎關(guān)注億速云行業(yè)資訊頻道！