如何比较python中默认dict中列表的索引值

Question

我在 python 中有一个默认字典 d，其中包含两个列表，如下所示：

{
    'data1': [0.8409093126477928, 0.9609093126477928, 0.642217399079215, 0.577003839123445, 0.7024399719949195, 1.0739533732043967], 
    'data2':  [0.9662666242560285, 0.9235637581239243, 0.8947656867577896, 0.9266919525550584, 1.0220039913024457]
}

将来默认字典中可以有很多列表，例如data1、data2、data3、data4 等。我需要将默认字典的索引值相互比较。因此，对于上述默认字典，我需要检查天气 data1[0]->0.8409093126477928 是否小于 data2[0]->0.9662666242560285，其他索引也是如此，并将获胜列表索引的结果存储在单独的列表中，如下所示：

result = ['data1', 'data2', 'data1', 'data1', 'data1']

如果任何列表的长度大于其他列表，我们只需要检查最后一个索引值是否小于1。就像data1[5] 不能与data2[5] 比较，因为data2[5] 没有值，因此我们将简单地检查data1[5] 是否小于1。如果它小于 1 则我们将考虑它并将其添加到 result 否则忽略它并且不会将其保存在 result 中。

我想解决这个问题，从默认字典中提取列表到单独列表，然后使用 for 循环比较索引值，但是当我使用print(d[0]) 打印0th 索引列表时，它打印出@ 987654339@。为什么它打印空。如何比较上面的索引值。请帮忙。谢谢

Answer 1

编辑：按照@ggorlen 的建议，将自定义迭代器替换为 zip_longest

我会像这样使用 custom_iterator 来做到这一点，

• 在每次迭代中从每个数组中压缩最长的项目。对于较短的数组，当迭代超过其长度时，它将返回 1
• 列表推导循环遍历迭代器并获取最小项item.index(min(item))的第一个索引，然后获取与最小值对应的键keys[item.index(min(item))]
• 如果所选列表比当前迭代器索引短，则它会跳过或给出“NA”值

from itertools import zip_longest

keys = list(d.keys())
lengths = list(map(len,d.values()))

result = [keys[item.index(min(item))] 
          for i, item in enumerate(zip_longest(*d.values(), fillvalue=1))
          if lengths[item.index(min(item))]>i]

result

如果你想在找到的最小值不小于一时给出默认键而不是跳过

result = [keys[item.index(min(item))] if lengths[item.index(min(item))]>i else "NA"
          for i, item in enumerate(zip_longest(*d.values(), fillvalue=1))]

Answer 2

我们可以使用来自 itertools 的zip_longest 和各种循环来实现结果：

from itertools import zip_longest

result = []
pairs = [[[z, y] for z in x] for y, x in data.items()]

for x in zip_longest(*pairs):
    x = [y for y in x if y]

    if len(x) > 1:
        result.append(min(x, key=lambda x: x[0])[1])
    elif x[0][0] < 1:
        result.append(x[0][1])

print(result) # => ['data1', 'data2', 'data1', 'data1', 'data1']

首先，我们在每个 dict 值及其键中创建每个项目的对。这使得以后更容易获得结果键。我们zip_longest 并遍历列表，过滤掉Nones。如果我们有多个要比较的元素，我们将取最小值并将其附加到结果中，否则我们检查唯一的元素并在其值小于 1 时保留它。

一个更可验证的例子是

data = {
    'foo':  [1, 0, 1, 0], 
    'bar':  [1, 1, 1, 1, 0],
    'baz':  [1, 1, 0, 0, 1, 1, 0],
    'quux': [0],
}

产生

['quux', 'foo', 'baz', 'foo', 'bar', 'baz']

元素方面，"quux" 赢得第 0 轮，"foo" 赢得第 1 轮，"baz" 2，"foo" 第 3 轮，这要归功于关键顺序（与 "baz" 并列），"bar" 用于第 4 轮。对于第 5 轮，"baz" 是最后一个站着但不低于 1，所以没有采取任何措施。在第 6 轮中，"baz" 仍然是最后一位，但由于 0

Answer 3

d = {
    'd0': [0.1, 1.1, 0.3],
    'd1': [0.4, 0.5, 1.4, 0.3, 1.6],
    'd2': [],
}

import itertools
import collections

# sort by length of lists, shortest first and longest last
d = sorted(d.items(), key=lambda k:len(k[1]))

# loop through all combinations possible
for (key1, list1), (key2, list2) in itertools.combinations(d, 2):
    result = []
    for v1, v2 in itertools.zip_longest(list1, list2): # shorter list is padded with None
        # no need to check if v2 is None because of sorting
        if v1 is None:
            result.append(key2 if v2 < 1 else None)
        else:
            result.append(key1 if v1 < v2 else key2)

    # DO stuff with result, keys, list, etc...
    print(f'{key1} vs {key2} = {result}')

输出

d2 vs d0 = ['d0', None, 'd0']
d2 vs d1 = ['d1', 'd1', None, 'd1', None]
d0 vs d1 = ['d0', 'd1', 'd0', 'd1', None]

---

我根据列表长度对它们进行了排序。这可确保list1 始终比list2 更短或长度相同。

对于不同的长度，其余索引将是None 和key2 的混合。

但是，当元素相等时，key2 会添加到结果中。这可能不是我们想要的行为。

Answer 4

可以这样吗

def compare2List(a, b):
   '''
   Input name of 2 lists that you need to compare
   a = name of 1st list appearing in dict d
   b = name of 2nd list appearing in dict d
   '''
   data1 = d[a]
   data2 = d[b]
   result = list()
   i = 0
   while i < len(data1) OR i < len(data2):
      if i < len(data1) AND i < len(data2):
         if data1[i] < data2[i]:
            result.append("data1")
         else:
            result.append("data2")
      else:
         if i >= len(data1):
            if data1[0] < 1:
               result.append("data1")
         elif i >= len(data2):
            if data2[0] < 1:
               result.append("data2")

      i = i + 1

   return result