1. 列舉 - enumerate 可以有引數哦

之前我們這樣操作：

i = 0for item in iterable:
print i, item i += 1

現在我們這樣操作：

for i, item in enumerate(iterable):

 print i, item

enumerate函式還可以接收第二個引數，就像下面這樣：

>>> list(enumerate('abc'))
[(0, 'a'), (1, 'b'), (2, 'c')] 
>>> list(enumerate('abc', 1)) 
[(1, 'a'), (2, 'b'), (3, 'c')]

另外要注意：不管你是為了Python就業還是興趣愛好，記住：專案開發經驗永遠是核心，如果你沒有2020最新python入門到高級實戰視頻教程，可以去小編的Python交流.裙 ：七衣衣九七七巴而五（數字的諧音）轉換下可以找到了，里面很多新python教程專案，還可以跟老司機交流討教！

點擊：python技術分享交流

2. 字典/集合 決議

你也許知道如何進行串列決議，但是可能不知道字典/集合決議，它們簡單易用且高效，就像下面這個例子：

my_dict = {i: i * i for i in xrange(100)} 
my_set = {i * 15 for i in xrange(100)}
# There is only a difference of ':' in both
# 兩者的區別在于字典推導中有冒號

3. 強制浮點除法

from __future__ import division 
result = 1/2# print(result)# 0.5

4. 對Python運算式求值

我們都知道eval函式，但是我們知道literal_eval函式么？也許很多人都不知道吧，可以用這種操作：

import ast 
my_list = ast.literal_eval(expr)

來代替以下這種操作：

expr = "[1, 2, 3]"my_list = eval(expr)

我相信對于大多數人來說這種形式是第一次看見，但是實際上這個在Python中已經存在很長時間了，

5. 字串/數列 逆序

你可以用以下方法快速逆序排列數列：

>>> a = [1,2,3,4]>>> a[::-1]
[4, 3, 2, 1]# This creates a new reversed list. # If you want to reverse a list in place you can do:a.reverse()

這總方式也同樣適用于字串的逆序：

>>> foo = "yasoob">>> foo[::-1]'boosay'

6. 三元運算

三元運算是if-else 陳述句的快捷操作，也被稱為條件運算，這里有幾個例子可以供你參考，它們可以讓你的代碼更加緊湊，更加美觀，

[on_true] if [expression] else [on_false]
x, y = 50, 25small = x if x < y else y

7. Python里面如何拷貝一個物件

標準庫中的copy模塊提供了兩個方法來實作拷貝.一個方法是copy,它回傳和引數包含內容一樣的物件.

import copynew_list = copy.copy(existing_list)

有些時候,你希望物件中的屬性也被復制,可以使用deepcopy方法:

import copynew_list_of_dicts = copy.deepcopy(existing_list_of_dicts)copy(x)Shallow copy operation on arbitrary Python objects.deepcopy(x, memo=None, _nil=[])
Deep copy operation on arbitrary Python objects.

8. python中如何判斷物件相等

首先是C#中字串的==和equal方法，“==” :
對于內置值型別而言， == 判斷兩個記憶體值是否相等，
對于用戶自定義的值型別而言(Struct)， == 需要多載，否則不能使用，
對于參考型別而言，默認是同一參考才回傳true，但是系統多載了很多參考型別的 == （比如下文提到的string），所以c#中參考型別的比較并不建議使用 ==，“equals” :
對于值型別而言， 記憶體相等才回傳true，
對于參考型別而言，指向同一個參考才算相等，
但是比較特殊的是字串String,是一個特殊的參考型型別，在C#語言中，多載了string的equals()方法，使string物件用起來就像是值型別一樣，python中的 ==
python中的物件包含三要素:id, type, valueid 用來標識唯一一個物件，type標識物件的型別，value用來設定物件的值，is 判斷是否是一個物件，使用id來判斷的，
== 是判斷a物件的值是否是b物件的值，默認呼叫它的__eq__方法，

9. 命名技巧

今天閱讀代碼，發現一個不錯的函式命名方式:

def request(_argv):

就是把所有的引數前面都加上_下劃線，這樣你在函式體中，一眼就可以看出那些是區域變數，那些是作為引數傳入的，類似把全域變數前面加上g，

10. 開發者工具集錦

• pydoc： 模塊可以根據源代碼中的docstrings為任何可匯入模塊生成格式良好的檔案，
• doctest模塊：該模塊可以從源代碼或獨立檔案的例子中抽取出測驗用例，
• unittest模塊：該模塊是一個全功能的自動化測驗框架，該框架提供了對測驗準備(test fixtures), 預定義測驗集(predefined test suite)以及測驗發現(test discovery)的支持，
• trace：模塊可以監控Python執行程式的方式，同時生成一個報表來顯示程式的每一行執行的次數，這些資訊可以用來發現未被自動化測驗集所覆寫的程式執行路徑，也可以用來研究程式呼叫圖，進而發現模塊之間的依賴關系，撰寫并執行測驗可以發現絕大多數程式中的問題，Python使得debug作業變得更加簡單，這是因為在大部分情況下，Python都能夠將未被處理的錯誤列印到控制臺中，我們稱這些錯誤資訊為traceback，如果程式不是在文本控制臺中運行的，traceback也能夠將錯誤資訊輸出到日志檔案或是訊息對話框中，當標準的traceback無法提供足夠的資訊時，可以使用cgitb 模塊來查看各級堆疊和源代碼背景關系中的詳細資訊，比如區域變數，cgitb模塊還能夠將這些跟蹤資訊以HTML的形式輸出，用來報告web應用中的錯誤，
• pdb：該模塊可以顯示出程式在錯誤產生時的執行路徑，同時可以動態地調整物件和代碼進行除錯，
• profile, timeit: 開發者可以使用profile以及timit模塊來測驗程式的速度，找出程式中到底是哪里很慢，進而對這部分代碼獨立出來進行調優的作業，
• compileall: Python程式是通過解釋器執行的，解釋器的輸入是原有程式的位元組碼編譯版本，這個位元組碼編譯版本可以在程式執行時動態地生成，也可以在程式打包的時候就生成，compileall模塊可以處理程式打包的事宜，它暴露出了打包相關的介面，該介面能夠被安裝程式和打包工具用來生成包含模塊位元組碼的檔案，同時，在開發環境中，compileall模塊也可以用來驗證源檔案是否包含了語法錯誤，
• YAPF：Google開源的Python代碼格式化工具，
• iPDB: iPDB是一個極好的工具，我已經用它查出了很多匪夷所思的bug，pip install ipdb 安裝該工具，然后在你的代碼中import ipdb; ipdb.set_trace()，然后你會在你的程式運行時，獲得一個很好的互動式提示，它每次執行程式的一行并且檢查變數，
• pycallgraph: 在一些場合，我使用pycallgraph來追蹤性能問題，它可以創建函式呼叫時間和次數的圖表，
• objgraph: objgraph對于查找記憶體泄露非常有用，

11. Python代碼微優化之加快查找

collections.OrderedDict類：
def __setitem__(self, key, value, dict_setitem=dict.__setitem__):    if key not in self:
        root = self.__root        last = root[0]        last[1] = root[0] = self.__map[key] = [last, root, key]    return dict_setitem(self, key, value)

注意最后一個引數：dict_setitem=dict.setitem，如果你仔細想就會感覺有道理，將值關聯到鍵上，你只需要給setitem傳遞三個引數：要設定的鍵，與鍵關聯的值，傳遞給內建dict類的setitem類方法，等會，好吧，也許最后一個引數沒什么意義， 最后一個引數其實是將一個函式系結到區域作用域中的一個函式上，具體是通過將dict.setitem賦值為引數的默認值，這里還有另一個例子：

def not_list_or_dict(value):
  return not (isinstance(value, dict) or isinstance(value, list))
def not_list_or_dict(value, _isinstance=isinstance, _dict=dict, _list=list):
  return not (_isinstance(value, _dict) or _isinstance(value, _list))

這里我們做同樣的事情，把本來將會在內建命名空間中的物件系結到區域作用域中去，因此，python將會使用LOCAL_FAST而不是LOAD_GLOBAL（全域查找），那么這到底有多快呢？我們做個簡單的測驗：

$ python -m timeit -s 'def not_list_or_dict(value): return not (isinstance(value, dict) or isinstance(value, list))' 'not_list_or_dict(50)'1000000 loops, best of 3: 0.48 usec per loop$ python -m timeit -s 'def not_list_or_dict(value, _isinstance=isinstance, _dict=dict, _list=list): return not (_isinstance(value, _dict) or _isinstance(value, _list))' 'not_list_or_dict(50)'1000000 loops, best of 3: 0.423 usec per loop

換句話說，大概有11.9%的提升 [2]，比我在文章開始處承諾的5%還多！

12. 包管理

Python世界最棒的地方之一，就是大量的第三方程式包，同樣，管理這些包也非常容易，按照慣例，會在 requirements.txt 檔案中列出專案所需要的包，每個包占一行，通常還包含版本號，

pelican==3.3Markdown

pelican-extended-sitemap==1.0.0

13. Python函式引數默認值的陷阱和原理深究

Python 2.7.9 (default, Dec 19 2014, 06:05:48)

[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.56)] on darwin

Type "help", "copyright", "credits" or "license" for more information.>>> def generate_new_list_with(my_list=[], element=None):

... my_list.append(element)

... return my_list

...>>> list_1 = generate_new_list_with(element=1)>>> list_1

[1]>>> list_2 = generate_new_list_with(element=2)>>> list_2

[1, 2]>>>

可見代碼運行結果并不和我們預期的一樣，list_2在函式的第二次呼叫時并沒有得到一個新的list并填入2，而是在第一次呼叫結果的基礎上append了一個2，為什么會發生這樣在其他編程語言中簡直就是設計bug一樣的問題呢？ 可見如果引數默認值是在函式編譯compile階段就已經被確定，之后所有的函式呼叫時，如果引數不顯示的給予賦值，那么所謂的引數默認值不過是一個指向那個在compile階段就已經存在的物件的指標，如果呼叫函式時，沒有顯示指定傳入引數值得話，那么所有這種情況下的該引數都會作為編譯時創建的那個物件的一種別名存在，如果引數的默認值是一個不可變(Imuttable)數值，那么在函式體內如果修改了該引數，那么引數就會重新指向另一個新的不可變值，而如果引數默認值是和本文最開始的舉例一樣，是一個可變物件(Muttable)，那么情況就比較糟糕了，所有函式體內對于該引數的修改，實際上都是對compile階段就已經確定的那個物件的修改，

14. 單下劃線（_）

1、在解釋器中：在這種情況下，“_”代表互動式解釋器會話中上一條執行的陳述句的結果，這種用法首先被標準CPython解釋器采用，然后其他型別的解釋器也先后采用，

>>> _ Traceback (most recent call last): 

File "<stdin>", line 1, in <module> NameError: name '_' is not defined >>> 42>>> _ 42>>> 'alright!' if _ else ':(''alright!'>>> _ 'alright!'

2、作為一個名稱：這與上面一點稍微有些聯系，此時“”作為臨時性的名稱使用，這樣，當其他人閱讀你的代碼時將會知道，你分配了一個特定的名稱，但是并不會在后面再次用到該名稱，例如，下面的例子中，你可能對回圈計數中的實際值并不感興趣，此時就可以使用“”，

n = 42for _ in range(n): 

    do_something()

3、國際化：也許你也曾看到”_“會被作為一個函式來使用，這種情況下，它通常用于實作國際化和本地化字串之間翻譯查找的函式名稱，這似乎源自并遵循相應的C約定，例如，在Django檔案“轉換”章節中，你將能看到如下代碼：

from django.utils.translation import ugettext as _ 

from django.http import HttpResponse 

def my_view(request): 

    output = _("Welcome to my site.") 

    return HttpResponse(output)

可以發現，場景二和場景三中的使用方法可能會相互沖突，所以我們需要避免在使用“”作為國際化查找轉換功能的代碼塊中同時使用“”作為臨時名稱，

15. 名稱前的單下劃線（如：_shahriar）

程式員使用名稱前的單下劃線，用于指定該名稱屬性為“私有”，這有點類似于慣例，為了使其他人（或你自己）使用這些代碼時將會知道以“”開頭的名稱只供內部使用，正如Python檔案中所述： 以下劃線 _ 為前綴的名稱（如*pam）應該被視為API中非公開的部分（不管是函式、方法還是資料成員），此時，應該將它們看作是一種實作細節，在修改它們時無需對外部通知， 正如上面所說，這確實類似一種慣例，因為它對解釋器來說確實有一定的意義，如果你寫了代碼 : from <模塊/包名> import * ，那么以 *開頭的名稱都不會被匯入，除非模塊或包中的 all 串列顯式地包含了它們，了解更多請查看 Importing * in Python

16. 名稱前的雙下劃線（如：__shahriar）

名稱（具體為一個方法名）前雙下劃線 _ 的用法并不是一種慣例，對解釋器來說它有特定的意義，Python中的這種用法是為了避免與子類定義的名稱沖突，Python檔案指出，spam 這種形式（至少兩個前導下劃線，最多一個后續下劃線）的任何識別符號將會被 正如所預料的，“_internal_use”并未改變，而“method_name”卻被變成了“_ClassName__method_name”，此時，如果你創建A的一個子類B，那么你將不能輕易地覆寫A中的方法“__method_name”，spam 這種形式原文取代，在這里 classname 是去掉前導下劃線的當前類名，例如下面的例子：

>>> class A(object): ... def _internal_use(self): ... pass... def __method_name(self): ... pass... >>> dir(A()) 

['_A__method_name', ..., '_internal_use']

正如所預料的，“_internal_use”并未改變，而“method_name”卻被變成了“_ClassNamemethod_name”，此時，如果你創建A的一個子類B，那么你將不能輕易地覆寫A中的方法“__method_name”，

17. 名稱前后的雙下劃線（如：init）

這種用法表示Python中特殊的方法名，其實，這只是一種慣例，對Python系統來說，這將確保不會與用戶自定義的名稱沖突，通常，你將會覆寫這些方法，并在里面實作你所需要的功能，以便Python呼叫它們，例如，當定義一個類時，你經常會覆寫“init”方法， 雖然你也可以撰寫自己的特殊方法名，但不要這樣做，

17. 隱藏特性 1，函式unpack

def foo(x, y):

 print x, y

alist = [1, 2]

adict = {'x': 1, 'y': 2}

foo(*alist) # 1, 2foo(**adict) # 1, 2

18. 隱藏特性 2， 鏈式比較運算子

>>> x = 3>>> 1 < x < 5True>>> 4 > x >=3True

19. 隱藏特性 3，函式的默認引數

>>> def foo(x=[]):

... x.append(1)

... print x

...>>> foo()

[1]>>> foo()

[1, 1]

更安全的做法是：

>>> def foo(x=None):... if x is None:... x = []... x.append(1)... print x

...>>> foo()

[1]>>> foo()

[1]

>>>

20. 隱藏特性 4，字典的get方法

21. 隱藏特性 5，帶關鍵字的格式化

>>> print "Hello %(name)s !" % {'name': 'James'}

Hello James !>>> print "I am years %(age)i years old" % {'age': 18}

I am years 18 years old

更新些的格式化:

>>> print "Hello {name} !".format(name="James")

Hello James !

22. 隱藏特性 6，切片操作的步長引數

可以用步長 -1 來反轉鏈表：>>> a = [1, 2, 3, 4, 5]>>> a[::2]

[1, 3, 5]>>> a[::-1]

[5, 4, 3, 2, 1]>>>

23. 隱藏特性 7，嵌套串列推導式

[(i, j) for i in range(3) for j in range(i)]

[(1, 0), (2, 0), (2, 1)]

串列推導構造permutation：可以用 itertools.permutations 來實作，

In[47]: a = 'abcd'In[48]: [i+j+k for i in a for j in a.replace(i,'') for k in a.replace(i,'').replace(j,'')]Out[48]: 

['abc', 'abd', 'acb', 'acd', 'adb', 'adc', 'bac', 'bad', 'bca', 'bcd', 'bda', 'bdc', 'cab', 'cad', 'cba', 'cbd', 'cda', 'cdb', 'dab', 'dac', 'dba', 'dbc', 'dca', 'dcb']

24. 隱藏特性 8，print 重定向輸出到檔案

注意打開的模式: “w+” 而不能 “w” , 當然 “a” 是可以的

>>> print >> open("somefile", "w+"), "Hello World"

25. 隱藏特性 9， Python3中的元組unpack

>>> a, b, *rest = range(10)

>>> a0>>> b1>>> rest

[2, 3, 4, 5, 6, 7, 8, 9]

>>>

>>> first, second, *rest, last = range(10)

>>> first0>>> second1>>> last9>>> rest

[2, 3, 4, 5, 6, 7, 8]

26. 隱藏特性 10，pow的第三個引數

其實第三個引數是來求模的: pow(x, y, z) == (x ** y) % z，注意，內置的 pow 和 math.pow 并不是一個函式，后者只接受2個引數，

>>> pow(4, 2, 2)0>>> pow(4, 2, 3)1

27. 隱藏特性 11，enumerate還有第二個引數

enumerate 很贊，可以給我們索引和序列值的對, 但是它還有第二個引數，這個引數用來: 指明索引的起始值，

>>> lst = ["a", "b", "c"]>>> list(enumerate(lst, 1))

[(1, 'a'), (2, 'b'), (3, 'c')]

28. 隱藏特性 12，顯式的宣告一個集合

在Python 2.7 之后可以這么宣告一個集合，
>>> {1,2,3}

set([1, 2, 3])

29. 隱藏特性 13，用切片來洗掉序列的某一段

>>> a = [1, 2, 3, 4, 5, 6, 7]>>> a[1:4] = []>>> a

[1, 5, 6, 7]

當然用 del a[1:4] 也是可以的，去除偶數項(偶數索引的):

>>> a = [0, 1, 2, 3, 4, 5, 6, 7]

>>> del a[::2]

>>> a[1, 3, 5, 7]

30. 隱藏特性 14，isinstance可以接收一個元組

這個真的鮮為人知, 我們可以用 isinstance(x, (float, int)) 來判斷 x 是不是數，也就是那個元組里面是 或 的關系，只要是其中一個的實體就回傳 True，

>>> isinstance(1, (float, int))True>>> isinstance(1.3, (float, int))True>>> isinstance("1.3", (float, int))False

31. 讓關鍵代碼依賴于外部包

雖然Python讓許多編程任務變得容易，但它可能并不總能為緊急的任務提供最佳性能，你可以為緊急的任務使用C、C++或機器語言撰寫的外部包，這樣可以提高應用程式的性能，這些包都是不能跨平臺的，這意味著你需要根據你正在使用的平臺，尋找合適的包，簡而言之，這個方案放棄了一些應用程式的可移植性，以換取只有在特定主機上直接編程才能獲得的程式性能，這里有一些你應該考慮加入到你的“性能兵工廠”的包：

Cython
PyInlne
PyPy
Pyrex

這些包以不同的方式提高性能，例如，Pyrex能夠擴展Python所能做的事情，例如使用C的資料型別來讓記憶體任務更加有效或直接，PyInIne讓你在Python應用程式中直接使用C代碼，程式中的行內代碼單獨編譯，但它在利用C語言所能提供的效率的同時，也讓所有的代碼都在同一個地方，

32. 排序時使用鍵（key）

有很多老的Python排序代碼，它們在你創建一個自定義的排序時花費你的時間，但在運行時確實能加速執行排序程序，元素排序的最好方法是盡可能使用鍵（key）和默認的sort()排序方法，例如，考慮下面的代碼：

import operator

somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(0))

somelist

#Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(1))

somelist

#Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(2))

somelist

每一個實體中，根據你選擇的作為key引數部分的索引，陣列進行了排序，類似于利用數字進行排序，這種方法同樣適用于利用字串排序，

33. 優化回圈

每種編程語言都會強調需要優化回圈，當使用Python的時候，你可以依靠大量的技巧使得回圈運行得更快，然而，開發者經常漏掉的一個方法是：避免在一個回圈中使用點操作，例如，考慮下面的代碼：

lowerlist = ['this', 'is', 'lowercase']

upper = str.upperupperlist = []

append = upperlist.appendfor word in lowerlist:

 append(upper(word))

 print(upperlist) #Output = ['THIS', 'IS', 'LOWERCASE']

每一次你呼叫方法str.upper，Python都會求該方法的值，然而，如果你用一個變數代替求得的值，值就變成了已知的，Python就可以更快地執行任務，優化回圈的關鍵，是要減少Python在回圈內部執行的作業量，因為Python原生的解釋器在那種情況下，真的會級訓執行的速度， （注意：優化回圈的方法有很多，這只是其中的一個，例如，許多程式員都會說，串列推導是在回圈中提高執行速度的最好方式，這里的關鍵是，優化回圈是程式取得更高的執行速度的更好方式之一，）

34. 嘗試多種編碼方法

如果每次你創建一個應用程式都是用相同的編碼方法，幾乎肯定會導致一些你的應用程式比它能夠達到的運行效率慢的情況，作為分析程序的一部分，你可以嘗試一些實驗，例如，在一個字典中管理一些元素，你可以采用安全的方法確定元素是否已經存在并更新，或者你可以直接添加元素，然后作為例外處理該元素不存在情況，考慮第一個編碼的例子：

n = 16myDict = {}for i in range(0, n): char = 'abcd'[i%4] if char not in myDict:

 myDict[char] = 0

 myDict[char] += 1

 print(myDict)

這段代碼通常會在myDict開始為空時運行得更快，然而，當mydict通常被資料填充（或者至少大部分被充填）時，另一種方法效果更好，

n = 16myDict = {}for i in range(0, n): char = 'abcd'[i%4] try:

 myDict[char] += 1

 except KeyError:

 myDict[char] = 1

 print(myDict)

兩種情況下具有相同的輸出：{‘d’: 4, ‘c’: 4, ‘b’: 4, ‘a’: 4}，唯一的不同是這個輸出是如何得到的，跳出固定的思維模式，創造新的編碼技巧，能夠幫助你利用你的應用程式獲得更快的結果，

35. 使用串列推導式

一個串列推導式包含以下幾個部分： 一個輸入序列 一個表示輸入序列成員的變數 一個可選的斷言運算式 一個將輸入序列中滿足斷言運算式的成員變換成輸出串列成員的輸出運算式

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = []for number in num:    if number > 0:

        filtered_and_squared.append(number ** 2)

print filtered_and_squared# [1, 16, 100, 4, 9]

而如果使用filter、lambda和map函式，則能夠將代碼大大簡化：

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = map(lambda x: x ** 2, filter(lambda x: x > 0, num))print filtered_and_squared

# [1, 16, 100, 4, 9]

## 更簡化的一種寫法 

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = [ x**2 for x in num if x > 0]print filtered_and_squared

# [1, 16, 100, 4, 9]

[圖片上傳失敗...(image-372582-1565252337522)]

comprehension.jpg

串列推導也可能會有一些負面效應，那就是整個串列必須一次性加載于記憶體之中，這對上面舉的例子而言不是問題，甚至擴大若干倍之后也都不是問題，但是總會達到極限，記憶體總會被用完， 針對上面的問題，生成器(Generator)能夠很好的解決，生成器運算式不會一次將整個串列加載到記憶體之中，而是生成一個生成器物件(Generator objector)，所以一次只加載一個串列元素， 生成器運算式同串列推導式有著幾乎相同的語法結構，區別在于生成器運算式是被圓括號包圍，而不是方括號：

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = ( x**2 for x in num if x > 0 )

print filtered_and_squared# <generator object <genexpr> at 0x00583E18>for item in filtered_and_squared:

    print item# 1, 16, 100 4,9

這比串列推導效率稍微提高一些，讓我們再一次改造一下代碼：

num = [1, 4, -5, 10, -7, 2, 3, -1]def square_generator(optional_parameter):

    return (x ** 2 for x in num if x > optional_parameter)print square_generator(0)# <generator object <genexpr> at 0x004E6418># Option Ifor k in square_generator(0):    print k# 1, 16, 100, 4, 9# Option IIg = list(square_generator(0))print g# [1, 16, 100, 4, 9]

除非特殊的原因，應該經常在代碼中使用生成器運算式，但除非是面對非常大的串列，否則是不會看出明顯區別的， 再來看一個通過兩階串列推導式遍歷目錄的例子：

import os

def tree(top):    for path, names, fnames in os.walk(top):        for fname in fnames:

            yield os.path.join(path, fname)for name in tree('C:\Users\XXX\Downloads\Test'):

    print name

36. 裝飾器(Decorators)

裝飾器為我們提供了一個增加已有函式或類的功能的有效方法，聽起來是不是很像Java中的面向切面編程(Aspect-Oriented Programming)概念？兩者都很簡單，并且裝飾器有著更為強大的功能，舉個例子，假定你希望在一個函式的入口和退出點做一些特別的操作(比如一些安全、追蹤以及鎖定等操作)就可以使用裝飾器， 裝飾器是一個包裝了另一個函式的特殊函式：主函式被呼叫，并且其回傳值將會被傳給裝飾器，接下來裝飾器將回傳一個包裝了主函式的替代函式，程式的其他部分看到的將是這個包裝函式，

import timefrom functools import wrapsdef timethis(func):

    '''

    Decorator that reports the execution time.

    '''    @wraps(func)

    def wrapper(*args, **kwargs):

        start = time.time()

        result = func(*args, **kwargs)

        end = time.time()

        print(func.__name__, end-start)        return result    return wrapper@timethisdef countdown(n):

    while n > 0:

        n -= 1countdown(100000)# ('countdown', 0.006999969482421875)

37. 背景關系管理庫(ContextLib)

contextlib模塊包含了與背景關系管理器和with宣告相關的工具，通常如果你想寫一個背景關系管理器，則你需要定義一個類包含enter方法以及exit方法，例如：

import timeclass demo:

    def __init__(self, label):        self.label = label    def __enter__(self):        self.start = time.time()    def __exit__(self, exc_ty, exc_val, exc_tb):        end = time.time()

        print('{}: {}'.format(self.label, end - self.start))

完整的例子在此：

import timeclass demo:

    def __init__(self, label):        self.label = label    def __enter__(self):        self.start = time.time()    def __exit__(self, exc_ty, exc_val, exc_tb):        end = time.time()

        print('{}: {}'.format(self.label, end - self.start))

with demo('counting'):

    n = 10000000

    while n > 0:

        n -= 1# counting: 1.36000013351

背景關系管理器被with宣告所激活，這個API涉及到兩個方法， enter方法，當執行流進入with代碼塊時，enter方法將執行，并且它將回傳一個可供背景關系使用的物件， 當執行流離開with代碼塊時，exit方法被呼叫，它將清理被使用的資源，

利用@contextmanager裝飾器改寫上面那個例子：

from contextlib import contextmanagerimport time@contextmanagerdef demo(label):

    start = time.time()    try:        yield

    finally:

        end = time.time()

        print('{}: {}'.format(label, end - start))with demo('counting'):

    n = 10000000

    while n > 0:

        n -= 1# counting: 1.32399988174

看上面這個例子，函式中yield之前的所有代碼都類似于背景關系管理器中enter方法的內容，而yield之后的所有代碼都如exit方法的內容，如果執行程序中發生了例外，則會在yield陳述句觸發，

38. 描述器(Descriptors)

描述器決定了物件屬性是如何被訪問的，描述器的作用是定制當你想參考一個屬性時所發生的操作， 構建描述器的方法是至少定義以下三個方法中的一個，需要注意，下文中的instance是包含被訪問屬性的物件實體，而owner則是被描述器修辭的類， get(self, instance, owner) – 這個方法是當屬性被通過(value = https://www.cnblogs.com/chengxuyuanaa/p/obj.attr)的方式獲取時呼叫，這個方法的回傳值將被賦給請求此屬性值的代碼部分， set(self, instance, value) – 這個方法是當希望設定屬性的值(obj.attr = ‘value’)時被呼叫，該方法不會回傳任何值， delete(self, instance) – 當從一個物件中洗掉一個屬性時(del obj.attr)，呼叫此方法， 譯者注：對于instance和owner的理解，考慮以下代碼：

class Celsius(object):

    def __init__(self, value=0.0):        self.value = float(value)    def __get__(self, instance, owner):        return self.value    def __set__(self, instance, value):        self.value = float(value)class Temperature(object):

    celsius = Celsius()

temp=Temperature()

temp.celsius #calls Celsius.__get__

39. Zipping and unzipping lists and iterables

>>> a = [1, 2, 3]>>> b = ['a', 'b', 'c']>>> z = zip(a, b)>>> z

[(1, 'a'), (2, 'b'), (3, 'c')]>>> zip(*z)

[(1, 2, 3), ('a', 'b', 'c')]

40. Grouping adjacent list items using zip

>>> a = [1, 2, 3, 4, 5, 6]>>> # Using iterators>>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))>>> group_adjacent(a, 3)

[(1, 2, 3), (4, 5, 6)]>>> group_adjacent(a, 2)

[(1, 2), (3, 4), (5, 6)]>>> group_adjacent(a, 1)

[(1,), (2,), (3,), (4,), (5,), (6,)]>>> # Using slices>>> from itertools import islice>>> group_adjacent = lambda a, k: zip(*(islice(a, i, None, k) for i in range(k)))>>> group_adjacent(a, 3)

[(1, 2, 3), (4, 5, 6)]>>> group_adjacent(a, 2)

[(1, 2), (3, 4), (5, 6)]>>> group_adjacent(a, 1)

[(1,), (2,), (3,), (4,), (5,), (6,)]

41. Sliding windows (n-grams) using zip and iterators

>>> from itertools import islice>>> def n_grams(a, n):... z = (islice(a, i, None) for i in range(n))... return zip(*z)

...>>> a = [1, 2, 3, 4, 5, 6]>>> n_grams(a, 3)

[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]>>> n_grams(a, 2)

[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]>>> n_grams(a, 4)

[(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

42. Inverting a dictionary using zip

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> m.items()

[('a', 1), ('c', 3), ('b', 2), ('d', 4)]>>> zip(m.values(), m.keys())

[(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]>>> mi = dict(zip(m.values(), m.keys()))>>> mi

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

43. Flattening lists

>>> a = [[1, 2], [3, 4], [5, 6]]>>> list(itertools.chain.from_iterable(a))

[1, 2, 3, 4, 5, 6]

>>> sum(a, [])

[1, 2, 3, 4, 5, 6]

>>> [x for l in a for x in l]

[1, 2, 3, 4, 5, 6]

>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

>>> [x for l1 in a for l2 in l1 for x in l2]

[1, 2, 3, 4, 5, 6, 7, 8]

>>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]

>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]

>>> flatten(a)

[1, 2, 3, 4, 5, 6, 7, 8]

44. Dictionary comprehensions

>>> m = {x: x ** 2 for x in range(5)}>>> m

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}>>> m = {x: 'A' + str(x) for x in range(10)}>>> m

{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

45. 常犯錯誤，濫用運算式作為函式引數默認值

Python允許開發者指定一個默認值給函式引數，雖然這是該語言的一個特征，但當引數可變時，很容易導致混亂，例如，下面這段函式定義：

>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz") # but this line could be problematic, as we'll see...... return bar

在上面這段代碼里，一旦重復呼叫foo()函式（沒有指定一個bar引數），那么將一直回傳’bar’，因為沒有指定引數，那么foo()每次被呼叫的時候，都會賦予[]，下面來看看，這樣做的結果：

>>> foo()

["baz"]>>> foo()

["baz", "baz"]>>> foo()

["baz", "baz", "baz"]

解決方案：

>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar

...>>> foo()

["baz"]>>> foo()

["baz"]>>> foo()

["baz"]

46. 誤解Python規則范圍

Python的作用域決議是基于LEGB規則，分別是Local、Enclosing、Global、Built-in，實際上，這種決議方法也有一些玄機，看下面這個例子：

>>> x = 10>>> def foo():

... x += 1... print x

...>>> foo()

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

 File "<stdin>", line 2, in fooUnboundLocalError: local variable 'x' referenced before assignment

許多人會感動驚訝，當他們在作業的函式體里添加一個引數陳述句，會在先前作業的代碼里報UnboundLocalError錯誤（ 點擊這里查看更詳細描述）， 在使用串列時，開發者是很容易犯這種錯誤的，看看下面這個例子：

>>> lst = [1, 2, 3]>>> def foo1():

... lst.append(5) # This works ok......>>> foo1()>>> lst

[1, 2, 3, 5]>>> lst = [1, 2, 3]>>> def foo2():

... lst += [5] # ... but this bombs!...>>> foo2()

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

 File "<stdin>", line 2, in fooUnboundLocalError: local variable 'lst' referenced before assignment

為什么foo2失敗而foo1運行正常？ 答案與前面那個例子是一樣的，但又有一些微妙之處，foo1沒有賦值給lst，而foo2賦值了，lst += [5]實際上就是lst = lst + [5]，試圖給lst賦值（因此，假設Python是在區域作用域里），然而，我們正在尋找指定給lst的值是基于lst本身，其實尚未確定，

47. 修改遍歷串列

>>> odd = lambda x : bool(x % 2)

>>> numbers = [n for n in range(10)]

>>> for i in range(len(numbers)):

... if odd(numbers[i]):

... del numbers[i] # BAD: Deleting item from a list while iterating over it

...

Traceback (most recent call last):

 File "<stdin>", line 2, in <module>

IndexError: list index out of range

在遍歷的時候，對串列進行洗掉操作，這是很低級的錯誤，稍微有點經驗的人都不會犯， 對上面的代碼進行修改，正確地執行：

>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers

[0, 2, 4, 6, 8]

48. 合理使用copy與deepcopy

對于dict和list等資料結構的物件，直接賦值使用的是參考的方式，而有些情況下需要復制整個物件，這時可以使用copy包里的copy和deepcopy，這兩個函式的不同之處在于后者是遞回復制的，效率也不一樣：（以下程式在ipython中運行） timeit后面的-n表示運行的次數，后兩行對應的是兩個timeit的輸出，下同，由此可見后者慢一個數量級，

import copya = range(100000)

%timeit -n 10 copy.copy(a) # 運行10次 copy.copy(a)%timeit -n 10 copy.deepcopy(a)10 loops, best of 3: 1.55 ms per loop10 loops, best of 3: 151 ms per loop

49. 合理使用生成器（generator）和yield

%timeit -n 100 a = (i for i in range(100000))

%timeit -n 100 b = [i for i in range(100000)]100 loops, best of 3: 1.54 ms per loop100 loops, best of 3: 4.56 ms per loop

使用()得到的是一個generator物件，所需要的記憶體空間與串列的大小無關，所以效率會高一些，在具體應用上，比如set(i for i in range(100000))會比set([i for i in range(100000)])快， 但是對于需要回圈遍歷的情況：

%timeit -n 10 for x in (i for i in range(100000)): pass

%timeit -n 10 for x in [i for i in range(100000)]: pass10 loops, best of 3: 6.51 ms per loop10 loops, best of 3: 5.54 ms per loop

后者的效率反而更高，但是如果回圈里有break,用generator的好處是顯而易見的，yield也是用于創建generator：

50. 使用級聯比較x < y < z

x, y, z = 1,2,3%timeit -n 1000000 if x < y < z:pass

%timeit -n 1000000 if x < y and y < z:pass1000000 loops, best of 3: 101 ns per loop1000000 loops, best of 3: 121 ns per loop

x < y < z效率略高，而且可讀性更好，

51. while 1 比 while True 更快

def while_1():

 n = 100000

 while 1:

 n -= 1

 if n <= 0: breakdef while_true():

 n = 100000

 while True:

 n -= 1

 if n <= 0: break m, n = 1000000, 1000000 %timeit -n 100 while_1()

%timeit -n 100 while_true()100 loops, best of 3: 3.69 ms per loop100 loops, best of 3: 5.61 ms per loop

while 1 比 while true快很多，原因是在python2.x中，True是一個全域變數，而非關鍵字，

52. 使用**而不是pow

%timeit -n 10000 c = pow(2,20)

%timeit -n 10000 c = 2**2010000 loops, best of 3: 284 ns per loop10000 loops, best of 3: 16.9 ns per loop

53. 使用 cProfile, cStringIO 和 cPickle等用c實作相同功能（分別對應profile, StringIO, pickle）的包

import cPickleimport pickle

a = range(10000)

%timeit -n 100 x = cPickle.dumps(a)

%timeit -n 100 x = pickle.dumps(a)100 loops, best of 3: 1.58 ms per loop100 loops, best of 3: 17 ms per loop

由c實作的包，速度快10倍以上！

54. 使用最佳的反序列化方式

下面比較了eval, cPickle, json方式三種對相應字串反序列化的效率，可見json比cPickle快近3倍，比eval快20多倍，

import jsonimport cPickle

a = range(10000)s1 = str(a)s2 = cPickle.dumps(a)s3 = json.dumps(a)%timeit -n 100 x = eval(s1)

%timeit -n 100 x = cPickle.loads(s2)

%timeit -n 100 x = json.loads(s3)100 loops, best of 3: 16.8 ms per loop100 loops, best of 3: 2.02 ms per loop100 loops, best of 3: 798 μs per loop

55. 怎么才算精通python

這個問題比較難回答，按照自己的看法整理了一些觀點，不要問我是按什么標準整理的，我只能說，整理的這些點，第一，在我看來都說得不錯；第二，我自己都會去按照這些點來看看自己離 “精通” python還有多遠，

1. 熟悉語法以及原聲資料結構
2. 熟悉基本實作中的性能特點，就是知道什么操作會慢
3. 會使用profile以及基于profile的性能分析工具
4. 會使用運行時編譯和靜態編譯的工具，pypy，numba，cython，ctypes，original C/C++ extension
5. 熟悉你所在領域的拓展庫，比如我，科學計算方面的庫不要太多，numpy衍生出來的一大堆大堆
6. 了解基本的編譯程序，基本的作業系統知識（只要你C、C++學的還行就可以了）
7. 要想精通python，寫的代碼首先得pythonic
8. 研讀牛B的開源代碼，在這程序中會遇到python的許多高階用法
9. 理解裝飾器，生成器，描述符，元類
10. 掌握list comprehension，
11. 多用內置函式：map，reduce，filter，iter，range，divmod，round，chr，enumerate，all，any，slice，zip+

56. python 猴子補丁相關

python里有一個很奇妙的monkey patch，中文叫做猴子補丁，是指的是在運行時動態替換某些已加載的模塊的實作，第一次了解這個概念是在使用gevent的時候，需要把python自帶的socket，os等相關模塊的實作改變成異步形式，但同時不改動python的源代碼，
最后注意：不管你是為了Python就業還是興趣愛好，記住：專案開發經驗永遠是核心，如果你沒有2020最新python入門到高級實戰視頻教程，可以去小編的Python交流.裙 ：七衣衣九七七巴而五（數字的諧音）轉換下可以找到了，里面很多新python教程專案，還可以跟老司機交流討教！

本文的文字及圖片來源于網路加上自己的想法,僅供學習、交流使用,不具有任何商業用途,著作權歸原作者所有,如有問題請及時聯系我們以作處理，

標籤：Python

上一篇：MEMO中顯示的SQL資料怎么換行？

下一篇：關于cxgrid重繪問題，請大神們解答啊