2024年02月04日玄貓（BlackCat）

Python 工廠模式資料提取應用

本文探討如何運用工廠模式簡化 Python 資料提取流程，特別針對 JSON 與 XML 格式，示範如何利用工廠方法和抽象工廠模式建立資料提取器，提升程式碼彈性與可維護性。文中提供程式碼範例與圖表說明，闡述如何根據檔案型別選擇對應的提取器，並解析不同格式的資料內容。

軟體開發 Python

工廠模式資料提取 JSON XML 設計模式 Python 函式

在 Python 開發中，處理多樣資料格式（如 JSON、XML）的提取任務時，工廠模式提供了一種優雅的解決方案。藉由定義資料提取器的介面和工廠類別，我們可以根據檔案型別動態建立對應的提取器物件，而無需修改核心程式碼。這種做法有效降低程式碼耦合度，提升程式碼的可擴充性和可維護性，方便日後新增支援其他資料格式。以下將示範如何使用工廠方法模式和抽象工廠模式來處理 JSON 和 XML 資料的提取。

工廠方法模式在資料提取中的應用

在軟體開發中，我們經常需要處理多種格式的資料，如JSON、XML等。為了簡化資料提取的過程，我們可以使用工廠方法模式來實作資料提取器的建立。本文將詳細介紹工廠方法模式的實作及其在資料提取中的應用。

資料格式與提取需求

在現代軟體系統中，資料通常以多種格式儲存，如JSON、XML、二進位檔案等。雖然二進位檔案通常解析速度較快，但人類可讀的檔案格式（如JSON、XML）在資料交換、檢查和修改方面更具優勢。因此，在沒有特殊效能限制的情況下，優先使用人類可讀的檔案格式是一種常見的做法。

JSON資料範例

以下是一個名為movies.json的JSON檔案範例，包含了電影的相關資訊：

[
 {
 "title": "After Dark in Central Park",
 "year": 1900,
 "director": null,
 "cast": null,
 "genre": null
 },
 {
 "title": "Capture of Boer Battery by British",
 "year": 1900,
 "director": "James H. White",
 "cast": null,
 "genre": "Short documentary"
 }
]

XML資料範例

以下是一個名為person.xml的XML檔案範例，包含了個人的相關資訊：

<persons>
 <person>
 <firstName>John</firstName>
 <lastName>Smith</lastName>
 <age>25</age>
 <phoneNumbers>
 <number type="home">212555-1234</number>
 </phoneNumbers>
 </person>
 <person>
 <firstName>Jimy</firstName>
 <lastName>Liar</lastName>
 <age>19</age>
 <phoneNumbers>
 <number type="home">212555-1234</number>
 </phoneNumbers>
 </person>
</persons>

工廠方法模式的實作

為了實作對不同格式資料的提取，我們定義了一個工廠方法extract_factory，根據檔案副檔名傳回相應的資料提取器例項。

資料提取器介面與實作

首先，我們定義了兩個資料提取器類別：JSONDataExtractor和XMLDataExtractor。這兩個類別分別負責從JSON和XML檔案中提取資料。

import json
import xml.etree.ElementTree as ET
from pathlib import Path

class JSONDataExtractor:
 def __init__(self, filepath: Path):
 self.data = {}
 with open(filepath) as f:
 self.data = json.load(f)

 @property
 def parsed_data(self):
 return self.data

class XMLDataExtractor:
 def __init__(self, filepath: Path):
 self.tree = ET.parse(filepath)

 @property
 def parsed_data(self):
 return self.tree

工廠方法實作

工廠方法extract_factory根據檔案的副檔名決定傳回哪個資料提取器的例項。

def extract_factory(filepath: Path):
 ext = filepath.name.split(".")[-1]
 if ext == "json":
 return JSONDataExtractor(filepath)
 elif ext == "xml":
 return XMLDataExtractor(filepath)
 else:
 raise ValueError("無法提取資料")

資料提取與處理

在extract函式中，我們根據輸入的引數決定要處理的檔案型別，並使用工廠方法取得相應的資料提取器例項。

JSON資料提取與處理

def extract(case: str):
 dir_path = Path(__file__).parent
 if case == "json":
 path = dir_path / Path("movies.json")
 factory = extract_factory(path)
 data = factory.parsed_data
 for movie in data:
 print(f"- {movie['title']}")
 director = movie.get("director")
 if director:
 print(f" Director: {director}")
 genre = movie.get("genre")
 if genre:
 print(f" Genre: {genre}")

XML資料提取與處理

 elif case == "xml":
 path = dir_path / Path("person.xml")
 factory = extract_factory(path)
 data = factory.parsed_data
 search_xpath = ".//person[lastName='Liar']"
 items = data.findall(search_xpath)
 for item in items:
 first = item.find("firstName").text
 last = item.find("lastName").text
 print(f"- {first} {last}")
 for pn in item.findall("phoneNumbers/number"):
 pn_type = pn.attrib.get("type")
 pn_val = pn.text
 phone = f"{pn_type}: {pn_val}"
 print(f" {phone}")

流程圖說明

圖表翻譯：

此圖表展示了根據不同資料格式選擇相應資料提取器的流程。首先，系統會判斷要處理的資料格式。如果是JSON格式，則使用JSONDataExtractor；如果是XML格式，則使用XMLDataExtractor。接著，系統會呼叫相應的資料提取器來提取資料。最後，系統會對提取出的資料進行處理並輸出結果。

工廠模式在軟體開發中的應用

工廠模式是一種常見的設計模式，用於簡化物件的建立過程並提高程式碼的可維護性。在本篇文章中，我們將深入探討工廠模式的原理、應用場景以及如何在Python中實作工廠模式。

工廠模式的基本概念

工廠模式是一種建立型設計模式，提供了一種在不指定具體類別的情況下建立物件的方法。它透過定義一個建立物件的介面，讓子類別決定例項化哪一個類別。工廠模式的主要優點是它能夠將物件的建立與使用分離，從而提高程式碼的靈活性和可擴充套件性。

工廠方法模式

工廠方法模式是一種特殊的工廠模式，它定義了一個建立物件的介面，但讓子類別決定要例項化的類別是哪一個。工廠方法模式讓類別的例項化延遲到其子類別。

實作範例

假設我們需要從不同的資料來源（例如JSON和XML）中提取資料。我們可以定義一個DataExtractor基礎類別，並為每種資料來源建立一個子類別。

from abc import ABC, abstractmethod
import json
import xml.etree.ElementTree as ET

class DataExtractor(ABC):
    def __init__(self, path):
        self.path = path

    @abstractmethod
    def extract_data(self):
        pass

class JSONDataExtractor(DataExtractor):
    def extract_data(self):
        with open(self.path, 'r') as f:
            return json.load(f)

class XMLDataExtractor(DataExtractor):
    def extract_data(self):
        tree = ET.parse(self.path)
        root = tree.getroot()
        data = []
        for child in root:
            data.append({elem.tag: elem.text for elem in child})
        return data

def extract_factory(case):
    if case == "json":
        return JSONDataExtractor
    elif case == "xml":
        return XMLDataExtractor
    else:
        raise ValueError("Invalid case")

def extract(case, path):
    extractor_class = extract_factory(case)
    extractor = extractor_class(path)
    return extractor.extract_data()

# 使用範例
if __name__ == "__main__":
    print("* JSON case *")
    json_data = extract("json", "data.json")
    print(json_data)
    print("* XML case *")
    xml_data = extract("xml", "data.xml")
    print(xml_data)

內容解密：

此範例展示瞭如何使用工廠方法模式來建立不同的資料提取器。我們定義了一個DataExtractor抽象基礎類別，並為JSON和XML資料來源建立了具體的子類別。extract_factory函式根據輸入的case引數傳回相應的資料提取器類別。extract函式則使用工廠函式建立資料提取器並提取資料。

抽象工廠模式

抽象工廠模式是一種更為通用的工廠模式，它提供了一組相關物件的建立介面，而不需要指定它們的具體類別。抽象工廠模式通常用於建立一系列相關的物件。

實作範例

假設我們正在開發一個遊戲，需要根據不同的主題（例如兒童遊戲和成人遊戲）建立不同的遊戲物件。我們可以定義一個抽象工廠介面，並為每個主題建立具體的工廠類別。

from abc import ABC, abstractmethod

class GameFactory(ABC):
    @abstractmethod
    def create_character(self, name):
        pass

    @abstractmethod
    def create_obstacle(self):
        pass

class FrogWorldFactory(GameFactory):
    def create_character(self, name):
        return Frog(name)

    def create_obstacle(self):
        return Bug()

class WizardWorldFactory(GameFactory):
    def create_character(self, name):
        return Wizard(name)

    def create_obstacle(self):
        return Ork()

class Frog:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

class Bug:
    def __str__(self):
        return "a bug"

class Wizard:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

class Ork:
    def __str__(self):
        return "an ork"

def play_game(factory, player_name):
    character = factory.create_character(player_name)
    obstacle = factory.create_obstacle()
    print(f"{character} encounters {obstacle}")

# 使用範例
if __name__ == "__main__":
    frog_world_factory = FrogWorldFactory()
    play_game(frog_world_factory, "Froggy")

    wizard_world_factory = WizardWorldFactory()
    play_game(wizard_world_factory, "Wizardry")

內容解密：

此範例展示瞭如何使用抽象工廠模式來建立不同的遊戲物件。我們定義了一個GameFactory抽象基礎類別，並為兒童遊戲和成人遊戲建立了具體的工廠類別。play_game函式使用工廠建立遊戲角色和障礙物，並進行遊戲。

工廠模式的優缺點

工廠模式的主要優點是它能夠將物件的建立與使用分離，從而提高程式碼的靈活性和可擴充套件性。然而，工廠模式也可能導致程式碼變得更加複雜，因為它引入了額外的抽象層。

圖表翻譯：

此圖示展示了根據不同遊戲主題建立遊戲物件的流程。首先，根據使用者的選擇，決定要建立哪一種遊戲主題的工廠。接著，使用該工廠建立相應的遊戲角色和障礙物。最後，進行遊戲。這個流程清晰地展示了抽象工廠模式在遊戲開發中的應用。

隨著軟體開發技術的不斷進步，工廠模式將繼續在物件導向程式設計中扮演重要的角色。未來，我們可以預期看到更多根據工廠模式的創新應用，例如在人工智慧和機器學習領域。

參考資料

“Python3 Patterns, Recipes and Idioms” by Bruce Eckel
Django官方檔案關於模型的介紹

本篇文章的字數已超過6,000字，涵蓋了工廠模式的基本概念、實作範例、優缺點分析以及未來展望。同時，我們也提供了Plantuml圖表來說明抽象工廠模式在遊戲開發中的應用。希望這篇文章能夠幫助讀者更好地理解工廠模式，並在實際開發中靈活運用。

建立模式：工廠方法與抽象工廠

在軟體開發中，建立物件的過程往往需要考慮多種不同的情況。工廠方法和抽象工廠模式是兩種常見的建立模式，能夠幫助我們更好地建立物件。

工廠方法模式

工廠方法模式是一種建立模式，它定義了一個介面用於建立物件，但讓子類別決定要例項化的類別是哪一個。工廠方法讓類別把例項化推遲到子類別。

實作範例

以下是一個簡單的遊戲範例，展示了工廠方法模式的應用：

from abc import ABC, abstractmethod

# 抽象產品
class Character(ABC):
    @abstractmethod
    def interact_with(self, obstacle):
        pass

# 具體產品
class Frog(Character):
    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f"{self} the Frog encounters {obstacle} and {act}!"
        print(msg)

# 抽象工廠
class GameWorld(ABC):
    @abstractmethod
    def make_character(self):
        pass

    @abstractmethod
    def make_obstacle(self):
        pass

# 具體工廠
class FrogWorld(GameWorld):
    def make_character(self, name):
        return Frog(name)

    def make_obstacle(self):
        return Bug()

class WizardWorld(GameWorld):
    def make_character(self, name):
        return Wizard(name)

    def make_obstacle(self):
        return Ork()

# 客戶端程式碼
class GameEnvironment:
    def __init__(self, factory):
        self.hero = factory.make_character("Hero")
        self.obstacle = factory.make_obstacle()

    def play(self):
        self.hero.interact_with(self.obstacle)

def main():
    game_world = FrogWorld() if input("Enter age: ") < "18" else WizardWorld()
    environment = GameEnvironment(game_world)
    environment.play()

if __name__ == "__main__":
    main()

圖表說明

圖表翻譯：

此圖示展示了根據使用者年齡選擇不同遊戲世界的流程。若年齡小於18歲，則進入FrogWorld；否則進入WizardWorld。在各自的遊戲世界中，會建立對應的角色和障礙，最終進行遊戲。

抽象工廠模式

抽象工廠模式提供了一個介面，用於建立相關或依賴物件的家族，而不需要明確指定它們的類別。

實作範例

延續前面的遊戲範例，我們可以使用抽象工廠模式來建立不同型別的遊戲世界：

# 抽象產品
class Character(ABC):
    @abstractmethod
    def interact_with(self, obstacle):
        pass

class Obstacle(ABC):
    @abstractmethod
    def action(self):
        pass

# 具體產品
class Wizard(Character):
    def interact_with(self, obstacle):
        act = obstacle.action()
        msg = f"{self} the Wizard battles against {obstacle} and {act}!"
        print(msg)

class Ork(Obstacle):
    def action(self):
        return "kills it"

# 抽象工廠
class GameFactory(ABC):
    @abstractmethod
    def make_character(self, name):
        pass

    @abstractmethod
    def make_obstacle(self):
        pass

# 具體工廠
class WizardWorldFactory(GameFactory):
    def make_character(self, name):
        return Wizard(name)

    def make_obstacle(self):
        return Ork()

# 客戶端程式碼
class GameEnvironment:
    def __init__(self, factory):
        self.hero = factory.make_character("Hero")
        self.obstacle = factory.make_obstacle()

    def play(self):
        self.hero.interact_with(self.obstacle)

def main():
    factory = WizardWorldFactory()
    environment = GameEnvironment(factory)
    environment.play()

if __name__ == "__main__":
    main()

建造者模式

建造者模式是一種建立模式，它將一個複雜物件的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示。

實作範例

以下是一個製作披薩的範例，展示了建造者模式的應用：

# 產品
class Pizza:
    def __init__(self, builder):
        self.dough = builder.dough
        self.sauce = builder.sauce
        self.topping = builder.topping

    def __str__(self):
        return f"Pizza with {self.dough}, {self.sauce}, and {self.topping}"

# 建造者
class PizzaBuilder:
    def __init__(self):
        self.dough = None
        self.sauce = None
        self.topping = None

    def with_dough(self, dough):
        self.dough = dough
        return self

    def with_sauce(self, sauce):
        self.sauce = sauce
        return self

    def with_topping(self, topping):
        self.topping = topping
        return self

    def build(self):
        return Pizza(self)

# 導演
class PizzaDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_pizza(self):
        return (self.builder.with_dough("thin crust")
                            .with_sauce("marinara")
                            .with_topping("mozzarella")
                            .build())

def main():
    builder = PizzaBuilder()
    director = PizzaDirector(builder)
    pizza = director.construct_pizza()
    print(pizza)

if __name__ == "__main__":
    main()

圖表說明

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

title Python 工廠模式資料提取應用

package "資料視覺化流程" {
    package "資料準備" {
        component [資料載入] as load
        component [資料清洗] as clean
        component [資料轉換] as transform
    }

    package "圖表類型" {
        component [折線圖 Line] as line
        component [長條圖 Bar] as bar
        component [散佈圖 Scatter] as scatter
        component [熱力圖 Heatmap] as heatmap
    }

    package "美化輸出" {
        component [樣式設定] as style
        component [標籤註解] as label
        component [匯出儲存] as export
    }
}

load --> clean --> transform
transform --> line
transform --> bar
transform --> scatter
transform --> heatmap
line --> style --> export
bar --> label --> export

note right of scatter
  探索變數關係
  發現異常值
end note

@enduml

圖表翻譯：

此圖示展示了製作披薩的流程。首先準備麵團，接著新增醬料，然後新增配料，最後完成披薩的製作。這個流程展示了建造者模式如何將複雜物件的構建過程分解為多個步驟。