摘要：還有一個工廠類。工廠類有一個方法名有兩個輸入參數，名字和性別。用戶使用工廠類，通過調用方法。抽象工廠模式提供一個創建一系列相關或相互依賴對象的接口，而無須指定它們具體的類。

概念
工廠模式：工廠模式就是不管如何實現的，只需要調用抽象話的接口就可以創建出特定類型的實例對象

簡單工廠模式：
eg：一個例子更能很好的理解以上的內容：
我們有一個基類Person ，包涵獲取名字，性別的方法 。有兩個子類male 和female，可以打招呼。還有一個工廠類。
工廠類有一個方法名getPerson有兩個輸入參數，名字和性別。
用戶使用工廠類，通過調用getPerson方法。

在程序運行期間，用戶傳遞性別給工廠，工廠創建一個與性別有關的對象。因此工廠類在運行期，決定了哪個對象應該被創建。

class Person:

def __init__(self):
    self.name = None
    self.gender = None

def getName(self):
    return self.name

def getGender(self):
    return self.gender

class Male(Person):

def __init__(self, name):
    print "Hello Mr." + name

class Female(Person):

def __init__(self, name):
    print "Hello Miss." + name

class Factory:

def getPerson(self, name, gender):
    if gender == ‘M":
            return Male(name)
        if gender == "F":
        return Female(name)

if name == "__main__":

factory = Factory()
person = factory.getPerson("Chetan", "M")

抽象工廠模式：
提供一個創建一系列相關或相互依賴對象的接口，而無須指定它們具體的類。
class Burger():

"""
漢堡
"""
name=""
price=0.0
type="BURGER"
def getPrice(self):
    return self.price
def setPrice(self,price):
    self.price=price
def getName(self):
    return self.name

class CheeseBurger(Burger):

def __init__(self):
    self.name="cheese burger"
    self.price=10.0

class SpicyChickenBurger(Burger):

def __init__(self):
    self.name="spicy chicken burger"
    self.price=15.0

class Snack():

"""
小食類
"""
name = ""
price = 0.0
type = "SNACK"
def getPrice(self):
    return self.price
def setPrice(self, price):
    self.price = price
def getName(self):
    return self.name

class Chips(Snack):

def __init__(self):
    self.name = "chips"
    self.price = 6.0

class ChickenWings(Snack):

def __init__(self):
    self.name = "chicken wings"
    self.price = 12.0

class Beverage():

"""
飲料
"""
name = ""
price = 0.0
type = "BEVERAGE"
def getPrice(self):
    return self.price
def setPrice(self, price):
    self.price = price
def getName(self):
    return self.name

class Coke(Beverage):

def __init__(self):
    self.name = "coke"
    self.price = 4.0

class Milk(Beverage):

def __init__(self):
    self.name = "milk"
    self.price = 5.0

class FoodFactory():

"""
抽象工廠foodFactory為抽象的工廠類，而burgerFactory，snackFactory，beverageFactory為具體的工廠類。
"""
type=""
def createFood(self,foodClass):
    print(self.type," factory produce a instance.")
    foodIns=foodClass()
    return foodIns

class BurgerFactory(foodFactory):

def __init__(self):
    self.type="BURGER"

class SnackFactory(foodFactory):

def __init__(self):
    self.type="SNACK"

class BeverageFactory(foodFactory):

def __init__(self):
    self.type="BEVERAGE"

if __name__=="__main__":

burger_factory=burgerFactory()
snack_factory=snackFactory()
beverage_factory=beverageFactory()
cheese_burger=burger_factory.createFood(cheeseBurger)
print(cheese_burger.getName(),cheese_burger.getPrice())
chicken_wings=snack_factory.createFood(chickenWings)
print(chicken_wings.getName(),chicken_wings.getPrice())
coke_drink=beverage_factory.createFood(coke)
print(coke_drink.getName(),coke_drink.getPrice())

工廠模式優點
工廠方法用來創建客戶所需要的產品，同時還向客戶隱藏了哪種具體產品類將被實例化這一細節 能夠讓工廠自主確定創建何種產品對象，而如何創建這個對象的細節則完全封裝在具體工廠內部 在系統中加入新產品時，完全符合開閉原則
工廠模式缺點
系統中類的個數將成對增加，在一定程度上增加了系統的復雜度，會給系統帶來一些額外的開銷 增加了系統的抽象性和理解難度
工廠模式適用環境
客戶端不知道它所需要的對象的類（客戶端不需要知道具體產品類的類名，只需要知道所對應的工廠即可，具體產品對象由具體工廠類創建） 抽象工廠類通過其子類來指定創建哪個對象

抽象工廠模式：
模式優點
隔離了具體類的生成，使得客戶端并不需要知道什么被創建 當一個產品族中的多個對象被設計成一起工作時，它能夠保證客戶端始終只使用同一個產品族中的對象 增加新的產品族很方便，無須修改已有系統，符合開閉原則
模式缺點
增加新的產品等級結構麻煩，需要對原有系統進行較大的修改，甚至需要修改抽象層代碼，這顯然會帶來較大的不便，違背了開閉原則
模式適用環境
一個系統不應當依賴于產品類實例如何被創建、組合和表達的細節 系統中有多于一個的產品族，但每次只使用其中某一產品族 屬于同一個產品族的產品將在一起使用，這一約束必須在系統的設計中體現出來 產品等級結構穩定，設計完成之后，不會向系統中增加新的產品等級結構或者刪除已有的產品等級結構

單例模式
單例模式（Singleton Pattern）是一種常用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你希望在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。 eg：系統中的打印機
實現方式：
使用模塊:
在mysingleton.py模塊文件中：(因為模塊在第一次導入時生成了.pyc文件，下次會直接從這個里面加載，不需要重新生成)
class Singleton:(object):

 def foo(self):
   pass

singleton = Singeton()

在其他文件中調用：
from mysingleton import singleton
使用裝飾器：
def Singleton(cls):

_instance = {}

def _singleton(*args, **kargs):

    if cls not in _instance:
        _instance[cls] = cls(*args, **kargs)
    return _instance[cls]

return _singleton

@Singleton
class A(object):

a = 1

def __init__(self, x=0):
    self.x = x

a1 = A(2)
a2 = A(3)
print(id(a1))
print(id(a2))

使用類
import time
import threading
class Singleton(object):

_instance_lock = threading.Lock()

def __init__(self):
    time.sleep(1)

@classmethod
def instance(cls, *args, **kwargs):
    if not hasattr(Singleton, "_instance"):
        with Singleton._instance_lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = Singleton(*args, **kwargs)
    return Singleton._instance

def task(arg):

obj = Singleton.instance()
print(obj)

for i in range(10):

t = threading.Thread(target=task,args=[i,])
t.start()

time.sleep(20)
obj = Singleton.instance()
print(obj)

基于__new__方法創建單例
import threading
class Singleton(object):

_instance_lock = threading.Lock()

def __init__(self):
    pass


def __new__(cls, *args, **kwargs):
    if not hasattr(Singleton, "_instance"):
        with Singleton._instance_lock:
            if not hasattr(Singleton, "_instance"):
                Singleton._instance = object.__new__(cls)  
    return Singleton._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1,obj2)

def task(arg):

obj = Singleton()
print(obj)

for i in range(10):

t = threading.Thread(target=task,args=[i,])
t.start()

基于metaclass方式來實現
import threading

class SingletonType(type):

_instance_lock = threading.Lock()
def __call__(cls, *args, **kwargs):
    if not hasattr(cls, "_instance"):
        with SingletonType._instance_lock:
            if not hasattr(cls, "_instance"):
                cls._instance = super(SingletonType,cls).__call__(*args, **kwargs)
    return cls._instance

class Foo(metaclass=SingletonType):

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

obj1 = Foo("name")
obj2 = Foo("name")
print(obj1,obj2)