Python 嵌套列表上的列表理解？

我有一个嵌套列表：

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

现在，我要做的是将列表中的每个元素转换为float。我的解决办法是：

newList = []
for x in l:
  for y in x:
    newList.append(float(y))

但这可以通过嵌套列表理解来实现吗

我所做的是：

[float(y) for y in x for x in l]

但结果是100个，加上2400个

---

如有任何解决方案，请解释。谢谢

下面是如何使用嵌套列表进行此操作：

>>> l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]
>>> new_list = [float(x) for xs in l for x in xs]
>>> new_list
[40.0, 20.0, 10.0, 30.0, 20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0, 30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]

[[float(y) for y in x] for x in l]

[deck.append((rank,suit)) for suit in suits for rank in ranks ]

---

这将为您提供一个列表列表，与您开始使用的列表类似，只是使用浮点数而不是字符串。如果您想要一个平面列表，那么您可以使用

[float（y）表示x中的x，l表示y中的x]

是的，您可以使用这样的代码：

l = [[float(y) for y in x] for x in l]

---

如果您不喜欢嵌套列表理解，也可以使用该函数

>>> from pprint import pprint

>>> l = l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']] 

>>> pprint(l)
[['40', '20', '10', '30'],
['20', '20', '20', '20', '20', '30', '20'],
['30', '20', '30', '50', '10', '30', '20', '20', '20'],
['100', '100'],
['100', '100', '100', '100', '100'],
['100', '100', '100', '100']]

>>> float_l = [map(float, nested_list) for nested_list in l]

>>> pprint(float_l)
[[40.0, 20.0, 10.0, 30.0],
[20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0],
[30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0],
[100.0, 100.0],
[100.0, 100.0, 100.0, 100.0, 100.0],
[100.0, 100.0, 100.0, 100.0]]

---

在我看来，最好的方法是使用python的

itertools

包

>>>import itertools
>>>l1 = [1,2,3]
>>>l2 = [10,20,30]
>>>[l*2 for l in itertools.chain(*[l1,l2])]
[2, 4, 6, 20, 40, 60]

---

不确定所需的输出是什么，但如果使用列表理解，则顺序遵循嵌套循环的顺序，而嵌套循环的顺序是向后的。所以我得到了我认为你想要的：

[float(y) for x in l for y in x]

---

其原理是：使用与嵌套for循环相同的顺序将其写出。

这个问题可以在不使用for循环的情况下解决。单行代码就足够了。使用嵌套映射和lambda函数也可以在这里使用

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

map(lambda x:map(lambda y:float(y),x),l)

输出列表如下所示：

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

---

以下是如何将嵌套for循环转换为嵌套列表：

[[float(y) for y in x] for x in l]

[deck.append((rank,suit)) for suit in suits for rank in ranks ]

下面是嵌套列表理解的工作原理：

            l a b c d e f
            ↓ ↓ ↓ ↓ ↓ ↓ ↓
In [1]: l = [ [ [ [ [ [ 1 ] ] ] ] ] ]
In [2]: for a in l:
   ...:     for b in a:
   ...:         for c in b:
   ...:             for d in c:
   ...:                 for e in d:
   ...:                     for f in e:
   ...:                         print(float(f))
   ...:                         
1.0

In [3]: [float(f)
         for a in l
   ...:     for b in a
   ...:         for c in b
   ...:             for d in c
   ...:                 for e in d
   ...:                     for f in e]
Out[3]: [1.0]

就你的情况而言，应该是这样的

In [4]: new_list = [float(y) for x in l for y in x]

---

因为我来晚了一点，但我想分享列表理解的实际工作原理，尤其是嵌套列表理解：

New_list= [[float(y) for x in l]

[[float(y) for y in x] for x in l]

实际上与：

New_list=[]
for x in l:
    New_list.append(x)

现在是嵌套列表理解：

New_list= [[float(y) for x in l]

[[float(y) for y in x] for x in l]

与,

new_list=[]
for x in l:
    sub_list=[]
    for y in x:
        sub_list.append(float(y))

    new_list.append(sub_list)

print(new_list)

输出：

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

---

我有一个类似的问题要解决，所以我遇到了这个问题。我对Andrew Clark和narayan的答案进行了性能比较，我想与大家分享一下

两个答案之间的主要区别在于它们在内部列表上的迭代方式。其中一个使用内置的，而另一个使用列表理解。所以在这个问题的上下文中，

map

应该比列表理解略好一些

让我们做一个性能基准测试，看看它是否真实。我使用python版本3.5.0来执行所有这些测试。在第一组测试中，我希望将每个列表的元素数保持在10个，并将列表数从10到100000不等

在下一组测试中，我想将每个列表的元素数提高到100

让我们勇敢地将列表中的元素数修改为1000

从这些测试中，我们可以得出结论，在这种情况下，

map

比列表理解有性能优势。如果您试图强制转换为

int

或

str

，这也适用。对于每个列表元素较少的少量列表，差异可以忽略不计。对于每个列表包含更多元素的较大列表，您可能希望使用

map

而不是列表理解，但这完全取决于应用程序的需要

然而，我个人认为列表理解比

map

更具可读性和习惯性。它是python中事实上的标准。通常，人们在使用列表理解方面比

map

更加熟练和舒适（特别是初学者）

    deck = [] 
    for rank in ranks:
        for suit in suits:
            deck.append(('%s%s')%(rank, suit))

这可以通过列表理解来实现：

[[float(y) for y in x] for x in l]

[deck.append((rank,suit)) for suit in suits for rank in ranks ]

---

是的，你可以做以下事情

[[float(y) for y in x] for x in l]

---

你也想把你的列表展平吗？@GregHewgill:OP没有回答，但根据他们接受的答案，他们似乎想保持嵌套的原样。

[float（y）表示y在x中表示x在l中表示x]

这将导致一系列的100，总计2400。你的代码生成的是映射对象，而不是列表：

>float\u l=[map（float，nested\u list）对于l]

[[]、[]、[]、[]、[]、[]、[]、[]、[]、[]]中的嵌套_列表，但添加一个额外的调用以列出它的效果与预期一样：
>>float_l=[list（map（float，nested_list）），对于l]
@pixelperfect，这是由于（错误信息…）更改
python3
以返回无法理解的生成器。这应该是答案，因为有些时候我们不想将迭代器括起来。这可能不是正确的答案，因为它输出一个非嵌套列表，但这正是我要寻找的，特别是原则。谢谢这是不正确的：应该在
[float（y）]
周围加上括号，lambdas是否比@Andrew Clark或Harry Binswanger的解决方案（更普通的列表理解）有任何性能优势？正如lambda看起来更难阅读一样。在几乎任何其他通用编程语言中，我们都会使用chained
map
——正如您所展示的那样。但是看看它在python中有多丑陋——特别是考虑到上面的输出是不够的：它是一个生成器而不是一个列表。需要添加更多的样板
list（list（..）
来完成图片。尝试
fluentpy
和类似的库，在一定程度上摆脱这个陷阱。非常有用！明确循环（从上到下）在生成器中从左到右排列。这并不明显，因为在
（f（x）表示l中的x）
中，for循环等价物的第二行放在了左侧。这似乎是我真正理解的一个解释，谢谢！作为一名python新手，来自Java，我花了几个小时努力理解嵌套理解，并搜索了多个地方。但是你让我度过了一个美好的夜晚。非常感谢@user48956是的，我认为将嵌套列表理解为一行代码不是很直观。这种用法将是一种反模式，这是一个很好且清晰的解释。谢谢这似乎根本没有解决上面的问题。请注意，作为答案发布的所有内容都必须是试图回答它发布到的问题。虽然此代码片段可能会解决问题，但确实有帮助