據(jù)說(shuō)：

2019年， 浙江信息技術(shù)高考可以考python了；

2018年， Python 進(jìn)入了小學(xué)生的教材；

2018年， 全國(guó)計(jì)算機(jī)等級(jí)考試，可以考python 了；

據(jù)外媒報(bào)道，微軟正考慮添加 Python 為官方的一種 Excel 腳本語(yǔ)言

……

Python作為一種編程語(yǔ)言，被稱為“膠水語(yǔ)言”，更被擁躉們譽(yù)為“最美麗”的編程語(yǔ)言，從云端到客戶端，再到物聯(lián)網(wǎng)終端，無(wú)所不在，同時(shí)還是人工智能優(yōu)選的編程語(yǔ)言。

因此，從全棧的角度看， Python 是一門(mén)必備的語(yǔ)言，因?yàn)樗浅蓑?qū)動(dòng)和操作系統(tǒng)外，其他都可以做好。

不積跬步無(wú)以至千里，不積小流無(wú)以成江海。—— 荀子《勸學(xué)》

語(yǔ)法

Python使用空格或制表符縮進(jìn)的方式分隔代碼，Python 2 僅有31個(gè)保留字，而且沒(méi)有分號(hào)、begin、end等標(biāo)記。

可以組織成打油詩(shī)， 更方便記憶：

• Global is class，def not pass。
• if eilf else， del as break。
• raise in while，import from yield，
• try for print，return and assert。
• exec except with lambda,
• finally or continue……

python中沒(méi)有提供定義常量的保留字，可以自己定義一個(gè)常量類來(lái)實(shí)現(xiàn)常量的功能。python中有3種表示字符串類型的方式，即單引號(hào)、雙引號(hào)、三引號(hào)。單引號(hào)和雙引號(hào)的作用是相同的，python程序員更喜歡用單引號(hào)，C/Java程序員則習(xí)慣使用雙引號(hào)表示字符串。三引號(hào)中可以輸入單引號(hào)、雙引號(hào)或換行等字符。python不支持自增運(yùn)算符和自減運(yùn)算符，其他運(yùn)算符和表達(dá)式都是類似的，尤其是分支判斷和循環(huán)。

Python的文件類型分為3種，即源代碼、字節(jié)代碼和優(yōu)化代碼。這些都可以直接運(yùn)行，不需要進(jìn)行預(yù)編譯或連接。

數(shù)據(jù)類型

Python中的基本數(shù)據(jù)類型有布爾類型，整數(shù)，浮點(diǎn)數(shù)和字符串等。

Python 中的數(shù)據(jù)結(jié)構(gòu)主要有元組（tuple），列表（list）和字典（dictionary）。元組、列表和字符串都屬于序列,是具有索引和切片能力的集合。

元組初始化后不可修改，是寫(xiě)保護(hù)的。元組往往代表一行數(shù)據(jù)，而元組中的元素代表不同的數(shù)據(jù)項(xiàng)，可以把元組看做不可修改的數(shù)組。

tuple_name=(“you”,”me”,”him”,”her”) 

列表可轉(zhuǎn)換為元組，是傳統(tǒng)意義上的數(shù)組，可以實(shí)現(xiàn)添加、刪除和查找操作，元素的值可以被修改。

list_name=[“you”,”me”,”him”,”her”] 

字典是鍵值對(duì),相對(duì)于哈希表。

dict_name={“y”:”you”, “m”:”me”, “hi”:”him”, “he”:”her”} 

列表推導(dǎo)（List Comprehensions）是構(gòu)建列表的快捷方式, 可讀性較好且效率更高. 運(yùn)用列表生成式，可以快速生成list，例如 得到當(dāng)前目錄下的所有目錄和文件：

>>> import os 
>>> [d for d in os.listdir('.')] 

也可以通過(guò)一個(gè)list推導(dǎo)出另一個(gè)list，代碼簡(jiǎn)潔，例如 將一個(gè)列表中的元素都變成小寫(xiě)：

>>> L = ['Hello', 'World', 'IBM', 'Apple'] 
>>> [s.lower() for s in L] 

通過(guò)這些基本類型，可以組成更有針對(duì)性需求的數(shù)據(jù)結(jié)構(gòu)，例如字典嵌套形成的樹(shù)等， 針對(duì)更復(fù)雜的數(shù)據(jù)結(jié)構(gòu)， Python 中提供了大量的庫(kù)。

類與繼承

python用class來(lái)定義一個(gè)類，當(dāng)所需的數(shù)據(jù)結(jié)構(gòu)不能用簡(jiǎn)單類型來(lái)表示時(shí)，就需要定義類，然后利用定義的類創(chuàng)建對(duì)象。當(dāng)一個(gè)對(duì)象被創(chuàng)建后，包含了三方面的特性，即對(duì)象的句柄、屬性和方法。創(chuàng)建對(duì)象的方法：

abel = Abel()  
　　Abel.do() 

類的方法同樣分為公有方法和私有方法。私有函數(shù)不能被該類之外的函數(shù)調(diào)用，私有的方法也不能被外部的類或函數(shù)調(diào)用。python使用函數(shù)”staticmethod()“或”@ staticmethod“的方法把普通的函數(shù)轉(zhuǎn)換為靜態(tài)方法，相當(dāng)于全局函數(shù)。python的構(gòu)造函數(shù)名為init，析構(gòu)函數(shù)名為del。繼承的使用方法：

class AbelApp(abel):  
     　　  def … 

Python 中的變量名解析遵循LEGB原則，本地作用域（Local），上一層結(jié)構(gòu)中的def或Lambda的本地作用域（Enclosing），全局作用域（Global），內(nèi)置作用域（Builtin），按順序查找。

和變量解析不同，Python 會(huì)按照特定的順序遍歷繼承樹(shù)，就是方法解析順序（Method Resolution Order，MRO）。類都有一個(gè)名為mro 的屬性，值是一個(gè)元組，按照方法解析順序列出各個(gè)超類，從當(dāng)前類一直向上，直到 object 類。

Python 中有一種特殊的類是元類（metaclass）。元類是由“type”衍生而出，所以父類需要傳入type，元類的操作都在 new中完成。通過(guò)元類創(chuàng)建的類，第一個(gè)參數(shù)是父類，第二個(gè)參數(shù)是metaclass。

包與模塊

python程序由包(package)、模塊(module)和函數(shù)組成。包是由一系列模塊組成的集合。包必須含有一個(gè)init.py文件，它用于標(biāo)識(shí)當(dāng)前文件夾是一個(gè)包。

模塊是處理某一類問(wèn)題的函數(shù)和類的集合。模塊把一組相關(guān)的函數(shù)或代碼組織到一個(gè)文件中，一個(gè)文件即是一個(gè)模塊。模塊由代碼、函數(shù)和類組成。導(dǎo)入模塊使用import語(yǔ)句，不過(guò)模塊不限于此，還可以被 import 語(yǔ)句導(dǎo)入的模塊共有以下四類:

• 使用Python寫(xiě)的程序( .py文件)
• C或C++擴(kuò)展(已編譯為共享庫(kù)或DLL文件)
• 包(包含多個(gè)模塊)
• 內(nèi)建模塊(使用C編寫(xiě)并已鏈接到Python解釋器內(nèi))

Python 提供內(nèi)建函數(shù)__import__動(dòng)態(tài)加載 module,import 本質(zhì)上是調(diào)用 __import__加載 module 的， 函數(shù)原型如下：

__import__(name, globals={}, locals={}, fromlist=[], level=-1) 

例如，加載名為 abel的目錄下所有模塊：

def loadModules(): 
    res = {} 
    import os 
    lst = os.listdir("abel") 
    dir = [] 
    for d in lst: 
        s = os.path.abspath("abel") + os.sep + d 
        if os.path.isdir(s) and os.path.exists(s + os.sep + "__init__.py"): 
            dir.append(d) 
    # load the modules 
    for d in dir: 
        res[d] = __import__("abel." + d, fromlist = ["*"]) 
    return res 

需要注意的是，如果輸入的參數(shù)如果帶有 “.”，采用 __import__直接導(dǎo)入 module 容易造成意想不到的結(jié)果。 OpenStack 的 oslo.utils 封裝了 __import__，支持動(dòng)態(tài)導(dǎo)入 class, object 等。

命名規(guī)范

Python 中的naming convention 以及 coding standard 有很多好的實(shí)踐，例如Google 的Python 編程規(guī)范等。 就命名規(guī)范而言， 可以參見(jiàn)Python之父Guido推薦的規(guī)范，見(jiàn)下表：

迭代器

迭代是數(shù)據(jù)處理的基礎(chǔ)， 采用一種惰性獲取數(shù)據(jù)的方式, 即按需一次獲取一個(gè)數(shù)據(jù)，這就是迭代器模式. 迭代器是一個(gè)帶狀態(tài)的對(duì)象，檢查一個(gè)對(duì)象 a 是否是迭代對(duì)象, 最準(zhǔn)確的方法是調(diào)用 iter(a) , 如果不可迭代, 則拋出 TypeError 異常.

標(biāo)準(zhǔn)的迭代器接口有兩個(gè)方法:

• __next__: 返回下一個(gè)可用元素, 如沒(méi)有, 拋出StopIteration 異常.
• __iter__: 返回self , 以便在應(yīng)該使用可迭代對(duì)象的地方使用迭代器.

可迭代對(duì)象一定不能是自身的迭代器. 也就是說(shuō), 可迭代對(duì)象必須實(shí)現(xiàn) __iter__方法, 但不能實(shí)現(xiàn) __next__ 方法.

實(shí)現(xiàn)一個(gè)斐波那契數(shù)列的迭代器例子如下：

class Fibonacci: 
    def __init__(self): 
        self.prevous = 0 
        self.current = 1 
 
    def __iter__(self): 
        return self 
 
    def __next__(self): 
        value = self.current 
        self.current = self.prevous + self.current 
        self.prevous = value 
        return value 

迭代器就是實(shí)現(xiàn)了工廠模式的對(duì)象，有很多關(guān)于迭代器的例子，比如itertools函數(shù)返回的都是迭代器對(duì)象。

生成器

生成器算得上是Python中最吸引人的特性之一，生成器其實(shí)是一種特殊的迭代器，但不需要寫(xiě)__iter__()和__next__()方法了，只需要一個(gè)yiled關(guān)鍵字即可。python中的 yield 關(guān)鍵字, 用于構(gòu)建生成器(generator), 其作用與迭代器一樣. 還以斐波那契數(shù)列為例：

def Fibonacci(): 
    prevous, current = 0, 1 
    while True: 
        yield current 
        prevous, current = current, current + prevous 

所有的生成器都是迭代器, 都實(shí)現(xiàn)了迭代器的接口。 一般地，只要python函數(shù)的定義體中使用了 yield 關(guān)鍵字, 該函數(shù)就是生成器函數(shù). 調(diào)用生成器函數(shù)時(shí), 會(huì)返回一個(gè)生成器對(duì)象。也就是說(shuō), 生成器函數(shù)是生成器工廠。

生成器函數(shù)會(huì)創(chuàng)建一個(gè)生成器對(duì)象, 包裝生成器函數(shù)的定義體. 把生成器傳給 next(…) 函數(shù)時(shí), 生成器函數(shù)會(huì)向前執(zhí)行函數(shù)體中下一個(gè) yield 語(yǔ)句, 返回產(chǎn)出的值, 并在函數(shù)定義體的當(dāng)前位置暫停.

(圖片來(lái)自http://nvie.com/posts/iterators-vs-generators/）

需要注意的是， 在協(xié)程中, yield 通常出現(xiàn)在表達(dá)式的右邊(data = yield), 可以產(chǎn)出值, 也可以不產(chǎn)出(如果yield后面沒(méi)有表達(dá)式, 那么會(huì)出None)。 協(xié)程可能會(huì)從調(diào)用方接收數(shù)據(jù), 調(diào)用方把數(shù)據(jù)提供給協(xié)程使用 通過(guò)的是 .send(data) 方法. 而不是 next(…) . 通常, 調(diào)用方會(huì)把值推送給協(xié)程.

生成器調(diào)用方是一直獲取數(shù)據(jù), 而協(xié)程調(diào)用方可以向它傳入數(shù)據(jù), 協(xié)程也不一定要產(chǎn)出數(shù)據(jù)。不管數(shù)據(jù)如何流動(dòng), yield 都是一種流程控制工具, 使用它可以實(shí)現(xiàn)寫(xiě)作式多任務(wù)即，協(xié)程可以把控制器讓步給中心調(diào)度程序, 從而激活其他的協(xié)程.

描述符

描述符是一種創(chuàng)建托管屬性的方法，托管屬性還可用于保護(hù)屬性不受修改，或自動(dòng)更新某個(gè)依賴屬性的值。描述符是一種在多個(gè)屬性上重復(fù)利用同一個(gè)存取邏輯的方式，能劫持那些本應(yīng)對(duì)于self.__dict__的操作。在其他編程語(yǔ)言中，描述符被稱作 setter 和 getter，用于獲得 (Get) 和設(shè)置 (Set) 一個(gè)私有變量。Python 沒(méi)有私有變量的概念，而描述符可以作為一種 Python 的方式來(lái)實(shí)現(xiàn)與私有變量類似的功能。

靜態(tài)方法、類方法、property都是構(gòu)建描述符的類。創(chuàng)建描述符的方式主要有3種：

1.創(chuàng)建一個(gè)類并覆蓋任意一個(gè)描述符方法：__set__、__ get__ 和 __delete__。當(dāng)需要某個(gè)描述符跨多個(gè)不同的類和屬性的時(shí)候，例如類型驗(yàn)證，則使用該方法，例如：

class MyNameDescriptor(object): 
     def __init__(self): 
        self._myname = '' 
 
    def __get__(self, instance, owner):              
        return self._myname    def __set__(self, instance, myname): 
        self._myname = myname.getText()    def __delete__(self, instance): 
        del self._myname 

2.使用屬性類型可以更加簡(jiǎn)單、靈活地創(chuàng)建描述符。通過(guò)使用 property()，可以輕松地為任意屬性創(chuàng)建可用的描述符。

class Student(object): 
    def __init__(self): 
        self._sname = '' 
 
    def fget(self): 
        return self._sname    def fset(self, value): 
          self._sname = value.title()    def fdel(self): 
        del self._sname 
    name = property(fget, fset, fdel, "This is the property.") 

3.使用屬性描述符，它結(jié)合了屬性類型方法和 Python裝飾器。

class Student(object): 
        def __init__(self): 
            self._sname = '' 
 
        @property 
        def name(self): 
            return self._sname        @name.setter 
        def name(self, value): 
            self._sname = value.title()        @name.deleter 
        def name(self): 
            del self._sname 

另外，還可以在運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建描述符。 描述符有很多經(jīng)典的應(yīng)用，例如Protobuf。

裝飾器

裝飾器(Decorator)是可調(diào)用的對(duì)象, 其參數(shù)是另一個(gè)函數(shù)(被裝飾的函數(shù)). 裝飾器可能會(huì)處理被裝飾的函數(shù), 然后把它返回, 或者將其替換成另一個(gè)函數(shù)或可調(diào)用對(duì)象.實(shí)際上裝飾器就是一個(gè)高階函數(shù)，它接收一個(gè)函數(shù)作為參數(shù)，然后返回一個(gè)新函數(shù)。

裝飾器有兩大特征:

• 把被裝飾的函數(shù)替換成其他函數(shù)
• 裝飾器在加載模塊時(shí)立即執(zhí)行

python內(nèi)置了三個(gè)用于裝飾方法的函數(shù): property、classmethod 和 staticmethod. 當(dāng)裝飾器不關(guān)心被裝飾函數(shù)的參數(shù)，或是被裝飾函數(shù)的參數(shù)多種多樣的時(shí)候，可變參數(shù)非常適合使用。

如果一個(gè)函數(shù)被多個(gè)裝飾器修飾，其實(shí)應(yīng)該是該函數(shù)先被最里面的裝飾器修飾，變成另一個(gè)函數(shù)后，再次被裝飾器修飾。例如：

def second(func): 
     print "running 2nd decorator" 
    def wrapper(): 
        func() 
    return wrapper 
 
def fisrt(func): 
     print "running 1st decorator" 
    def wrapper(): 
        func() 
    return wrapper 
 
@second 
@first 
def myfunction(): 
    print "running myfunction" 

就擴(kuò)展功能而言，裝飾器模式比子類化更加靈活。

在設(shè)計(jì)模式中，具體的裝飾器實(shí)例要包裝具體組件的實(shí)例，即裝飾器和所裝飾的組件接口一致，對(duì)使用該組件的客戶端透明，并將客戶端的請(qǐng)求轉(zhuǎn)發(fā)給該組件，并且可能在轉(zhuǎn)發(fā)前后執(zhí)行一些額外的操作，透明性使得可以遞歸嵌套多個(gè)裝飾器，從而可以添加任意多個(gè)功能。裝飾器模式和Python裝飾器之間并不是一對(duì)一的等價(jià)關(guān)系，Python裝飾器函數(shù)更為強(qiáng)大，不僅僅可以實(shí)現(xiàn)裝飾器模式。

Lambda

Python 不是純萃的函數(shù)式編程語(yǔ)言，但本身提供了一些函數(shù)式編程的特性，像 map、reduce、filter等都支持函數(shù)作為參數(shù)，lambda 函數(shù)函數(shù)則是函數(shù)式編程中的翹楚。

Lambda 函數(shù)又稱匿名函數(shù)，在某種意義上，return語(yǔ)句隱含在lambda中。和其他很多語(yǔ)言相比，Python 的 lambda 限制很多，最嚴(yán)重的是它只能由一條表達(dá)式組成。lambda規(guī)范必須包含只有一個(gè)表達(dá)式，表達(dá)式必須返回一個(gè)值，由lambda創(chuàng)建一個(gè)匿名函數(shù)隱式地返回表達(dá)式的返回值。

在PySpark 中經(jīng)常會(huì)用到使用Lambda 的操作，例如：

li = [1, 2, 3, 4, 5]

### 列表中國(guó)年的每個(gè)元素加5

map(lambda x: x+5, li) 

### 返回其中的偶數(shù)

filter(lambda x: x % 2 == 0, li) # [2, 4]

### 返回所有元素的乘積

reduce(lambda x, y: x * y, li) 

lambda 可以接收任意多個(gè)參數(shù) (包括可選參數(shù)) 并且返回單個(gè)表達(dá)式的值。

本質(zhì)上，Lambda 函數(shù)是一個(gè)只與輸入?yún)?shù)有關(guān)的抽象代碼樹(shù)片段。在很多語(yǔ)言里，lambda 函數(shù)的調(diào)用會(huì)被套上一層接口，還會(huì)形成閉包，在 lambda 函數(shù)構(gòu)造的同時(shí)就可以完成，之后 lambda 函數(shù)內(nèi)部就是完全靜態(tài)的。而一般的函數(shù)還要加上存儲(chǔ)局部變量的區(qū)域，對(duì)外部環(huán)境的操作，以及命名，大部分語(yǔ)言強(qiáng)制了一般函數(shù)必須與名字綁定。

線程

python是支持多線程的, python的線程就是C語(yǔ)言的一個(gè)pthread，并通過(guò)操作系統(tǒng)調(diào)度算法進(jìn)行調(diào)度。 python 的thread模塊是輕量級(jí)的，而threading模塊是對(duì)thread做了一些封裝，方便使用。threading 經(jīng)常和Queue結(jié)合使用,Queue模塊中提供了同步的、線程安全的隊(duì)列類，包括FIFO隊(duì)列，LIFO隊(duì)列，和優(yōu)先級(jí)隊(duì)列等。這些隊(duì)列都實(shí)現(xiàn)了鎖，能夠在多線程中直接使用，可以使用隊(duì)列來(lái)實(shí)現(xiàn)線程間的同步。

運(yùn)行線程(線程中包含name屬性)的兩種常用方式如下:

• 在構(gòu)造函數(shù)中傳入用于線程運(yùn)行的函數(shù)
• 在子類中重寫(xiě)threading.Thread基類中run()方法(只需重寫(xiě)init()和run()方法)

實(shí)現(xiàn)一個(gè)守護(hù)線程的簡(jiǎn)單例子如下：

class MyThread(threading.Thread): 
    def run(self): 
        time.sleep(30) 
        print 'thread %s finished.' % self.name 
 
def MyDaemons(): 
    print 'start thread:' 
    for i in range(5): 
        t = MyThread() 
        t.setDaemon(1) 
        t.start() 
    print 'end thread.' 
 
if __name__ == '__main__': 
    MyDaemons() 

為了避免線程不同步造成數(shù)據(jù)不同步，可以對(duì)資源進(jìn)行加鎖，也就是訪問(wèn)資源的線程需要獲得鎖，才能訪問(wèn)。threading 模塊中提供了一個(gè) Lock 功能。從Python3.X開(kāi)始，標(biāo)準(zhǔn)庫(kù)為提供了concurrent.futures模塊，其中的ThreadPoolExecutor和ProcessPoolExecutor兩個(gè)類，實(shí)現(xiàn)了對(duì)threading和multiprocessing的進(jìn)一步抽象，對(duì)編寫(xiě)線程池提供了直接支持。

線程在python 被詬病的是，由于GIL的機(jī)制致使多線程不能利用機(jī)器多核的特性。其實(shí)，GIL并不是Python的特性，只是在實(shí)現(xiàn)Python解析器(CPython)的時(shí)侯所引入的。盡管Python完全支持多線程編程， 但解釋器的C語(yǔ)言實(shí)現(xiàn)部分在完全并行執(zhí)行時(shí)并不是線程安全的，解釋器被一個(gè)全局鎖即GIL保護(hù)著，它確保任何時(shí)候都只有一個(gè)Python線程執(zhí)行。

在多線程環(huán)境中，Python 虛擬機(jī)按以下方式執(zhí)行:

設(shè)置GIL

切換到一個(gè)線程去執(zhí)行

運(yùn)行指定的字節(jié)碼指令集合

線程主動(dòng)讓出控制

把線程設(shè)置完睡眠狀態(tài)

解鎖GIL

再次重復(fù)以上步驟

因此，Python的多線程在多核CPU上，只對(duì)于IO密集型計(jì)算產(chǎn)生正面效果；而當(dāng)有至少有一個(gè)CPU密集型線程存在，那么多線程效率會(huì)由于GIL而大幅下降。

GC

Python 中的GC為可配置的垃圾回收器提供了一個(gè)接口。通過(guò)它可以禁用回收器、調(diào)整回收頻率以及設(shè)置debug選項(xiàng)，也為用戶能夠查看那些無(wú)法回收的對(duì)象。

需要了解GC 的兩個(gè)重要函數(shù)是gc.collect（） 和 gc.set_threshold（）。

gc.collect([generation])觸發(fā)回收行為，返回unreachable object的數(shù)量。generation可選參數(shù)，用于指定回收第幾代垃圾回收，由此也可看出python使用的是分代垃圾回收。如果不提供參數(shù)，表示對(duì)整個(gè)堆進(jìn)行回收，即Full GC。

gc.set_threshold(threshold0[,threshold1[,threshold2)設(shè)置不同代的回收頻率，GC會(huì)把生命周期不同的對(duì)象分別放到3種代去管理回收，generation 0即傳說(shuō)中的年輕代，generation 1為老年代等。

一般地，通過(guò)比較上次回收之后，比較分配的資源數(shù)和釋放的資源數(shù)來(lái)決定是否啟動(dòng)回收，比如，當(dāng)分配的資源減去釋放的資源數(shù)超過(guò)閾值0時(shí)，回收年輕代的對(duì)象。相應(yīng)的，可以通過(guò)gc.get_referents(*objs)得到對(duì)objs任一對(duì)象引用的所有對(duì)象列表。

在要求極限性能的情況下，并確保程序不會(huì)造成對(duì)象循環(huán)引用的時(shí)候，可以禁掉垃圾回收器。通過(guò)使用gc.disable()，可以禁掉自動(dòng)垃圾回收器。

1. gc.enable()：激活GC

2. gc.disable()：禁用GC

3. gc.isenabled():檢查是否激活

同時(shí)，可以用gc.set_debug(gc.DEBUG_LEAK)來(lái)調(diào)試有內(nèi)存泄露的程序。除此之外，還有DEBUG_SAVEALL，該選項(xiàng)能夠讓被回收的對(duì)象保存在gc.garbage里面，以便檢查。

調(diào)試

iPDB是一個(gè)不錯(cuò)的工具，通過(guò) pip install ipdb 安裝該工具，然后在你的代碼中import ipdb; ipdb.set_trace()，然后在程序運(yùn)行時(shí)，會(huì)獲得一個(gè)交互式提示，每次執(zhí)行程序的一行并且檢查變量。示例代碼如下：

import ipdb 
ipdb.set_trace() 
ipdb.set_trace(context=5)  # will show five lines of code 
                           # instead of the default three lines 
ipdb.pm() 
ipdb.run('x[0] = 3') 
result = ipdb.runcall(function, arg0, arg1, kwarg='foo') 
result = ipdb.runeval('f(1,2) - 3') 

另外，python內(nèi)置了一個(gè)很好的追蹤模塊，當(dāng)希望搞清其他程序的內(nèi)部構(gòu)造的時(shí)候，這個(gè)功能非常有用。

python -m trace --trace tracing.py                                                                                      

在一些場(chǎng)合，可以使用pycallgraph來(lái)追蹤性能問(wèn)題，它可以創(chuàng)建函數(shù)調(diào)用時(shí)間和次數(shù)的圖表。同時(shí)，objgraph對(duì)于查找內(nèi)存泄露非常有用。

當(dāng)然， 在Python 程序員八榮八恥中談到“以打印日志為榮 , 以單步跟蹤為恥“，日志在很多時(shí)候都是調(diào)試的不二法門(mén)。

性能優(yōu)化中的雕蟲(chóng)小技

從時(shí)空的角度看，優(yōu)化通常包含兩方面的內(nèi)容：減小代碼的體積，提高代碼的運(yùn)行效率。

一個(gè)良好的算法往往對(duì)性能起到關(guān)鍵作用，因此性能改進(jìn)的首要點(diǎn)是對(duì)算法的改進(jìn)。在算法的時(shí)間復(fù)雜度排序上依次是：

O(1) -> O(log n) -> O(n) -> O(n log n) -> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!)

因此能在時(shí)間復(fù)雜度上對(duì)算法進(jìn)行一定的改進(jìn)，對(duì)性能的提高不言而喻。

Python 字典中查找操作的復(fù)雜度為O(1)，而list 實(shí)際是個(gè)數(shù)組，在list 中查找需要遍歷整個(gè)表，其復(fù)雜度為O(n)，因此對(duì)成員的讀操作字典要比列表 更快。在需要多數(shù)據(jù)成員進(jìn)行頻繁訪問(wèn)的時(shí)候，字典是一個(gè)較好的選擇。set的union， intersection，difference操作要比list的迭代要快。因此如果涉及到求list交集，并集或者差的問(wèn)題可以轉(zhuǎn)換為set來(lái)操作。

對(duì)循環(huán)的優(yōu)化所遵循的原則是盡量減少循環(huán)過(guò)程中的計(jì)算量，有多重循環(huán)的盡量將內(nèi)層的計(jì)算提到上一層。 在循環(huán)的時(shí)候使用 xrange 而不是 range，因?yàn)?xrange() 在序列中每次調(diào)用只產(chǎn)生一個(gè)整數(shù)元素。而 range() 將直接返回完整的元素列表，用于循環(huán)時(shí)會(huì)有不必要的開(kāi)銷(xiāo)。另外，while 1 要比 while True 更快。另外，要充分利用Lazy if-evaluation的特性，也就是說(shuō)如果存在條件表達(dá)式if x and y，在 x 為false的情況下y表達(dá)式的值將不再計(jì)算。

python中的字符串對(duì)象是不可改變的，因此對(duì)任何字符串的操作如拼接，修改等都將產(chǎn)生一個(gè)新的字符串對(duì)象，而不是基于原字符串，因此這種持續(xù)的copy會(huì)在一定程度上影響python的性能。因此，在字符串連接的使用盡量使用join()而不是+，當(dāng)對(duì)字符串處理的時(shí)候，首選內(nèi)置函數(shù)，對(duì)字符進(jìn)行格式化比直接串聯(lián)讀取要快，盡量使用列表推導(dǎo)和生成器表達(dá)式。

優(yōu)化的前提是需要了解性能瓶頸在什么地方，對(duì)于比較復(fù)雜的代碼可以借助一些工具來(lái)定位，如profile。profile的使用非常簡(jiǎn)單，只需要在使用之前進(jìn)行import即可。對(duì)于profile的剖析數(shù)據(jù)，如果以二進(jìn)制文件的時(shí)候保存結(jié)果的時(shí)候，可以通過(guò)pstats模塊進(jìn)行文本報(bào)表分析，它支持多種形式的報(bào)表輸出，是文本界面下一個(gè)較為實(shí)用的工具。

Python性能優(yōu)化除了改進(jìn)算法，選用合適的數(shù)據(jù)結(jié)構(gòu)之外，還可以將關(guān)鍵python代碼部分重寫(xiě)成C擴(kuò)展模塊，或者選用在性能上更為優(yōu)化的解釋器等。

強(qiáng)大的庫(kù)

Python最棒的地方之一，就是大量的第三方庫(kù)，覆蓋之廣，令人驚嘆。Python 庫(kù)有一個(gè)缺陷就是默認(rèn)會(huì)進(jìn)行全局安裝。為了使每個(gè)項(xiàng)目都有一個(gè)獨(dú)立的環(huán)境，需要使用工具virtualenv，再用包管理工具pip和virtualenv配合工作。

盡管都可以求助于google或者baidu，但還要不自量力，按照個(gè)人認(rèn)知給出一個(gè)列表，如下：

雖然羅列很多，但終歸是滄海一粟，重要的是，這些都是開(kāi)源的。

不是小結(jié)的小結(jié)

語(yǔ)法數(shù)據(jù)，類與繼承；

包與模塊，規(guī)范命名；

描述裝飾，迭代生成；

Lambda GC， 并發(fā)線程；

調(diào)試優(yōu)化，類庫(kù)無(wú)窮；

人生苦短，Python 編程。

【本文來(lái)自51CTO專欄作者“老曹”的原創(chuàng)文章，作者微信公眾號(hào)：喔家ArchiSelf,id:wrieless-com】

戳這里，看該作者更多好文