类别:Python / 日期:2019-12-02 / 浏览:101 / 评论:0

Python容器运用的5个技能和2个误区

“容器”这两个字很少被 Python 技术文章提起。一看到“容器”,人人想到的多是那头蓝色小鲸鱼:Docker,但这篇文章和它没有任何关系。本文里的容器,是 Python 中的一个笼统概念,是对特地用来装其他对象的数据范例的统称。

在 Python 中,有四类最罕见的内建容器范例: 列表(list)、 元组(tuple)、 字典(dict)、 鸠合(set)。经由历程零丁或是组合运用它们,能够高效的完成许多事变。

Python 言语自身的内部完成细节也与这些容器范例息息相干。比方 Python 的类实例属性、全局变量 globals() 等就都是经由历程字典范例来存储的。

在这篇文章里,我起首会从容器范例的定义动身,尝试总结出一些一样平常编码的最好实践。今后再缭绕各个容器范例供应的迥殊机能,分享一些编程的小技能。

当我们议论容器时,我们在谈些什么?

我在前面给了“容器”一个简朴的定义:特地用来装其他对象的就是容器。但这个定义太广泛了,没法对我们的一样平常编程发生什么指点代价。要真正掌握 Python 里的容器,须要离别从两个层面入手:

·底层完成:内置容器范例运用了什么数据构造?某项操纵怎样事情?

·高层笼统:什么决议了某个对象是不是是容器?哪些行动定义了容器?

下面,让我们一同站在这两个差别的层面上,从新认识容器。

底层看容器

Python 是一门高等编程言语,它所供应的内置容器范例,都是经由高度封装和笼统后的效果。和“链表”、“红黑树”、“哈希表”这些名字比拟,统统 Python 内建范例的名字,都只形貌了这个范例的功用特征,其他人完全没法只经由历程这些名字相识它们的哪怕一丁点内部细节。

这是 Python 编程言语的上风之一。比拟 C 言语这类更靠近盘算机底层的编程言语,Python 从新设想并完成了对编程者更友爱的内置容器范例,屏障掉了内存治理等分外事情。为我们供应了更好的开辟体验。

但假如这是 Python 言语的上风的话,为何我们还要费力去相识容器范例的完成细节呢?答案是:关注细节能够协助我们编写出更快的代码。

写更快的代码

1. 防止频仍扩大列表/建立新列表

统统的内建容器范例都不限定容量。假如你情愿,你能够把递增的数字不停塞进一个空列表,终究撑爆整台机械的内存。

在 Python 言语的完成细节里,列表的内存是按需分派的[注1],当某个列表当前具有的内存不够时,便会触发内存扩容逻辑。而分派内存是一项高贵的操纵。虽然大部份情况下,它不会对你的递次机能发生什么严峻的影响。然则当你处置惩罚的数据量迥殊大时,很轻易由于内存分派拖累全部递次的机能。

还好,Python 早就认识到了这个题目,并供应了官方的题目解决指引,那就是:“变懒”。

怎样诠释“变懒”? range() 函数的进化是一个非常好的例子。

在 Python 2 中,假如你挪用 range(100000000),须要守候好几秒才拿到效果,由于它须要返回一个庞大的列表,花费了非常多的时刻在内存分派与盘算上。但在 Python 3 中,一样的挪用立时就可以拿到效果。由于函数返回的不再是列表,而是一个范例为 range 的懒散对象,只要在你迭代它、或是对它举行切片时,它才会返回真正的数字给你。

所以说,为了进步机能,内建函数 range “变懒”了。而为了防止过于频仍的内存分派,在一样平常编码中,我们的函数一样也须要变懒,这包含:

·更多的运用 yield 症结字,返回生成器对象

·只管运用生成器表达式替换列表推导表达式

·生成器表达式: (iforinrange(100))

·列表推导表达式: [iforinrange(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!")

Hint: 强烈发起浏览 TimeComplexity - Python Wiki,相识更多关于罕见容器范例的时刻复杂度相干内容。

假如你对字典的完成细节感兴趣,也强烈发起寓目 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 函数吸收一个列表作为参数,然后遍历它,替换掉须要修正的成员。这统统看上去很合理,由于我们接到的最原始需求就是:“有一个 列表,内里...”。但假如有一天,我们拿到的批评不再是被继承装在列内外,而是在不可变的元组里呢?

那样的话,现有的函数设想就会强迫我们写出 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:

·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

全部 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 模块:

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 返回一个生成器。而不是修正被迭代的列表或是字典对象自身。

以上就是Python容器运用的5个技能和2个误区的细致内容,更多请关注ki4网别的相干文章!

打赏

感谢您的赞助~

打开支付宝扫一扫,即可进行扫码打赏哦~

版权声明 : 本文未使用任何知识共享协议授权,您可以任何形式自由转载或使用。

 可能感兴趣的文章

评论区

发表评论 / 取消回复

必填

选填

选填

◎欢迎讨论,请在这里发表您的看法及观点。