巨蟒中的稀疏向量？

Question

稀疏向量是一个几乎所有条目都为零的向量，如[1, 0, 0, 0, 0, 0, 0, 2, 0]。存储所有这些零会浪费内存，而字典通常用于跟踪非零项。例如，前面显示的向量可以表示为{0:1, 7:2}，因为它表示的向量在索引0处有值1，在索引7处有值2。编写一个将稀疏向量转换为字典的函数，如上文所述。

示例

>>> convertVector([1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4])
{0: 1, 3: 2, 7: 3, 12: 4}
>>> convertVector([1, 0, 1 , 0, 2, 0, 1, 0, 0, 1, 0])
{0: 1, 2: 1, 4: 2, 6: 1, 9: 1}
>>> convertVector([0, 0, 0, 0, 0])
{}

我的代码

def convertVector(numbers):
    d = {i: 0 for i in numbers}
    for k, c in enumerate(numbers):
        d[c] = k  # increment its value

    return d
print convertVector([1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4])
print convertVector([1, 0, 1 , 0, 2, 0, 1, 0, 0, 1, 0])
print convertVector([0, 0, 0, 0, 0])

代码将其返回为

{0: 11, 1: 0, 2: 3, 3: 7, 4: 12}
{0: 10, 1: 9, 2: 4}
{0: 4}

问题是它返回的是最后一个索引，对应于值。它应该返回的地方

   {0: 1, 3: 2, 7: 3, 12: 4}
    {0: 1, 2: 1, 4: 2, 6: 1, 9: 1}
    {}

有什么帮助吗？

Answer 1

def convertVector(numbers):
    d = {}
    for k, c in enumerate(numbers):
        if c:
            d[k] = c  
    return d

print convertVector([1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4])
print convertVector([1, 0, 1 , 0, 2, 0, 1, 0, 0, 1, 0])
print convertVector([0, 0, 0, 0, 0])

Answer 2

使用条件字典理解的一行：

def sparseVector(v): 
    return {n: val for n, val in enumerate(v) if val}

 v1 = [1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4]
 v2 = [1, 0, 1 , 0, 2, 0, 1, 0, 0, 1, 0]
 v3 = [0, 0, 0, 0, 0]

 >>> [sparseVector(v) for v in [v1, v2, v3]]
 [{0: 1, 3: 2, 7: 3, 12: 4}, 
  {0: 1, 2: 1, 4: 2, 6: 1, 9: 1}, 
  {}]

压缩结束时的if val意味着，如果val没有计算为False (即它不是0、None等)，它只会将键和值添加到字典中。

enumerate(v)遍历一个可迭代对象(例如，一个列表)，并在该位置返回它的索引值和对象/值。

n: val将该值添加到在索引值n上键键的字典中(只有当val不是零/无时)。

Answer 3

def convertVector(numbers):
    dic = {}    
    for i in range(len(numbers)):
        if numbers[i] != 0:
            dic[i] = numbers[i]
    return dic