python 商品制造信息

转载

mob64ca140b0bc8 2024-10-31 18:36:49

文章标签 python 商品制造信息 Python User Access 抽象工厂模式 文章分类 Python 后端开发

这篇文章主要介绍了Python设计模式编程中对抽象工厂模式的运用,文中的例子体现了抽象工厂模式程序的一些设计优化点,需要的朋友可以参考下
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
优点：易于交换“产品系列”，只要更改相应的工厂即可。
缺点：建立产品的时候很繁琐，需要增加和修改很多东西。
优化1：为了避免客户端有过多的逻辑判断，可以封装出一个简单工厂类来生成产品类。
优化2：为了减少简单工厂类里面的逻辑判断，可以采用“反射”机制，直接根据外部的配置文件读取出需要使用产品类的信息。
#encoding=utf-8
#
#by panda
#抽象工厂模式

def printInfo(info):
print unicode(info, 'utf-8').encode('gbk')

#抽象产品A：user表
class IUser():
def Insert(self):
    pass
def GetUser(self):
    pass

#sqlserver实现的User
class SqlserverUser(IUser):
def Insert(self):
    printInfo("在SQL Server中给User表增加一条记录")
def GetUser(self):
    printInfo("在SQL Server中得到User表的一条记录")

#Access实现的User
class AccessUser(IUser):
def Insert(self):
    printInfo("在Access中给User表增加一条记录")
def GetUser(self):
    printInfo("在Access中得到User表一条记录")


#抽象产品B：部门表
class IDepartment():
def Insert(self):
    pass
def GetUser(self):
    pass

#sqlserver实现的Department
class SqlserverDepartment(IUser):
def Insert(self):
    printInfo("在SQL Server中给Department表增加一条记录")
def GetUser(self):
    printInfo("在SQL Server中得到Department表的一条记录")

#Access实现的Department
class AccessDepartment(IUser):
def Insert(self):
    printInfo("在Access中给Department表增加一条记录")
def GetUser(self):
    printInfo("在Access中得到Department表一条记录")


#抽象工厂
class IFactory():
def CreateUser(self):
    pass
def CreateDepartment(self):
    pass

#sql server工厂
class SqlServerFactory(IFactory):
def CreateUser(self):
    return SqlserverUser()
def CreateDepartment(self):
    return SqlserverDepartment()

#access工厂
class AccessFactory(IFactory):
def CreateUser(self):
    return AccessUser()
def CreateDepartment(self):
    return AccessDepartment()

#优化一：采用一个简单工厂类，封装逻辑判断操作
class DataAccess():
# db = "Sqlserver"
db = "Access"
@staticmethod
def CreateUser():
    if (DataAccess.db == "Sqlserver"):
      return SqlserverUser()
    elif(DataAccess.db == "Access"):
      return AccessUser()
@staticmethod
def CreateDepartment():
    if (DataAccess.db == "Sqlserver"):
      return SqlserverDepartment()
    elif(DataAccess.db == "Access"):
      return AccessDepartment()

#优化二：采用反射机制，避免使用太多判断
##以下信息可以从配置文件中获取
DBType = 'Sqlserver' #'Access'
DBTab_User = 'User'
DBTab_Department = 'Department'

class DataAccessPro():
# db = "Sqlserver"
db = "Access"
@staticmethod
def CreateUser():
    funName = DBType + DBTab_User
    return eval（funName)() #eval 将其中的字符串转化为python表达式
@staticmethod
def CreateDepartment():
    funName = DBType + DBTab_Department
    return eval（funName)()

def clientUI():
printInfo("\n--------抽象工厂方法--------")
factory = SqlServerFactory()
iu = factory.CreateUser()
iu.Insert()
iu.GetUser()
id = factory.CreateDepartment()
id.Insert()
id.GetUser()

printInfo("\n--抽象工厂方法+简单工厂方法--")
iu = DataAccess.CreateUser()
iu.Insert()
iu.GetUser()
id = DataAccess.CreateDepartment()
id.Insert()
id.GetUser()

printInfo("\n-抽象工厂方法+简单工厂方法+反射-")
iu = DataAccessPro.CreateUser()
iu.Insert()
iu.GetUser()
id = DataAccessPro.CreateDepartment()
id.Insert()
id.GetUser()
return


if __name__ == '__main__':
clientUI();

类图：

python 商品制造信息_抽象工厂模式

工厂模式和抽象工厂模式的区别：工厂模式是在派生类中定义一个工厂的抽象接口，然后基类负责创建具体对象；抽象工厂模式是维护一个产品家族，由基类定义产品被生产的方法，客户根据派生类的接口进行开发。
实例：人民群众喜闻乐见的披萨店例子这里又可以搬出来了，这次我们根据抽象工厂模式的特点，用不同原材料制作不同口味的披萨，创建不同原材料的工厂，不同实体店做出口味不同的披萨。创建一个产品家族（Dough、Sauce、Cheese和Clam）的抽象类型（PizzaIngredientFactory），这个类型的子类（NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory）定义了产品被产生的方法。
代码：
#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')

'''
披萨
'''
class Pizza:
name = ""
dough = None
sauce = None
cheese = None
clam = None

def prepare(self):
    pass

def bake(self):
    print "烘烤25分钟在350。".decode('utf-8')

def cut(self):
    print "切割成对角线切片。".decode('utf-8')

def box(self):
    print "放在官方的盒子中。".decode('utf-8')

def get_name(self):
    return self.name

def set_name(self, name):
    self.name = name

def to_string(self):
    string = "%s:\n" % self.name
    string += " 面团: %s\n" % self.dough.to_string() if self.dough else ""
    string += " 酱汁: %s\n" % self.sauce.to_string() if self.sauce else ""
    string += " 奶酪: %s\n" % self.cheese.to_string() if self.cheese else ""
    string += " 文蛤: %s\n" % self.clam.to_string() if self.clam else ""
    return string

'''
什么类别的披萨
'''
class CheesePizza(Pizza):
def __init__(self, ingredient_factory):
    self.ingredient_factory = ingredient_factory

def prepare(self):
    print "准备: %s" % self.name
    self.dough = self.ingredient_factory.create_dough()
    self.sauce = self.ingredient_factory.create_sauce()
    self.cheese = self.ingredient_factory.create_cheese()


class ClamPizza(Pizza):
def __init__(self, ingredient_factory):
    self.ingredient_factory = ingredient_factory

def prepare(self):
    print "准备: %s" % self.name
    self.dough = self.ingredient_factory.create_dough()
    self.sauce = self.ingredient_factory.create_sauce()
    self.clam = self.ingredient_factory.create_clam()

'''
披萨店
'''
class PizzaStore:
def order_pizza(self, pizza_type):
    self.pizza = self.create_pizza(pizza_type)
    self.pizza.prepare()
    self.pizza.bake()
    self.pizza.cut()
    self.pizza.box()
    return self.pizza

def create_pizza(self, pizza_type):
    pass

'''
纽约披萨实体店1
'''
class NYPizzaStore(PizzaStore):
def create_pizza(self, pizza_type):
    ingredient_factory = NYPizzaIngredientFactory()

    if pizza_type == "cheese":
      pizza = CheesePizza(ingredient_factory)
      pizza.set_name("纽约风格芝士披萨".decode('utf-8'))
    elif pizza_type == "clam":
      pizza = ClamPizza(ingredient_factory)
      pizza.set_name("纽约风格文蛤披萨".decode('utf-8'))
    else:
      pizza = None

    return pizza

'''
芝加哥披萨实体店2
'''
class ChicagoPizzaStore(PizzaStore):
   def create_pizza(self, pizza_type):
    ingredient_factory = ChicagoPizzaIngredientFactory()

    if pizza_type == "cheese":
      pizza = CheesePizza(ingredient_factory)
      pizza.set_name("芝加哥风格芝士披萨".decode('utf-8'))
    elif pizza_type == "clam":
      pizza = ClamPizza(ingredient_factory)
      pizza.set_name("芝加哥风格文蛤披萨".decode('utf-8'))
    else:
      pizza = None

    return pizza

'''
生产披萨的工厂
'''
class PizzaIngredientFactory:
def create_dough(self):
    pass

def create_sauce(self):
    pass

def create_cheese(self):
    pass

def create_clam(self):
    pass

'''
生产披萨的实体工厂1
'''
class NYPizzaIngredientFactory(PizzaIngredientFactory):
def create_dough(self):
    return ThinDough()

def create_sauce(self):
    return MarinaraSauce()

def create_cheese(self):
    return FreshCheese()

def create_clam(self):
    return FreshClam()

'''
生产披萨的实体工厂2
'''
class ChicagoPizzaIngredientFactory(PizzaIngredientFactory):
def create_dough(self):
    return ThickDough()

def create_sauce(self):
    return MushroomSauce()

def create_cheese(self):
    return BlueCheese()

def create_clam(self):
    return FrozenClam()


class Dough:
def to_string(self):
    pass

class ThinDough(Dough):
def to_string(self):
    return "薄的面团"

class ThickDough(Dough):
def to_string(self):
    return "厚的生面团"

class Sauce:
def to_string(self):
    pass

class MarinaraSauce(Sauce):
def to_string(self):
    return "番茄酱"

class MushroomSauce(Sauce):
def to_string(self):
    return "蘑菇酱"

class Cheese:
def to_string(self):
    pass

class FreshCheese(Cheese):
def to_string(self):
    return "新鲜的奶酪"

class BlueCheese(Cheese):
def to_string(self):
    return "蓝纹奶酪"

class Clam:
def to_string(self):
    pass

class FreshClam(Clam):
def to_string(self):
    return "新鲜的文蛤"

class FrozenClam(Clam):
def to_string(self):
    return "冷冻的文蛤"

if __name__ == "__main__":
# 创建了两个披萨实体店
ny_store = NYPizzaStore()
chicago_store = ChicagoPizzaStore()

# 在第一个披萨对象中订购了一个cheese风味的披萨
pizza = ny_store.order_pizza("cheese")
print pizza.to_string()
print "迈克订购了一个 %s" % pizza.get_name()
print

pizza = chicago_store.order_pizza("clam")
print pizza.to_string()
print "约翰订购了一个%s" % pizza.get_name()

结果：
准备: 纽约风格芝士披萨
烘烤25分钟在350。
切割成对角线切片。
放在官方的盒子中。
纽约风格芝士披萨:
面团: 薄的面团
酱汁: 番茄酱
奶酪: 新鲜的奶酪

迈克订购了一个纽约风格芝士披萨

准备: 芝加哥风格文蛤披萨
烘烤25分钟在350。
切割成对角线切片。
放在官方的盒子中。
芝加哥风格文蛤披萨:
面团: 厚的生面团
酱汁: 蘑菇酱
文蛤: 冷冻的文蛤

约翰订购了一个芝加哥风格文蛤披萨