Python：用字符序列查找所有可能的单词组合（分词）

Question

我正在做一些分词实验，如下所示。

lst 是一个字符序列，output 是所有可能的单词。

lst = ['a', 'b', 'c', 'd']

def foo(lst):
    ...
    return output

output = [['a', 'b', 'c', 'd'],
          ['ab', 'c', 'd'],
          ['a', 'bc', 'd'],
          ['a', 'b', 'cd'],
          ['ab', 'cd'],
          ['abc', 'd'],
          ['a', 'bcd'],
          ['abcd']]

我在itertools 库中检查了combinations 和permutations，
也试过combinatorics.
但是，我似乎看错了一面，因为这不是纯粹的排列组合......

似乎我可以通过使用大量循环来实现这一点，但效率可能会很低。

编辑

词序很重要，因此['ba', 'dc'] 或['cd', 'ab'] 等组合无效。

顺序应该总是从左到右。

编辑

@Stuart 的解决方案在 Python 2.7.6 中不起作用

编辑

@Stuart 的解决方案确实适用于 Python 2.7.6，请参阅下面的 cmets。

Answer 1

itertools.product确实应该可以帮到你。

这个想法是这样的：- 考虑由板隔开的 A1、A2、...、AN。将有 N-1 个平板。 如果有板，则有分段。如果没有平板，则有连接。 因此，对于长度为 N 的给定序列，您应该有 2^(N-1) 个这样的组合。

就像下面这样

import itertools
lst = ['a', 'b', 'c', 'd']
combinatorics = itertools.product([True, False], repeat=len(lst) - 1)

solution = []
for combination in combinatorics:
    i = 0
    one_such_combination = [lst[i]]
    for slab in combination:
        i += 1
        if not slab: # there is a join
            one_such_combination[-1] += lst[i]
        else:
            one_such_combination += [lst[i]]
    solution.append(one_such_combination)

print solution

Answer 2

#!/usr/bin/env python
from itertools import combinations
a = ['a', 'b', 'c', 'd']
a = "".join(a)
cuts = []
for i in range(0,len(a)):
    cuts.extend(combinations(range(1,len(a)),i))
for i in cuts:
    last = 0
    output = []
    for j in i:
        output.append(a[last:j])
        last = j
    output.append(a[last:])
    print(output)

输出：

zsh 2419 % ./words.py  
['abcd']
['a', 'bcd']
['ab', 'cd']
['abc', 'd']
['a', 'b', 'cd']
['a', 'bc', 'd']
['ab', 'c', 'd']
['a', 'b', 'c', 'd']

Answer 3

有 8 个选项，每个选项都映射二进制数 0 到 7：

000
001
010
011
100
101
110
111

每个 0 和 1 表示该索引处的 2 个字母是否“粘合”在一起。 0 表示否，1 表示是。

>>> lst = ['a', 'b', 'c', 'd']
... output = []
... formatstr = "{{:0{}.0f}}".format(len(lst)-1)
... for i in range(2**(len(lst)-1)):
...     output.append([])
...     s = "{:b}".format(i)
...     s = str(formatstr.format(float(s)))
...     lstcopy = lst[:]
...     for j, c in enumerate(s):
...         if c == "1":
...             lstcopy[j+1] = lstcopy[j] + lstcopy[j+1]
...         else:
...             output[-1].append(lstcopy[j])
...     output[-1].append(lstcopy[-1])
... output
[['a', 'b', 'c', 'd'],
 ['a', 'b', 'cd'],
 ['a', 'bc', 'd'],
 ['a', 'bcd'],
 ['ab', 'c', 'd'],
 ['ab', 'cd'],
 ['abc', 'd'],
 ['abcd']]
>>> 

Answer 4

您可以使用递归生成器：

def split_combinations(L):
    for split in range(1, len(L)):
        for combination in split_combinations(L[split:]):
            yield [L[:split]] + combination
    yield [L]

print (list(split_combinations('abcd')))

编辑。我不确定这对于长字符串的扩展效果如何，以及它在什么时候达到 Python 的递归限制。与其他一些答案类似，您也可以使用 itertools 中的 combinations 来处理每个可能的分割点组合。

def split_string(s, t):
    return [s[start:finish] for start, finish in zip((None, ) + t, t + (None, ))]

def split_combinations(s):
    for i in range(len(s)):
        for split_points in combinations(range(1, len(s)), i):
            yield split_string(s, split_points)

这些似乎在 Python 2.7 (see here) 和 Python 3.2 (here) 中都能正常工作。正如@twasbrillig 所说，请确保如图所示缩进。