序言

这是 “Python 工匠”系列的第 4 篇文章

容器”这两个字很少被 Python 技术文章提起。一看到“容器”，大家想到的多是那头蓝色小鲸鱼：Docker，但这篇文章和它没有任何关系。本文里的容器，是 Python 中的一个抽象概念，是对专门用来装其余对象的数据类型的统称。

在 Python 中，有四类最常见的内建容器类型：列表（list）、元组（tuple）、字典（dict）、汇合（set）。通过独自或是组合应用它们，能够高效的实现很多事件。

Python 语言本身的外部实现细节也与这些容器类型非亲非故。比方 Python 的类实例属性、全局变量 globals() 等就都是通过字典类型来存储的。

在这篇文章里，我首先会从容器类型的定义登程，尝试总结出一些日常编码的最佳实际。之后再围绕各个容器类型提供的非凡机能，分享一些编程的小技巧。

内容目录

1) 底层看容器  - 防止频繁裁减列表/创立新列表  - 在列表头部操作多的场景应用 deque 模块  - 应用汇合/字典来判断成员是否存在  - 写更快的代码2) 高层看容器  - 面向容器接口编程  - 写扩展性更好的代码3) 罕用技巧  - 应用元组改善分支代码  - 在更多中央应用动静解包  - 最好不必“获取许可”，也无需“要求原谅”  - 应用 next() 函数  - 应用有序字典来去重4) 常见误区  - 当心那些曾经枯竭的迭代器  - 别在循环体内批改被迭代对象5) 总结6) 系列其余文章7) 注解

当咱们议论容器时，咱们在谈些什么？

我在后面给了“容器”一个简略的定义：专门用来装其余对象的就是容器。但这个定义太宽泛了，无奈对咱们的日常编程产生什么领导价值。要真正把握 Python 里的容器，须要别离从两个层面动手：

  • 底层实现：内置容器类型应用了什么数据结构？某项操作如何工作？
  • 高层形象：什么决定了某个对象是不是容器？哪些行为定义了容器？

上面，让咱们一起站在这两个不同的层面上，重新认识容器。

底层看容器

Python 是一门高级编程语言，它所提供的内置容器类型，都是通过高度封装和形象后的后果。和 “链表”、“红黑树”、“哈希表” 这些名字相比，所有 Python 内建类型的名字，都只形容了这个类型的性能特点，其他人齐全没法只通过这些名字理解它们的哪怕一丁点外部细节。

这是 Python 编程语言的劣势之一。相比 C 语言这类更靠近计算机底层的编程语言，Python 从新设计并实现了对编程者更敌对的内置容器类型，屏蔽掉了内存治理等额定工作。为咱们提供了更好的开发体验。

但如果这是 Python 语言的劣势的话，为什么咱们还要吃力去理解容器类型的实现细节呢？答案是：关注细节能够帮忙咱们编写出更快的代码。

写更快的代码

1. 防止频繁裁减列表/创立新列表

所有的内建容器类型都不限度容量。如果你违心，你能够把递增的数字一直塞进一个空列表，最终撑爆整台机器的内存。

在 Python 语言的实现细节里，列表的内存是按需分配的 注1，当某个列表以后领有的内存不够时，便会触发内存扩容逻辑。而分配内存是一项低廉的操作。尽管大部分状况下，它不会对你的程序性能产生什么重大的影响。然而当你解决的数据量特地大时，很容易因为内存调配连累整个程序的性能。

还好，Python 早就意识到了这个问题，并提供了官网的问题解决指引，那就是：“变懒”。
如何解释“变懒”？range() 函数的进化是一个十分好的例子。

在 Python 2 中，如果你调用 range(100000000)，须要期待好几秒能力拿到后果，因为它须要返回一个微小的列表，破费了十分多的工夫在内存调配与计算上。但在 Python 3 中，同样的调用马上就能拿到后果。因为函数返回的不再是列表，而是一个类型为 range 的懈怠对象，只有在你迭代它、或是对它进行切片时，它才会返回真正的数字给你。

所以说，为了进步性能，内建函数 range “变懒”了。 而为了防止过于频繁的内存调配，在日常编码中，咱们的函数同样也须要变懒，这包含：

  • 更多的应用 yield 关键字，返回生成器对象

  • 尽量应用生成器表达式代替列表推导表达式

    • 生成器表达式：(i for i in range(100))
    • 列表推导表达式：[i for i 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:        # 此处应用了 Python 3.6 增加的 f-strings 个性        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]](https://github.com/piglei/one...)定义。让咱们别离看看那些内建容器类型都满足了什么接口：

  • 列表（list）：满足 Iterable、Sequence、MutableSequence 等接口
  • 元组（tuple）：满足 Iterable、Sequence
  • 字典（dict）：满足 Iterable、Mapping、MutableMapping [[注3]](https://github.com/piglei/one...)
  • 汇合（set）：满足 Iterable、Set、MutableSet [[注4]](https://github.com/piglei/one...)

每个内置容器类型，其实就是满足了多个接口定义的组合实体。比方所有的容器类型都满足 “可被迭代的”（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 commentscomments = [    "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 commentprint("\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 内置模块里能够找到更多对于解决可迭代对象的宝藏。

罕用技巧

应用元组改善分支代码

有时，咱们的代码里会呈现超过三个分支的 if/else 。就像上面这样：

import timedef 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 分支外，有些状况下字典也能被用来做同样的事件。关键在于从现有代码找到反复的逻辑与法则，并多多尝试。

在更多中央应用动静解包

动静解包操作是指应用 * 或 ** 运算符将可迭代对象“解开”的行为，在 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：

  • PEP 3132 -- Extended Iterable Unpacking | Python.org
  • PEP 448 -- Additional Unpacking Generalizations | Python.org

最好不必“获取许可”，也无需“要求原谅”

这个小标题可能会略微让人有点懵，让我来简短的解释一下：“获取许可”与“要求原谅”是两种不同的编程格调。如果用一个经典的需要：“计算列表内各个元素呈现的次数” 来作为例子，两种不同格调的代码会是这样：

# 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 defaultdictdef 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]

应用 next() 函数

next() 是一个十分实用的内建函数，它接管一个迭代器作为参数，而后返回该迭代器的下一个元素。应用它配合生成器表达式，能够高效的实现 “从列表中查找第一个满足条件的成员” 之类的需要。

numbers = [3, 7, 8, 2, 21]# 获取并 **立刻返回** 列表里的第一个偶数print(next(i for i in numbers if i % 2 == 0))# OUTPUT: 8

应用有序字典来去重

字典和汇合的构造特点保障了它们的成员不会反复，所以它们常常被用来去重。然而，应用它们俩去重后的后果会失落原有列表的程序。这是由底层数据结构“哈希表（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。

常见误区

当心那些曾经枯竭的迭代器

在文章后面，咱们提到了应用“懈怠”生成器的种种益处。然而，所有事物都有它的两面性。生成器的最大的毛病之一就是：它会枯竭。当你残缺遍历过它们后，之后的反复遍历就不能拿到任何新内容了

numbers = [1, 2, 3]numbers = (i * 2 for i in numbers)# 第一次循环会输入 2, 4, 6for 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 的演讲摘要，搜寻“迭代器”能够查看具体内容。

别在循环体内批改被迭代对象

这是一个很多 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()

系列其余文章

Python 工匠：善用变量来改善代码品质
Python 工匠：编写条件分支代码的技巧
Python 工匠：应用数字与字符串的技巧

蓝鲸智云

本文由腾讯蓝鲸智云编辑公布，腾讯蓝鲸智云（简称蓝鲸）软件体系是一套基于PaaS的技术解决方案，致力于打造行业当先的一站式自动化运维平台。目前曾经推出社区版、企业版，欢送体验。

  • 官网：https://bk.tencent.com/
  • 下载链接：https://bk.tencent.com/download/
  • 社区：https://bk.tencent.com/s-mart/community/question