1

我正在尝试练习对文本进行分类的逻辑回归技术，并且我想以 apxn 矩阵的形式构建数据集，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

为清楚起见，我创建了一个示例，其中每个戏剧仅由独特的单词组成 - 自然在现实中这根本不是真的。

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

4

3 回答 3

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'

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

于 2012-03-12T01:39:10.363 回答
0

我会使用嵌套字典或二维字典。对于嵌套，首先，您需要将字典的格式更改为适当的形式：

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}
      }

希望这可以帮助。

于 2012-03-12T01:34:47.303 回答
0

最后，我最终做的是实现一个 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()
于 2012-03-15T17:48:34.413 回答