在Python中计数并根据结果创建矩阵

我有一套我关心计数的标签。假设它们是：

pos_tags = ["NN", "NNS", "JJ"]

我想让我的程序遍历一系列可能如下所示的句子：

sents = ["I want to go home.", "I have five dollars.", "The grass is green and wet."]

我使用nltk.pos_标记标记每个单词，结果是：

['I', 'want', 'to', 'go', 'home', '.']
[('I', 'PRP'), ('want', 'VBP'), ('to', 'TO'), ('go', 'VB'), ('home', 'NN'), ('.', '.')]
['I', 'have', 'five', 'dollars', '.']
[('I', 'PRP'), ('have', 'VBP'), ('five', 'CD'), ('dollars', 'NNS'), ('.', '.')]
['The', 'grass', 'is', 'green', 'and', 'wet', '.']
[('The', 'DT'), ('grass', 'NN'), ('is', 'VBZ'), ('green', 'JJ'), ('and', 'CC'), ('wet', 'NN'), ('.', '.')]

我想检查一下这里是否有任何带有pos_标签的单词，我想我已经完成了这一点；然而，我在以我想要的形式返回结果时遇到了巨大的困难，这是一种矩阵样式

行数就是句子的数量。在这种情况下，3。列将是存在的标记数。在这种情况下，也是3

最终结果如下所示：

[1, 0, 0 
 0, 1, 0
 2, 0, 1]

这就是我到目前为止所做的：

def tagging(sents):

    matrix = []
    pos_tags = ["NN", "NNS", "JJ"]

    for sent in sents:

        tokens = nltk.word_tokenize(sent)

        tagged_tokens = nltk.pos_tag(tokens)
        tagged_tokens_final = tagged_tokens


    for key, val in tagged_tokens_final:
        if val in common_pos_tags:
            counting = val.count(val)

---

有几种不同的方法来解决这个问题。也许最简单的方法是注意到每个句子都是独立于其他句子处理的。因此，您可以将一个句子的所有操作放在一个函数中，然后分别为每个句子运行该函数：

tags = ['NN', 'NNS', 'JJ'] 

matrix = [None] * len(sents)
for index, sent in enumerate(sents):
    matrix[index] = do_counting(sent, tags)

如果您喜欢动态扩展矩阵，而不是使用

[None]*len（sent）

预分配，您也可以这样做：

matrix = []
for sent in sents:
    matrix.append(do_counting(sent, tags))

在这两种情况下，

do_counting

是一个函数，它接受一个句子字符串和一个标记列表，返回矩阵的一行。如果您决定更改感兴趣的标记的顺序或名称，则这些标记是一种输入。输出将始终与输入列表匹配

解析将使用

nltk

完成，方法与您已经想到的相同。计数最容易用一个物体来完成，这个物体基本上就是为这个目的而制造的。它将统计每个标记出现的次数。然后，我们可以根据作为第二个参数传入的列表选择所需的标记：

from collections import Counter
def do_counting(sentence, tags)
    tokens = nltk.word_tokenize(sent)
    tagged_tokens = nltk.pos_tag(tokens)
    counts = Counter(tag for _, tag in tagged_tokens)
    tag_counts = [counts[tag] for tag in tags]
    return tag_counts

注意，为了计数，我忽略了标记

\u

在Python中是一个有效的变量名，但通常用于指示丢弃的参数。计数器可以写为

counts = Counter(item[0] for item in tagged_tokens)

如果不使用

计数器，自己进行计数也不会太困难：

def do_counting(sentence, tags)
    tokens = nltk.word_tokenize(sent)
    tagged_tokens = nltk.pos_tag(tokens)
    counts = [sum(items[1] == tag for items in tagged_tokens) for tag in tags]
    return counts

希望我已经提出了一个方法，你可以遵循，但更重要的是，你要理解。我试着为您提供一些选项来完成一些任务，让您在自己学习的过程中感受到各种可能性。
有几种不同的方法来解决这个问题。也许最简单的方法是注意到每个句子都是独立于其他句子处理的。因此，您可以将一个句子的所有操作放在一个函数中，然后分别为每个句子运行该函数：

tags = ['NN', 'NNS', 'JJ'] 

matrix = [None] * len(sents)
for index, sent in enumerate(sents):
    matrix[index] = do_counting(sent, tags)

如果您喜欢动态扩展矩阵，而不是使用
[None]*len（sent）
预分配，您也可以这样做：

matrix = []
for sent in sents:
    matrix.append(do_counting(sent, tags))

在这两种情况下，
do_counting
是一个函数，它接受一个句子字符串和一个标记列表，返回矩阵的一行。如果您决定更改感兴趣的标记的顺序或名称，则这些标记是一种输入。输出将始终与输入列表匹配

解析将使用
nltk
完成，方法与您已经想到的相同。计数最容易用一个物体来完成，这个物体基本上就是为这个目的而制造的。它将统计每个标记出现的次数。然后，我们可以根据作为第二个参数传入的列表选择所需的标记：

from collections import Counter
def do_counting(sentence, tags)
    tokens = nltk.word_tokenize(sent)
    tagged_tokens = nltk.pos_tag(tokens)
    counts = Counter(tag for _, tag in tagged_tokens)
    tag_counts = [counts[tag] for tag in tags]
    return tag_counts

注意，为了计数，我忽略了标记
\u
在Python中是一个有效的变量名，但通常用于指示丢弃的参数。计数器可以写为

counts = Counter(item[0] for item in tagged_tokens)

如果不使用
计数器，自己进行计数也不会太困难：

def do_counting(sentence, tags)
    tokens = nltk.word_tokenize(sent)
    tagged_tokens = nltk.pos_tag(tokens)
    counts = [sum(items[1] == tag for items in tagged_tokens) for tag in tags]
    return counts

希望我已经提出了一个方法，你可以遵循，但更重要的是，你要理解。我试图为您提供一些选项来完成一些任务，让您在自己学习的过程中感受到各种可能性。
Python、Libs中有各种矩阵类型，但我只是列出了一个列表

s1 = ['I', 'want', 'to', 'go', 'home', '.']
ts1 = [('I', 'PRP'), ('want', 'VBP'), ('to', 'TO'), ('go', 'VB'), ('home', 'NN'), ('.', '.')]
s2 = ['I', 'have', 'five', 'dollars', '.']
ts2 = [('I', 'PRP'), ('have', 'VBP'), ('five', 'CD'), ('dollars', 'NNS'), ('.', '.')]
s3 = ['The', 'grass', 'is', 'green', 'and', 'wet', '.']
ts3 = [('The', 'DT'), ('grass', 'NN'), ('is', 'VBZ'), ('green', 'JJ'), ('and', 'CC'), ('wet', 'NN'), ('.', '.')]

pos_tags = ["NN", "NNS", "JJ"]

嵌套列表理解在这里可以很好地构造列表列表

sum（sen，（））
使元组列表变得平坦，但这并不是性能方面的最佳建议

tagd_sents = [ts1, ts2, ts3]

tagm = [[sum(sen,()).count(tag) for tag in pos_tags] for sen in tagd_sents]

print(*tagm, sep='\n')
[1, 0, 0]
[0, 1, 0]
[2, 0, 1]

Mad Physician关于快速和肮脏的上面计数标记的说法是正确的，这些标记也是句子中的单词，考虑到数据结构会更安全
Python、Libs中有各种矩阵类型，但我只是列出了一个列表

s1 = ['I', 'want', 'to', 'go', 'home', '.']
ts1 = [('I', 'PRP'), ('want', 'VBP'), ('to', 'TO'), ('go', 'VB'), ('home', 'NN'), ('.', '.')]
s2 = ['I', 'have', 'five', 'dollars', '.']
ts2 = [('I', 'PRP'), ('have', 'VBP'), ('five', 'CD'), ('dollars', 'NNS'), ('.', '.')]
s3 = ['The', 'grass', 'is', 'green', 'and', 'wet', '.']
ts3 = [('The', 'DT'), ('grass', 'NN'), ('is', 'VBZ'), ('green', 'JJ'), ('and', 'CC'), ('wet', 'NN'), ('.', '.')]

pos_tags = ["NN", "NNS", "JJ"]

嵌套列表理解在这里可以很好地构造列表列表

sum（sen，（））
使元组列表变得平坦，但这并不是性能方面的最佳建议

tagd_sents = [ts1, ts2, ts3]

tagm = [[sum(sen,()).count(tag) for tag in pos_tags] for sen in tagd_sents]

print(*tagm, sep='\n')
[1, 0, 0]
[0, 1, 0]
[2, 0, 1]

《疯狂物理学家》关于快速、肮脏的上面计数标签的说法是正确的，这些标签也是句子中的单词，尊重数据结构会更安全
肯定会将其视为一种聪明的方法。尤其是
sum（sen，（））
让我很开心。也就是说，如果其中一个标签出现在一个句子中，这将失败
sum（x[1]表示sen中的x，（））
可能是更好的选择。三层嵌套的理解仍然很清晰：）这绝对是一个聪明的方法。尤其是
sum（sen，（））
让我很开心。也就是说，如果其中一个标签出现在一个句子中，这将失败
sum（x[1]表示sen中的x，（））
可能是更好的选择。三层嵌套的理解仍然很清晰：）非常感谢你的透彻解释-计数部分特别有用！对于矩阵部分，我最终在numpy库中使用了np.array——工作起来很有魅力！没问题。您可以根据最终结果创建一个numpy数组，也可以使用一个数组从头开始填充。我想坚持使用核心Python来回答这个问题，因为你似乎想要一些更基本的东西。非常感谢你的透彻解释——特别是计数部分