蟒蛇 - 从匹配列表项与字典值，在列表顺序获得关键

问题描述：

d = {'h' : 11111111, 't' : 1010101, 'e' : 10101111, 'n' : 1} 

my_list = [1010101, 11111111, 10101111, 1] 

get_keys = [k for k, v in d.items() if v in my_list] 

print(get_keys)

我得到的输出是：

['h', 't', 'e', 'n']

但是我想它在my_list的顺序如下：

['t', 'h', 'e', 'n']

我该怎么做？谢谢！

python词典没有排序。你可能想使用['OrderedDict']（https://docs.python.org/3/library/collections.html#collections.OrderedDict） – yash

这些值是否都是唯一的？否则，某些键可能不明确。 – dawg

都是独一无二的是 – kieron

答

d = {'h' : 11111111, 't' : 1010101, 'e' : 10101111, 'n' : 1} 

my_list = [1010101, 11111111, 10101111, 1] 

new_list = [] 

for i in my_list: 
    for key, value in d.items(): 
     if value == i: 
      new_list.append(key) 

print(new_list)

对于'my_list'中的每个项目，您正在循环字典'd'中的每个项目。换言之，这具有O（n^2）复杂性。请不要使用这个.... – dawg

答

考虑（其中所有的值也是唯一的）：

>>> d = {'h' : 11111111, 't' : 1010101, 'e' : 10101111, 'n' : 1} 
>>> my_list = [1010101, 11111111, 10101111, 1]

您可以反字典：

>>> d_inverted={v:k for k,v in d.items()}

随后指数如您所愿：

>>> [d_inverted[e] for e in my_list] 
['t', 'h', 'e', 'n']

这适用于任何最新版本的Python。

请注意，您发布的方法具有O(n^2)复杂性。这意味着执行代码的时间将随着元素数量的平方增加。 将元素加倍，可以使执行时间增加四倍。效果不好。

在视觉上，看起来像这样：

相比较而言，我张贴的方法是O(n)，或者正比于单独元件的数量。 数据翻倍是执行时间的两倍。效果更好。（但不如O(1)这是相同的执行时间，无论数据的大小。）

如果你想不想来一次他们进行比较：

def bad(d,l): 
    new_list = [] 

    for i in l: 
     for key, value in d.items(): 
      if value == i: 
       new_list.append(key) 
    return new_list 

def better(d,l): 
    d_inverted={v:k for k,v in d.items()} 
    return [d_inverted[e] for e in my_list] 

if __name__=='__main__': 
    import timeit 
    import random 

    for tgt in (5,10,20,40,80,160,320,640,1280): 
     d={chr(i):i for i in range(100,100+tgt)} 
     my_list=list(d.values()) 
     random.shuffle(my_list) 
     print("Case of {} elements:".format(len(my_list))) 
     for f in (bad, better): 
      print("\t{:10s}{:.4f} secs".format(f.__name__, timeit.timeit("f(d,my_list)", setup="from __main__ import f, d, my_list", number=100)))

打印：

Case of 5 elements: 
    bad  0.0003 secs 
    better 0.0001 secs 
Case of 10 elements: 
    bad  0.0006 secs 
    better 0.0002 secs 
Case of 20 elements: 
    bad  0.0022 secs 
    better 0.0003 secs 
Case of 40 elements: 
    bad  0.0071 secs 
    better 0.0004 secs 
Case of 80 elements: 
    bad  0.0240 secs 
    better 0.0008 secs 
Case of 160 elements: 
    bad  0.0912 secs 
    better 0.0018 secs 
Case of 320 elements: 
    bad  0.3571 secs 
    better 0.0032 secs 
Case of 640 elements: 
    bad  1.3704 secs 
    better 0.0053 secs 
Case of 1280 elements: 
    bad  5.4443 secs 
    better 0.0107 secs

您可以看到，嵌套循环方法在3x处开始较慢，随着数据大小增加而逐渐增加至500x。时间的增加跟踪大O的预测。你可以想象数百万元素会发生什么。

蟒蛇 - 从匹配列表项与字典值，在列表顺序获得关键

相关推荐