5.Python的語言特點
前言
Python有哪些語言特點？可以列出的特點很多，例如，《Python核心程式設計》第二版列出了十多條特點。本文的三個特點是筆者學習Python的體會，其他特點有體會之後再寫，筆者是這樣概括的：Python是 解釋性和編譯性結合的 、 動態的 、 面向物件的 。
解釋性和編譯性
解釋性是指高階語言程式執行的時候依賴於解析器將程式翻譯成計算機能理解的低階語言指令，編譯性指高階語言執行前先編譯成計算機可執行目標低階語言，然後讓計算機執行。由於解釋型語言在執行過程中仍需直譯器逐句翻譯而編譯型語言只要編譯好就可以直接執行而無需再解釋，所以相對來說，編譯型語言的執行速度快，即效能高。筆者認為，python語言是解釋性和編譯性混合的。 下面多餘的展開也就這個意思 。
計算機無法識別和執行高階語言，一個高階語言程式在可執行之前先要翻譯成一種能被計算機執行的低階語言，這沒有貶低的意思，方便而已。而完成這項翻譯工作的就是語言處理器，常見的有編譯器和直譯器。編譯器可以將某種高階語言程式翻譯成等價的目標語言程式，以被計算機執行。直譯器則是在程式檔案執行的過程中將其逐句翻譯成計算能看懂的指令（二進位制碼）。由於編譯型語言一經編譯成目標語言程式，計算機馬上可以執行，而解釋型在程式執行時還要慢慢的解釋每一句給計算機執行，所以，一般來說解釋型語言執行速度比編譯型的慢；所以把使用者輸入對映成輸出的過程中，由一個編譯器產生的機器語言目標程式要比由一個直譯器快，也就是編譯型的效能好。
然而為什麼還存在解釋型呢？當然是由於解釋型相對於編譯型的一些優點，比如動態（也是缺點，不過筆者認為是優大於缺，而動態和解釋性相關，不同觀點勿見怪）等。所以為了兼顧效能與開發效率，某些語言自然混合瞭解釋性和編譯性。筆者認為，python程式的執行是混合瞭解釋性和編譯性的：當程式執行時，python內部（這是一個抽象）先將源程式（即我們編寫的程式）編譯成“位元組碼”，這個過程是我們看不見的，即被隱藏起來了，如果python程序在機器上擁有寫入許可權，那麼，它將把程式的位元組碼儲存為一個以.pyc為副檔名的檔案（這是一個優化效能的步驟：在下次執行該程式時，如果程式沒有變化，那麼直譯器將直接載入這個檔案從而跳過了編譯這個步驟以提高速度），然後再發送給虛擬機器。位元組碼一旦傳送給虛擬機器（PVM），虛擬機器便開始逐條執行翻譯（如下圖）。位元組碼並不是cpu碼（二進位制碼），所以執行起來相對編譯後的二進位制碼仍然是慢。
不知道為啥圖片要重新整理才會顯示@部落格園團隊
動態的
動態，相對於靜態，意味著隨時可變，意為靈動。也可以稱之為動態型別：型別由程式碼執行過程中自行決定，無需宣告強調，而靜態型別則是在執行前決定。
變數
python的變數就是在特定的時間引用一個特定的物件，不同的變數可以引用同一個物件，所以物件地址也是相同的，物件的型別必須是明確的，而所有物件首先必須要知道自己的型別（解析器能夠判斷，例如物件3知道自己的型別是int），這樣的賦值才是有意義，像單純一句“a=b”這樣的變數引用是錯誤的，因為直譯器無法在其作用域中判斷出物件b的型別。型別屬於物件而不是變數名，所以無需指明變數的型別。
變數的引用和記憶體管理相關，可以查詢 引用計數和垃圾回收 方面的資料，祥略。
>>> a=1
>>> a=0.5
>>> a='a'
>>> a=[]
>>> type(1)
<class 'int'>
>>> type(0.5)
<class 'float'>
>>> type('a')
<class 'str'>
>>> type([])
<class 'list'>
>>> a=b
Traceback (most recent call last):
File "<pyshell#16>", line 1, in <module>
a=b
NameError: name 'b' is not defined
引數
Python中，引數通過賦值傳遞，賦值相當於變數的引用，自然，函式和方法中的引數的值和型別也都是動態的，這些引數的值只有在被呼叫的時候定義，而非在函式內定義。其實，函式定義內的引數是形參，而呼叫時提供給引數的的值則為實參，引數在函式定義的圓括號對內指定，用逗號分割。當我們呼叫函式的時候，我們以同樣的方式提供值。由於數字不能作為變數，這樣的賦值語句是會引發異常的：4=3，如果將函式作為一個引數，即將函式物件被引用，那麼該函式就是一個 回撥函式 。
>>> def add(x=1, y=2):# 動態引數
return x+y
>>> add()
3
>>> add(2,3)
5
>>> add('a','b')
'ab'
>>> add([1],[2,3])
[1, 2, 3]
>>> 4=3# 數字不能作為變數
SyntaxError: can't assign to literal
>>> def call_back(i):# 回撥函式
print(i)
>>> def call(i, func):
func(i)
>>> call((1,2,3,4,5),call_back)
(1, 2, 3, 4, 5)
類物件
類是面向物件常用的方法，在python中定義了類也是很“動態”的，前一篇文章說過，類相當於一個 理想模型--模具 ，所以類例項都具有類的某些共同的特性，但每個類例項又有不同的地方，動態屬性和動態方法也是造成這種差異的原因。再次強調，所謂動態，是指執行過程中的變化。
動態屬性
>>> class Spider: def __init__(self, url): self.url=url# 要引用url屬性，url就要作為引數新增到括號裡 >>> s=Spider(url='https://music.163.com/')# 例項化，不帶括號則指向類本身而不是例項物件，由於__init__方法的原因，必須給類提供一個引數url >>> s.cookies="cookies"# 執行過程中繫結類屬性 >>> s.cookies 'cookies'
動態方法
要在執行過程中實現方法的繫結，需要藉助於types模組中的MethodType方法，MethodType方法需要傳遞兩個引數，第一個是function,第二個是instance。
>>> class Spider:
def __init__(self, url):
self.url=url
>>> s=Spider(url='https://music.163.com/')
>>> import types
>>> def parse(self):
print('retrun the txt')
>>> s.parse=types.MethodType(parse, s)
>>> s.parse()
retrun the txt
面向物件（object）
宣告一下，以下全是個人在寫這部分內容的想法細節，所以會很囉嗦@唐三藏，如果看官不想看，筆者不想浪費大家的時間。但筆者相信有人想看的，畢竟人最想看到的東西就是人自己遮住的東西。當然筆者更希望的是能幫助到別人，和筆者同樣處境的人。
面向物件的基本思想
物件（object）是什麼？可以理解為男朋友和女朋友嗎？好像不太符合現階段，好像也可以···這樣理解比較複雜。筆者的理解是：物件是類的例項化。程式設計物件是具有特定標識地址、屬性值和方法的事物，面向物件其實就是通過建立一個 理想模型 來“生產”物件，這個理想模型就是類，而物件就是一個個例項化後的類，物件具有類的屬性和方法，方法往往可以呼叫屬性。例如建立一個抽象模型--Person，賦予屬性（name、age)和方法（say_hello)，這個say_hello方法就是呼叫了P本身並利用了屬性name的值。然後就可以這個類來“生產“不同的Person例項，比如Jack，比如mark···，
>>> class Person:
def __init__(self, name, age):
self.name=name
self.age=age
def say_hello(self):
print('hello, my name is %s'%self.name)
>>> P=Person('jack',23)# 由於__init__方法的原因，必須提供兩引數，不能這樣例項化：P=Person()
>>> P.name
'jack'
>>> P.age
23
>>> P.say_hello()# 這裡就不用提供引數了，這也是方法（類的方法）和函式的唯一區別
hello, my name is jack
>>> P=Person('mark',24)
>>> P.name
'mark'
>>> P.age
24
>>> P.say_hello()
hello, my name is mark
>>>
設計模式（工廠模式）
設計模式和麵向物件密切相關，關於設計模式的內容太大，這裡只簡單說下工廠模式，工廠模式屬於建立型模式，又可分為簡單工廠模式、工廠方法模式、抽象工廠模式三種。這裡以設計模式教程中的製造pizza為列子。再次重複強調，面向物件就是要創 建理想模型，然後例項化這個模型 ， 繼而模擬現實的物件 。好吧，原諒我沉溺於柏拉圖的理想模型吧（個人觀點）。所以，我們要建立pizza的模型和例項化pizza物件！
如何去設計pizza呢？依據pizza這個物件在現實情況，很容易就代入了pizza的賣家和買家，我們的理想模型要模擬的就是賣家，而例項化的過程是模擬買家的過程（最後我們的口號就是是賣家多賣錢，買家少花錢······，別信！）。
如何去模擬賣家和買家呢？既然是面向物件，當先從物件——買家的角度出發，考慮到生活實際，當我們想吃pizza的時候，首先要看下有哪些可以種類的pizza選擇，例如有海鮮pizza——SeafoodPizza，你想吃這個，然後你就會去買這個pizza或者網上訂購這個piazza，假如是在網上訂購，賣家肯定是需要提供給你進入這家piazza店——PizzaStore的一個店的入口，然後讓顧客去選擇這個SeafoodPizza？
如何提供呢？我們要做的當然是寫一個程式，當買家與這個程式互動的時候，提供piazza的種類給買家選擇。所以，這個程式應該是什麼樣的呢？看官不用在意筆者的思路，不同的人有不同的觀點，況且筆者的觀點淺薄不堪！筆者是這麼想的，先定義一個SeafoodPiazza，然後再定義一個主程式作為入口，當顧客進入了這個入口，就可以選擇自己喜歡的pizza，當顧客選擇了自己想要的pizza之後，剩下的就是pizza店的事情了。
那麼pizza店在接收到訂單之後要如何處理這個海鮮pizza訂單呢？筆者不知道怎麼做海鮮pizza，不過筆者知道做海鮮pizza的流程應該是一個自動化的流程，包含了一些步驟，而這些步驟將會是一些類方法，然後我們去呼叫這些方法去把pizza做出來。看到教程的做法是這樣的，如此這般，準備pizza——prepare()、烤pizza——bake()、切pizza——cut()、 包裝——box()。蛋刀直入，直接就建立一個海鮮pizza！
定義好如何做pizza之後，又如何去呼叫這些方法呢？當然是"'物件'+'點'+'方法'”這樣呼叫，而這個物件就是例項化的SeafoodPizza——SeafoodPizza()！程式碼如下（但請千萬不要這麼寫）：
class SeafoodPizza:
def prepare(self):
return 'prepare seafood_pizza'
def bake(self):
return 'bake seafood_pizza'
def cut(self):
return 'cut seafood_pizza'
def box(self):
return 'box seafood_pizza'
def orderPizza(self):# 這個self就是我們下面將要例項化的SeafoodPizza——SeafoodPizza()
print(self.prepare())
print(self.bake())
print(self.cut())
print(self.box())
def main():
pizza = input('you will order seafood_pizza,please enter yes or no\n')# 放在迴圈外便於返回
while True:
if pizza == 'yes':
pizza = SeafoodPizza()
pizza.orderPizza()
print('seafood_pizza completed')
pizza = input('you have order seafood_pizza, anything else? yes or no\n ')
elif pizza == 'no':
print('bye')
return
else:
pizza = input('please enter yes or no\n')# 返回pizza獲取使用者輸入
if __name__ == '__main__':
main()
好了，what，why，how，what，how，why；why，what，how；what······頭暈······且慢，革命尚未成功，還不能倒下······（cry，hopeless······）
如果單單是隻經營一種pizza是可以這麼寫的，然鵝單單是一種顯然是不夠的，人都是喜新厭舊的嘛，面向物件也是這樣，因為一個物件不可能滿足顧客慾望的所有需求，所以要弄出多些花樣，輪流去滿足顧客才能維持這段供需關係。而且，作為生意人為了追求利益最大化肯定會拓展業務，增加產量，直到利潤最大化，原理祥略。所以店長又增加了兩種pizza模型——CheesePizza和ClamPizza。繼續按照上面那樣寫也是可以的，加兩段程式碼就可以了，可是此時的main()h函式就需要選擇是哪種型別的pizza了。畢竟三個不算多，但如果數量增加到10個呢？程式碼太富態了！在獲取輸入方面問題其實是不大的。程式碼如下但千萬別這麼寫！
1 class SeafoodPizza:
2
3def prepare(self):
4return 'prepare seafood_pizza'
5
6def bake(self):
7return 'bake seafood_pizza'
8
9def cut(self):
10return 'cut seafood_pizza'
11
12def box(self):
13return 'box seafood_pizza'
14
15def orderPizza(self):
16print(self.prepare())
17print(self.bake())
18print(self.cut())
19print(self.box())
20
21
22 class CheesePizza:
23
24def prepare(self):
25return 'prepare cheese_pizza'
26
27def bake(self):
28return 'bake cheese_pizza'
29
30def cut(self):
31return 'cut cheese_pizza'
32
33def box(self):
34return 'box cheese_pizza'
35
36def orderPizza(self):
37print(self.prepare())
38print(self.bake())
39print(self.cut())
40print(self.box())
41
42
43 class ClamPizza:
44
45def prepare(self):
46return 'prepare clam_pizza'
47
48def bake(self):
49return 'bake clam_pizza'
50
51def cut(self):
52return 'cut clam_pizza'
53
54def box(self):
55return 'box clam_pizza'
56
57def orderPizza(self):
58print(self.prepare())
59print(self.bake())
60print(self.cut())
61print(self.box())
62
63
64 def main():
65pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n')# 放在迴圈外便於返回
66while True:
67if pizza == 'seafood':
68pizza = SeafoodPizza()
69pizza.orderPizza()
70print('seafood_pizza completed')
71pizza = input('you have order seafood_pizza, anything else? Enter seafood cheese clam or no?\n ')
72
73elif pizza == 'cheese':
74pizza = CheesePizza()
75pizza.orderPizza()
76print('cheese_pizza completed')
77pizza = input('you have order cheese_pizza, anything else? Enter seafood cheese clam or no?\n ')
78
79elif pizza == 'clam':
80pizza = ClamPizza()
81pizza.orderPizza()
82print('clam_pizza completed')
83pizza = input('you have order clam_pizza, anything else? Enter seafood cheese clam or no?\n ')
84
85elif pizza == 'no':
86print('bye')
87return
88else:
89pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n')
90
91
92 if __name__ == '__main__':
93main()
View Code
那麼如何寫的簡短點呢？很快，我們發現，雖然pizza不一樣，但每種pizza的orderPizza的形式是一樣的，所有有什麼辦法讓它獨立出來以達一勞永逸呢？因此我們要處理不同pizza的訂單，那麼我們應該建立一個專門處理訂單的類，orderPizza將作為它的方法被呼叫，那麼如何建立這個類以相容不同的訂單呢？無論這個類取啥名，只要它能夠實現方法呼叫即可，但是如古裝劇非常講究名正言順一樣，起名適宜也是很重要的。例如：書上起的名字就是PizzaStore。
既然PizzaStore要能夠處理不同的訂單，那麼它的orderPizza方法就需要引入不同的型別判斷，而型別可以通過特殊方法__int__初始化型別引數？程式碼如下，但請別這樣搞。
1 class SeafoodPizza:
2
3def prepare(self):
4return 'prepare seafood_pizza'
5
6def bake(self):
7return 'bake seafood_pizza'
8
9def cut(self):
10return 'cut seafood_pizza'
11
12def box(self):
13return 'box seafood_pizza'
14
15
16 class CheesePizza:
17
18def prepare(self):
19return 'prepare cheese_pizza'
20
21def bake(self):
22return 'bake cheese_pizza'
23
24def cut(self):
25return 'cut cheese_pizza'
26
27def box(self):
28return 'box cheese_pizza'
29
30
31 class ClamPizza:
32
33def prepare(self):
34return 'prepare clam_pizza'
35
36def bake(self):
37return 'bake clam_pizza'
38
39def cut(self):
40return 'cut clam_pizza'
41
42def box(self):
43return 'box clam_pizza'
44
45
46 class PizzaStore:
47
48def __init__(self, type):# 初始化型別引數type
49self.type = type# 賦值屬性self.type為引數type
50
51def orderPizza(self):
52if self.type == 'seafood':# 引入引數判斷
53self.pizza = SeafoodPizza()
54elif self.type == 'cheese':
55self.pizza = CheesePizza()
56elif self.type == 'clam':
57self.pizza = ClamPizza()
58
59print(self.pizza.prepare())# 型別方法呼叫
60print(self.pizza.bake())
61print(self.pizza.cut())
62print(self.pizza.box())
63print(self.type + '_pizza completed!')
64
65
66 def main():
67pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n')# 放在迴圈外便於返回
68while True:
69if pizza in ['seafood', 'cheese', 'clam']:# 如果列表太長只能上資料庫啦
70pizza = PizzaStore(pizza)
71pizza.orderPizza()
72pizza = input('you have order one pizza anything else? seafood cheese clam or no?\n')
73
74elif pizza == 'no':
75print('bye')
76return
77
78else:
79pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n')
80
81
82 if __name__ == '__main__':
83main()
View Code
不過見不得好到哪裡去！如何進一步編呢？很快我們又發現了上述程式碼中orderPizza函式仍然是不變的，而型別判斷那部分是隨時有可能變化的，能不能讓PizzaStore中變化的程式碼抽出去免得老是要新增來新增去呢？為了廉價付人工，把它交給製造工廠吧！這就是下面要是的簡單工廠模式！
工廠模式介紹
在介紹簡單工廠前，先看下工廠模式，書上是這麼寫的，在面向物件程式設計中，術語“工廠”表示一個負責建立其他型別物件的類。通常，這個類有一個物件以及多個和物件相關的多個方法，至於為什麼要建立這樣的一個類來建立物件呢?因為從上面的程式碼也可以看到，我們可以在main()函式裡面例項化。那為什麼還要這麼做呢？當然因為這樣做是由好吃的。
- 鬆耦合，即物件的建立可以獨立於類的實現
- 客戶端無需瞭解建立物件的類，也可以使用它來建立物件
- 輕鬆地在工廠中新增其他類來建立其他型別的物件，而這無需更改客戶端程式碼，客戶端只需要傳遞一個引數即可。
- 工廠可以重用現有物件。但是客戶端則總是建立一個新的物件。
這些優點不要說沒實踐過，就算親自實踐過也可能不知道它說的啥，比如：按照上面的例子客戶端也只需提供一個引數啊！不管了，還是繼續往下寫吧，人生苦短······
簡單工廠模式
很多介紹都說簡單工廠不是一種模式，無論如何，筆者只想看看它的特徵，嗯，筆者看到了，書上是這麼寫的：允許介面建立物件，但不會暴露物件的建立邏輯！參考前面的程式碼，如果要創一個“簡單工廠”，就創一個SimPizzaFactory，再定義一個create_pizza函式，然後進行型別判斷，然後在進行型別建立。在“工廠”裡建立了型別物件，自然在PizzaStore類裡面進可以不用再做這麼多工作了，但是，要把工廠建立的物件導進來，如何導進來呢？對啦！寄望於魔術方法__init__！將“簡單工廠”作為引數傳遞給PizzaStore來進行初始化，這樣就可以將型別作為引數傳遞給orderPizza了。程式碼如下：
1 class SeafoodPizza:
2
3def prepare(self):
4return 'prepare seafood_pizza'
5
6def bake(self):
7return 'bake seafood_pizza'
8
9def cut(self):
10return 'cut seafood_pizza'
11
12def box(self):
13return 'box seafood_pizza'
14
15
16 class CheesePizza:
17
18def prepare(self):
19return 'prepare cheese_pizza'
20
21def bake(self):
22return 'bake cheese_pizza'
23
24def cut(self):
25return 'cut cheese_pizza'
26
27def box(self):
28return 'box cheese_pizza'
29
30
31 class ClamPizza:
32
33def prepare(self):
34return 'prepare clam_pizza'
35
36def bake(self):
37return 'bake clam_pizza'
38
39def cut(self):
40return 'cut clam_pizza'
41
42def box(self):
43return 'box clam_pizza'
44
45
46 class SimPizzaFactory:
47
48def creat_pizza(self, type):
49pizza = None
50
51if type == 'seafood':
52pizza = SeafoodPizza()
53elif type == 'cheese':
54pizza = CheesePizza()
55elif type == 'clam':
56pizza = ClamPizza()
57return pizza
58
59
60 class PizzaStore:
61
62def __init__(self, factory):
63self.factory = factory
64
65def orderPizza(self, type):
66pizza = self.factory.creat_pizza(type)
67print(pizza.prepare())
68print(pizza.bake())
69print(pizza.cut())
70print(pizza.box())
71print(type + '_pizza completed!')
72
73
74 def main():
75type = input('input the type of pizza you want from the options seafood cheese clam or no?\n')
76while True:
77if type in ['seafood', 'cheese', 'clam']:# 如果列表太長只能上資料庫啦
78pizza = PizzaStore(SimPizzaFactory())
79pizza.orderPizza(type)
80type = input('you have order one pizza anything else? seafood cheese clam or no?\n')
81
82elif type == 'no':
83print('bye')
84return
85
86else:
87type = input('input the pizza you want from the options seafood cheese clam or no?\n')
88
89
90 if __name__ == '__main__':
91main()
View Code
好像也不見得什麼啊，不過還是實現了將幾乎不用改變的程式碼和經常需要變動的程式碼分離開，還是繼續往下寫吧，人生······
工廠方法模式
一個“簡單工廠”類實現了型別的例項化，無論有多少種pizza要做我都扔給工廠去做，問題到此似乎該告一段落了，然而人的慾望是不可能有盡頭的，該來的還是來了，店長決定在全國都開起了分店。現在要怎麼編呢？比如北京一個店，上海開一個······
如果按照簡單工廠前面的想法去寫，應該也是可以的。但是通過不同方法的比較，我們已經認為簡單工廠的方法目前是比較好的一種方式。所以這裡就直接用簡單工廠的方法去開分店了。
現在製造pizza的型別要重新建立了，因為多了一個地域變數使得製造pizza的方法也各有不同，這些程式碼自然是不能省的，那麼，工廠方法現在又要如何去處理（建立型別），自然很快就帶來了一個問題：再不能僅僅依靠類似前面的型別判斷去建立物件，因為不同分店的同種pizza是不同的！例如：北京分店的seafood_pizza和上海分店的seafood_pizza做法是有差別的！例如人們經常說的某酒必須要它當地的水才能釀成那種味道云云···，所以，在工廠還需確定是那種風格的pizza——北京風格還是上海風格？，再確定是那種口味的pizza，然後才能準確的呼叫相應的pizza種類。為此，我們可以通過建立不同種類的簡單工廠來建立pizza型別。無論如何先帖程式碼，程式碼如下：
1 class BeijingSeafoodPizza:
2
3def prepare(self):
4return 'prepare Beijing_Seafood_Pizza'
5
6def bake(self):
7return 'bake Beijing_Seafood_Pizza'
8
9def cut(self):
10return 'cut Beijing_Seafood_Pizza'
11
12def box(self):
13return 'box Beijing_Seafood_Pizza'
14
15
16 class BeijingCheesePizza:
17
18def prepare(self):
19return 'prepare Beijing_Cheese_Pizza'
20
21def bake(self):
22return 'bake Beijing_Cheese_Pizza'
23
24def cut(self):
25return 'cut Beijing_Cheese_Pizza'
26
27def box(self):
28return 'box Beijing_Cheese_Pizza'
29
30
31 class BeijingClamPizza:
32
33def prepare(self):
34return 'prepare Beijing_Clam_Pizza'
35
36def bake(self):
37return 'bake Beijing_Clam_Pizza'
38
39def cut(self):
40return 'cut Beijing_Clam_Pizza'
41
42def box(self):
43return 'box Beijing_Clam_Pizza'
44
45 class ShanghaiSeafoodPizza:
46
47def prepare(self):
48return 'prepare Shanghai_Seafood_Pizza'
49
50def bake(self):
51return 'bake Shanghai_Seafood_Pizza'
52
53def cut(self):
54return 'cut Shanghai_Seafood_Pizza'
55
56def box(self):
57return 'box Shanghai_Seafood_Pizza'
58
59
60 class ShanghaiCheesePizza:
61
62def prepare(self):
63return 'prepare Shanghai_Cheese_Pizza'
64
65def bake(self):
66return 'bake Shanghai_Cheese_Pizza'
67
68def cut(self):
69return 'cut Shanghai_Cheese_Pizza'
70
71def box(self):
72return 'box Shanghai_Cheese_Pizza'
73
74
75 class ShanghaiClamPizza:
76
77def prepare(self):
78return 'prepare Shanghai_Clam_Pizza'
79
80def bake(self):
81return 'bake Shanghai_Clam_Pizza'
82
83def cut(self):
84return 'cut Shanghai_Clam_Pizza'
85
86def box(self):
87return 'box Shanghai_Clam_Pizza'
88
89
90 class BeijingFactory:
91
92def creat_pizza(self, type):
93pizza = None
94
95if type == 'seafood':
96pizza = BeijingSeafoodPizza()
97elif type == 'cheese':
98pizza = BeijingCheesePizza()
99elif type == 'clam':
100pizza = BeijingClamPizza()
101return pizza
102
103
104 class ShanghaiFactory:
105
106def creat_pizza(self, type):
107pizza = None
108
109if type == 'seafood':
110pizza = ShanghaiSeafoodPizza()
111elif type == 'cheese':
112pizza = ShanghaiCheesePizza()
113elif type == 'clam':
114pizza = ShanghaiClamPizza()
115return pizza
116
117
118 class PizzaStore:
119
120def __init__(self, factory):
121self.factory = factory
122
123def orderPizza(self, type):
124pizza = self.factory.creat_pizza(type)
125print(pizza.prepare())
126print(pizza.bake())
127print(pizza.cut())
128print(pizza.box())
129print(type + '_pizza completed!')
130
131
132 def main():
133region = input('input the region of pizza of you want Bejing Shanghai or no\n')
134if region == 'no':
135print('bye')
136return
137type = input('input the type of pizza you want from the options seafood cheese clam or no?\n')
138
139while True:
140
141if region == 'Beijing' and type in ['seafood', 'cheese', 'clam']:
142factory = BeijingFactory()
143pizza = PizzaStore(factory)
144pizza.orderPizza(type)
145region = input('you have order one pizza anything else?Bejing Shanghai or no\n')
146if region == 'no':
147print('bye')
148return
149type = input('you have order one pizza anything else? seafood cheese clam or no?\n')
150
151elif region == 'Shanghai' and type in ['seafood', 'cheese', 'clam']:
152factory = ShanghaiFactory()
153pizza = PizzaStore(factory)
154pizza.orderPizza(type)
155region = input('you have order one pizza anything else?Bejing Shanghai or no\n')
156if region == 'no':
157print('bye')
158return
159type = input('you have order one pizza anything else? seafood cheese clam or no?\n')
160
161else:
162region = input('input the region of pizza of you want Bejing Shanghai or no\n')
163
164
165 if __name__ == '__main__':
166main()
View Code
這個程式碼又笨又長，但筆者認為，只要每種pizza的製作方法不一樣，有多少種pizza，就有多少段pizza程式碼，儘管程式碼很長，當然可以藉助from ...import...來縮短程式碼，但總的程式碼數應當不能減少，當然也可以用繼承，但是不夠簡單粗暴。其實建立簡單工廠的時候也可以加入一個額外的引數變數——region，那樣的判斷和主函式的邏輯是一樣的。另外，當pizza種類越來越多的時候，互動的內容也會越來越多，所以這裡也可以定義一個help函式去簡潔點處理。如此看來，簡單工廠也是可以實現的，但是，也看到了這樣的工廠在種類多起來的時候，工廠專業化程度越來越高，變動成本（重新調整邏輯的時間）越來越高！
這時候怎麼辦呢？書上說要仰賴工廠方法，先看看工廠方法的特點：
- 我們定義了一個介面來建立，但是工廠本身並不負責建立物件，而是將這個任務交由子類來完成，即由子類決定了要例項化哪些類
- 工廠方法的建立是通過繼承而不是通過例項化來完成的
- 工廠方法使設計更加具有可定製性。它可以返回相同的例項或子類，而不是某些型別的物件(就像在簡單工廠方法中的那樣)
先看下程式碼：
1 class BeijingSeafoodPizza:
2
3def prepare(self):
4return 'prepare Beijing_Seafood_Pizza'
5
6def bake(self):
7return 'bake Beijing_Seafood_Pizza'
8
9def cut(self):
10return 'cut Beijing_Seafood_Pizza'
11
12def box(self):
13return 'box Beijing_Seafood_Pizza'
14
15
16 class BeijingCheesePizza:
17
18def prepare(self):
19return 'prepare Beijing_Cheese_Pizza'
20
21def bake(self):
22return 'bake Beijing_Cheese_Pizza'
23
24def cut(self):
25return 'cut Beijing_Cheese_Pizza'
26
27def box(self):
28return 'box Beijing_Cheese_Pizza'
29
30
31 class BeijingClamPizza:
32
33def prepare(self):
34return 'prepare Beijing_Clam_Pizza'
35
36def bake(self):
37return 'bake Beijing_Clam_Pizza'
38
39def cut(self):
40return 'cut Beijing_Clam_Pizza'
41
42def box(self):
43return 'box Beijing_Clam_Pizza'
44
45
46 class ShanghaiSeafoodPizza:
47
48def prepare(self):
49return 'prepare Shanghai_Seafood_Pizza'
50
51def bake(self):
52return 'bake Shanghai_Seafood_Pizza'
53
54def cut(self):
55return 'cut Shanghai_Seafood_Pizza'
56
57def box(self):
58return 'box Shanghai_Seafood_Pizza'
59
60
61 class ShanghaiCheesePizza:
62
63def prepare(self):
64return 'prepare Shanghai_Cheese_Pizza'
65
66def bake(self):
67return 'bake Shanghai_Cheese_Pizza'
68
69def cut(self):
70return 'cut Shanghai_Cheese_Pizza'
71
72def box(self):
73return 'box Shanghai_Cheese_Pizza'
74
75
76 class ShanghaiClamPizza:
77
78def prepare(self):
79return 'prepare Shanghai_Clam_Pizza'
80
81def bake(self):
82return 'bake Shanghai_Clam_Pizza'
83
84def cut(self):
85return 'cut Shanghai_Clam_Pizza'
86
87def box(self):
88return 'box Shanghai_Clam_Pizza'
89
90
91 class PizzaStore:
92
93def create_pizza(self, type):# 抽象方法，由子類去實現
94raise NotImplementedError
95
96def orderPizza(self, type):
97pizza = self.create_pizza(type)
98print(pizza.prepare())
99print(pizza.bake())
100print(pizza.cut())
101print(pizza.box())
102print(type + '_pizza completed!')
103
104
105 class BeijingPizzaStore(PizzaStore):
106def create_pizza(self, pizza_type):
107pizzas = dict(cheese=BeijingCheesePizza, clam=BeijingClamPizza, seafood=BeijingSeafoodPizza)
108return pizzas[pizza_type]()
109
110
111 class ShanghaiPizzaStore(PizzaStore):
112def create_pizza(self, pizza_type):
113pizzas = dict(cheese=ShanghaiCheesePizza, clam=ShanghaiClamPizza, seafood=ShanghaiSeafoodPizza)
114return pizzas[pizza_type]()
115
116
117 def main():
118region = input('input the region of pizza of you want Bejing Shanghai or no\n')
119if region == 'no':
120print('bye')
121return
122type = input('input the type of pizza you want from the options seafood cheese clam or no?\n')
123
124while True:
125
126if region == 'Beijing' and type in ['seafood', 'cheese', 'clam']:
127store = BeijingPizzaStore()
128store.orderPizza(type)
129region = input('you have order one pizza anything else?Bejing Shanghai or no\n')
130if region == 'no':
131print('bye')
132return
133type = input('you have order one pizza anything else? seafood cheese clam or no?\n')
134
135elif region == 'Shanghai' and type in ['seafood', 'cheese', 'clam']:
136store = ShanghaiPizzaStore()
137store.orderPizza(type)
138region = input('you have order one pizza anything else?Bejing Shanghai or no\n')
139if region == 'no':
140print('bye')
141return
142type = input('you have order one pizza anything else? seafood cheese clam or no?\n')
143
144else:
145region = input('input the region of pizza of you want Bejing Shanghai or no\n')
146
147
148 if __name__ == '__main__':
149main()
View Code
可以看到，相對來說，這裡的程式碼貌似簡潔了一點。這其中拋棄了簡單工廠，從而將create_pizza函式搬到 Pizza_Store工廠 下面，並用抽象類的方法重新定義，然後讓Pizza_Store工廠的子類BeijingPizzaStore和ShanghaiPizzaStore分店分別取實現自己的create_pizza，這也是工廠方法常用的方法。程式碼太長主要還是是piazza的種類的程式碼但必須要有，而互動隨著pizza種類而也變得複雜。工廠方法的優點書上所說如下：
- 它具有更大的靈活性，使得程式碼更加通用，因為它不是單純地例項化某個類。這樣實現哪些類取決於介面（product），而不是ConcreteCreator類。
- 鬆耦合，因為建立物件的程式碼與使用它的程式碼是分開的。客戶端無需關心傳遞哪些引數以及需要例項化哪些類。由於新增新類更加容易，所以降低了維護成本。
抽象工廠
抽象工廠模式的主要目的是提供一個介面來建立一系列相關物件，而無需指定具體的類。工廠方法將建立例項的任務委託給了子類，而抽象工廠方法的目標是建立一系列相關物件。程式碼和書本差不多，所以大家看書即可，可能前面囉嗦太甚，這節草草了事湊下整，哈哈，看起來程式碼比上面的短，但仿照來寫應該不會比上面的短很多，程式碼貼上自於這篇部落格：
3600/article/details/82586557" target="_blank" rel="nofollow,noindex">https://blog.csdn.net/weixin_38853600/article/details/82586557 ：
1 from abc import ABCMeta, abstractmethod
2
3
4 # AbstractFactory
5 class PizzaFactory(metaclass=ABCMeta):
6@abstractmethod
7def createVegPizza(self):
8pass
9
10@abstractmethod
11def createNonVegPizza(self):
12pass
13
14
15 # ConcreteFactory
16 class IndianPizzaFactory(PizzaFactory):
17def createVegPizza(self):
18return DeluxVeggiePizza()
19
20def createNonVegPizza(self):
21return ChickenPizza()
22
23
24 # ConcreteFactory
25 class USPizzaFactory(PizzaFactory):
26def createVegPizza(self):
27return MexicanVegPizza()
28
29def createNonVegPizza(self):
30return HamPizza()
31
32
33 # 進一步定義AbstractProducts:
34 # AbstractProduct
35 class VegPizza(metaclass=ABCMeta):
36@abstractmethod
37def prepare(self, VegPizza):# 定義自己的方法
38pass
39
40
41 # AnotherAbstractProduct
42 class NonVegPizza(metaclass=ABCMeta):
43@abstractmethod
44def serve(self, VegPizza):# 定義自己的方法
45pass
46
47
48 # 為每個AbstractProducts定義ConcreteProducts,建立DeluxVeggiePizza和MexicanVegPizza:
49 class DeluxVeggiePizza(VegPizza):# ConcreteProducts1
50def prepare(self):
51print('Prepare:', type(self).__name__)
52
53
54 # 定義AnotherConcreteProduct：
55 class MexicanVegPizza(VegPizza):# ConcreteProducts2
56def prepare(self):
57print('Prepare:', type(self).__name__)
58
59
60 # 定義ChickenPizza和HamPizza,分別代表AnotherConcreteProducts1和AnotherConcreteProducts2：
61 class ChickenPizza(NonVegPizza):# AnotherConcreteProducts1
62def serve(self, VegPizza):
63print(type(self).__name__, ' is served with Chicken on ', type(VegPizza).__name__)
64
65
66 class HamPizza(NonVegPizza):
67def serve(self, VegPizza):
68print(type(self).__name__, ' is served with Ham on ', type(VegPizza).__name__)
69
70
71 # 當終端使用者來到PizzaStore並要一份美式非素食披薩的時候，USPizzaFactory負責準備素食，
72 # 然後在上面加上火腿，馬上就變成非素食披薩了：
73 class PizzaStore:
74def __init__(self):
75pass
76
77def makePizzas(self):
78for factory in [IndianPizzaFactory(), USPizzaFactory()]:
79self.factory = factory
80self.NonVegPizza = self.factory.createNonVegPizza()
81self.VegPizza = self.factory.createVegPizza()
82self.VegPizza.prepare()
83self.NonVegPizza.serve(self.VegPizza)
84
85
86 if __name__ == '__main__':
87pizza = PizzaStore()
88pizza.makePizzas()
View Code
至此，筆者的笨拙想法卒。