工厂模式、抽象类，单例及复制对象的简单介绍

1. 简单工厂模式
   优缺点：
   定义起来简单，容易理解
   但是如果对象的创建方式过于复杂，则会导致工厂代码急剧增加

# 商场买鞋，首先有各种品牌的鞋子
# 商场的功能是出售各种品牌的鞋子，鞋子由工厂提供
# 工厂生产各种品牌的鞋子

# 各个品牌的鞋子
class NikeShoe:
    # __str__是为了能够返回字符串
    def __str__(self):
        return '耐克鞋子'
class LiniShoe:
    def __str__(self):
        return '李宁鞋子'
class NeiShoe:
    def __str__(self):
        return '内联升鞋子'
class AdiShoe:
    def __str__(self):
        return '阿迪鞋子'

# 商店
class Store:
    def __init__(self,factory):
        self.factory=factory
    def sell_shoe(self,brand):
        return self.factory.create(brand)

# 工厂
class ShoeFactory:
    def create(self,brand):
        if brand=='nike':
            return NikeShoe()
        elif brand=='lining':
            return LiniShoe()
        elif brand=='nei':
            return NeiShoe()

# 补充工厂
class NikeAdiFactory:
    def create(self,brand):
        if brand=='nike':
            return NikeShoe()
        elif brand=='adi':
            return AdiShoe()

# 创建商场
my_store=Store(ShoeFactory())
my_store2=Store(NikeAdiFactory())

# 销售鞋子
s1=my_store.sell_shoe('nike')
s2=my_store.sell_shoe('lining')
s3=my_store2.sell_shoe('adi')

print(s1)
print(s2)
print(s3)

2.工厂方法模式
优缺点：
一个工厂只创建一种对象，适用于创建对象比较复杂的情况
不适用类过多的情况

# 创建飞船类
class Ship:
    def __init__(screen,gc,bullet,oil):
        self.screen=screen
        self.gc=gc
        self.bullet=bullet
        self.oil=oil

# 创建外星人类
class Alien:
    def __init__(screen,gc):
        self.screen=screen
        self.gc=gc

# 各种属性类
class GameConfig:
    pass
class Bullet:
    pass
class Screen:
    pass
class Oil:
    pass

# 飞船工厂
class ShipFactory:
    def create(self):
        gc=GameConfig()
        bullet=Bullet()
        screen=Screen()
        oil=Oil()
        return Ship(screen,gc,bullet,oil)

# 外星人工厂
class AlienFactory:
    def create(self):
        gc=GameConfig()
        screen=Screen()
        return Alien(screen,gc)

class GameMain:
    def __init__(self):
        self.ship_factory=ShipFactory()
        self.alien_factory=AlienFactory()
        ship=self.ship_factory.create()
        alien=self.alien_factory.create()

3.抽象工厂
优缺点：
抽象类不是用来创建对象的，而是用来定义接口的
一个工厂类可以用来创建多种对象，每个工厂所创建的对象都是一组相关的对象
将工厂中共有的方法统一抽象到一个父类中，这样就避免了在工厂中编写重复性的代码

class NikeShoe:
    def __str__(self):
        return '耐克鞋子'
class NikeClothes:
    def __str__(self):
        return '耐克衣服'
class AdiShoe:
    def __str__(self):
        return '阿迪鞋子'
class AdiClothes:
    def __str__(self):
        return '阿迪衣服'

class Stroe:
    def __init__(self,factory):
        self.factory=factory
    def sell_shoe(self):
        return self.factory.create_shoe()
    def sell_clothes(self):
        return self.factory.create_clothes()

class Factory:
    def create_shoe(self):
        return self.shoe()
    def create_clothes(self):
        return self.clothes()    

class NikeFactory(Factory):
    def __init__(self):
        self.shoe=NikeShoe
        self.clothes=NikeClothes

class AdiFactory(Factory):
    def __init__(self):
        self.shoe=AdiShoe
        self.clothes=AdiClothes

s=Stroe(AdiFactory())

print(s.sell_shoe())
print(s.sell_clothes())

4.抽象类（只是延伸）
抽象类（接口）不是用来创建对象，而是用来定义类的标准，抽象类主要是用来规定类中具有哪些方法，一般用来被其他类继承

# 在python中，提供了一个类ABC，这个类专门用来被抽象类继承
# ABC=AbstractClass
import abc
# 引入abc模块
class A(abc.ABC):
    '''
    抽象类
    '''
    @abc.abstractmethod
    # 将方法装饰为抽象方法，抽象方法必须被子类实现
    def fn1(self):
        pass
    def fn2(self):
        pass
    def fn3(self):
        pass

class B(A):
    '''
    子类必须要实现抽象类中的抽象方法
    '''
    def fn1(self):
        print('hello')
b=B()
print(b)

#运行结果：<__main__.B object at 0x0000000001EB7BA8>

5.单例
Singleton类型的对象只能有一个

class Singleton:
    instance=None   #实例
    def __new__(cls):#创建新类
        # 判断是否该类对象存在，不存在则根据父类创建，
        # 存在则返回已有对象
        if not cls.instance:
            cls.instance=super().__new__(cls)
        return cls.instance
    def __init__(self):
        pass

6.复制
http://www.pythontutor.com(检测程序运行轨迹的网址)
浅复制，就是只复制对象本身，而对象中的属性（元素）不会被复制，当对象本身发生改变时，复制方也会随之发生改变

#几种常见的浅复制
l=[1,2,3,[4,5,6]]
l1=l.copy()
l2=l[:]
l3=list(l)
print(l1)
print(l2)
print(l3)

对于深浅复制的对比

import copy
class Bus:
    def __init__(self,people):
        self.people=people
    def up(self,name):
        self.people.append(name)
    def down(self,name):
        self.people.remove(name)
b=Bus(['小明','小红','小芳'])
b1=copy.copy(b)        #对b进行浅复制
b2=copy.deepcopy(b)    #对b进行深复制

b.up('小华')
b.down('小明')

print(b.people)
print(b1.people)
print(b2.people)

运行结果：
['小红', '小芳', '小华']
['小红', '小芳', '小华']
['小明', '小红', '小芳']

---

小白笔记