通过学习这些技巧，让你的Python代码更加简洁和高效

前言

今天看到一些关于容器的使用技巧，这里分享给大家，一起提高python编程能力

列表性能陷阱

陷阱一

列表中插入数据，我们通常使用append()方法在尾部追加，也可以使用insert()在任意位置插入。但是当数据量比较大时，有些操作会变的很慢。我们测验一下

python 复制代码

def list_append():
    """不断往尾部追加"""
    l = []
    for i in range(5000):
        l.append(i)


def list_insert():
    """不断往头部插入"""
    l = []
    for i in range(5000):
        l.insert(0, i)

使用timeit模块进行测试，

python 复制代码

import timeit

append_spent = timeit.timeit(list_append, number=1000)
print("list_append:", append_spent) # list_append: 0.30923892399999997

insert_spent = timeit.timeit(list_insert, number=1000)
print("list_insert", insert_spent) # list_insert 5.752398332

通过结果，可以看到，list_append和list_insert两个函数都是构建长度为5000的列表，list_insert比list_append耗时多达18倍。这是因为，列表的底层是数组，在数组中间插入成员时，这个成员之后的成员都需要移动位置，这个操作的平均时间复杂度是O(n)，而在尾部插入，这个操作的平均时间复杂度是O(1)。

那如何解决该性能问题呢？

我们可以使用collections.deque来代替列表，像这样

python 复制代码

from collections import deque


def deque_append():
    """不断往尾部追加"""
    l = deque()
    for i in range(5000):
        l.append(i)


def deque_insert():
    """不断往头部插入"""
    l = deque()
    for i in range(5000):
        l.insert(0, i)

我们使用deque实现了同样的逻辑，我们再来测试一下

python 复制代码

import timeit


append_spent = timeit.timeit(deque_append, number=1000)
print("deque_append:", append_spent) # deque_append: 0.300922523

insert_spent = timeit.timeit(deque_insert, number=1000)
print("deque_insert", insert_spent) # deque_insert 0.47996506299999997

通过结果可以看到，使用deque，不论从尾部还是从头部追加成员都非常快。

陷阱二

判断成员是否在列表中存在，像这样

scss 复制代码

nums = list(range(1000000))
def is_True():
    return 1000000 in nums

我们还是使用timeit来测试一下

ini 复制代码

import timeit


spent = timeit.timeit(is_True, number=1000)
print("is_True:", spent) # is_True: 10.706976014

可以看到耗时很长，这是因为，判断某个成员是否存在，只能从前往后遍历所有成员，这个操作的平均时间复杂度是O(n)。

那该如何解决该性能问题吗？

可以考虑将列表转换成集合类型，像这样

scss 复制代码

nums = list(range(1000000))
nums_set = set(nums)
def is_True():
    return 1000000 in nums_set

我们再测试一下，

ini 复制代码

import timeit


spent = timeit.timeit(is_True, number=1000)
print("is_True:", spent) # is_True: 0.00022141500000000258

可以看到速度很快，这是因为，在集合底层使用了哈希表数据结构，判断某个成员是否存在，只需算出该成员的哈希值，然后去哈希表对应位置检查obj是否存在就可以了，这个操作的平均时间复杂度是O(1)

快速合并字典

提到合并字典，我们想到最简单的方法，就是使用update方法

ini 复制代码

d1 = {"name": "honey"}
d2 = {"age": 18}
d1.update(d2)
print(d1) # {'name': 'honey', 'age': 18}

这有一个缺陷，修改了字典d1原始内容。那该如何解决呢？我们可以使用动态解包表达式

go 复制代码

d1 = {"name": "honey"}
d2 = {"age": 18}

print({**d1, **d2}) # {'name': 'honey', 'age': 18}
print(d1) # {'name': 'honey'}

解包过程会进行浅拷贝操作

通过有序字典去重

给定一个列表，我们去重，会想到使用集合

bash 复制代码

nums = [10, 2, 3, 3, 51, 5, 10, 7, 8, 5]
print(set(nums)) # {2, 3, 5, 7, 8, 10, 51}

很容易就去重了，但是如果我们要求，去重并且要保留成员原有的顺序呢？此时我们可以使用有序字典来实现

less 复制代码

from collections import OrderedDict

nums = [10, 2, 3, 3, 51, 5, 10, 7, 8, 5]
print(list(OrderedDict.fromkeys(nums).keys())) # [10, 2, 3, 51, 5, 7, 8]

OrderedDict可以保证键是有序的且不会重复

最后

这些技巧还是很实用的，看似是技巧，实则需要了解容器的底层，才能理解使用这些技巧。