hdx*_*hdx 88 python search tuples list
所以我有一个像这样的元组列表:
[(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
我希望这个列表的元组值等于某个元组.
所以,如果我这样做search(53)将返回索引值2
是否有捷径可寻？
Ign*_*ams 86
[i for i, v in enumerate(L) if v[0] == 53]
Gre*_*ill 48
您可以使用列表理解:
>>> a = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
>>> [x[0] for x in a]
[1, 22, 53, 44]
>>> [x[0] for x in a].index(53)
2
Jon*_*ell 43
一个生成器表达式可能是最高效和简单的解决问题的方法:
l = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
result = next((i for i, v in enumerate(l) if v[0] == 53), None)
# 2
有几个答案通过列表推导为这个问题提供了一个简单的解决方案.虽然这些答案完全正确,但它们并非最佳.根据您的使用情况,进行一些简单的修改可能会有很大的好处.
我在这个用例中使用列表推导的主要问题是整个列表将被处理,尽管你只想找到1个元素.
Python提供了一个简单的构造,在这里是理想的.它被称为生成器表达式.这是一个例子:
# Our input list, same as before
l = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
# Call next on our generator expression.
next((i for i, v in enumerate(l) if v[0] == 53), None)
我们可以期望这个方法在我们简单的例子中与列表推导基本相同,但是如果我们使用更大的数据集呢？这就是使用发电机方法的优势发挥作用的地方.我们将使用现有列表作为迭代,而不是构建新列表,并使用next()从我们的生成器中获取第一个项目.
让我们看一下这些方法在一些较大的数据集上的表现方式.这些是大型列表,由10000000 + 1个元素组成,我们的目标位于开头(最佳)或结束(最差).我们可以使用以下列表理解来验证这两个列表是否同等地执行:
worst_case = ([(False, 'F')] * 10000000) + [(True, 'T')]
print [i for i, v in enumerate(worst_case) if v[0] is True]
# [10000000]
# 2 function calls in 3.885 seconds
#
# Ordered by: standard name
#
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 3.885 3.885 3.885 3.885 so_lc.py:1(<module>)
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
best_case = [(True, 'T')] + ([(False, 'F')] * 10000000)
print [i for i, v in enumerate(best_case) if v[0] is True]
# [0]
# 2 function calls in 3.864 seconds
#
# Ordered by: standard name
#
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 3.864 3.864 3.864 3.864 so_lc.py:1(<module>)
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
这是我对发电机的假设:我们会看到发电机在最好的情况下表现会更好,但在最坏的情况下也是如此.这种性能增益主要是由于生成器被懒惰地评估,这意味着它只计算产生值所需的内容.
# 10000000
# 5 function calls in 1.733 seconds
#
# Ordered by: standard name
#
# ncalls tottime percall cumtime percall filename:lineno(function)
# 2 1.455 0.727 1.455 0.727 so_lc.py:10(<genexpr>)
# 1 0.278 0.278 1.733 1.733 so_lc.py:9(<module>)
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
# 1 0.000 0.000 1.455 1.455 {next}
best_case = [(True, 'T')] + ([(False, 'F')] * 10000000)
print next((i for i, v in enumerate(best_case) if v[0] == True), None)
# 0
# 5 function calls in 0.316 seconds
#
# Ordered by: standard name
#
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 0.316 0.316 0.316 0.316 so_lc.py:6(<module>)
# 2 0.000 0.000 0.000 0.000 so_lc.py:7(<genexpr>)
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
# 1 0.000 0.000 0.000 0.000 {next}
什么？!最好的情况打破了列表理解,但我并不期望我们最坏的情况在这种程度上超越列表理解.那个怎么样？坦率地说,我只能在没有进一步研究的情况下推测.
考虑到所有这些,我没有在这里进行任何强大的分析,只是一些非常基本的测试.这应该足以理解生成器表达式对于这种类型的列表搜索更具性能.
请注意,这是所有基本的内置python.我们不需要导入任何东西或使用任何库.
我第一次看到这种技术用于在Peter Norvig 的Udacity cs212课程中搜索.
And*_*ffe 26
你的元组基本上是键值对 - 一个python dict--so:
l = [(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")]
val = dict(l)[53]
编辑 - 啊哈,你说你想要索引值为(53,"xuxa").如果这真的是你想要的,你将不得不遍历原始列表,或者可能制作一个更复杂的字典:
d = dict((n,i) for (i,n) in enumerate(e[0] for e in l))
idx = d[53]
Dav*_*d Z 12
嗯......好吧,想到的简单方法就是将它转换成字典
d = dict(thelist)
和访问d[53].
编辑:哎呀,第一次误读了你的问题.听起来你真的想要获得存储给定数字的索引.在那种情况下,试试吧
dict((t[0], i) for i, t in enumerate(thelist))
而不是一个普通的旧dict转换.那d[53]就是2.
假设列表可能很长并且数字可能重复,请考虑使用Python sortedcontainers模块中的SortedList类型.SortedList类型将按编号自动维护元组,并允许快速搜索.
例如:
from sortedcontainers import SortedList
sl = SortedList([(1,"juca"),(22,"james"),(53,"xuxa"),(44,"delicia")])
# Get the index of 53:
index = sl.bisect((53,))
# With the index, get the tuple:
tup = sl[index]
这通过二进制搜索比列表理解建议快得多.字典建议会更快但如果可能存在具有不同字符串的重复数字则不会起作用.
如果存在具有不同字符串的重复数字,则需要再执行一个步骤:
end = sl.bisect((53 + 1,))
results = sl[index:end]
通过二等分54,我们将找到切片的结束索引.与接受的答案相比,这在长列表上会明显加快.