Question

我正在构建一个用单词构建字典的函数，例如：

{'b': ['b', 'bi', 'bir', 'birt', 'birth', 'birthd', 'birthda', 'birthday'],
'bi': ['bi', 'bir', 'birt', 'birth', 'birthd', 'birthda', 'birthday'],
'birt': ['birt', 'birth', 'birthd', 'birthda', 'birthday'], 
'birthda': ['birthda', 'birthday'], 
'birthday': ['birthday'], 
'birth': ['birth', 'birthd', 'birthda', 'birthday'],
'birthd': ['birthd', 'birthda', 'birthday'], 
'bir': ['bir', 'birt', 'birth', 'birthd', 'birthda', 'birthday']}

这就是它的样子：

def add_prefixs(word, prefix_dict):
    lst=[]
    for letter in word:
        n=word.index(letter)
        if n==0:
            lst.append(word[0])
        else:
            lst.append(word[0:n])
    lst.append(word)
    lst.remove(lst[0])
    for elem in lst:
        b=lst.index(elem)
        prefix_dict[elem]=lst[b:]
    return prefix_dict

它对于像“生日”这样的词很有用，但是当我有一个重复的字母时，我有一个问题......例如，“你好”。

{'h': ['h', 'he', 'he', 'hell', 'hello'], 'hell': ['hell', 'hello'], 'hello': ['hello'], 'he': ['he', 'he', 'hell', 'hello']}

我知道这是因为索引（python选择字母第一次出现的索引）但我不知道如何解决它。是的，这是我的作业，我真的想向你们学习：）

Answer 1

你已经循环了这个词;而不是使用.index()保持计数器。 Python让你很容易;使用enumerate()函数：

for n, letter in enumerate(word):
    if n==0:
        lst.append(word[0])
    else:
        lst.append(word[0:n])

现在你不再使用 letter变量了，所以只改为range(len(word)：

for n in range(len(word)):
    if n==0:
        lst.append(word[0])
    else:
        lst.append(word[0:n])

我们可以将其简化为列表理解：

lst = [word[0:max(n, 1)] for n in range(len(word))]

注意那里的max();而不是测试n是否为0，我们为切片设置了最小值1。

由于您再次删除第一个条目（因为它与第二个结果相同）和您添加完整的单词，只需将1添加到反而n计数器：

lst = [word[0:n+1] for n in range(len(word))]

你的函数的后半部分可以有效地使用enumerate()函数，而不是.index()：

for b, elem in enumerate(lst):
    prefix_dict[elem]=lst[b:]

现在你的功能更简单了;请注意，您无需返回 prefix_dict，因为您正在对其进行操作：

def add_prefixs(word, prefix_dict):
    lst = [word[0:n+1] for n in range(len(word))]
    for b, elem in enumerate(lst):
        prefix_dict[elem]=lst[b:]

Answer 2

通过考虑索引而不是字母来简化解决方案要容易得多。通常在Python中，我们循环使用值，因为这是我们关心的。在这里，我们实际上是为字符串生成前缀，其中内容无关紧要，而且位置确实如此：

def prefixes(seq):
    for i in range(len(seq)):
        yield seq[:i+1]

segments = list(prefixes("birthday"))
print({segment: segments[start:] for start, segment in enumerate(segments)})

你真正想要的是获得你的单词的每个前缀，我们可以在极少数情况下进行循环索引是一个有效的选项，因为这是我们正在尝试做的。

然后，我们使用dictionary comprehension为每个细分选择正确的“子”组。

这给了我们（为了清晰起见，增加了一些空格）：

{
    'birt': ['birt', 'birth', 'birthd', 'birthda', 'birthday'], 
    'bir': ['bir', 'birt', 'birth', 'birthd', 'birthda', 'birthday'], 
    'birthday': ['birthday'], 
    'bi': ['bi', 'bir', 'birt', 'birth', 'birthd', 'birthda', 'birthday'], 
    'birthda': ['birthda', 'birthday'], 
    'b': ['b', 'bi', 'bir', 'birt', 'birth', 'birthd', 'birthda', 'birthday'], 
    'birthd': ['birthd', 'birthda', 'birthday'], 
    'birth': ['birth', 'birthd', 'birthda', 'birthday']
}

如果您不介意一些额外的循环，我们甚至可以将其简化为：

def prefixes(word):
    for i in range(len(word)):
        segment = word[:i+1]
        yield segment, [segment[:i+1] for i in range(len(segment))]

print(dict(prefixes("birthday")))

作为旁注，prefixes()的另一个实现是：

def prefixes(seq):
    return prefixes(seq[:-1])+[seq] if seq else []

但是，这是一个递归函数，并且由于Python没有针对递归进行优化，因此这是一种更糟糕的方法。它还创建了一个列表而不是生成器，在某些情况下它的内存效率较低。

Answer 3

Martijn was faster than me，但我有一些补充：

def add_prefixs(word, prefix_dict):
    lst=[]
    for n, letter in enumerate(word):
        if n > 0:
            lst.append(word[0:n])
    lst.append(word)
    for elem in lst:
        b=lst.index(elem)
        prefix_dict[elem]=lst[b:]
    return prefix_dict

为什么要立即删除第0个条目？

另一种简化可能是

def add_prefixs(word, prefix_dict):
    #lst=[word[0:n] for n, letter in enumerate(word) if n > 0] + [word]
    # why do I think so complicated? Better use
    lst=[word[0:n+1] for n, letter in enumerate(word)]
    prefix_dict.update((elem, lst[b:]) for b, elem in enumerate(lst))
    return prefix_dict

使用像

这样的课程

class Segments(object):
    def __init__(self, string, minlength=1):
        self.string = string
        self.minlength = minlength
    def __getitem__(self, index):
        s = self.string[:self.minlength + index]
        if len(s) < self.minlength + index: raise IndexError
        if index >= len(self): raise IndexError # alternatively
        return s
    def cut(self, num):
        return type(self)(self.string, self.minlength + num)
    def __repr__(self):
        return repr(list(self))
    def __len__(self):
        return len(self.string) - self.minlength + 1

你可以进一步简化：

def add_prefixes(word, prefix_dict):
    lst = Segments(word)
    prefix_dict.update((prefix, lst.cut(n)) for n, prefix in enumerate(lst))
    return prefix_dict

嗯。如果我再考虑一下，这不是简化。但它避免了许多基本相同的数据或部分数据的副本......

Answer 4

我认为最 pythonic 方法是：

def add_prefixs(word, prefix_dict):
    lst = [word[0:n+1] for n in range(len(word))]
    prefix_dict.update((k, lst[n:]) for n, k in enumerate(lst))

在重复字母上使用`.index（）`

4 个答案: