在python中访问字典中的列表列表

我正在尝试编写一个名为compute的函数

import math
def compute(index):
    res=0
    x=0
    res = sum(val[-1] * val[-1] for key,val in index.items())
    x = math.sqrt(res)
    return x

我的输出：

>>compute({'a': [0, 3], 'b': [0, 4]})
5.0

在上面的示例索引中，文档0有两个术语“a”（带有 tf idf重量3）和“b”（tf idf重量4）。它的长度是 因此，5=sqrt（9+16）

现在如何访问字典中的列表元素列表？？ 例如，

compute（{'a'：[[0,3]]，'b'：[[0,4]}）

所以我想要的输出是这样的

期望输出：

>>length = compute(({'a': [[0, 3]], 'b': [[0, 4]]})
>>length[0]
5.0

因此，应分别对每个列表进行计算。 例如在

>>length = compute(({'a': [[0, 3],[1,3]], 'b': [[0, 4],[1,2]]})
>>length[1]
3.6

---

有人能建议修改我的函数吗？

我想你想说的是（使用x和y来避免混淆）

以及

x = [4,7]
y = [5,9]
length = 5

但是你有一个额外的列表顺序。所以你只需要像平常一样重新索引它

def compute(index):
    output = []
    for i in range(0,len(index['a'])): #no error checking to ensure len(index['a']) == len(index['b'])
        output.append(math.sqrt(math.pow(index['a'][i][1]-index['a'][i][0],2)+math.pow(index['b'][i][1]-index['b'][i][0],2)))
    return output

而且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

需要一个收尾价，并且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

长度[1]

长度[1]=2.23

---

如果我上面的数学假设是正确的。如果不是，你需要更清楚地解释你在做什么

我想你想说的是（使用x和y来避免混淆）

以及

x = [4,7]
y = [5,9]
length = 5

但是你有一个额外的列表顺序，所以你只需要像平常一样重新索引它

def compute(index):
    output = []
    for i in range(0,len(index['a'])): #no error checking to ensure len(index['a']) == len(index['b'])
        output.append(math.sqrt(math.pow(index['a'][i][1]-index['a'][i][0],2)+math.pow(index['b'][i][1]-index['b'][i][0],2)))
    return output

而且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

需要一个收尾价，并且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

长度[1]

长度[1]=2.23

---

如果我上面的数学假设是正确的。如果不是，你需要更清楚地解释你在做什么

我想你想说的是（使用x和y来避免混淆）

以及

x = [4,7]
y = [5,9]
length = 5

但是你有一个额外的列表顺序，所以你只需要像平常一样重新索引它

def compute(index):
    output = []
    for i in range(0,len(index['a'])): #no error checking to ensure len(index['a']) == len(index['b'])
        output.append(math.sqrt(math.pow(index['a'][i][1]-index['a'][i][0],2)+math.pow(index['b'][i][1]-index['b'][i][0],2)))
    return output

而且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

需要一个收尾价，并且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

长度[1]

长度[1]=2.23

---

如果我上面的数学假设是正确的。如果不是，你需要更清楚地解释你在做什么

我想你想说的是（使用x和y来避免混淆）

以及

x = [4,7]
y = [5,9]
length = 5

但是你有一个额外的列表顺序，所以你只需要像平常一样重新索引它

def compute(index):
    output = []
    for i in range(0,len(index['a'])): #no error checking to ensure len(index['a']) == len(index['b'])
        output.append(math.sqrt(math.pow(index['a'][i][1]-index['a'][i][0],2)+math.pow(index['b'][i][1]-index['b'][i][0],2)))
    return output

而且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

需要一个收尾价，并且

长度=计算（{'a'：[[0,3]，[1,3]]，'b'：[[0,4]，[1,2]}）

长度[1]

长度[1]=2.23

---

如果我上面的数学假设是正确的。如果不是，你需要更清楚地解释你在做什么

如果我理解你想要正确的结果：

import math

def compute_lengths(d):
    l = []

    for i in xrange(len( d[ d.keys()[0] ] )):
        ## len is number of inner lists within an outer list

        sum = 0
        for v in d.values():
            sum += (v[i][-1]) ** 2

        l.append(math.sqrt(sum))

    return l


d = {
    'a': [ [0, 3], [1, 3] ],
    'b': [ [0, 4], [1, 2] ]
}

l = compute_lengths(d)
print l

[5.0, 3.605551275463989]

---

您当然可以压缩此代码，但这是一种简单的方法，希望与您的算法相匹配。请在更大的字典中测试此方法，看看它是否能满足您的需要。

如果我了解您想要的结果，请更正：

import math

def compute_lengths(d):
    l = []

    for i in xrange(len( d[ d.keys()[0] ] )):
        ## len is number of inner lists within an outer list

        sum = 0
        for v in d.values():
            sum += (v[i][-1]) ** 2

        l.append(math.sqrt(sum))

    return l


d = {
    'a': [ [0, 3], [1, 3] ],
    'b': [ [0, 4], [1, 2] ]
}

l = compute_lengths(d)
print l

[5.0, 3.605551275463989]

---

您当然可以压缩此代码，但这是一种简单的方法，希望与您的算法相匹配。请在更大的字典中测试此方法，看看它是否能满足您的需要。

如果我了解您想要的结果，请更正：

import math

def compute_lengths(d):
    l = []

    for i in xrange(len( d[ d.keys()[0] ] )):
        ## len is number of inner lists within an outer list

        sum = 0
        for v in d.values():
            sum += (v[i][-1]) ** 2

        l.append(math.sqrt(sum))

    return l


d = {
    'a': [ [0, 3], [1, 3] ],
    'b': [ [0, 4], [1, 2] ]
}

l = compute_lengths(d)
print l

[5.0, 3.605551275463989]

---

您当然可以压缩此代码，但这是一种简单的方法，希望与您的算法相匹配。请在更大的字典中测试此方法，看看它是否能满足您的需要。

如果我了解您想要的结果，请更正：

import math

def compute_lengths(d):
    l = []

    for i in xrange(len( d[ d.keys()[0] ] )):
        ## len is number of inner lists within an outer list

        sum = 0
        for v in d.values():
            sum += (v[i][-1]) ** 2

        l.append(math.sqrt(sum))

    return l


d = {
    'a': [ [0, 3], [1, 3] ],
    'b': [ [0, 4], [1, 2] ]
}

l = compute_lengths(d)
print l

[5.0, 3.605551275463989]

---

您当然可以压缩此代码，但这是一种简单的方法，希望能与您的算法相匹配。请在更大的词典中测试此方法，看看它是否能满足您的需要。

这就是您要寻找的内容，我认为您可以得到它：

import math

def compute(index):
    count = 0
    res=0
    listy = [] 
    for i in range(len( index[ index.keys()[0] ] )):
        res = sum(val[i][-1]*val[i][-1] for key,val in index.items())
        listy.append(math.sqrt(res))
    return listy

输出：

计算（{'a'：[[0,3]，[1,3]，'b'：[[0,4]，[1,2]}））

=>[5.0,3.60551275463989]

---

基本上，您所做的就是在第一个

for

循环中的

键
列表的长度上迭代每个元素，每次迭代将每个
dict
的位置1处的值的所有平方相加，这就是您要寻找的，正如我认为您可以得到的那样：

import math

def compute(index):
    count = 0
    res=0
    listy = [] 
    for i in range(len( index[ index.keys()[0] ] )):
        res = sum(val[i][-1]*val[i][-1] for key,val in index.items())
        listy.append(math.sqrt(res))
    return listy

输出：

计算（{'a'：[[0,3]，[1,3]，'b'：[[0,4]，[1,2]}））

=>[5.0,3.60551275463989]

基本上，您所做的就是在第一个
for
循环中的
键
列表的长度上迭代每个元素，每次迭代将每个
dict
的位置1处的值的所有平方相加，这就是您要寻找的，正如我认为您可以得到的那样：

import math

def compute(index):
    count = 0
    res=0
    listy = [] 
    for i in range(len( index[ index.keys()[0] ] )):
        res = sum(val[i][-1]*val[i][-1] for key,val in index.items())
        listy.append(math.sqrt(res))
    return listy

输出：

计算（{'a'：[[0,3]，[1,3]，'b'：[[0,4]，[1,2]}））

=>[5.0,3.60551275463989]

基本上，您所做的就是在第一个
for
循环中的
键
列表的长度上迭代每个元素，每次迭代将每个
dict
的位置1处的值的所有平方相加，这就是您要寻找的，正如我认为您可以得到的那样：

import math

def compute(index):
    count = 0
    res=0
    listy = [] 
    for i in range(len( index[ index.keys()[0] ] )):
        res = sum(val[i][-1]*val[i][-1] for key,val in index.items())
        listy.append(math.sqrt(res))
    return listy

输出：

计算（{'a'：[[0,3]，[1,3]，'b'：[[0,4]，[1,2]}））

=>[5.0,3.60551275463989]

基本上，您所做的就是迭代第一个
for
循环中
键
列表长度中的每个元素，每次迭代将每个
dict
的位置1处的值的所有平方相加，您的函数仅以前缀方式计算术语“a”和“b”，发生了什么变化如果字典中有很多术语，比如“c”和“d”，我们可以使用for循环吗？而且它不是x[1]-x[0]^2 co