精华内容
下载资源
问答
  • python理解工厂模式

    2020-02-26 15:09:16
    return Putong_factory() 四、抽象工厂模式 当方法工厂模式中,工厂类太多时,对于同一系列的集中式生产,对于不同系列的分散式生产,面向多个产品系列 class Kouzhao_factory: # def create_kouzhao(self): # ...

    一、定义两个需要实例化的系列

    class Kouzhao:
    
        def houdu(self):
            pass
    
    
    class N95(Kouzhao):
    
        def houdu(self):
            print('3 层 ....')
    
    
    class Yihu(Kouzhao):
    
        def houdu(self):
            print('3 层')
    
    
    class Putong(Kouzhao):
    
        def houdu(self):
            print('2 层 ....')
    
    class Job:
    
        def get_name(self):
            pass
    
    
    class Doctor(Job):
    
        def get_name(self):
            print('doctor')
    
    
    class Student(Job):
    
        def get_name(self):
            print('student')
    

    二、简单工厂模式

    根据传入的参数返回相应的实例对象,一个工厂类来负责所有产品的创建,集中生产
    
    def choose_kouzhao(type):
        if type == 'n95':
            return N95()
        elif type == 'yihu':
            return Yihu()
        elif type == 'putong':
            return Putong
    

    三、方法工厂模式

    一个工厂只负责创建一个产品遵从了单一职责原则,分散生产
    
    class Method_Factory:
        def get_kouzhao(self):
            pass
    
    
    class N95_factory(Method_Factory):
        def get_kouzhao(self):
            return N95()
    
    
    class Yihu_factory(Method_Factory):
        def get_kouzhao(self):
            return Yihu()
    
    
    class Putong_factory(Method_Factory):
        def get_kouzhao(self):
            return Putong()
    
    
    def factory_choose(type):
        if type == 'n95':
            return N95_factory()
        elif type == 'yihu':
            return Yihu_factory()
        elif type == 'putong':
            return Putong_factory()
    

    四、抽象工厂模式

    当方法工厂模式中,工厂类太多时,对于同一系列的集中式生产,对于不同系列的分散式生产,面向多个产品系列
    
    class Kouzhao_factory:
    
    	# def create_kouzhao(self):
    	# 	pass
    		
        def get_n95(self):
            return N95()
    
        def get_putong(self):
            return Putong()
    
        def get_yihu(self):
            return Yihu()
    
    class Job_factory:
    
        def create_job(self, type):
            if type == 'd':
                return Doctor()
            if type == 's':
                return Student()
    
    def get_factory(name):
        if name == 'job':
            return Job_factory()
        if name == 'kouzhao':
            return Kouzhao_factory()
    
    展开全文
  • Python设计模式之工厂模式普通工厂抽象工厂 普通工厂 工厂模式,可以理解为创建一个工厂(类),这个工厂会根据你的需求(输入)生产出(输出)你想要的产品(对象)。简单说就是工厂类会根据你的输入给你返回恰当的...

    Python设计模式之工厂模式

    普通工厂

    工厂模式,可以理解为创建一个工厂(类),这个工厂会根据你的需求(输入)生产出(输出)你想要的产品(对象)。简单说就是工厂类会根据你的输入给你返回恰当的对象。

    class Shape:
        @staticmethod
        def factory(shape):
            if shape == 'square':
                return Square()
            if shape == 'circle':
                return Circle()
    
    class Square:
        @staticmethod
        def draw():
            return "I am a Square"
    
    
    class Circle:
        @staticmethod
        def draw():
            return "I am a Circle"
    
    
    if __name__ == '__main__':
        shape = Shape().factory("square")
        print(shape.draw())
        shape = Shape().factory("circle")
        print(shape.draw())
    

    抽象工厂

    抽象工厂:有时候我们希望通过单个接口能够访问所有的工厂,而不用关心具体的工厂,此时就需要定义一个抽象类,让所有的工厂类都继承这个类并实现这个接口。

    from abc import ABCMeta, abstractmethod
    
    
    class AbstractFactory(metaclass=ABCMeta):
        """
        抽象工厂,定义所有工厂需要实现的接口
        """
        @abstractmethod
        def make_object(self):
            pass
    
    
    class SquareFactory(AbstractFactory):
        """
        具体工厂,继承抽象工厂,实现必要接口
        """
        def make_object(self):
            return Square()
    
    
    class CircleFactory(AbstractFactory):
        """
        具体工厂,继承抽象工厂,实现必要接口
        """
        def make_object(self):
            return Circle()
    
    
    class Square:
        @staticmethod
        def draw():
            return "I am a Square"
    
    
    class Circle:
        @staticmethod
        def draw():
            return "I am a Circle"
    
    
    if __name__ == '__main__':
        def draw_func(factory):
            """
            调用函数,不关心具体工厂,直接使用make_object()接口创建对象。
            """
            obj = factory.make_object()
            print(obj.draw())
    
        factory = SquareFactory()
        draw_func(factory)
        factory = CircleFactory()
        draw_func(factory)
    
    展开全文
  • python设计模式之工厂模式 一.理解工厂模式 在面向对象编程中,术语“工厂”表示一个负责创建替他类型对象的类。通常情况下,作为一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法,...

    python设计模式之工厂模式

    一.理解工厂模式

    在面向对象编程中,术语“工厂”表示一个负责创建替他类型对象的类。通常情况下,作为一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法,之后,工厂会据此创建所需类型的对象,然后将它们返回给客户端。

    简单理解:工厂模式依然是一种创建型设计模式,作为工厂,它所关心的是产品的产生,也就是对象的创建,我们利用工厂来创建对象,而不必我们亲自创建对象,我们无需去理解如何创建对象,只需要向工厂提出要求,让工厂去根据你的要求,给你生产你要的产品,给你相应的对象,这种模式便叫做工厂模式。

    二.工厂模式的优点

    • 松耦合,对象的创建独立于类的实现

    • 客户端无需了解创建对象的类,只需知道需要传递的接口,方法和参数就能够创建所需要的对象

    • 很容易扩展工厂添加其他类型对象的创建,而使用者只需要改变参数就可以了

    三.python实现工厂模式

    1.简单工厂模式

    
    from abc import ABCMeta,abstractmethod
    
    class Coke(metaclass=ABCMeta):
        @abstractmethod
        def drink(self):
            pass
    
    class Coca(Coke):
        def drink(self):
            print('drink Coca-Cola')
    
    class Pepsi(Coke):
        def drink(self):
            print('drink Pepsi-Cola')
    
    class Fast_food_restaurant():
        def make_coke(self ,name):
            return eval(name)()
    
    KCD=Fast_food_restaurant()
    coke=KCD.make_coke('Coca')
    coke.drink()#drink Coca-Cola
    

    ABCMeta是python的一个元类,用于在Python程序中创建抽象基类,抽象基类中声明的抽象方法,使用abstractmethod装饰器装饰。

    eval(类名)返回的是一个class类型的对象

    我们建立一个可乐的抽象类,百事可乐和可口可乐继承这个抽象类,我们又建立了快餐店类,也就是所说的工厂类,让它生产可乐。当用户需要可乐时,只需要告诉快餐店做一份什么品牌的可乐,告诉快餐店可乐的名字,然后快餐店使用make_coke方法做可乐,返回了你所需要的对象——一杯可口可乐,然后就可以快乐的喝可乐了。。

    2.工厂方法模式

    简单工厂模式已经帮我们做到我们需要某种对象时,可以不关心对象是怎么创建的,只需要向工厂类要对象即可,但是如果我们又多了一种对象,例如又出现了一个可乐品牌,嗯,我们叫它sfencs可乐吧,那么我们快餐店也得新添加这种可乐,也就是工厂类也得能够创建sfencs可乐对象了,但是这样就得在工厂类中加入新的逻辑判断来根据用户需求制造新添加的这个对象,显然是不恰当的,因为这样每当有一个新的类型的可乐增加的时候,我们都得修改工厂类的逻辑代码,使之能够判断出新的类型。这个问题使用工厂方法模式可以得到解决。

    这里有一个小问题,如上面的简单工厂模式的代码,如果要新加sfencs可乐,似乎并不需要修改快餐店工厂类,只需要在sfencs可乐类定义之后,依然向make_coke函数传递类名即可,那这样岂不是不需要工厂方法模式了吗?

    对于这个现象,其实是得益于eval()函数的功能,它能依据传入的字符串转换成相应的类,也就是eval函数就是工厂类的逻辑判断,如果不使用eval,那么逻辑判断可能就是多个if语句了,判断条件就是输入的字符串参数是否等于这个,是否等于那个。。。等。但是eval使用也有很大的局限性,它只能根据字符串来判断,我们不一定创建对象时都知道它的类名。除此之外,个人感觉eval这个函数有点厉害,越厉害就有可能造成不必要的麻烦,eval使用时还是得多注意。

    接下来介绍工厂方法模式:

    
    from abc import ABCMeta,abstractmethod
    
    class Coke(metaclass=ABCMeta):
        @abstractmethod
        def drink(self):
            pass
    
    class Coca(Coke):
        def drink(self):
            print('drink Coca-Cola')
    
    class Pepsi(Coke):
        def drink(self):
            print('drink Pepsi-Cola')
    
    class Sfencs(Coke):
        def drink(self):
            print('drink Sfencs-Cola')
    
    class Fast_food_restaurant(metaclass=ABCMeta):
        @abstractmethod
        def make_coke(self):
            pass
    
    class Coca_produce(Fast_food_restaurant):
        def make_coke(self):
            return Coca()
    
    class Pepsi_produce(Fast_food_restaurant):
        def make_coke(self):
            return Pepsi()
    
    class Sfencs_produce(Fast_food_restaurant):
        def make_coke(self):
            return Sfencs()
    
    KCD=Sfencs_produce()
    coke=KCD.make_coke()
    coke.drink()#drink Sfencs-Cola
    

    工厂方法模式将原来的工厂类变为了抽象类,不同类型的可乐通过不同的子类生产,也就是工厂方法模式定义了一个创建对象的接口,但具体创建哪个类的对象由子类来决定,这种方式的逻辑判断相当于交给了客户端,也就是KCD=Sfencs_produce()来选择使用哪个子类,这样如果有新可乐产品出现的话,只需要再写一个子类继承工厂抽象类。

    这里的类中,快餐店抽象类也叫做抽象工厂类,它的子类称为具体工厂类。可乐也一样,Coke为抽象产品类,它的子类为具体产品类。

    3.抽象工厂模式

    抽象工厂模式的主要目的是提供一个接口来创建一系列相关对象而无需指定具体的类。这个模式与与工厂方法模式的区别在于,它的一个方法子类,可以创建一系列的对象。

    依然用可乐来举例,只喝普通的可乐还不足以让我们非常快乐,那么如果有一杯冰可乐,想必就能满足我们了。

    于是我们的抽象产品类变为了两个,一个是冰可乐,一个是普通可乐,具体产品类有百事冰可乐、可口可乐冰可乐,普通百事,普通可口可乐。抽象工厂类有生产冰可乐和生产普通可乐的抽象方法,具体工厂类有百事工厂,可口可乐工厂。

    
    from abc import ABCMeta,abstractmethod
    
    class Ice_coke(metaclass=ABCMeta):
        @abstractmethod
        def drink(self):
            pass
    
    class Ordinary_coke(metaclass=ABCMeta):
        @abstractmethod
        def drink(self):
            pass
    
    class Coca_ice(Ice_coke):
        def drink(self):
            print('drink  Coca-ice-Cola')
    
    class Pepsi_ice(Ice_coke):
        def drink(self):
            print('drink Pepsi-ice-Cola')
    
    class Coca_ordinary(Ordinary_coke):
        def drink(self):
            print('drink Coca-ordinary-Cola')
    
    class Pepsi_ordinary(Ordinary_coke):
        def drink(self):
            print('drink Pepsi-ordinary-Cola')
    
    class Fast_food_restaurant(metaclass=ABCMeta):
        @abstractmethod
        def make_ice_coke(self):
            pass
    
        @abstractmethod
        def make_ordinary_coke(self):
            pass
    
    class Coca_produce(Fast_food_restaurant):
        def make_ice_coke(self):
            return Coca_ice()
        def make_ordinary_coke(self):
            return Coca_ordinary()
    
    class Pepsi_produce(Fast_food_restaurant):
        def make_ice_coke(self):
            return Pepsi_ice()
        def make_ordinary_coke(self):
            return Pepsi_ordinary()
    
    KCD=Coca_produce()
    coke=KCD.make_ice_coke()
    coke.drink()#drink  Coca-ice-Cola
    

    这样再有其他类型的可乐或者其他品牌的可乐,只需要添加方法或者类就可以了。


    参考《Python设计模式(第2版)》

     

    展开全文
  • python 工厂设计模式

    2019-07-29 10:49:11
    一、对工厂设计模式的理解 在现实生活中,工厂是用于生产产品的,我们告诉工厂,我们需要什么样的产品,工厂就会生产出该...1、工厂模式巨有非常好的封装性,代码结构清晰; 2、屏蔽产品类,使产品的被使用业务场...

    一、对工厂设计模式的理解

    在现实生活中,工厂是用于生产产品的,我们告诉工厂,我们需要什么样的产品,工厂就会生产出该产品,我们无需知道该产品到底是怎么生产的。在python中也是一样的,我们只需要调用工厂类的方法,传入参数后,就能得到我们想要的对象,此时我们并不关心该对象的内部实现。

    二、工厂设计模式的优点

    1、工厂模式巨有非常好的封装性,代码结构清晰;

    2、屏蔽产品类,使产品的被使用业务场景和产品的功能细节可以分而开发进行,是比较典型的解耦框架。

    三、工厂模式的简单实现

    流程图:

    代码实现

    class Factory(object):
        """定义工厂类"""
        def create_fruit(self,fruit):
            """定义创建水果方法"""
            if fruit == "apple":
                return Apple()
            elif fruit == "peach":
                return Peach()
    
    class Fruit(object):
        """创建水果类"""
        def __str__(self):
            return "fruit"
    
    class Apple(Fruit):
        """创建苹果类"""
        def __str__(self):
            return "apple"
    
    class Peach(Fruit):
        """创建桃子类"""
        def __str__(self):
            return "peach"
    
    if __name__ == "__main__":
        #工厂实例化
        factory = Factory()
        #使用工厂创建水果
        fruit = factory.create_fruit("apple")
        print(fruit)

     

    展开全文
  • 主要介绍了Python 工厂模式的相关资料,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 个人理解抽象工厂模式就是将工厂方法模式进行了一般化,一个工厂不仅仅只生产一种产品,而是一个产品族。 示例代码如下: from abc import ABCMeta, abstractmethod from Tools.scripts.serve import app class ...
  • 抽象工厂模式和简单工厂/工厂方法不同,抽象工厂可能最好理解,举个例子: 比如2个动物,猫和狗,他们都有speak和eat的function,但是很明显他们执行的结果是不同的 有个’工厂’(抽象工厂里面一个类型就是一个工厂,...
  • 主要介绍了Python 抽象工厂模式的优缺点,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 三、工厂模式 四、策略模式 五、观察者模式 一、引入 程序中设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。 这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。...
  • 记录学习 本系列文章是希望将软件项目中最常见的设计模式用通俗易懂的语言来讲解清楚,并通过Python来实现,每个设计...理解了为什么我们也就基本了解了什么情况下使用这个模式,不过在这里还是会细化使用场景,阐...
  • 转自:http://blog.csdn.net/ericzhong83/article/details/7604728
  • 程序中设计模式是软件开发人员在软件开发过程...设计模式主要包括:单例模式,工厂模式,策略模式 一、单例模式 保证只有一个对象。 注意:在python中导入模块就是一种单例模式。 练习1:创建Sun类 class Person(obj...
  • 本系列文章是希望将软件项目中最常见的设计模式用通俗易懂的语言来讲解清楚,并通过Python来实现,每个...理解了为什么我们也就基本了解了什么情况下使用这个模式,不过在这里还是会细化使用场景,阐述模式的局限...
  • 使用swift、python两种语言来编写demo介绍工厂模式,便于大家理解
  • 在使用到多个窗口时,往往需要进行窗口通讯,和窗口跳转,但是每次窗口跳转时都重新创建的话,一个是会不利于窗口...工厂模式 实现代码如下: #!/AME/OMOstep4/phtest python # _*_ conding:utf-8 _*_ # @TIME.
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 工厂方法与抽象工厂是否傻傻分不清,力求以最简单和最直接的方式来理解模式设计,毕竟模式的初衷是化繁为简,就该用最...工厂模式 #-*-coding:utf-8-*-classA: def__init__(self): self.word="运行A" defrun(self):...
  • 专业介绍: 简单工厂模式是属于创建型模式,又叫做...简单工厂模式工厂模式家族中最简单实用的模式,可以理解为是不同于工厂模式的一个特殊实现。引用自-百度百科 关键词:一个工厂、简单实用 通俗介绍: ...
  • 工厂方法与抽象工厂是否傻傻分不清,力求以最简单和最直接的方式来理解模式设计,毕竟模式的初衷是化繁为简,就该用最...工厂模式 #-*-coding:utf-8-*-classA: def__init__(self): self.word="运行A" defrun(self):...
  • python设计模式

    2019-06-26 01:00:50
    设计模式 设计模式代表了一种最佳实践,是被开发人员长期总结,用来解决某一问题的思路方法。...单例模式 工厂模式 生产者模式。。。。。 生产者消费者模式 功能:控制数据资源数量,降低耦合度 ...

空空如也

空空如也

1 2 3 4 5
收藏数 84
精华内容 33
热门标签
关键字:

python工厂模式理解

python 订阅