工厂通常有两种形式：一种是工厂方法（Factory Method），它是一个方法，对不同的输入参数返回不同的对象；另一种是抽象工厂，它是一组用于创建一系列相关事物对象的工厂方法。

一、工厂方法：

• 代码示例：

import xml.etree.ElementTree as etree
import json

class JSONConnector:
    def __init__(self, filepath):
        self.data = dict()
        with open(filepath, mode='r', encoding='utf-8') as f:
            self.data = json.load(f)

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

class XMLConnector:
    def __init__(self, filepath):
        self.tree = etree.parse(filepath)

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

def connection_factory(filepath):
    if filepath.endswith('json'):
        connector = JSONConnector
    elif filepath.endswith('xml'):
        connector = XMLConnector
    else:
        raise ValueError("Can't connect to {}".format(filepath))
    return connector(filepath)

def connect_to(filepath):
    factory = None
    try:
        factory = connection_factory(filepath)
    except ValueError as e:
        print(e)
    return factory

def main():
    sqlite_factory = connect_to('data/person.sq3')
    print(sqlite_factory)

    xml_factory = connect_to('data/person.xml')
    xml_data = xml_factory.parsed_data
    print(xml_data)

    json_factory = connect_to('data/donut.json')
    json_data = json_factory.parsed_data
    print(json_data)

if __name__ == '__main__':
    main()

从上述代码可以看出，虽然对文件的解析使用了同一接口进行处理（工厂方法的主要功能），但是返回的结构却不是一致的，所以需要使用不同的方法去解析。

二、抽象工厂：

抽象工厂设计模式是抽象方法的一种泛华，一个抽象工厂从逻辑上讲是一组工厂方法的集合，其中每个工厂方法负责产生不同种类的对象。

抽象工厂模式能够让对象的创建容易追踪，将对象创建与使用解耦，提供优化内存占用和应用性能的潜力。

开发过程中，通常一开始使用工厂方法，因为它更加简单易用；如果后来发现应用需要许多工厂方法，那么将创建一系列对象的过程合并在一起更加合理，则可以引入抽象工厂。

• 代码示例：

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

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        print('{} the Frog encounters {} and {}!'.format(self, obstacle, obstacle.action()))

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

    def action(self):
        return 'eats it'

class FrogWorld:
    def __init__(self, name):
        print(self)
        self.player_name = name  

    def __str__(self):
        return '\n\n\t------ Frog World ------'

    def make_character(self):
        return Frog(self.player_name)

    def make_obstacle(self):
        return Bug()

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

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        print('{} the Wizard battles against {} and {}!'.format(self, obstacle, obstacle.action()))

class Ork:
    def __str__(self):
        return 'an evil ork'

    def action(self):
        return 'kills it'

class WizardWorld:
    def __init__(self, name):
        print(self)
        self.player_name = name

    def __str__(self):
        return '\n\n\t------Wizard World------'

    def make_character(self):
        return Wizard(self.player_name)

    def make_obstacle(self):
        return Ork()

class GameEnv:
    def __init__(self, factory):
        self.hero = factory.make_character()
        self.obstacle = factory.make_obstacle()

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

def validate_age(name):
    try:
        age = input('Welcome {}. How old are you?'.format(name))
        age = int(age)
    except ValueError as err:
        print("Age {} is invalid, please try again...").format(age)
        return (False, age)
    return (True, age)

def main():
    name = input("Hello. What's your name?")
    valid_input = False
    while not valid_input:
        valid_input, age = validate_age(name)
    game = FrogWorld if age<18 else WizardWorld
    environment = GameEnv(game(name))
    environment.play()

从上述代码可以看出，GameEnv实现了对两个工厂方法的封装，它就是这里要讲的抽象工厂的核心。

小结：

工厂模式可以用于以下几种场景：

• 追踪对象的创建；
• 将对象的创建与使用解耦；
• 优化应用的性能和资源占用；

工厂方法设计模式的实现是一个不属于任何一个类的单一函数，负责单一种类对象的创建。抽象工厂设计模式的实现是同属于单个类的许多个工厂方法用于创建一系列种类的相关对象

参考资料：

• 《精通Python设计模式》