Question

我正在尝试使用逻辑回归技术来分类文本，我想以p x n矩阵的形式构建数据集，p行用于播放，n列用于唯一字。我已经有了一个可以使用的文本，我只需要计算其中的单词。

跟踪哪个单词出现在哪个单元中非常重要，因此对于给定的播放，我已经能够创建一个符合唯一单词的Python字典。我不知道该怎么做就是将这些词组合起来，例如

romeo = {[alas,2],[julliet,35]}
caesar = {[et,1],[tu,3],[cassius,12]}

可以合并

以生成矩阵

      alas  julliet  et  tu cassius
romeo  2        35    0   0  0 
caesar 0        0     1   3  12

为了清楚起见，我创建了一个例子，其中每个游戏仅由独特的单词组成 - 实际上，这根本不是真的。

有人可以从这些词典中构建这个矩阵吗？从其他地方开始会更容易吗？

Answer 1

这是有效的，经过测试：

from itertools import chain
from collections import defaultdict

romeo = {'alas':2, 'juliet':35, 'hello':1}
caesar = {'et':1, 'tu':3, 'cassius':12, 'hello':1}

dicts = defaultdict(dict)
dicts['romeo'] = romeo
dicts['caesar'] = caesar

columns = list(set(list(chain(romeo.keys(), caesar.keys()))))

matrix = defaultdict(dict)

for coll in ('romeo', 'caesar'):
    matrix[coll] = {}
    for key in columns:
        if dicts[coll].has_key(key):
            matrix[coll][key] = dicts[coll][key]
        else:
            matrix[coll][key] = 0

print columns

for coll in matrix.keys():
    for key in columns:
        print matrix[coll][key], 
    print '\n'

说明：将两个词典中的所有键组合在一起，然后运行循环并填充一个全新的词典：）

Answer 2

我会使用嵌套词典或二维词典。对于嵌套，首先，您需要将dicitonary的格式更改为正确的格式：

romeo = {[alas,2],[julliet,35]}
caesar = {[et,1],[tu,3],[cassius,12]}

应该是：

romeo = {'alas':2,'julliet': 35}
caesar = {'et':1,'tu':3,'cassius':12}

从那里，你可以循环遍历字典中的所有“值”并嵌套字典，而不是像你拥有的那样，你可以有类似的东西：

#declare first:
Ds = {{}}

然后使用循环填充：

Ds = {
      'romeo' : {'et': 0, 'alas':2,'julliet': 35, tu':0,'cassius':0}, 
      'caesar' :  {'et':1, 'alas':0, 'julliet': 0, 'tu':3,'cassius':12}
      }

希望这有帮助。

Answer 3

最后，我最终做的是实现一个defaultdict，因为我喜欢它在以前不存在引用时如何创建字典或字典条目（取决于位置）。

我用我想要的东西构建了一个完整的defaultdict，然后输出到CSV。

我使用opensourceshakespeare.com的全文转储，这是我写的：

    playNames = {}

    for line in listOfLines:
            try:
                    playNames[line.rsplit('~')[0]] += 1
                    if line.rsplit('~')[0] == '':
                        print line
            except:
                    playNames[line.rsplit('~')[0]] = 1

    #print playNames.keys()

    #
    # Now let's build a dictionary for each play
    #

    for line in listOfLines:

            try:
                    playNames[line.rsplit('~')[0]] += line.rsplit('~,~')[2]
                    playNames[line.rsplit('~')[0]] += " "
            except:
                    playNames[line.rsplit('~')[0]] = line.rsplit('~,~')[2]
                    playNames[line.rsplit('~')[0]]+= " "

    #
    # for each play, tokenize text into list of words
    #

    for key in playNames.iterkeys():
            playNames[key] = playNames[key].split(' ')

    plays = collections.defaultdict(dict)

    for key in playNames.iterkeys():
            for val in playNames[key]:
                    try:
                            plays[key][val] += 1
                    except:
                            plays[key][val] = 1

    #
    # build a set of words
    #

    words = set()

    for eachplay in plays.itervalues():
            words.update(eachplay.keys())

    outfile = open("wordlist.csv",'w')

    i=0
    outfile.write(",")
    for word in words:

            outfile.write(word)
            outfile.write(",")
            i+=1
    print "words ",i

    outfile.write("\n")
    for eachplay in plays.iterkeys():
            i = 0
            outfile.write(eachplay)

            outfile.write(",")
            for word in words:
                    try:
                            outfile.write(str(plays[eachplay].get(word,"0")))
                            #print word,plays[eachplay][word]
                    except:
                         outfile.write("")
                    i+=1
                    outfile.write(",")
            outfile.write("\n")
            print eachplay," ",i
    outfile.close()

概念 - 如何在Python中构建2D字频矩阵？

3 个答案: