Python内置的容器对象有,python容器类型包括

　　Python容器使用的5个技巧和2个误区

　　Python技术文章中很少提到“容器”这个词。看到“集装箱”，大家想到的都是小蓝鲸：Docker，但本文与此无关。本文中的容器是Python中的一个抽象概念，是专门用于保存其他对象的数据类型的通用术语。

　　在Python中，有四种最常见的内置容器类型：dict、tuple、dictionary和set。通过单独或组合使用它们，许多事情可以有效地完成。

　　Python本身的内部实现细节也与这些容器类型密切相关。比如Python的类实例属性，全局变量globals()等。都是按字典类型存储的。

　　在本文中，我将从容器类型的定义开始，并尝试总结一些日常编码的最佳实践。然后，围绕每个容器类型提供的特殊功能，分享一些编程小技巧。

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

　　我之前给了“容器”一个简单的定义：容器是专门用来装其他对象的。但是这个定义太宽泛了，对我们的日常编程没有任何指导价值。要真正掌握Python中的容器，我们需要从两个层面入手：

　　:的底层实现内置容器类型使用什么数据结构？手术是如何进行的？

　　高级抽象：什么决定了一个对象是否是容器？哪些行为定义了容器？

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

　　底层看容器

　　Python是一种高级编程语言，它提供的内置容器类型是高度封装和抽象的结果。与“链表”、“红黑树”、“哈希表”等名称相比，Python内置类型的所有名称都只是描述了该类型的功能特征，其他人仅凭这些名称无法知道它们哪怕是最细微的内部细节。

　　这是Python编程语言的优势之一。与更接近计算机底层的编程语言C相比，Python重新设计并实现了对程序员更友好的内置容器类型，屏蔽了内存管理等额外工作。它为我们提供了更好的开发体验。

　　但如果这就是Python的优势，我们又何必去理解容器类型的实现细节呢？回答：关注细节可以帮助我们写出更快的代码。

　　写更快的代码

　　1. 避免频繁扩充列表/创建新列表

　　的所有内置容器类型都没有容量限制。如果你愿意，你可以把递增的数字塞进一个空列表，最终挤爆整个机器的内存。

　　在Python语言的实现细节中，链表的内存是按需分配的【注1】。当一个列表当前没有足够的内存时，它将触发内存扩展逻辑。分配内存是一项开销很大的操作。虽然在大多数情况下，对你的程序性能不会有什么严重的影响。但是当你处理的数据量特别大的时候，很容易因为内存分配而拖累整个程序的性能。

　　好在Python很早就意识到了这个问题，并且提供了官方的解决问题指南，就是“变懒”。

　　如何解释「变懒」？range()函数的演变就是一个很好的例子。

　　在Python 2中，如果调用range(100000000)，需要等待几秒钟才能得到结果，因为它需要返回一个庞大的列表，而且在内存分配和计算上花费了大量的时间。但是在Python 3中，同样的调用可以马上得到结果。因为该函数返回一个range类型的惰性对象而不是一个list，所以当你对它进行迭代或切片时，它只会返回一个实数。

　　于是，为了提高性能，内置函数范围“变懒”了。为了避免过于频繁的内存分配，我们的函数在日常编码中也需要偷懒，这包括：

　　更经常使用yield关键字返回生成器对象。

　　试图使用生成器表达式，而不是列表派生表达式。

　　表达式：(iforinrange(100))

　　列表的派生表达式：[I范围(100)]

　　试图使用模块提供的懒惰对象：

　　用re . finditer代替re.findall

　　直接使用迭代文件对象：forlineinfp，而不是forlineinfp.readlines()

　　2. 在列表头部操作多的场景使用 deque 模块

　　列表是基于数组结构(Array)实现的。当您在列表的开头插入一个新成员(list.insert(0，item))时，它后面的所有其他成员都需要移动。该运算的时间复杂度为O(n)。这导致在列表的开头插入成员比在末尾追加成员要慢得多(list.append(item)的时间复杂度是O(1))。

　　。

　　如果你的代码需要执行很多次这类操作，请考虑使用 collections.deque 类型来替代列表。因为 deque 是基于双端队列实现的，无论是在头部还是尾部追加元素，时间复杂度都是 O(1)。

　　3. 使用集合/字典来判断成员是否存在

　　当你需要判断成员是否存在于某个容器时，用集合比列表更合适。因为 itemin[...] 操作的时间复杂度是 O(n)，而 itemin{...} 的时间复杂度是 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!")

　　如果你对字典的实现细节感兴趣，也强烈建议观看 Raymond Hettinger 的演讲 Modern Dictionaries(YouTube)

　　相关推荐：《Python入门教程》

　　高层看容器

　　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(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

　　从边界提炼规律是优化这段代码的关键。如果我们将所有的这些边界放在一个有序元组中，然后配合二分查找模块 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)

　　2. 在更多地方使用动态解包

　　动态解包操作是指使用 * 或 ** 运算符将可迭代对象“解开”的行为，在 Python 2 时代，这个操作只能被用在函数参数部分，并且对出现顺序和数量都有非常严格的要求，使用场景非常单一。

def calc(a, b, multiplier=1):
　　 return (a + b) * multiplier
　　# Python2 中只支持在函数参数部分进行动态解包
　　print calc(*[1, 2], **{"multiplier": 10})
　　# OUTPUT: 30

def merge_dict(d1, d2):
　　 # 因为字典是可被修改的对象，为了避免修改原对象，此处需要复制一个 d1 的浅拷贝
　　 result = d1.copy()
　　 result.update(d2)
　　 return result
　　user = merge_dict({"name": "piglei"}, {"movies": ["Fight Club"]})

user = {**{"name": "piglei"}, **{"movies": ["Fight Club"]}}

　　Hint：推进动态解包场景扩充的两个 PEP：

　　 ·PEP 3132 -- Extended Iterable Unpacking Python.org

　　 ·PEP 448 -- Additional Unpacking Generalizations Python.org

　　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

　　不过，示例里的两段代码在现实世界中都非常少见。为什么？因为如果你想统计次数的话，直接用 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

　　字典和集合的结构特点保证了它们的成员不会重复，所以它们经常被用来去重。但是，使用它们俩去重后的结果会丢失原有列表的顺序。这是由底层数据结构“哈希表（Hash Table）”的特点决定的。

>>> l = [10, 2, 3, 21, 10, 3]
　　# 去重但是丢失了顺序
　　>>> set(l)
　　{3, 10, 2, 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)

　　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]

　　所以对于这类操作，请使用一个新的空列表保存结果，或者利用 yield 返回一个生成器。而不是修改被迭代的列表或是字典对象本身。以上就是Python容器使用的5个技巧和2个误区的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。