5.Python的語言特點_ZenDei技術網路在線

前言 Python有哪些語言特點？可以列出的特點很多，例如，《Python核心編程》第二版列出了十多條特點。本文的三個特點是筆者學習Python的體會，其他特點有體會之後再寫，筆者是這樣概括的：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('