Question

说我有一个嵌套词典：

      myDict = { 'a': { 1: 2,
                        2: 163,
                        3: 12,
                        4: 67,
                        5: 84
                        },
             'about': { 1: 27,
                        2: 45,
                        3: 21,
                        4: 10,
                        5: 15
                        },
                'an': { 1:  3,
                        2: 15,
                        3:  1,
                        4:312,
                        5:100
                        }
        'anticipate': { 1:  1,
                        2:  5,
                        3:  0,
                        4:  8,
                        5:  7
                        }
             'apple': { 1:  0,
                        2:  5,
                        3:  0,
                        4:  10,
                        5:  0
                        }
           }

外键是一个单词，内键是该单词包含的文件，值是该单词在该文件中出现的次数。

我想解决两件事：

第一个是每个单词总共出现的次数，因此对于'a'，它将是328。

第二个是包含每个单词的文件数量，因此'a'为5，而'apple'为2。

我猜这些'值'将是两个字典而不是标准字典，而不是嵌套，即{word：total count}和{word：它出现的文件数量}。

编辑：我想解决的另一件事是每个文件的单词矢量幅度。

因此，对于文件1，它将是sqrt（2 ^ 2 + 27 ^ 2 + 3 ^ 2 + 1 ^ 2 + 0 ^ 2）

Answer 1

IIUC，你可以用字典理解直接做到这一点。

给定单词词典中所有值的总和：

>>> {k: sum(d.values()) for k,d in myDict.items()}
{'a': 328, 'about': 118, 'apple': 15, 'anticipate': 21, 'an': 431}

子字典中大于零的值：

>>> {k: sum(v > 0 for v in d.values()) for k,d in myDict.items()}
{'a': 5, 'about': 5, 'apple': 2, 'anticipate': 4, 'an': 5}

最后一个依赖于int(True) == 1和int(False) == 0这一事实，因此我们不需要写1 if v > 0 else 0或其他东西，但可以总结一下布尔值。

Answer 2

好的，你的问题并不是很困难。

问题1：“第一个是每个单词出现的总次数，因此对于'a'，它将是328。”

word = "a"
total = sum(myDict[word].values())
print total

或者，如果你想为myDict中的每个键计算它：

for word in myDict:
    total = sum(myDict[word].values())
    print word, total

问题2：“第二个是包含每个单词的文件数量，因此'a'为5，而'apple'为2。”

for word in myDict:
    number_of_files = sum(bool(v) for v in myDict[word].values())
    print word, number_of_files

Answer 3

嵌套字典对于术语 - 文档矩阵来说是非常糟糕的数据结构。而是使用Calculating distance between word/document vectors from a nested dictionary

中建议的numpy数组

即使您不喜欢使用numpy数组，也不需要字典结构字典，因为您的内部键是顺序的。您可以使用以下结构来简化存储数据的方式：

myDict = {'a':[2, 163, 12, 67, 84], 
          'about':[27, 45, 21, 10, 15], 
          'apple':[0, 5, 0, 10, 0], 
          'anticipate': [1, 5, 0, 8, 7], 
          'an':[3, 15, 1, 312, 100]}

当您访问时，使用相同的方法，但从内键中的第0个索引开始：

print myDict['a'][0] # a in 1st document
print myDict['a'][1] # a in 2nd document
print myDict['apple'][2] # apple in 3rd document

简单地计算每个单词的总和：

sum(myDict['a'])
sum([1 for word in myDict if myDict[word] > 0])

这里是完整的代码：

myDict = {'a': {1:2, 2:163, 3:12, 4:67, 5:84}, 
          'about': {1:27, 2:45, 3:21, 4:10, 5:15}, 
          'apple': {1:0, 2: 5, 3:0, 4:10, 5:0}, 
          'anticipate': {1:1, 2:5, 3:0, 4:8, 5:7}, 
          'an': {1:3, 2:15, 3:1, 4:312, 5:100}}

myDict = {'a':[2, 163, 12, 67, 84], 
          'about':[27, 45, 21, 10, 15], 
          'apple':[0, 5, 0, 10, 0], 
          'anticipate': [1, 5, 0, 8, 7], 
          'an':[3, 15, 1, 312, 100]}

print myDict['a'][0] # a in 1st document
print myDict['a'][1] # a in 2nd document
print myDict['apple'][2] # apple in 3rd document 

print sum(myDict['a'])
# How many documents does apple occur in?
print sum([1 for doc in myDict['apple'] if doc > 0])

再一次，我强调使用字典字典，其中内部键是顺序整数，你可以简单地剥离内部键。

从嵌套字典中计算出某些值

3 个答案: