zip(*) 如何生成 n-gram？ 直觉代码示例替代列表理解

如何解决zip(*) 如何生成 n-gram？ 直觉代码示例替代列表理解

我正在查看有关 n-gram 的一些笔记，并且遇到了几个有趣的函数。首先是生成二元组：

def bigrams(word):
    return sorted(list(set(''.join(bigram)
                           for bigram in zip(word,word[1:]))))

def bigram_print(word):
    print("The bigrams of",word,"are:")
    print(bigrams(word))

bigram_print("ababa")
bigram_print("babab")

在自己阅读和玩 Python 之后，我明白了为什么会这样。然而，在查看这个函数时，我对这里的zip(*word[i:])的使用感到非常困惑。我知道 * 是一个解包运算符（如 here 所解释的），但我真的被它与列表理解结合在一起的方式绊倒了。谁能解释一下？

def ngrams(word,n):
    return sorted(list(set(''.join(ngram)
                           for ngram in zip(*[word[i:]
                                              for i in range(n)]))))

def ngram_print(word,n):
    print("The {}-grams of {} are:".format(n,word))
    print(ngrams(word,n))

for n in [2,3,4]:
    ngram_print("ababa",n)
    ngram_print("babab",n)
    print()

解决方法

如果你崩溃了

zip(*[word[i:] for i in range(n)])

你得到：

[word[i:] for i in range(n)]

相当于：

[word[0:],word[1:],word[2:],... word[n-1:]]

从word

中不同位置开始的每个字符串

现在，如果您对其应用解包 * 运算符：

*[word[0:],... word[n-1:]]

您将每个列表 word[0:]、word[1:] 等传递给 zip()

所以，zip 被这样调用：

zip(word[0:],... word[n-1:])

哪个 - 根据 zip 的工作原理 - 将创建 n 元组，每个条目来自相应的参数之一：

[(words[0:][0],words[1:][0]....),(words[0:][1],words[1:][1]....)
...

如果映射索引，您会看到这些值对应于 word 的 n-gram 定义

,

下面的例子应该解释它是如何工作的。我已经添加了代码和它的可视化表示。

直觉

核心思想是将同一列表的多个版本压缩在一起，每个版本都从下一个后续元素开始。

假设 L 是一个单词/元素列表 ['A','B','C','D']

然后，这里发生的事情是 L,L[1:],L[2:] 被压缩，这意味着每个元素的第一个元素（L 的第一个、第二个和第三个元素）被连接在一起，第二个元素被连接在一起并且等等..

在视觉上这可以显示为：

我们担心的声明 -

  zip (   *    [L[i:] for i in range(n)])
#|___||_______||________________________|     
#  |      |                  |
# zip  unpack    versions of L with subsequent 0 to n elements skipped

代码示例

l = ['A','D']

print('original list: '.ljust(27),l)
print('list skipping 1st element: ',l[1:])
print('list skipping 2 elements: '.ljust(27),l[2:])
print('bi-gram: '.ljust(27),list(zip(l,l[1:])))
print('tri-gram: '.ljust(27),l[1:],l[2:])))

original list:              ['A','D']
list skipping 1st element:  ['B','D']
list skipping 2 elements:   ['C','D']
bi-gram:                    [('A','B'),('B','C'),('C','D')]
tri-gram:                   [('A','D')]

如您所见，您基本上压缩了相同的列表，但跳过了一个。这将 (A,B) 和 (B,C) ... 压缩到了二元组中。

* 运算符用于解包。当您更改 i 值以跳过元素时，您基本上是在压缩 [l[0:],l[2:]...] 的列表。这将传递给 zip() 并使用 * 在其中解压缩。

zip(*[word[i:] for i in range(n)] #where word is the list of words

---

替代列表理解

上面的列表推导等价于 -

n = 3
lists = []
for i in range(3):
    print(l[i:])        #comment this if not needed
    lists.append(l[i:])
    
out = list(zip(*lists))
print(out)

['A','D']
['B','D']
['C','D']

[('A','D')]