Python 对重复的字母使用“.index（）”

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

{'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

它对“生日”这样的词很有用，但当我有一封重复的信时，我有一个问题。。。例如，“你好”

---

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

你们已经把这个单词循环了一遍；不要使用

.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（）

：

现在，您的函数简单多了；请注意，由于您正在就地操作，因此不需要返回

prefix\u 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:]

---

您已经在单词上循环；而不是使用

.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（）

：

现在，您的函数简单多了；请注意，由于您正在就地操作，因此不需要返回

prefix\u 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:]

---

通过使用索引而不是字母来简化解决方案要容易得多。通常在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)})

你真正想要的是得到你单词的每个前缀，我们可以在一个罕见的情况下这样做，在索引中循环是一个有效的选择，因为这就是我们正在尝试做的

然后，我们使用a为每个片段选择正确的“儿童”组

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

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

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没有针对递归进行优化，这是一种更糟糕的方法。它还创建了一个列表而不是生成器，在某些情况下，这会降低内存效率。

通过考虑索引而不是字母来简化解决方案要容易得多。通常在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)})

你真正想要的是得到你单词的每个前缀，我们可以在一个罕见的情况下这样做，在索引中循环是一个有效的选择，因为这就是我们正在尝试做的

然后，我们使用a为每个片段选择正确的“儿童”组

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

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

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没有针对递归进行优化，这是一种更糟糕的方法。它还创建了一个列表而不是生成器，在某些情况下内存效率较低。

Martijn，但我有一些补充：

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

嗯。如果我再想一想，这不是简单化。但它避免了有许多基本相同数据或部分数据的副本…

Martijn，但我有一些补充：

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

嗯。如果我再想一想，这不是简单化。但它避免了有许多基本相同的数据或部分数据的副本…

我认为最具python风格的方法是：

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

我认为最具python风格的方法是：

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

---

@Yarden：这是因为我为您用空格替换了制表符。编辑器用8个空格替换制表符，而代码仅用4个空格呈现，这导致您手动缩进的第一行的缩进处于关闭状态。@Yarden：这是因为我为您用空格替换了制表符。编辑器用8个空格替换制表符，而代码呈现为打开增加4个空格，导致手动缩进的第一行缩进关闭。