摘要：查看原函數(shù)的參數(shù)注釋甚至函數(shù)名的時候，只能看到裝飾器的相關(guān)信息。也就是說，它是裝飾器的裝飾器，并且以原函數(shù)為參數(shù)，作用是保留原函數(shù)的各種信息，使得我們之后查看被裝飾了的原函數(shù)的信息時，可以保持跟原函數(shù)一模一樣。

貌似只能創(chuàng)建一個專欄，所以這篇文章只好放到“JavaScript從前端到全終端”里了?
原文鏈接：Effective Python

Python 作為一門入門極易并容易上癮的語音，相信已經(jīng)成為了很多人 “寫著玩” 的標(biāo)配腳本語言。但很多教材并沒有教授 Python 的進(jìn)階和優(yōu)化。本文作為進(jìn)階系列的文章，從基礎(chǔ)的語法到函數(shù)、迭代器、類，還有之后系列的線程 / 進(jìn)程、第三方庫、網(wǎng)絡(luò)編程等內(nèi)容，共同學(xué)習(xí)如何寫出更加 Pythonic 的代碼

部分提煉自書籍：《Effective Python》&《Python3 Cookbook》，但也做出了修改，并加上了我自己的理解和運用中的最佳實踐

list[start:end:step]

如果從列表開頭開始切割，那么忽略 start 位的 0，例如list[:4]

如果一直切到列表尾部，則忽略 end 位的 0，例如list[3:]

切割列表時，即便 start 或者 end 索引跨界也不會有問題

列表切片不會改變原列表。索引都留空時，會生成一份原列表的拷貝

b = a[:]
assert b == a and b is not a # true

使用列表推導(dǎo)式來取代map和filter

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# use map
squares = map(lambda x: x ** 2, a)
# use list comprehension
squares = [x ** 2 for x in a]
# 一個很大的好處是，列表推導(dǎo)式可以對值進(jìn)行判斷，比如
squares = [x ** 2 for x in a if x % 2 == 0]
# 而如果這種情況要用 map 或者 filter 方法實現(xiàn)的話，則要多寫一些函數(shù)

不要使用含有兩個以上表達(dá)式的列表推導(dǎo)式

# 有一個嵌套的列表，現(xiàn)在要把它里面的所有元素扁平化輸出
list = [[
  [1, 2, 3],
  [4, 5, 6]
]]
# 使用列表推導(dǎo)式
flat_list = [x for list0 in list for list1 in list0 for x in list1]
# [1, 2, 3, 4, 5, 6]

# 可讀性太差，易出錯。這種時候更建議使用普通的循環(huán)
flat_list = []
for list0 in list:
    for list1 in list0:
        flat_list.extend(list1)

數(shù)據(jù)多時，列表推導(dǎo)式可能會消耗大量內(nèi)存，此時建議使用生成器表達(dá)式

# 在列表推導(dǎo)式的推導(dǎo)過程中，對于輸入序列的每個值來說，都可能要創(chuàng)建僅含一項元素的全新列表。因此數(shù)據(jù)量大時很耗性能。
# 使用生成器表達(dá)式
list = (x ** 2 for x in range(0, 1000000000))
# 生成器表達(dá)式返回的迭代器，只有在每次調(diào)用時才生成值，從而避免了內(nèi)存占用

需要獲取 index 時使用enumerate

enumerate可以接受第二個參數(shù)，作為迭代時加在index上的數(shù)值

list = ["a", "b", "c", "d"]

for index, value in enumerate(list):
    print(index)
# 0
# 1
# 2
# 3

for index, value in enumerate(list, 2):
    print(index)
# 2
# 3
# 4
# 5

用zip同時遍歷兩個迭代器

list_a = ["a", "b", "c", "d"]
list_b = [1, 2, 3]
# 雖然列表長度不一樣，但只要有一個列表耗盡，則迭代就會停止
for letter, number in zip(list_a, list_b):
    print(letter, number)
# a 1
# b 2
# c 3

zip遍歷時返回一個元組

a = [1, 2, 3]
b = ["w", "x", "y", "z"]
for i in zip(a,b):
    print(i)

# (1, "w")
# (2, "x")
# (3, "y")

關(guān)于for和while循環(huán)后的else塊

循環(huán)正常結(jié)束之后會調(diào)用else內(nèi)的代碼

循環(huán)里通過break跳出循環(huán)，則不會執(zhí)行else

要遍歷的序列為空時，立即執(zhí)行else

for i in range(2):
    print(i)
else:
    print("loop finish")
# 0
# 1
# loop finish

for i in range(2):
    print(i)
    if i % 2 == 0:
        break
else:
    print("loop finish")
# 0

對于普通的序列（列表），我們可以通過內(nèi)置的reversed()函數(shù)進(jìn)行反向迭代：

list_example = [i for i in range(5)]
iter_example = (i for i in range(5)) # 迭代器
set_example = {i for i in range(5)} # 集合

# 普通的正向迭代
# for i in list_example

# 通過 reversed 進(jìn)行反向迭代
for i in reversed(list_example):
    print(i)
# 4
# 3
# 2
# 1
# 0

# 但無法作用于 集合 和 迭代器
reversed(iter_example) # TypeError: argument to reversed() must be a sequence

除此以外，還可以通過實現(xiàn)類里的__reversed__方法，將類進(jìn)行反向迭代：

class Countdown:
    def __init__(self, start):
        self.start = start

    # 正向迭代
    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

    # 反向迭代
    def __reversed__(self):
        n = 1
        while n <= self.start:
            yield n
            n += 1

for i in reversed(Countdown(4)):
    print(i)
# 1
# 2
# 3
# 4
for i in Countdown(4):
    print(i)
# 4
# 3
# 2
# 1

如果try內(nèi)沒有發(fā)生異常，則調(diào)用else內(nèi)的代碼

else會在finally之前運行

最終一定會執(zhí)行finally，可以在其中進(jìn)行清理工作

裝飾器用于在不改變原函數(shù)代碼的情況下修改已存在的函數(shù)。常見場景是增加一句調(diào)試，或者為已有的函數(shù)增加log監(jiān)控

舉個栗子：

def decorator_fun(fun):
    def new_fun(*args, **kwargs):
        print("current fun:", fun.__name__)
        print("position arguments:", args)
        print("key arguments:", **kwargs)
        result = fun(*args, **kwargs)
        print(result)
        return result
    return new_fun
    
@decorator_fun
def add(a, b):
    return a + b

add(3, 2)
# current fun: add
# position arguments: (3, 2)
# key arguments: {}
# 5

除此以外，還可以編寫接收參數(shù)的裝飾器，其實就是在原本的裝飾器上的外層又嵌套了一個函數(shù)：

def read_file(filename="results.txt"):
    def decorator_fun(fun):
        def new_fun(*args, **kwargs):
            result = fun(*args, **kwargs)
            with open(filename, "a") as f:
                f.write(result + "
")
            return result
        return new_fun
    return decorator_fun

# 使用裝飾器時代入?yún)?shù)
@read_file(filename="log.txt")
def add(a, b):
    return a + b

但是像上面那樣使用裝飾器的話有一個問題：

@decorator_fun
def add(a, b):
    return a + b

print(add.__name__)
# new_fun

也就是說原函數(shù)已經(jīng)被裝飾器里的new_fun函數(shù)替代掉了。調(diào)用經(jīng)過裝飾的函數(shù)，相當(dāng)于調(diào)用一個新函數(shù)。查看原函數(shù)的參數(shù)、注釋、甚至函數(shù)名的時候，只能看到裝飾器的相關(guān)信息。為了解決這個問題，我們可以使用 Python 自帶的functools.wraps方法。

stackoverflow: What does functools.wraps do?

functools.wraps是個很 hack 的方法，它本事作為一個裝飾器，做用在裝飾器內(nèi)部將要返回的函數(shù)上。也就是說，它是裝飾器的裝飾器，并且以原函數(shù)為參數(shù)，作用是保留原函數(shù)的各種信息，使得我們之后查看被裝飾了的原函數(shù)的信息時，可以保持跟原函數(shù)一模一樣。

from functools import wraps

def decorator_fun(fun):
    @wraps(fun)
    def new_fun(*args, **kwargs):
        result = fun(*args, **kwargs)
        print(result)
        return result
    return new_fun
    
@decorator_fun
def add(a, b):
    return a + b

print(add.__name__)
# add

此外，有時候我們的裝飾器里可能會干不止一個事情，此時應(yīng)該把事件作為額外的函數(shù)分離出去。但是又因為它可能僅僅和該裝飾器有關(guān)，所以此時可以構(gòu)造一個裝飾器類。原理很簡單，主要就是編寫類里的__call__方法，使類能夠像函數(shù)一樣的調(diào)用。

from functools import wraps

class logResult(object):
    def __init__(self, filename="results.txt"):
        self.filename = filename
    
    def __call__(self, fun):
        @wraps(fun)
        def new_fun(*args, **kwargs):
            result = fun(*args, **kwargs)
            with open(filename, "a") as f:
                f.write(result + "
")
            return result
        self.send_notification()
        return new_fun
    
    def send_notification(self):
        pass

@logResult("log.txt")
def add(a, b):
    return a + b

考慮使用生成器來改寫直接返回列表的函數(shù)

# 定義一個函數(shù)，其作用是檢測字符串里所有 a 的索引位置，最終返回所有 index 組成的數(shù)組
def get_a_indexs(string):
    result = []
    for index, letter in enumerate(string):
        if letter == "a":
            result.append(index)
    return result

用這種方法有幾個小問題：

每次獲取到符合條件的結(jié)果，都要調(diào)用append方法。但實際上我們的關(guān)注點根本不在這個方法，它只是我們達(dá)成目的的手段，實際上只需要index就好了

返回的result可以繼續(xù)優(yōu)化

數(shù)據(jù)都存在result里面，如果數(shù)據(jù)量很大的話，會比較占用內(nèi)存

因此，使用生成器generator會更好。生成器是使用yield表達(dá)式的函數(shù)，調(diào)用生成器時，它不會真的執(zhí)行，而是返回一個迭代器，每次在迭代器上調(diào)用內(nèi)置的next函數(shù)時，迭代器會把生成器推進(jìn)到下一個yield表達(dá)式：

def get_a_indexs(string):
    for index, letter in enumerate(string):
        if letter == "a":
            yield index

獲取到一個生成器以后，可以正常的遍歷它：

string = "this is a test to find a" index"
indexs = get_a_indexs(string)

# 可以這樣遍歷
for i in indexs:
    print(i)

# 或者這樣
try:
    while True:
        print(next(indexs))
except StopIteration:
    print("finish!")

# 生成器在獲取完之后如果繼續(xù)通過 next() 取值，則會觸發(fā) StopIteration 錯誤
# 但通過 for 循環(huán)遍歷時會自動捕獲到這個錯誤

如果你還是需要一個列表，那么可以將函數(shù)的調(diào)用結(jié)果作為參數(shù)，再調(diào)用list方法

results = get_a_indexs("this is a test to check a")
results_list = list(results)

需要注意的是，普通的迭代器只能迭代一輪，一輪之后重復(fù)調(diào)用是無效的。解決這種問題的方法是，你可以定義一個可迭代的容器類：

class LoopIter(object):
    def __init__(self, data):
        self.data = data
    # 必須在 __iter__ 中 yield 結(jié)果
    def __iter__(self):
        for index, letter in enumerate(self.data):
            if letter == "a":
                yield index

這樣的話，將類的實例迭代重復(fù)多少次都沒問題：

string = "this is a test to find a" index"
indexs = LoopIter(string)

print("loop 1")
for _ in indexs:
    print(_)
# loop 1
# 8
# 23

print("loop 2")
for _ in indexs:
    print(_)
# loop 2
# 8
# 23

但要注意的是，僅僅是實現(xiàn)__iter__方法的迭代器，只能通過for循環(huán)來迭代；想要通過next方法迭代的話則需要使用iter方法：

string = "this is a test to find a" index"
indexs = LoopIter(string)

next(indexs) # TypeError: "LoopIter" object is not an iterator

iter_indexs = iter(indexs)
next(iter_indexs) # 8

有時候，方法接收的參數(shù)數(shù)目可能不一定，比如定義一個求和的方法，至少要接收兩個參數(shù)：

def sum(a, b):
    return a + b

# 正常使用
sum(1, 2) # 3
# 但如果我想求很多數(shù)的總和，而將參數(shù)全部代入是會報錯的，而一次一次代入又太麻煩
sum(1, 2, 3, 4, 5) # sum() takes 2 positional arguments but 5 were given

對于這種接收參數(shù)數(shù)目不一定，而且不在乎參數(shù)傳入順序的函數(shù)，則應(yīng)該利用位置參數(shù)*args：

def sum(*args):
    result = 0
    for num in args:
        result += num
    return result

sum(1, 2) # 3
sum(1, 2, 3, 4, 5) # 15
# 同時，也可以直接把一個數(shù)組帶入，在帶入時使用 * 進(jìn)行解構(gòu)
sum(*[1, 2, 3, 4, 5]) # 15

但要注意的是，不定長度的參數(shù)args在傳遞給函數(shù)時，需要先轉(zhuǎn)換成元組tuple。這意味著，如果你將一個生成器作為參數(shù)帶入到函數(shù)中，生成器將會先遍歷一遍，轉(zhuǎn)換為元組。這可能會消耗大量內(nèi)存：

def get_nums():
    for num in range(10):
        yield num

nums = get_nums()
sum(*nums) # 45
# 但在需要遍歷的數(shù)目較多時，會占用大量內(nèi)存

關(guān)鍵字參數(shù)可提高代碼可讀性

可以通過關(guān)鍵字參數(shù)給函數(shù)提供默認(rèn)值

便于擴(kuò)充函數(shù)參數(shù)

定義只能使用關(guān)鍵字參數(shù)的函數(shù)

普通的方式，在調(diào)用時不會強(qiáng)制要求使用關(guān)鍵字參數(shù)

# 定義一個方法，它的作用是遍歷一個數(shù)組，找出等于(或不等于)目標(biāo)元素的 index
def get_indexs(array, target="", judge=True):
    for index, item in enumerate(array):
        if judge and item == target:
            yield index
        elif not judge and item != target:
            yield index

array = [1, 2, 3, 4, 1]
# 下面這些都是可行的
result = get_indexs(array, target=1, judge=True)
print(list(result)) # [0, 4]
result = get_indexs(array, 1, True)
print(list(result)) # [0, 4]
result = get_indexs(array, 1)
print(list(result)) # [0, 4]

使用 Python3 中強(qiáng)制關(guān)鍵字參數(shù)的方式

# 定義一個方法，它的作用是遍歷一個數(shù)組，找出等于(或不等于)目標(biāo)元素的 index
def get_indexs(array, *, target="", judge=True):
    for index, item in enumerate(array):
        if judge and item == target:
            yield index
        elif not judge and item != target:
            yield index

array = [1, 2, 3, 4, 1]
# 這樣可行
result = get_indexs(array, target=1, judge=True)
print(list(result)) # [0, 4]
# 也可以忽略有默認(rèn)值的參數(shù)
result = get_indexs(array, target=1)
print(list(result)) # [0, 4]
# 但不指定關(guān)鍵字參數(shù)則報錯
get_indexs(array, 1, True)
# TypeError: get_indexs() takes 1 positional argument but 3 were given

使用 Python2 中強(qiáng)制關(guān)鍵字參數(shù)的方式

# 定義一個方法，它的作用是遍歷一個數(shù)組，找出等于(或不等于)目標(biāo)元素的 index
# 使用 **kwargs，代表接收關(guān)鍵字參數(shù)，函數(shù)內(nèi)的 kwargs 則是一個字典，傳入的關(guān)鍵字參數(shù)作為鍵值對的形式存在
def get_indexs(array, **kwargs):
    target = kwargs.pop("target", "")
    judge = kwargs.pop("judge", True)
    for index, item in enumerate(array):
        if judge and item == target:
            yield index
        elif not judge and item != target:
            yield index

array = [1, 2, 3, 4, 1]
# 這樣可行
result = get_indexs(array, target=1, judge=True)
print(list(result)) # [0, 4]
# 也可以忽略有默認(rèn)值的參數(shù)
result = get_indexs(array, target=1)
print(list(result)) # [0, 4]
# 但不指定關(guān)鍵字參數(shù)則報錯
get_indexs(array, 1, True)
# TypeError: get_indexs() takes 1 positional argument but 3 were given

算是老生常談了：函數(shù)的默認(rèn)值只會在程序加載模塊并讀取到該函數(shù)的定義時設(shè)置一次

也就是說，如果給某參數(shù)賦予動態(tài)的值（ 比如[]或者{}），則如果之后在調(diào)用函數(shù)的時候給參數(shù)賦予了其他參數(shù)，則以后再調(diào)用這個函數(shù)的時候，之前定義的默認(rèn)值將會改變，成為上一次調(diào)用時賦予的值：

def get_default(value=[]):
    return value
    
result = get_default()
result.append(1)
result2 = get_default()
result2.append(2)
print(result) # [1, 2]
print(result2) # [1, 2]

因此，更推薦使用None作為默認(rèn)參數(shù)，在函數(shù)內(nèi)進(jìn)行判斷之后賦值：

def get_default(value=None):
    if value is None:
        return []
    return value
    
result = get_default()
result.append(1)
result2 = get_default()
result2.append(2)
print(result) # [1]
print(result2) # [2]

默認(rèn)情況下，Python 用一個字典來保存一個對象的實例屬性。這使得我們可以在運行的時候動態(tài)的給類的實例添加新的屬性：

test = Test()
test.new_key = "new_value"

然而這個字典浪費了多余的空間 --- 很多時候我們不會創(chuàng)建那么多的屬性。因此通過__slots__可以告訴 Python 不要使用字典而是固定集合來分配空間。

class Test(object):
    # 用列表羅列所有的屬性
    __slots__ = ["name", "value"]
    def __init__(self, name="test", value="0"):
        self.name = name
        self.value = value

test = Test()
# 此時再增加新的屬性則會報錯
test.new_key = "new_value"
# AttributeError: "Test" object has no attribute "new_key"

通過定義類中的__call__方法，可以使該類的實例能夠像普通函數(shù)一樣調(diào)用。

class AddNumber(object):
    def __init__(self):
        self.num = 0

    def __call__(self, num=1):
        self.num += num

add_number = AddNumber()
print(add_number.num) # 0
add_number() # 像方法一樣的調(diào)用
print(add_number.num) # 1
add_number(3)
print(add_number.num) # 4

通過這種方式實現(xiàn)的好處是，可以通過類的屬性來保存狀態(tài)，而不必創(chuàng)建一個閉包或者全局變量。

資料：

Python @classmethod and @staticmethod for beginner

Difference between staticmethod and classmethod in python

@classmethod和@staticmethod很像，但他們的使用場景并不一樣。

類內(nèi)部普通的方法，都是以self作為第一個參數(shù)，代表著通過實例調(diào)用時，將實例的作用域傳入方法內(nèi)；

@classmethod以cls作為第一個參數(shù)，代表將類本身的作用域傳入。無論通過類來調(diào)用，還是通過類的實例調(diào)用，默認(rèn)傳入的第一個參數(shù)都將是類本身

@staticmethod不需要傳入默認(rèn)參數(shù)，類似于一個普通的函數(shù)

來通過實例了解它們的使用場景：

假設(shè)我們需要創(chuàng)建一個名為Date的類，用于儲存 年/月/日 三個數(shù)據(jù)

class Date(object):
    def __init__(self, year=0, month=0, day=0):
        self.year = year
        self.month = month
        self.day = day
    
    @property
    def time(self):
        return "{year}-{month}-{day}".format(
            year=self.year,
            month=self.month,
            day=self.day
        )

上述代碼創(chuàng)建了Date類，該類會在初始化時設(shè)置day/month/year屬性，并且通過property設(shè)置了一個getter，可以在實例化之后，通過time獲取存儲的時間：

date = Date("2016", "11", "09")
date.time # 2016-11-09

但如果我們想改變屬性傳入的方式呢？畢竟，在初始化時就要傳入年/月/日三個屬性還是很煩人的。能否找到一個方法，在不改變現(xiàn)有接口和方法的情況下，可以通過傳入2016-11-09這樣的字符串來創(chuàng)建一個Date實例？

你可能會想到這樣的方法：

date_string = "2016-11-09"
year, month, day = map(str, date_string.split("-"))
date = Date(year, month, day)

但不夠好：

在類外額外多寫了一個方法，每次還得格式化以后獲取參數(shù)

這個方法也只跟Date類有關(guān)

沒有解決傳入?yún)?shù)過多的問題

此時就可以利用@classmethod，在類的內(nèi)部新建一個格式化字符串，并返回類的實例的方法：

# 在 Date 內(nèi)新增一個 classmethod
@classmethod
def from_string(cls, string):
    year, month, day = map(str, string.split("-"))
    # 在 classmethod 內(nèi)可以通過 cls 來調(diào)用到類的方法，甚至創(chuàng)建實例
    date = cls(year, month, day)
    return date

這樣，我們就可以通過Date類來調(diào)用from_string方法創(chuàng)建實例，并且不侵略、修改舊的實例化方式：

date = Date.from_string("2016-11-09")
# 舊的實例化方式仍可以使用
date_old = Date("2016", "11", "09")

好處：

在@classmethod內(nèi)，可以通過cls參數(shù)，獲取到跟外部調(diào)用類時一樣的便利

可以在其中進(jìn)一步封裝該方法，提高復(fù)用性

更加符合面向?qū)ο蟮木幊谭绞?/p>

而@staticmethod，因為其本身類似于普通的函數(shù)，所以可以把和這個類相關(guān)的 helper 方法作為@staticmethod，放在類里，然后直接通過類來調(diào)用這個方法。

# 在 Date 內(nèi)新增一個 staticmethod
@staticmethod
def is_month_validate(month):
    return int(month) <= 12 and int(month) >= 1

將與日期相關(guān)的輔助類函數(shù)作為@staticmethod方法放在Date類內(nèi)后，可以通過類來調(diào)用這些方法：

month = "08"
if not Date.is_month_validate(month):
    print("{} is a validate month number".format(month))

上下文管理器，通俗的介紹就是：在代碼塊執(zhí)行前，先進(jìn)行準(zhǔn)備工作；在代碼塊執(zhí)行完成后，做收尾的處理工作。with語句常伴隨上下文管理器一起出現(xiàn)，經(jīng)典場景有：

with open("test.txt", "r") as file:
    for line in file.readlines():
        print(line)

通過with語句，代碼完成了文件打開操作，并在調(diào)用結(jié)束，或者讀取發(fā)生異常時自動關(guān)閉文件，即完成了文件讀寫之后的處理工作。如果不通過上下文管理器的話，則會是這樣的代碼：

file = open("test.txt", "r")
try:
    for line in file.readlines():
        print(line)
finally:
    file.close()

比較繁瑣吧？所以說使用上下文管理器的好處就是，通過調(diào)用我們預(yù)先設(shè)置好的回調(diào)，自動幫我們處理代碼塊開始執(zhí)行和執(zhí)行完畢時的工作。而通過自定義類的__enter__和__exit__方法，我們可以自定義一個上下文管理器。

class ReadFile(object):
    def __init__(self, filename):
        self.file = open(filename, "r")
    
    def __enter__(self):
        return self.file
    
    def __exit__(self, type, value, traceback):
        # type, value, traceback 分別代表錯誤的類型、值、追蹤棧
        self.file.close()
        # 返回 True 代表不拋出錯誤
        # 否則錯誤會被 with 語句拋出
        return True

然后可以以這樣的方式進(jìn)行調(diào)用：

with ReadFile("test.txt") as file_read:
    for line in file_read.readlines():
        print(line)

在調(diào)用的時候：

with語句先暫存了ReadFile類的__exit__方法

然后調(diào)用ReadFile類的__enter__方法

__enter__方法打開文件，并將結(jié)果返回給with語句

上一步的結(jié)果被傳遞給file_read參數(shù)

在with語句內(nèi)對file_read參數(shù)進(jìn)行操作，讀取每一行

讀取完成之后，with語句調(diào)用之前暫存的__exit__方法

__exit__方法關(guān)閉了文件

要注意的是，在__exit__方法內(nèi)，我們關(guān)閉了文件，但最后返回True，所以錯誤不會被with語句拋出。否則with語句會拋出一個對應(yīng)的錯誤。