• 当前位置：首页
  • IT科技
  • 如何使用列表推导来处理嵌套列表？

如何使用列表推导来处理嵌套列表？

2024-11-29 08:41:00
admin
原创
185
摘要：问题描述：我有这个嵌套列表：l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '1...

问题描述：

我有这个嵌套列表：

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

我想将 中的每个元素转换l为float。我有以下代码：

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

我怎样才能用嵌套列表理解来解决问题？

另请参阅：如何从列表推导而不是嵌套列表获得平面结果？

解决方案 1：

使用嵌套列表推导式可以这样做：

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

这将为您提供一个列表列表，与您开始时的列表类似，只是使用浮点数而不是字符串。

如果你想要一个平面列表，那么你可以使用

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

注意循环顺序 -for x in l在这个循环中是第一位的。

解决方案 2：

以下是将嵌套 for 循环转换为嵌套列表推导的方法：

#   l a b c d e f
#   ↓ ↓ ↓ ↓ ↓ ↓ ↓
l = [ [ [ [ [ [ 1 ] ] ] ] ] ]

new_list = []
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.append(float(f))
                        


new_list = [
    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
]

# new_list => [1.0]

对于您的情况，如果您想要一个平面列表，它将是这样的。

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

另一个有趣的例子是混合了 if 条件的：

school_data = [
    {
        "students": [
            {"name": "John", "age": 18, "friends": ["Alice", "Bob"]},
            {"name": "Alice", "age": 19, "friends": ["John", "Bob"]},
        ],
        "teacher": "Mr. Smith",
    },
    {
        "students": [
            {"name": "Sponge", "age": 20, "friends": ["Bob"]},
        ],
        "teacher": "Mr. tom",
    },
]

result = []

for class_dict in school_data:
    for student_dict in class_dict["students"]:
        if student_dict["name"] == "John" and student_dict["age"] == 18:
            for friend_name in student_dict["friends"]:
                if friend_name.startswith("A"):
                    result.append(friend_name)

这是listcomp版本

result = [
    friend_name
    for class_dict in school_data
        if class_dict["teacher"] == "Mr. Smith"
            for student_dict in class_dict["students"]
                if student_dict["name"] == "John" and student_dict["age"] == 18
                    for friend_name in student_dict["friends"]
                        if friend_name.startswith("A")
]
# result => ['Alice']

解决方案 3：

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

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

原则是：使用与嵌套 for 循环相同的顺序来写出它。

解决方案 4：

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

解决方案 5：

我想分享列表推导的实际工作方式，尤其是嵌套列表推导：

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

实际上与以下相同：

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

现在来看看嵌套列表的理解：

[[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]]

解决方案 6：

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

两个答案之间的主要区别在于它们如何迭代内部列表。其中一个使用内置map，而另一个使用列表理解。如果不需要使用 lambdas ，则 Map 函数比其等效列表理解具有轻微的性能优势。因此，在这个问题的背景下，它的map表现应该比列表理解略好。

让我们进行性能基准测试，看看这是否属实。我使用 Python 版本 3.5.0 执行所有这些测试。在第一组测试中，我希望将每个列表的元素数保持在10 个，并将列表数量从10 到100,000 个不等

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10]"
>>> 100000 loops, best of 3: 15.2 usec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100]"
>>> 100000 loops, best of 3: 15.2 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*1000]"
>>> 1000 loops, best of 3: 1.43 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*1000]"
>>> 100 loops, best of 3: 1.91 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10000]"
>>> 100 loops, best of 3: 13.6 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10000]"
>>> 10 loops, best of 3: 19.1 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 164 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 216 msec per loop

在此处输入图片描述

在下一组测试中，我想将每个列表的元素数量增加到100。

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 110 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 151 usec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.11 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.5 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 11.2 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 16.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 134 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 171 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.32 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.7 sec per loop

在此处输入图片描述

让我们勇敢地迈出一步，将列表中元素的数量修改为1000

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 800 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 1.16 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 8.26 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 11.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 83.8 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 118 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 868 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 1.23 sec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 9.2 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 12.7 sec per loop

在此处输入图片描述

从这些测试中，我们可以得出结论，map在这种情况下，与列表推导相比，它具有性能优势。如果您尝试转换为int或，这也适用str。对于每个列表中元素较少的少量列表，差异可以忽略不计。对于每个列表中元素较多的较大列表，人们可能希望使用它map而不是列表推导，但这完全取决于应用程序的需求。

但是我个人觉得列表推导比 更易读、更符合语法map。它是 Python 中事实上的标准。通常人们（尤其是初学者）使用列表推导比 更熟练、更自如map。

解决方案 7：

如果你不喜欢嵌套列表推导，你也可以使用map函数，

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

解决方案 8：

无需使用 for 循环即可解决此问题。单行代码就足够了。使用嵌套 Map 和 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]]

解决方案 9：

是的，你可以用这样的代码来实现：

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

解决方案 10：

如果需要扁平列表：

[y for x in l for y in x]

如果需要嵌套列表（列表中的列表）：

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

解决方案 11：

我认为实现此目的的最佳方法是使用 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]

解决方案 12：

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

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

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

解决方案 13：

是的，您可以执行以下操作。

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

解决方案 14：

from py_linq import Enumerable

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

# non-flattened
Enumerable(l).select(lambda ls: Enumerable(ls).select(lambda x: float(x)))

# flattened
Enumerable(l).select_many(lambda ls: Enumerable(ls).select(lambda x: float(x)))
相关推荐
置顶 政府信创国产化的10大政策解读
政府信创国产化的10大政策解读
  政府信创国产化的10大政策解读一、信创国产化的背景与意义信创国产化，即信息技术应用创新国产化，是当前中国信息技术领域的一个重要发展方向。其核心在于通过自主研发和创新，实现信息技术应用的自主可控，减少对外部技术的依赖，并规避潜在的技术制裁和风险。随着全球信息技术竞争的加剧，以及某些国家对中国在科技领域的打压，信创国产化显...
工程项目管理   1989  
置顶 2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
  为什么项目管理通常仍然耗时且低效？您是否还在反复更新电子表格、淹没在便利贴中并参加每周更新会议？这确实是耗费时间和精力。借助软件工具的帮助，您可以一目了然地全面了解您的项目。如今，国内外有足够多优秀的项目管理软件可以帮助您掌控每个项目。什么是项目管理软件？项目管理软件是广泛行业用于项目规划、资源分配和调度的软件。它使项...
项目管理软件   1446  
【行业前瞻】IT项目经理力推的2025年10款管理工具
【行业前瞻】IT项目经理力推的2025年10款管理工具
  在当今快速发展的IT行业中，项目管理工具的选择对于项目的成功至关重要。随着技术的不断进步，项目经理们需要更加高效、灵活的工具来应对复杂的项目需求。本文将介绍2025年IT项目经理力推的10款管理工具，帮助您在项目管理中取得更好的成果。信创国产项目管理软件 - 禅道禅道是一款国产开源的项目管理软件，禅道开源版不限人数，功...
项目管理工具   0  
【专业评测】项目管理软件风云榜：2025年10款工具谁主沉浮？
【专业评测】项目管理软件风云榜：2025年10款工具谁主沉浮？
  在当今快速变化的商业环境中，项目管理软件已成为企业提升效率、优化资源分配和确保项目成功的关键工具。随着技术的不断进步，市场上涌现出众多功能各异的项目管理工具，每一款都有其独特的优势和适用场景。本文将深入评测2025年最受欢迎的10款项目管理软件，帮助您根据自身需求做出明智的选择。信创国产项目管理软件 - 禅道禅道是一款...
项目管理平台   2  
如何通过PLM提升产品开发效率的7个关键步骤
如何通过PLM提升产品开发效率的7个关键步骤
  产品开发效率对于企业的竞争力至关重要。在当今复杂多变的商业环境中，如何有效提升产品开发效率成为众多企业关注的焦点。产品生命周期管理（PLM）作为一种整合产品全生命周期信息的管理理念和技术，为提升产品开发效率提供了有力的支持。通过合理运用PLM，企业能够优化流程、加强协作、提高数据管理水平，从而实现产品开发的高效运作。接...
plm开发流程软件   3  
热门文章
项目管理软件
政府信创国产化的10大政策解读
2025soft
2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
img020
使用 Python 'Requests' 模块的代理
img044
10个项目管理常见问题解答：包括难点和解决方法
项目管理软件
项目延期的原因有哪些？如何有效预防和管理？
项目里程碑计划模板
项目里程碑计划模板怎么写?设定项目里程碑的5个方法
项目管理软件
项目管理指南：制定项目实施计划的6大步骤有哪些？
项目管理软件有哪些？
热门标签
更多>
IPD流程 项目管理 plm项目管理软件 敏捷开发 项目管理软件 Scrum 敏捷项目管理 IPD流程管理 项目风险管理 项目管理工具 项目经理 极限编程  产品管理  项目经理职责 项目路线图 项目进度管理 团队管理 测试管理工具 项目预算管理 PMP认证 瀑布式管理 项目范围管理 IT科技 项目管理平台 工程项目管理 项目资源管理 pmp证书考试
云禅道AD
禅道项目管理软件

云端的项目管理软件

尊享禅道项目软件收费版功能

无需维护，随时随地协同办公

内置subversion和git源码管理

每天备份，随时转为私有部署

免费试用