Question

我知道就地列表方法返回None而不是变异列表。据我所知，这使得不可能将这些方法用作列表理解的内部逻辑的一部分。

创建列表理解的最Python方式是什么，其成员是由其他列表的变异产生的？换句话说：什么是替代此（无效）行的最佳选择：

new_list = [old_list.insert(0, "X") for old_list in list_of_old_lists]

由于None返回list.insert()，因此会产生None列表。

难道没有大量的切片和连接就不可能在优雅的单行代码中做到这一点吗？

为了说明我的问题，上面的示例很简单，但实际上，我想在更复杂的情况下代替多个嵌套的“ for”循环。

这是我要做的事情的简化示例：

word = 'abcdefg'

variations_list = []
characters_to_insert = ['X', 'Y', 'Z']

for character in characters_to_insert:
    for position in range(len(word) + 1):
        w = list(word)
        w.insert(position, character)
        this_variation = ''.join(w)
        variations_list.append(this_variation)

for v in variations_list:
    print(v)

使用嵌套的“ for”循环，效果很好，就像这样（我的实际应用程序比此示例复杂/冗长）。

但是我不能使用列表理解来做同样的事情，因为'insert'方法返回None：

variations_list_comprehension = [list(word).insert(position, character) for position in range(len(word) +1) for character in ['X', 'Y', 'Z']]

for v in variations_list_comprehension:
    print(v)

由于就地突变返回“无”，因此会产生None值列表。

Answer 1

不是所有问题都应该通过理解来解决。 for循环还不错-有时它们比理解力要好，尤其是因为循环趋向于避免自动在一行中执行太多。

但是，如果您真的想要一个列表理解解决方案，则可以使用包装就位操作的辅助函数：

def insert(it, index, value):
    lst = list(it)
    lst.insert(index, value)
    return lst

[''.join(insert(word, position, character)) for position in range(len(word) +1) for character in ['X', 'Y', 'Z']]

但是，要真正等同于您的循环解决方案，您需要交换理解中的循环：

[''.join(insert(word, position, character)) for character in ['X', 'Y', 'Z'] for position in range(len(word) +1)]

此处的优点是，包装就位方法可以在很多情况下应用，它不仅在这种情况下有效（您可以用这种方式包装任何就地函数）。它很冗长，但可读性和重用性很好！

我个人会使用带有循环的生成器函数，因为您可以使用它来创建列表，但也可以根据需要创建项目（不需要列表）：

def insert_characters_everywhere(word, chars):
    for character in characters_to_insert:
        for position in range(len(word) + 1):
            lst = list(word)
            lst.insert(position, character)
            yield ''.join(lst)

list(insert_characters_everywhere('abcdefg', ['X', 'Y', 'Z']))

Answer 2

如果您不在乎更改另一个列表的结果，则无需使用临时列表：

variations_list = [word[:i] + char + word[i:] 
                   for char in characters_to_insert 
                   for i in range(len(word) + 1)]

['Xabcdefg', 'aXbcdefg', 'abXcdefg', 'abcXdefg', 'abcdXefg', 'abcdeXfg', 'abcdefXg', 'abcdefgX', 
 'Yabcdefg', 'aYbcdefg', 'abYcdefg', 'abcYdefg', 'abcdYefg', 'abcdeYfg', 'abcdefYg', 'abcdefgY', 
 'Zabcdefg', 'aZbcdefg', 'abZcdefg', 'abcZdefg', 'abcdZefg', 'abcdeZfg', 'abcdefZg', 'abcdefgZ']

我仍然会说这充其量只是一种边缘理解：作为for循环更容易理解。

Answer 3

我认为了解您在此实际要实现的目标很重要。

new_list = [old_list.insert(0, "X") for old_list in list_of_old_lists]

案例1：在上面的代码中，您是否要尝试创建一个包含更新的{strong>旧（!!!）列表的new_list，包括{{ 1}}字符是他们的第一个元素？在这种情况下，'X'将是“新列表”的列表。

例如，

list_of_old_lists

将打印：

list_of_old_lists = [['A'], ['B']]
new_list = []
for old_list in list_of_old_lists:
    old_list.insert(0, 'X')
    new_list.append(old_list)
print(list_of_old_lists)
print(new_list)
print(list_of_old_lists == new_list)

也就是说，[['X', 'A'], ['X', 'B']] [['X', 'A'], ['X', 'B']] True是new_list的浅表副本，包含“已更新”列表。 如果这是您想要的，则可以使用列表推导功能执行以下操作：

list_of_old_lists

代替上面的示例中的[old_list.insert(0, "X") for old_list in list_of_old_lists] new_list = list_of_old_lists[:]循环。

情况2：或者，您是在尝试让for保留原始列表的同时创建一个包含更新列表的新列表吗？在这种情况下，您可以通过以下方式使用列表理解：

list_of_old_lists

然后：

new_list = [['X'] + old_list for old_list in list_of_old_lists]

在列表理解中使用就地列表方法的替代方法？

3 个答案: