Python 進階（一些進階技巧）

個人筆記，基本都摘抄自 Python3 官方文檔

一. 上下文管理

1. 傳統的類方式

Java 使用 try 來自動管理資源，只要實現了 AutoCloseable 接口，就可以部分擺脫手動 colse 的地獄了。
而 Python，則是定義了兩個 Protocol：__enter__ 和 __exit__. 下面是一個 open 的模擬實現：

class OpenContext(object):

    def __init__(self, filename, mode):  # 調用 open(filename, mode) 返回一個實例
        self.fp = open(filename, mode)

    def __enter__(self):  # 用 with 管理 __init__ 返回的實例時，with 會自動調用這個方法
        return self.fp

    # 退出 with 代碼塊時，會自動調用這個方法。
    def __exit__(self, exc_type, exc_value, traceback):
        self.fp.close()

# 這里先構造了 OpenContext 實例，然后用 with 管理該實例
with OpenContext('/tmp/a', 'a') as f:
    f.write('hello world')

這里唯一有點復雜的，就是 __exit__ 方法。和 Java 一樣，__exit__ 相當於 try - catch - finally 的 finally 代碼塊，在發生異常時，它也會被調用。

當沒有異常發生時，__exit__ 的三個參數 exc_type, exc_value, traceback 都為 None，而當發生異常時，它們就對應異常的詳細信息。
發生異常時， __exit__ 的返回值將被用於決定是否向外層拋出該異常，返回 True 則拋出，返回 False 則抑制（swallow it）。

Note 1：Python 3.6 提供了 async with 異步上下文管理器，它的 Protocol 和同步的 with 完全類似，是 __aenter__ 和 __aexit__ 兩個方法。
Note 2：與 Java 相同，with 支持同時管理多個資源，因此可以直接寫 with open(x) as a, open(y) as b: 這樣的形式。

2. contextlib

2.1 @contextlib.contextmanager

對於簡單的 with 資源管理，編寫一個類可能會顯得比較繁瑣，為此 contextlib 提供了一個方便的裝飾器 @contextlib.contextmanager 用來簡化代碼。

使用它，上面的 OpenContext 可以改寫成這樣：

from contextlib import contextmanager
@contextmanager
def make_open_context(filename, mode):
    fp = open(filename, mode)
    try:
        yield fp  # 沒錯，這是一個生成器函數
    finally:
        fp.close()


with make_open_context('/tmp/a', 'a') as f:
    f.write('hello world')

使用 contextmanager 裝飾一個生成器函數，yield 之前的代碼對應 __enter__，finally 代碼塊就對應 __exit__.

Note：同樣，也有異步版本的裝飾器 @contextlib.asynccontextmanager

2.2 contextlib.closing(thing)

用於將原本不支持 with 管理的資源，包裝成一個 Context 對象。

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen('http://www.python.org')) as page:
    for line in page:
        print(line)

# closing 等同於
from contextlib import contextmanager

@contextmanager
def closing(thing):
    try:
        yield thing
    finally:
        thing.close()  # 就是添加了一個自動 close 的功能

2.3 contextlib.suppress(*exceptions)

使 with 管理器抑制代碼塊內任何被指定的異常：

from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove('somefile.tmp')

# 等同於
try:
    os.remove('somefile.tmp')
except FileNotFoundError:
    pass

2.4 contextlib.redirect_stdout(new_target)

將 with 代碼塊內的 stdout 重定向到指定的 target（可用於收集 stdout 的輸出）

f = io.StringIO()
with redirect_stdout(f):  # 將輸出直接寫入到 StringIO
    help(pow)
s = f.getvalue()

# 或者直接寫入到文件
with open('help.txt', 'w') as f:
    with redirect_stdout(f):
        help(pow)

redirect_stdout 函數返回的 Context 是可重入的（ reentrant），可以重復使用。

二、pathlib

提供了 OS 無關的文件路徑抽象，可以完全替代 os.path 和 glob.

學會了 pathlib.Path，你就會了 Python 處理文件路徑的所有功能。

1. 路徑解析與拼接

from pathlib import Path

data_folder = Path("./source_data/text_files/")
data_file = data_folder / "raw_data.txt"  # Path 重載了 / 操作符，路徑拼接超級方便

# 路徑的解析
data_file.parent  # 獲取父路徑，這里的結果就是 data_folder
data_foler.parent # 會返回 Path("source_data")
data_file.parents[1] # 即獲取到 data_file 的上上層目錄，結果和上面一樣是 Path("source_data")
data_file.parents[2] # 上上上層目錄，Path(".")

dara_file.name # 文件名 "raw_data.txt"
dara_file.suffix  # 文件的后綴（最末尾的）".txt"，還可用 suffixes 獲取所有后綴

data_file.stem  # 去除掉最末尾的后綴后（只去除一個），剩下的文件名：raw_data

# 替換文件名或者文件后綴
data_file.with_name("test.txt")  # 變成 .../test.txt
data_file.with_suffix(".pdf")  # 變成 .../raw_data.pdf

# 當前路徑與另一路徑 的相對路徑
data_file.relative_to(data_folder)  # PosixPath('raw_data.txt')

2. 常用的路徑操作函數

if not data_folder.exists():
    data_folder.mkdir(parents=True)  # 直接創建文件夾，如果父文件夾不存在，也自動創建

if not filename.exists():  # 文件是否存在
    filename.touch()  # 直接創建空文件，或者用 filename.open() 直接獲取文件句柄

# 路徑類型判斷
if data_file.is_file():  # 是文件
    print(data_file, "is a file")
elif data_file.is_dir():  # 是文件夾
    for child in p.iterdir():  # 通過 Path.iterdir() 迭代文件夾中的內容
        print(child)

# 路徑解析
# 獲取文件的絕對路徑（符號鏈接也會被解析到真正的文件）
filename.resolve()  # 在不區分大小寫的系統上（Windows），這個函數也會將大小寫轉換成實際的形式。

# 可以直接獲取 Home 路徑或者當前路徑
Path.home() / "file.txt" # 有時需要以 home 為 base path 來構建文件路徑
Path.cwd()  / "file.txt" # 或者基於當前路徑構建

還有很多其它的實用函數，可在使用中慢慢探索。

3. glob

pathlib 也提供了 glob 支持，也就是廣泛用在路徑匹配上的一種簡化正則表達式。

data_file.match(glob_pattern)  # 返回 True 或 False，表示文件路徑與給出的 glob pattern 是否匹配

for py_file in data_folder.glob("*/*.py"):  # 匹配當前路徑下的子文件夾中的 py 文件，會返回一個可迭代對象
    print(py_file)

# 反向匹配，相當於 glob 模式開頭添加 "**/"
for py_file in data_folder.glob("**/*.py"):  # 匹配當前路徑下的所有 py 文件（所有子文件夾也會被搜索），返回一個可迭代對象
    print(py_file)

glob 中的 * 表示任意字符，而 ** 則表示任意層目錄。（在大型文件樹上使用 ** 速度會很慢！）

三、functools

functools 提供了幾個有時很有用的函數和裝飾器

1. @functools.wraps

這個裝飾器用於使裝飾器 copy 被裝飾的對象的 __module__, __name__, __qualname__, __annotations__ and __doc__ 屬性，這樣裝飾器就顯得更加透明。

from functools import wraps
def my_decorator(f):
     @wraps(f)
     def wrapper(*args, **kwds):
         print('Calling decorated function')
         return f(*args, **kwds)
     return wrapper  # 用了 wraps，wrapper 會復制 f 的各種文檔屬性

@my_decorator
def func(xx):
    """ this is func's docstring"""
    print("this is func~")

如果不用 wraps 的話，因為實際上返回的是 wrapper，被裝飾對象的這些文檔屬性都會丟失。（比如 docstring）
因此在使用 wrapper 裝飾器時，添加 @wraps() 裝飾器是個好習慣。

2. functools.partial

這個感覺和高等數學的偏函數很像：比如函數 z = f(x, y) 有 x 和 y 兩個變量，現在把 x 看作常數，就可以對 y 進行求導運算。
而 python 的 partial 也差不多，不過它不是把 x 看作常數，而是先給定 x 的值。用法如下：

from functools import partial
basetwo = partial(int, base=2)  # 先給定 int 函數的 base 參數為 2
basetwo.__doc__ = 'Convert base 2 string to an int.'  # 如果需要文檔，可以添加 __doc__ 屬性
basetwo('10010')  # return 18

此外，還有個 partialmethod 函數，待了解

3. @functools.lru_cache(maxsize=128, typed=False)

如果某方法可能被頻繁調用（使用相同的參數），而且它的結果在一定時間內不會改變。可以用 lru_cache 裝飾它，減少運算量或 IO 操作。

from functools import lru_cache

# 緩存最近的（least recently used，lru） 64 次參數不同的調用結果。
@lru_cache(maxsize=64)
def my_sum(x):  # 后續的調用中，如果參數能匹配到緩存，就直接返回緩存結果
    return sum(x)

比如用遞歸計算斐波那契數列，數值較低的參數會被頻繁使用，於是可以用 lru_cache 來緩存它們。
或者爬取網頁，可能會需要頻繁爬取一個變化不快的網頁，這時完全可以用 cache 緩存。

但是它不能控制緩存失效時間，因此不能用於 Web 系統的緩存。還是得自己寫個簡單的裝飾器，把緩存存到 redis 里並設置 expires。或者直接用 Flask 或 Django 的 caching 插件。

4. @functools.singledispatch

單重派發，即根據函數的第一個參數的類型，來決定調用哪一個同名函數。

@singledispatch
def parse(arg):  # 首先定義一個默認函數
    print('沒有合適的類型被調用')  # 如果參數類型沒有匹配上，就調用這個默認函數

@parse.register(type(None))  # 第一個參數為 None
def _(arg):
    print('出現 None 了')

@parse.register(int)  # 第一個參數為整數
def _(arg):
    print('這次輸入的是整數')

@parse.register
def _(arg: list):  # python3.7 開始，可以直接用類型注解來標注第一個參數的類型
    print('這次輸入的是列表')

畫外：有單重派發，自然就有多重派發，Julia 語言就支持多重派發，即根據函數所有參數的類型，來決定調用哪一個同名函數。
Julia 語言根本沒有類這個定義，類型的所有方法都是通過多重派發來定義的。

其他

1. @functools.total_ordering：用於自動生成比較函數。
2. functools.cmp_to_key(func)：用於將老式的比較函數，轉換成新式的 key 函數。

四、operator

operator 模塊包含四種類型的方法：

1. operator.itemgetter

經常被用於 sorted/max/mix/itertools.groupby 等

使用方法：

# itemgetter
f = itemgetter(2)
f(r)  # return r[2]

# 還能一次獲取多個值，像 numpy 那樣索引
f2 = itemgetter(2,4,5)
f2(r)  # return (r[2], r[4], r[5])

# 或者使用 slice 切片
s = itemgetter(slice(2, None))
s[r]  # return r[2:]

# dict 索引也能用
d = itemgetter('rank', 'name')
d[r]  # return d['rank'], d['name']

用途：

# 用於指定用於比較大小的屬性
key = itemgetter(1)
sorted(iterable, key=key)  # 使用 iterable[1] 對 iterable 進行排序
max(iterable, key=key)  # 找出最大的元素，使用 iterable[1] 做比較

# 用於高級切片（比如像 numpy 那樣的，指定只獲取某幾列）
s = itemgetter(1,3,4)
matrix = [[0,1,2,3,4], [1,2,3,4,5]]
map(s, matrix)  # list 后得到 [(1, 3, 4), (2,4,5)]

2. operator.attrgetter

可用於動態獲取對象的屬性，與直接用 getattr() 不同的是，它可以嵌套訪問屬性。

# 嵌套訪問屬性
att = attrgetter("a.b.c")
att(obj)  # return obj.a.b.c

# 和 itemgetter 一樣，也可以一次獲取多個屬性
att = attrgetter("a.b.c", "x.y")
att(obj)  # return (obj.a.b.c, obj.x.y)

# 不嵌套的話，用 getattr 就行
getattr(obj, "a")  # return obj.a

這里可以回顧一下類的兩個魔法函數：

1. __getattr__: 當被訪問的屬性不存在時，這個方法會被調用，它的返回值會成為對象的該屬性。
   • 用於動態生成實例的屬性/函數
2. __getattribute__: 與 __getattr__ 唯一的差別在於，訪問對象的任何屬性，都會直接調用這個方法，不管屬性存不存在。

3. operator.methodcaller

可用於調用函數，它和 attrgetter 很像，差別在於 attrgetter 只是返回指定的屬性，而 methodcaller 會直接把指定的屬性當成函數調用，然后返回結果。

舉例

f = methodcaller('name', 'foo', bar=1)
f(b)  # returns b.name('foo', bar=1)

4. 各種操作符對應的函數

operator.add、operator.sub、operator.mul、operator.div 等等，函數式編程有時需要用到。

五、itertools

itertools 提供了許多針對可迭代對象的實用函數

方法很多，基本不可能一次全記住。還是要用到時多查吧。大致記住有提供哪些功能，需要用到時能想起可以查這個模塊就行。

1. 無限迭代器

1. count(start=0, step=1): 從 start 開始，每次迭代時，返回值都加一個 step
   • 默認返回序列為 0 1 2 3...
2. cycle(iterable): 不斷循環迭代 iterable
3. repeat(element, times=None): 默認永遠返回 element。（如果 times 不為 None，就迭代 times 后結束）

2. 排列組合迭代器

1. product(p1, p2, ..., repeat=1)：p1, p2... 的元素的笛卡爾積，相當於多層 for 循環
   • repeat 指參數重復次數，比如

>>> from itertools import product
>>> r = product([1, 2], [3, 4], [5, 6])  # 重復一次，也就是 (p1, p2, p3) 的笛卡爾積
>>> pprint(list(r))       
[(1, 3, 5),
 (1, 3, 6),
 (1, 4, 5),
 (1, 4, 6),
 (2, 3, 5),
 (2, 3, 6),
 (2, 4, 5),
 (2, 4, 6)]
>>> r2 = product([1, 2], [3, 4], [5, 6], repeat=2)  # 重復兩次，即 (p1, p2, p3, p1, p2, p3) 的笛卡爾積
>>> pprint(list(r2))
[(1, 3, 5, 1, 3, 5),
 (1, 3, 5, 1, 3, 6),
 (1, 3, 5, 1, 4, 5),
 (1, 3, 5, 1, 4, 6),
 (1, 3, 5, 2, 3, 5),
...

1. permutations(p[, r])：p 中元素，長度為 r 的所有可能的排列。相當於 product 去重后的結果。
2. combinations(p, r)：既然有排列，當然就有組合了。

3. 其他

1. zip_longest(*iterables, fillvalue=None)：和 zip 的差別在於，缺失的元素它會用 fillvalue 補全，而不是直接結束。
2. takewhile()
3. dropwhile()
4. groupby()

等等等，用得到的時候再查了。。。

六、collections

提供了一些實用的高級數據結構（容器）

1. defaultdict：這個感覺是最常用的，可以給定 key 的默認值
2. Counter：方便、快速的計數器。常用於分類統計
3. deque：一個線程安全的雙端隊列
4. OrderedDict：有時候會需要有序字典
5. namedtuple：命名元組，有時用於參數傳遞。與 tuple 的差別是它提供了關鍵字參數和通過名字訪問屬性的功能
6. ChainMap：將多個 map 連接（chain）在一起，提供一個統一的視圖。因為是視圖，所以原來的 map 不會被影響。