Python 如何从循环中的变量生成新列表？

我的实际例子更为复杂，因此我将概念归结为一个简单的例子：

l = [1,2,3,4,5,6,7,8]

for number in l:
    calc = number*10
    print calc

对于循环的每次迭代，我都会得到一个变量（

calc

），我想用它来填充一个新列表。我的实际过程远不止将值乘以

10

，因此我希望能够通过此方法设置新列表中的每个值。新代码可能如下所示：

l = [1,2,3,4,5,6,7,8]

for number in l:
    calc = number*10
    # set calc as x'th entry in a new list called l2 (x = iteration cycle)

print l2

然后它将打印新列表：

[10,20,30,40，…]

使用：

这大致相当于，但列表理解比循环的正常理解快：

>>> l2 = []
>>> for number in l:
...     calc = number * 10  #do some more calculations
...     l2.append(calc)     #appends the final calculated value at the end of l2
...     
>>> l2
[10, 20, 30, 40, 50, 60, 70, 80]

您还可以为正在进行的所有计算创建一个函数，然后在列表中调用该函数：

def solve(x):
   #do some calculations here
   return calculated_value

l2 = [ solve(item) for item in l]

---

有几种选择

列表解析 如果足够短，请使用：

new_list = [number * 10 for number in old_list]

map（）

如果函数以前存在，您也可以使用

map（）

（或者您将使用

lambda

）：

请注意，在Python3.x中，

map（）

不会返回列表（因此需要执行以下操作：

new\u list=list（map（my\u func，old\u list））

）

使用简单的

为…填写其他列表。。。在

循环中 或者，您也可以使用简单循环-它仍然有效且符合Python：

new_list = []

for item in old_list:
    new_list.append(item * 10)

发电机 有时，如果您有很多处理（正如您所说的），您希望在请求时惰性地执行它，或者结果可能太大，您可能希望使用生成器。生成器记住生成下一个元素的方法，并忘记之前发生的任何事情（我正在简化），因此您可以对它们进行一次迭代（但您也可以显式创建例如存储所有结果的列表）

在您的情况下，如果这只是用于打印，您可以使用：

def process_list(old_list):
    for item in old_list:
        new_item = ...  # lots of processing - item into new_item
        yield new_item

然后打印：

for new_item in process_list(old_list):
    print(new_item)

有关生成器的更多信息，可以在Python的wiki中找到：

访问“迭代编号” 但是，如果您的问题更多地是关于如何检索迭代次数，请查看

enumerate（）

：

---

下面是如何做到这一点而不直接跳入列表理解。使用

l

作为变量名不是一个好主意，因为它在某些字体中与

1

相同，所以我对其进行了更改（尽管

l1

并没有太好：）

列表理解确实提供了一种更简洁的方式来编写此模式

l2 = [ number*10 for number in l1 ]

---

因此，我相信您希望对列表中的每个元素应用一个函数

你试过列表理解吗

[num*10 for num in l]

应该为这个简单的示例提供所需的信息

当然，如果您有一些更复杂的操作集，您可以使用前面定义的函数，即：

def explode(n):
    return (n + (n * n) - (3 * n))

[explode(num) for num in l]

---

您的问题的一个简单答案是将

calc

附加到列表中，如下所示：

l = [1,2,3,4,5,6,7,8]

your_list = []
for number in l:
    calc = number*10
    your_list.append(calc)

要访问列表中的变量，请使用切片语法

也就是说，列表中的第二个元素是

你的列表[1]

，第五个元素是

你的列表[4]

---

我想你需要在某个时候清空列表。要使用切片，请使用

calc[：]=[]

其他人都给了您正确的答案：使用列表理解

我会给你一个替代的正确答案：使用带有lambda或函数的map

当“函数”非常简单时，可以使用lambda：

print map(lambda x: x*10,[1,2,3,4,5,6,7,8])
# [10, 20, 30, 40, 50, 60, 70, 80]

map使用的函数可以具有任意复杂度，因此使用函数更容易：

def more_complex(x):
    # can be as complex as a function can be
    # for now -- *10
    return x*10

print map(more_complex,[1,2,3,4,5,6,7,8])

但这也需要理解：

l2=[more_complex(x) for x in [1,2,3,4,5,6,7,8]]

---

只是为了让您熟悉地图与列表理解的形式。

生成列表的循环

KOT = []
l = [1,2,3,4,5,6,7,8]


for number in l:
    calc = number*10
    KOT.append(calc)

你得到KOT名单了吗

KOT = [10, 20, 30, 40, 50, 60, 70, 80]

---

谢谢你的提示。在我的实际示例中，有很多计算正在进行，因此我希望能够从循环中的变量填充列表。您的示例将解决x10问题，但我的问题涉及大量查找和计算，以确定因变量。我可以很好地计算循环中所需的值，因此我想在循环的每次迭代中使用该变量填充列表中的每个项。@bigCow使用第二种方法，即使用

列表。append

@bigCow:这通常取决于您是否有“大量的查找和计算”封装在单个函数中——根据这一点，理解、循环或映射（见我的答案）或多或少是合适的。这主要取决于它看起来有多漂亮或者代码应该有多灵活，但也有轻微的速度差异（如果你有预先存在的函数，

map（）

可能是最有效的）。@Tadeck我认为人们不太喜欢

map

：@AshwiniChaudhary:有些人肯定不喜欢

map（）

，但它仍然有它的用途。尽管将

reduce（），所以，如果你想做任何索引，或者任何其他需要实际列表的事情，你需要在调用
list
时将其包装起来。我有一个问题。为什么Python在运行此代码时将值8赋给number并将其存储为变量？很好的解决方案。@Seanospien，你的意思是为什么循环完成后
number
在范围内？Python循环不会创建新的作用域，因此在其中创建的任何变量都将保留在函数的作用域中（如果循环不在函数中，则保留在全局作用域中）@johnlaroy，谢谢。我只是觉得奇怪，变量是在使用.append时存储的，而不是在其他情况下。
def more_complex(x):
    # can be as complex as a function can be
    # for now -- *10
    return x*10

print map(more_complex,[1,2,3,4,5,6,7,8])

l2=[more_complex(x) for x in [1,2,3,4,5,6,7,8]]

KOT = []
l = [1,2,3,4,5,6,7,8]


for number in l:
    calc = number*10
    KOT.append(calc)

KOT = [10, 20, 30, 40, 50, 60, 70, 80]