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 3 def prepare(self): 4 return 'prepare seafood_pizza' 5 6 def bake(self): 7 return 'bake seafood_pizza' 8 9 def cut(self): 10 return 'cut seafood_pizza' 11 12 def box(self): 13 return 'box seafood_pizza' 14 15 def orderPizza(self): 16 print(self.prepare()) 17 print(self.bake()) 18 print(self.cut()) 19 print(self.box()) 20 21 22 class CheesePizza: 23 24 def prepare(self): 25 return 'prepare cheese_pizza' 26 27 def bake(self): 28 return 'bake cheese_pizza' 29 30 def cut(self): 31 return 'cut cheese_pizza' 32 33 def box(self): 34 return 'box cheese_pizza' 35 36 def orderPizza(self): 37 print(self.prepare()) 38 print(self.bake()) 39 print(self.cut()) 40 print(self.box()) 41 42 43 class ClamPizza: 44 45 def prepare(self): 46 return 'prepare clam_pizza' 47 48 def bake(self): 49 return 'bake clam_pizza' 50 51 def cut(self): 52 return 'cut clam_pizza' 53 54 def box(self): 55 return 'box clam_pizza' 56 57 def orderPizza(self): 58 print(self.prepare()) 59 print(self.bake()) 60 print(self.cut()) 61 print(self.box()) 62 63 64 def main(): 65 pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n') # 放在迴圈外便於返回 66 while True: 67 if pizza == 'seafood': 68 pizza = SeafoodPizza() 69 pizza.orderPizza() 70 print('seafood_pizza completed') 71 pizza = input('you have order seafood_pizza, anything else? Enter seafood cheese clam or no?\n ') 72 73 elif pizza == 'cheese': 74 pizza = CheesePizza() 75 pizza.orderPizza() 76 print('cheese_pizza completed') 77 pizza = input('you have order cheese_pizza, anything else? Enter seafood cheese clam or no?\n ') 78 79 elif pizza == 'clam': 80 pizza = ClamPizza() 81 pizza.orderPizza() 82 print('clam_pizza completed') 83 pizza = input('you have order clam_pizza, anything else? Enter seafood cheese clam or no?\n ') 84 85 elif pizza == 'no': 86 print('bye') 87 return 88 else: 89 pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n') 90 91 92 if __name__ == '__main__': 93 main()View Code
那麼如何寫的簡短點呢？很快，我們發現，雖然pizza不一樣，但每種pizza的orderPizza的形式是一樣的，所有有什麼辦法讓它獨立出來以達一勞永逸呢？因此我們要處理不同pizza的訂單，那麼我們應該建立一個專門處理訂單的類，orderPizza將作為它的方法被呼叫，那麼如何建立這個類以相容不同的訂單呢？無論這個類取啥名，只要它能夠實現方法呼叫即可，但是如古裝劇非常講究名正言順一樣，起名適宜也是很重要的。例如：書上起的名字就是PizzaStore。
既然PizzaStore要能夠處理不同的訂單，那麼它的orderPizza方法就需要引入不同的型別判斷，而型別可以通過特殊方法__int__初始化型別引數？程式碼如下，但請別這樣搞。
1 class SeafoodPizza: 2 3 def prepare(self): 4 return 'prepare seafood_pizza' 5 6 def bake(self): 7 return 'bake seafood_pizza' 8 9 def cut(self): 10 return 'cut seafood_pizza' 11 12 def box(self): 13 return 'box seafood_pizza' 14 15 16 class CheesePizza: 17 18 def prepare(self): 19 return 'prepare cheese_pizza' 20 21 def bake(self): 22 return 'bake cheese_pizza' 23 24 def cut(self): 25 return 'cut cheese_pizza' 26 27 def box(self): 28 return 'box cheese_pizza' 29 30 31 class ClamPizza: 32 33 def prepare(self): 34 return 'prepare clam_pizza' 35 36 def bake(self): 37 return 'bake clam_pizza' 38 39 def cut(self): 40 return 'cut clam_pizza' 41 42 def box(self): 43 return 'box clam_pizza' 44 45 46 class PizzaStore: 47 48 def __init__(self, type): # 初始化型別引數type 49 self.type = type # 賦值屬性self.type為引數type 50 51 def orderPizza(self): 52 if self.type == 'seafood': # 引入引數判斷 53 self.pizza = SeafoodPizza() 54 elif self.type == 'cheese': 55 self.pizza = CheesePizza() 56 elif self.type == 'clam': 57 self.pizza = ClamPizza() 58 59 print(self.pizza.prepare()) # 型別方法呼叫 60 print(self.pizza.bake()) 61 print(self.pizza.cut()) 62 print(self.pizza.box()) 63 print(self.type + '_pizza completed!') 64 65 66 def main(): 67 pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n') # 放在迴圈外便於返回 68 while True: 69 if pizza in ['seafood', 'cheese', 'clam']: # 如果列表太長只能上資料庫啦 70 pizza = PizzaStore(pizza) 71 pizza.orderPizza() 72 pizza = input('you have order one pizza anything else? seafood cheese clam or no?\n') 73 74 elif pizza == 'no': 75 print('bye') 76 return 77 78 else: 79 pizza = input('enter the pizza you want from the options seafood cheese clam or no?\n') 80 81 82 if __name__ == '__main__': 83 main()View Code
不過見不得好到哪裡去！如何進一步編呢？很快我們又發現了上述程式碼中orderPizza函式仍然是不變的，而型別判斷那部分是隨時有可能變化的，能不能讓PizzaStore中變化的程式碼抽出去免得老是要新增來新增去呢？為了廉價付人工，把它交給製造工廠吧！這就是下面要是的簡單工廠模式！
工廠模式介紹
在介紹簡單工廠前，先看下工廠模式，書上是這麼寫的，在面向物件程式設計中，術語“工廠”表示一個負責建立其他型別物件的類。通常，這個類有一個物件以及多個和物件相關的多個方法，至於為什麼要建立這樣的一個類來建立物件呢?因為從上面的程式碼也可以看到，我們可以在main()函式裡面例項化。那為什麼還要這麼做呢？當然因為這樣做是由好吃的。
- 鬆耦合，即物件的建立可以獨立於類的實現
- 客戶端無需瞭解建立物件的類，也可以使用它來建立物件
- 輕鬆地在工廠中新增其他類來建立其他型別的物件，而這無需更改客戶端程式碼，客戶端只需要傳遞一個引數即可。
- 工廠可以重用現有物件。但是客戶端則總是建立一個新的物件。
這些優點不要說沒實踐過，就算親自實踐過也可能不知道它說的啥，比如：按照上面的例子客戶端也只需提供一個引數啊！不管了，還是繼續往下寫吧，人生苦短······
簡單工廠模式
很多介紹都說簡單工廠不是一種模式，無論如何，筆者只想看看它的特徵，嗯，筆者看到了，書上是這麼寫的：允許介面建立物件，但不會暴露物件的建立邏輯！參考前面的程式碼，如果要創一個“簡單工廠”，就創一個SimPizzaFactory，再定義一個create_pizza函式，然後進行型別判斷，然後在進行型別建立。在“工廠”裡建立了型別物件，自然在PizzaStore類裡面進可以不用再做這麼多工作了，但是，要把工廠建立的物件導進來，如何導進來呢？對啦！寄望於魔術方法__init__！將“簡單工廠”作為引數傳遞給PizzaStore來進行初始化，這樣就可以將型別作為引數傳遞給orderPizza了。程式碼如下：
1 class SeafoodPizza: 2 3 def prepare(self): 4 return 'prepare seafood_pizza' 5 6 def bake(self): 7 return 'bake seafood_pizza' 8 9 def cut(self): 10 return 'cut seafood_pizza' 11 12 def box(self): 13 return 'box seafood_pizza' 14 15 16 class CheesePizza: 17 18 def prepare(self): 19 return 'prepare cheese_pizza' 20 21 def bake(self): 22 return 'bake cheese_pizza' 23 24 def cut(self): 25 return 'cut cheese_pizza' 26 27 def box(self): 28 return 'box cheese_pizza' 29 30 31 class ClamPizza: 32 33 def prepare(self): 34 return 'prepare clam_pizza' 35 36 def bake(self): 37 return 'bake clam_pizza' 38 39 def cut(self): 40 return 'cut clam_pizza' 41 42 def box(self): 43 return 'box clam_pizza' 44 45 46 class SimPizzaFactory: 47 48 def creat_pizza(self, type): 49 pizza = None 50 51 if type == 'seafood': 52 pizza = SeafoodPizza() 53 elif type == 'cheese': 54 pizza = CheesePizza() 55 elif type == 'clam': 56 pizza = ClamPizza() 57 return pizza 58 59 60 class PizzaStore: 61 62 def __init__(self, factory): 63 self.factory = factory 64 65 def orderPizza(self, type): 66 pizza = self.factory.creat_pizza(type) 67 print(pizza.prepare()) 68 print(pizza.bake()) 69 print(pizza.cut()) 70 print(pizza.box()) 71 print(type + '_pizza completed!') 72 73 74 def main(): 75 type = input('input the type of pizza you want from the options seafood cheese clam or no?\n') 76 while True: 77 if type in ['seafood', 'cheese', 'clam']: # 如果列表太長只能上資料庫啦 78 pizza = PizzaStore(SimPizzaFactory()) 79 pizza.orderPizza(type) 80 type = input('you have order one pizza anything else? seafood cheese clam or no?\n') 81 82 elif type == 'no': 83 print('bye') 84 return 85 86 else: 87 type = input('input the pizza you want from the options seafood cheese clam or no?\n'