设计模式 -创建型模式 ，python工厂模式 抽象工厂模式（1）

工厂模式

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 parsed_data(self):

        return self.data

class XMLConnector:

    def __init__(self, filepath):

        self.tree = etree.parse(filepath)

    @property

    def parsed_data(self):

        return self.tree

def connection_factory(filepath):

    if filepath.endswith('json'):

        connector = JSONConnector

    elif filepath.endswith('xml'):

        connector = XMLConnector

    else:

        raise ValueError('Cannot connect to {}'.format(filepath))

    return connector(filepath)

def connect_to(filepath):

    factory = None

    try:

        factory = connection_factory(filepath)

    except ValueError as ve:

        print(ve)

    return factory

def main():

    sqlite_factory = connect_to('data/person.sq3')

    print()

    xml_factory = connect_to('data/person.xml')

    xml_data = xml_factory.parsed_data

    liars = xml_data.findall(".//{}[{}='{}']".format('person',

                                                     'lastName', 'Liar'))

    print('found: {} persons'.format(len(liars)))

    for liar in liars:

        print('first name: {}'.format(liar.find('firstName').text))

        print('last name: {}'.format(liar.find('lastName').text))

        [print('phone number ({})'.format(p.attrib['type']),

               p.text) for p in liar.find('phoneNumbers')]

    print()

    json_factory = connect_to('data/donut.json')

    json_data = json_factory.parsed_data

    print('found: {} donuts'.format(len(json_data)))

    for donut in json_data:

        print('name: {}'.format(donut['name']))

        print('price: ${}'.format(donut['ppu']))

        [print('topping: {} {}'.format(t['id'], t['type'])) for t in donut['topping']]

if __name__ == '__main__':

    main()

抽象工厂

import random

class PetShop:

    """A pet shop"""

    def __init__(self, animal_factory=None):

        """pet_factory is our abstract factory.  We can set it at will."""

        self.pet_factory = animal_factory

    def show_pet(self):

        """Creates and shows a pet using the abstract factory"""

        pet = self.pet_factory.get_pet()

        print("We have a lovely {}".format(pet))

        print("It says {}".format(pet.speak()))

        print("We also have {}".format(self.pet_factory.get_food()))

# Stuff that our factory makes

class Dog:

    def speak(self):

        return "woof"

    def __str__(self):

        return "Dog"

class Cat:

    def speak(self):

        return "meow"

    def __str__(self):

        return "Cat"

# Factory classes

class DogFactory:

    def get_pet(self):

        return Dog()

    def get_food(self):

        return "dog food"

class CatFactory:

    def get_pet(self):

        return Cat()

    def get_food(self):

        return "cat food"

# Create the proper family

def get_factory():

    """Let's be dynamic!"""

    return random.choice([DogFactory, CatFactory])()

# Show pets with various factories

for i in range(3):

    shop = PetShop(get_factory())

    shop.show_pet()

    print("=" * 20)

工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。

猫类和狗类的公用方法必须是speak(),不能让猫类的方法名是miaomiao()   ,狗类的方法叫wangwang()，把它当鸭子类，在java是用实现接口来规范。py没有接口。