Python 工匠：容器的門道

時間  2019-11-08
標籤 python 工匠 容器 門道 欄目 Python 简体版
原文   原文鏈接

序言

這是 「Python 工匠」系列的第四篇文章。[查看系列全部文章]html

圖片來源: "The Humble Mason Jar" by Chiot's Run - 非商業性使用 2.0 通用

容器」這兩個字不多被 Python 技術文章提起。一看到「容器」，你們想到的可能是那頭藍色小鯨魚：Docker，但這篇文章和它沒有任何關係。本文裏的容器，是 Python 中的一個抽象概念，是對專門用來裝其餘對象的數據類型的統稱。python

在 Python 中，有四類最多見的內建容器類型：列表（list）、元組（tuple）、字典（dict）、集合（set）。經過單獨或是組合使用它們，能夠高效的完成不少事情。git

Python 語言自身的內部實現細節也與這些容器類型息息相關。好比 Python 的類實例屬性、全局變量 globals() 等就都是經過字典類型來存儲的。github

在這篇文章裏，我首先會從容器類型的定義出發，嘗試總結出一些平常編碼的最佳實踐。以後再圍繞各個容器類型提供的特殊機能，分享一些編程的小技巧。編程

內容目錄

  • 底層看容器
    • 寫更快的代碼
        1. 避免頻繁擴充列表/建立新列表
        1. 在列表頭部操做多的場景使用 deque 模塊
        1. 使用集合/字典來判斷成員是否存在
  • 高層看容器
    • 寫擴展性更好的代碼
      • 面向容器接口編程
  • 經常使用技巧
      1. 使用元組改善分支代碼
      1. 在更多地方使用動態解包
      1. 最好不用「獲取許可」，也無需「要求原諒」
      1. 使用 next() 函數
      1. 使用有序字典來去重
  • 常見誤區
      1. 小心那些已經枯竭的迭代器
      1. 別在循環體內修改被迭代對象
  • 總結
  • 系列其餘文章
  • 註解

當咱們談論容器時，咱們在談些什麼？

我在前面給了「容器」一個簡單的定義：專門用來裝其餘對象的就是容器。但這個定義太寬泛了，沒法對咱們的平常編程產生什麼指導價值。要真正掌握 Python 裏的容器，須要分別從兩個層面入手：數組

  • **底層實現：**內置容器類型使用了什麼數據結構？某項操做如何工做？
  • **高層抽象：**什麼決定了某個對象是否是容器？哪些行爲定義了容器？

下面，讓咱們一塊兒站在這兩個不一樣的層面上，從新認識容器。bash

底層看容器

Python 是一門高級編程語言，**它所提供的內置容器類型，都是通過高度封裝和抽象後的結果。**和「鏈表」、「紅黑樹」、「哈希表」這些名字相比，全部 Python 內建類型的名字，都只描述了這個類型的功能特色，其餘人徹底無法只經過這些名字瞭解它們的哪怕一丁點內部細節。數據結構

這是 Python 編程語言的優點之一。相比 C 語言這類更接近計算機底層的編程語言，Python 從新設計並實現了對編程者更友好的內置容器類型，屏蔽掉了內存管理等額外工做。爲咱們提供了更好的開發體驗。app

但若是這是 Python 語言的優點的話，爲何咱們還要費勁去了解容器類型的實現細節呢？答案是：關注細節能夠幫助咱們編寫出更快的代碼。less

寫更快的代碼

1. 避免頻繁擴充列表/建立新列表

全部的內建容器類型都不限制容量。若是你願意，你能夠把遞增的數字不斷塞進一個空列表，最終撐爆整臺機器的內存。

在 Python 語言的實現細節裏，列表的內存是按需分配的[注1]，當某個列表當前擁有的內存不夠時，便會觸發內存擴容邏輯。而分配內存是一項昂貴的操做。雖然大部分狀況下，它不會對你的程序性能產生什麼嚴重的影響。可是當你處理的數據量特別大時，很容易由於內存分配拖累整個程序的性能。

還好，Python 早就意識到了這個問題，並提供了官方的問題解決指引，那就是：「變懶」。

如何解釋「變懶」？range() 函數的進化是一個很是好的例子。

在 Python 2 中，若是你調用 range(100000000)，須要等待好幾秒才能拿到結果，由於它須要返回一個巨大的列表，花費了很是多的時間在內存分配與計算上。但在 Python 3 中，一樣的調用立刻就能拿到結果。由於函數返回的再也不是列表，而是一個類型爲 range 的懶惰對象，只有在你迭代它、或是對它進行切片時，它纔會返回真正的數字給你。

**因此說，爲了提升性能，內建函數 range 「變懶」了。**而爲了不過於頻繁的內存分配，在平常編碼中，咱們的函數一樣也須要變懶，這包括：

  • 更多的使用 yield 關鍵字，返回生成器對象
  • 儘可能使用生成器表達式替代列表推導表達式
    • 生成器表達式：(i for in range(100)) 👍
    • 列表推導表達式：[i for in range(100)]
  • 儘可能使用模塊提供的懶惰對象：
    • 使用 re.finditer 替代 re.findall
    • 直接使用可迭代的文件對象： for line in fp，而不是 for line in fp.readlines()

2. 在列表頭部操做多的場景使用 deque 模塊

列表是基於數組結構（Array）實現的，當你在列表的頭部插入新成員（list.insert(0, item)）時，它後面的全部其餘成員都須要被移動，操做的時間複雜度是 O(n)。這致使在列表的頭部插入成員遠比在尾部追加（list.append(item) 時間複雜度爲 O(1)）要慢。

若是你的代碼須要執行不少次這類操做，請考慮使用 collections.deque 類型來替代列表。由於 deque 是基於雙端隊列實現的，不管是在頭部仍是尾部追加元素，時間複雜度都是 O(1)。

3. 使用集合/字典來判斷成員是否存在

當你須要判斷成員是否存在於某個容器時，用集合比列表更合適。由於 item in [...] 操做的時間複雜度是 O(n)，而 item in {...} 的時間複雜度是 O(1)。這是由於字典與集合都是基於哈希表（Hash Table）數據結構實現的。

# 這個例子不是特別恰當，由於當目標集合特別小時，使用集合仍是列表對效率的影響微乎其微
# 但這不是重點 :)
VALID_NAMES = ["piglei", "raymond", "bojack", "caroline"]

# 轉換爲集合類型專門用於成員判斷
VALID_NAMES_SET = set(VALID_NAMES)


def validate_name(name):
    if name not in VALID_NAMES_SET:
        raise ValueError(f"{name} is not a valid name!")
複製代碼

Hint: 強烈建議閱讀 TimeComplexity - Python Wiki，瞭解更多關於常見容器類型的時間複雜度相關內容。

若是你對字典的實現細節感興趣，也強烈建議觀看 Raymond Hettinger 的演講 Modern Dictionaries(YouTube)

高層看容器

Python 是一門「鴨子類型」語言：*「當看到一隻鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那麼這隻鳥就能夠被稱爲鴨子。」*因此，當咱們說某個對象是什麼類型時，在根本上其實指的是：**這個對象知足了該類型的特定接口規範，能夠被當成這個類型來使用。**而對於全部內置容器類型來講，一樣如此。

打開位於 collections 模塊下的 abc*（「抽象類 Abstract Base Classes」的首字母縮寫）*子模塊，能夠找到全部與容器相關的接口（抽象類）[注2]定義。讓咱們分別看看那些內建容器類型都知足了什麼接口：

  • 列表（list）：知足 Iterable、Sequence、MutableSequence 等接口
  • 元組（tuple）：知足 Iterable、Sequence
  • 字典（dict）：知足 Iterable、Mapping、MutableMapping [注3]
  • 集合（set）：知足 Iterable、Set、MutableSet [注4]

每一個內置容器類型，其實就是知足了多個接口定義的組合實體。好比全部的容器類型都知足 「可被迭代的」（Iterable） 這個接口，這意味着它們都是「可被迭代」的。可是反過來，不是全部「可被迭代」的對象都是容器。就像字符串雖然能夠被迭代，但咱們一般不會把它當作「容器」來看待。

瞭解這個事實後，咱們將在 Python 裏從新認識面向對象編程中最重要的原則之一：面向接口而非具體實現來編程。

讓咱們經過一個例子，看看如何理解 Python 裏的「面向接口編程」。

寫擴展性更好的代碼

某日，咱們接到一個需求：有一個列表，裏面裝着不少用戶評論，爲了在頁面正常展現，須要將全部超過必定長度的評論用省略號替代。

這個需求很好作，很快咱們就寫出了第一個版本的代碼：

# 注：爲了增強示例代碼的說明性，本文中的部分代碼片斷使用了Python 3.5
# 版本添加的 Type Hinting 特性

def add_ellipsis(comments: typing.List[str], max_length: int = 12):
    """若是評論列表裏的內容超過 max_length，剩下的字符用省略號代替 """
    index = 0
    for comment in comments:
        comment = comment.strip()
        if len(comment) > max_length:
            comments[index] = comment[:max_length] + '...'
        index += 1
    return comments


comments = [
    "Implementation note",
    "Changed",
    "ABC for generator",
]
print("\n".join(add_ellipsis(comments)))
# OUTPUT:
# Implementati...
# Changed
# ABC for gene...
複製代碼

上面的代碼裏，add_ellipsis 函數接收一個列表做爲參數，而後遍歷它，替換掉須要修改的成員。這一切看上去很合理，由於咱們接到的最原始需求就是：「有一個 列表，裏面...」。但若是有一天，咱們拿到的評論再也不是被繼續裝在列表裏，而是在不可變的元組裏呢？

那樣的話，現有的函數設計就會逼迫咱們寫出 add_ellipsis(list(comments)) 這種即慢又難看的代碼了。😨

面向容器接口編程

咱們須要改進函數來避免這個問題。由於 add_ellipsis 函數強依賴了列表類型，因此當參數類型變爲元組時，如今的函數就再也不適用了*（緣由：給 comments[index] 賦值的地方會拋出 TypeError 異常）*。如何改善這部分的設計？祕訣就是：讓函數依賴「可迭代對象」這個抽象概念，而非實體列表類型。

使用生成器特性，函數能夠被改爲這樣：

def add_ellipsis_gen(comments: typing.Iterable[str], max_length: int = 12):
    """若是可迭代評論裏的內容超過 max_length，剩下的字符用省略號代替 """
    for comment in comments:
        comment = comment.strip()
        if len(comment) > max_length:
            yield comment[:max_length] + '...'
        else:
            yield comment


print("\n".join(add_ellipsis_gen(comments)))
複製代碼

在新函數裏，咱們將依賴的參數類型從列表改爲了可迭代的抽象類。這樣作有不少好處，一個最明顯的就是：不管評論是來自列表、元組或是某個文件，新函數均可以輕鬆知足：

# 處理放在元組裏的評論
comments = ("Implementation note", "Changed", "ABC for generator")
print("\n".join(add_ellipsis_gen(comments)))

# 處理放在文件裏的評論
with open("comments") as fp:
    for comment in add_ellipsis_gen(fp):
        print(comment)
複製代碼

將依賴由某個具體的容器類型改成抽象接口後，函數的適用面變得更廣了。除此以外，新函數在執行效率等方面也都更有優點。如今讓咱們再回到以前的問題。從高層來看，什麼定義了容器？

答案是：**各個容器類型實現的接口協議定義了容器。**不一樣的容器類型在咱們的眼裏，應該是 是否能夠迭代、是否能夠修改、有沒有長度 等各類特性的組合。咱們須要在編寫相關代碼時，更多的關注容器的抽象屬性，而非容器類型自己，這樣能夠幫助咱們寫出更優雅、擴展性更好的代碼。

Hint：在 itertools 內置模塊裏能夠找到更多關於處理可迭代對象的寶藏。

經常使用技巧

1. 使用元組改善分支代碼

有時，咱們的代碼裏會出現超過三個分支的 if/else 。就像下面這樣：

import time


def from_now(ts):
    """接收一個過去的時間戳，返回距離當前時間的相對時間文字描述 """
    now = time.time()
    seconds_delta = int(now - ts)
    if seconds_delta < 1:
        return "less than 1 second ago"
    elif seconds_delta < 60:
        return "{} seconds ago".format(seconds_delta)
    elif seconds_delta < 3600:
        return "{} minutes ago".format(seconds_delta // 60)
    elif seconds_delta < 3600 * 24:
        return "{} hours ago".format(seconds_delta // 3600)
    else:
        return "{} days ago".format(seconds_delta // (3600 * 24))


now = time.time()
print(from_now(now))
print(from_now(now - 24))
print(from_now(now - 600))
print(from_now(now - 7500))
print(from_now(now - 87500))
# OUTPUT:
# less than 1 second ago
# 24 seconds ago
# 10 minutes ago
# 2 hours ago
# 1 days ago
複製代碼

上面這個函數挑不出太多毛病，不少不少人都會寫出相似的代碼。可是，若是你仔細觀察它，能夠在分支代碼部分找到一些明顯的**「邊界」**。好比，當函數判斷某個時間是否應該用「秒數」展現時，用到了 60。而判斷是否應該用分鐘時，用到了 3600。

**從邊界提煉規律是優化這段代碼的關鍵。**若是咱們將全部的這些邊界放在一個有序元組中，而後配合二分查找模塊 bisect。整個函數的控制流就能被大大簡化：

import bisect


# BREAKPOINTS 必須是已經排好序的，否則沒法進行二分查找
BREAKPOINTS = (1, 60, 3600, 3600 * 24)
TMPLS = (
    # unit, template
    (1, "less than 1 second ago"),
    (1, "{units} seconds ago"),
    (60, "{units} minutes ago"),
    (3600, "{units} hours ago"),
    (3600 * 24, "{units} days ago"),
)


def from_now(ts):
    """接收一個過去的時間戳，返回距離當前時間的相對時間文字描述 """
    seconds_delta = int(time.time() - ts)
    unit, tmpl = TMPLS[bisect.bisect(BREAKPOINTS, seconds_delta)]
    return tmpl.format(units=seconds_delta // unit)
複製代碼

除了用元組能夠優化過多的 if/else 分支外，有些狀況下字典也能被用來作一樣的事情。關鍵在於從現有代碼找到重複的邏輯與規律，並多多嘗試。

2. 在更多地方使用動態解包

動態解包操做是指使用 * 或 ** 運算符將可迭代對象「解開」的行爲，在 Python 2 時代，這個操做只能被用在函數參數部分，而且對出現順序和數量都有很是嚴格的要求，使用場景很是單一。

def calc(a, b, multiplier=1):
    return (a + b) * multiplier


# Python2 中只支持在函數參數部分進行動態解包
print calc(*[1, 2], **{"multiplier": 10})
# OUTPUT: 30
複製代碼

不過，Python 3 尤爲是 3.5 版本後，* 和 ** 的使用場景被大大擴充了。舉個例子，在 Python 2 中，若是咱們須要合併兩個字典，須要這麼作：

def merge_dict(d1, d2):
    # 由於字典是可被修改的對象，爲了不修改原對象，此處須要複製一個 d1 的淺拷貝
    result = d1.copy()
    result.update(d2)
    return result
    
user = merge_dict({"name": "piglei"}, {"movies": ["Fight Club"]})
複製代碼

可是在 Python 3.5 之後的版本，你能夠直接用 ** 運算符來快速完成字典的合併操做：

user = {**{"name": "piglei"}, **{"movies": ["Fight Club"]}}
複製代碼

除此以外，你還能夠在普通賦值語句中使用 * 運算符來動態的解包可迭代對象。若是你想詳細瞭解相關內容，能夠閱讀下面推薦的 PEP。

Hint：推動動態解包場景擴充的兩個 PEP：

3. 最好不用「獲取許可」，也無需「要求原諒」

這個小標題可能會稍微讓人有點懵，讓我來簡短的解釋一下：「獲取許可」與「要求原諒」是兩種不一樣的編程風格。若是用一個經典的需求：「計算列表內各個元素出現的次數」 來做爲例子，兩種不一樣風格的代碼會是這樣：

# AF: Ask for Forgiveness
# 要作就作，若是拋出異常了，再處理異常
def counter_af(l):
    result = {}
    for key in l:
        try:
            result[key] += 1
        except KeyError:
            result[key] = 1
    return result


# AP: Ask for Permission
# 作以前，先問問能不能作，能夠作再作
def counter_ap(l):
    result = {}
    for key in l:
        if key in result:
            result[key] += 1
        else:
            result[key] = 1
    return result
複製代碼

整個 Python 社區對第一種 Ask for Forgiveness 的異常捕獲式編程風格有着明顯的偏心。這其中有不少緣由，首先，在 Python 中拋出異常是一個很輕量的操做。其次，第一種作法在性能上也要優於第二種，由於它不用在每次循環的時候都作一次額外的成員檢查。

不過，示例裏的兩段代碼在現實世界中都很是少見。爲何？由於若是你想統計次數的話，直接用 collections.defaultdict 就能夠了：

from collections import defaultdict


def counter_by_collections(l):
    result = defaultdict(int)
    for key in l:
        result[key] += 1
    return result
複製代碼

這樣的代碼既不用「獲取許可」，也無需「請求原諒」。整個代碼的控制流變得更清晰天然了。因此，若是可能的話，請儘可能想辦法省略掉那些非核心的異常捕獲邏輯。一些小提示：

  • 操做字典成員時：使用 collections.defaultdict 類型
    • 或者使用 dict[key] = dict.setdefault(key, 0) + 1 內建函數
  • 若是移除字典成員，不關心是否存在：
    • 調用 pop 函數時設置默認值，好比 dict.pop(key, None)
  • 在字典獲取成員時指定默認值：dict.get(key, default_value)
  • 對列表進行不存在的切片訪問不會拋出 IndexError 異常：["foo"][100:200]

4. 使用 next() 函數

next() 是一個很是實用的內建函數，它接收一個迭代器做爲參數，而後返回該迭代器的下一個元素。使用它配合生成器表達式，能夠高效的實現「*從列表中查找第一個知足條件的成員」*之類的需求。

numbers = [3, 7, 8, 2, 21]
# 獲取並 **當即返回** 列表裏的第一個偶數
print(next(i for i in numbers if i % 2 == 0))
# OUTPUT: 8
複製代碼

5. 使用有序字典來去重

字典和集合的結構特色保證了它們的成員不會重複，因此它們常常被用來去重。可是，使用它們倆去重後的結果會丟失原有列表的順序。這是由底層數據結構「哈希表（Hash Table）」的特色決定的。

>>> l = [10, 2, 3, 21, 10, 3]
# 去重可是丟失了順序
>>> set(l)
{3, 10, 2, 21}
複製代碼

若是既須要去重又必須保留順序怎麼辦？咱們可使用 collections.OrderedDict 模塊:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(l).keys())
[10, 2, 3, 21]
複製代碼

Hint: 在 Python 3.6 中，默認的字典類型修改了實現方式，已經變成有序的了。而且在 Python 3.7 中，該功能已經從 語言的實現細節 變成了爲 可依賴的正式語言特性。

可是我以爲讓整個 Python 社區習慣這一點還須要一些時間，畢竟目前「字典是無序的」仍是被印在無數本 Python 書上。因此，我仍然建議在一切須要有序字典的地方使用 OrderedDict。

常見誤區

1. 小心那些已經枯竭的迭代器

在文章前面，咱們提到了使用「懶惰」生成器的種種好處。可是，全部事物都有它的兩面性。生成器的最大的缺點之一就是：它會枯竭。當你完整遍歷過它們後，以後的重複遍歷就不能拿到任何新內容了。

numbers = [1, 2, 3]
numbers = (i * 2 for i in numbers)

# 第一次循環會輸出 2, 4, 6
for number in numbers:
    print(number)

# 此次循環什麼都不會輸出，由於迭代器已經枯竭了
for number in numbers:
    print(number)
複製代碼

並且不光是生成器表達式，Python 3 裏的 map、filter 內建函數也都有同樣的特色。忽視這個特色很容易致使代碼中出現一些難以察覺的 Bug。

Instagram 就在項目從 Python 2 到 Python 3 的遷移過程當中碰到了這個問題。它們在 PyCon 2017 上分享了對付這個問題的故事。訪問文章 Instagram 在 PyCon 2017 的演講摘要，搜索「迭代器」能夠查看詳細內容。

2. 別在循環體內修改被迭代對象

這是一個不少 Python 初學者會犯的錯誤。好比，咱們須要一個函數來刪掉列表裏的全部偶數：

def remove_even(numbers):
    """去掉列表裏全部的偶數 """
    for i, number in enumerate(numbers):
        if number % 2 == 0:
            # 有問題的代碼
            del numbers[i]


numbers = [1, 2, 7, 4, 8, 11]
remove_even(numbers)
print(numbers)
# OUTPUT: [1, 7, 8, 11]
複製代碼

注意到結果裏那個多出來的 「8」 了嗎？當你在遍歷一個列表的同時修改它，就會出現這樣的事情。由於被迭代的對象 numbers 在循環過程當中被修改了。遍歷的下標在不斷增加，而列表自己的長度同時又在不斷縮減。這樣就會致使列表裏的一些成員其實根本就沒有被遍歷到。

因此對於這類操做，請使用一個新的空列表保存結果，或者利用 yield 返回一個生成器。而不是修改被迭代的列表或是字典對象自己。

總結

在這篇文章中，咱們首先從「容器類型」的定義出發，在底層和高層兩個層面探討了容器類型。以後遵循系列文章傳統，提供了一些編寫容器相關代碼時的技巧。

讓咱們最後再總結一下要點：

  • 瞭解容器類型的底層實現，能夠幫助你寫出性能更好的代碼
  • 提煉需求裏的抽象概念，面向接口而非實現編程
  • 多使用「懶惰」的對象，少生成「迫切」的列表
  • 使用元組和字典能夠簡化分支代碼結構
  • 使用 next() 函數配合迭代器能夠高效完成不少事情，可是也須要注意「枯竭」問題
  • collections、itertools 模塊裏有很是多有用的工具，快去看看吧！

看完文章的你，有沒有什麼想吐槽的？請留言或者在 項目 Github Issues 告訴我吧。

系列其餘文章

註解

  1. Python 這門語言除了 CPython 外，還有許許多多的其餘版本實現。如無特別說明，本文以及 「Python 工匠」 系列裏出現的全部 Python 都特指 Python 的 C 語言實現 CPython
  2. Python 裏沒有相似其餘編程語言裏的「Interface 接口」類型，只有相似的「抽象類」概念。爲了表達方便，後面的內容均統一使用「接口」來替代「抽象類」。
  3. 有沒有隻實現了 Mapping 但又不是 MutableMapping 的類型？試試 MappingProxyType({})
  4. 有沒有隻實現了 Set 但又不是 MutableSet 的類型？試試 frozenset()
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程