在字典列表中搜索键值

Question

我有一个列表l，其中包含多个字典l = [ d1, d2, ...., d100]，其中每个字典都用键'id'、'address'、'price' 定义。 现在，我想从列表l 中取出所有字典d，其中键'price' 的值等于50。有比使用for 循环更快的方法吗？此处理已封装在其他 for 循环函数中，因此如果可能，我宁愿不要有两个 for 循环。 该函数的骨架现在看起来如下：

for ... (external for loop):
    results = []
    for d in l:
        if d['price'] == 50:
           results.append(d)

Answer 1

除非你知道列表的结构（例如按价格排序，或者只有三个项目可以有这样的价格），否则我们不能使算法比O( n)（线性时间）。所以我们必须以某种方式循环。

列表理解

我们可以使用列表推导，例如：

[d for d in l if d.get('price') == 50]

（这也会过滤掉没有价格属性的字典）。

熊猫

我们也可以使用熊猫。 Pandas 是一个高效的数据帧库，在数据巨大的情况下，它往往优于 Python 循环。在这种情况下，我们可以在 datframe 中加载字典，对其执行过滤，然后检索字典列表。请注意，这些将是不同的字典（即包含相同数据的其他对象）。所以数据被“复制”了。

import pandas as pd
df = pd.DataFrame(l)
result = list(df[df.price == 50].T.to_dict().values())

所以在这里我们使用df.price == 50 进行过滤。请注意，在窗帘后面有一些循环来进行过滤。

这也是一种更声明性的方法：代码解释了更多什么它在做什么，而不是如何。 pandas 的过滤方式不是你的问题，语法相当优雅地表明你正在过滤数据。

Answer 2

您可以使用list comprehension：

results = [d for d in l if d['price'] == 50]

这在算法上与您的循环没有什么不同（它还必须迭代整个列表），但理解在 C 中进行了优化，因此速度更快。另一种选择是使 results 成为惰性迭代器：

# generator expression
results = (d for d in l if d['price'] == 50)

# filter (not the most elegant/readable with lambda)
results = filter(lambda d: d['price'] == 50, l)

这不会在声明时迭代list。只有当您迭代 results 时它才会这样做（您只能执行一次）。如果您并不总是或仅部分需要迭代 results，这可能会有所帮助。

Answer 3

tl;dr - 使用列表理解不会出错

我探索了以下方法：

1. 基本的for循环
2. 使用 if 比较的列表理解
3. 带有 lambda 表达式的内置过滤器函数
4. 生成器的列表理解

在 Python 2.7.12 和 Python 3.5.2（不是最新版本）中探索了这些方法。似乎在 Python 2 中最好的方法是方法 4，而在 Python 3 中最好的方法是方法 2（至少对于我的版本，这又不是最新的）。

以下是 Python 2.7.12 的结果：

# 2.7.12
# [GCC 5.4.0 20160609]
# Method 1 found 496 item in 0.382161 seconds. (basic for-loop)
# Method 2 found 496 item in 0.365456 seconds. (list comprehension)
# Method 3 found 496 item in 0.565614 seconds. (built in filter function)
# Method 4 found 496 item in 0.273335 seconds. (list comprehension over a generator expression)

以下是 Python 3.5.2 的结果：

# 3.5.2 
# [GCC 5.4.0 20160609]
# Method 1 found 493 item in 0.500266 seconds. (basic for-loop)
# Method 2 found 493 item in 0.338361 seconds. (list comprehension)
# Method 3 found 493 item in 0.796027 seconds. (built in filter function)
# Method 4 found 493 item in 0.351668 seconds. (list comprehension over a generator expression)

这是用于获取结果的代码：

import time
import random
import sys

print(sys.version)

l = []
for i in range(10000):
    d = {'price': random.randint(40, 60), 'id': i}
    l.append(d)

#METHOD 1 - basic for-loop
start = time.time()
for _ in range(1000):
    results = []
    for d in l:
        if d['price'] == 50:
           results.append(d)
end = time.time()
print("Method 1 found {} item in {:f} seconds. (basic for-loop)".format(len(results), (end - start)))

#METHOD 2 - list comp with if statement
start = time.time()
results = []
for _ in range(1000):
    results = []
    results = [d for d in l if d['price'] == 50]
end = time.time()
print("Method 2 found {} item in {:f} seconds. (list comprehension)".format(len(results), (end - start)))

#METHOD 3 - using filter and a lambda expression
start = time.time()
results = []
for _ in range(1000):
    results = []
    results = list(filter(lambda d: d['price'] == 50, l))
end = time.time()
print("Method 3 found {} item in {:f} seconds. (built in filter function)".format(len(results), (end - start)))

#METHOD 4 - list comp over generator expression
start = time.time()
results = []
once = True
for _ in range(1000):
    results = []
    genResults = (d for d in l if d['price'] == 50)
    results = [it for it in genResults]
end = time.time()
print("Method 4 found {} item in {:f} seconds. (list comprehension over a generator expression)".format(len(results), (end - start)))