Python中为循环嵌套的单行

我有一个物体看起来像这样：

obj = {
    "outer_list": [
        {
            "inner_list_1": ["string1", "string2"]
        },
        {
            "inner_list_2": ["string3", "string4"]
        }
    ]
}

result = []
for inner_object in obj['outer_list']:
    for my_str in inner_object['inner_list']:
        result.append(my_str)

我想创建一个由两个内部列表组合而成的新列表：

["string1", "string2", "string3", "string4"]

目前，我有这样的想法：

obj = {
    "outer_list": [
        {
            "inner_list_1": ["string1", "string2"]
        },
        {
            "inner_list_2": ["string3", "string4"]
        }
    ]
}

result = []
for inner_object in obj['outer_list']:
    for my_str in inner_object['inner_list']:
        result.append(my_str)

我想知道如何在一行中编写嵌套循环

result = [...]

---

Python中的嵌套表示法是我见过的最奇怪的。 它的构造[x代表y，z代表x代表y]

试试这个：

result = []
for inner_object in obj['outer_list']:
    for k in inner_object:
        result.extend(inner_object[k])

这是一条单行线：

result = [i for inner_object in obj['outer_list'] for v in inner_object.values() for i in v]

输出：

---

如果我必须在一行中完成，我可能会这样做

import itertools
result = list(itertools.chain.from_iterable([tuple(el.values())[0] for el in d['outer_list']]))

屈服

['string1', 'string2', 'string3', 'string4']

但是您已经提出的解决方案要好得多。

您可以使用itertools.chain.from\u iterables:

因此，鉴于：

obj = {
    "outer_list": [
        {
            "inner_list": ["string1", "string2"]
        },
        {
            "inner_list": ["string3", "string4"]
        }
    ]
}

obj = {
    "outer_list": [
        {
            "inner_list_1": ["string1", "string2"]
        },
        {
            "inner_list_2": ["string3", "string4"]
        }
    ]
}

这将返回：

['string1', 'string2', 'string3', 'string4']

['string1', 'string2', 'string3', 'string4']

或者，如果您希望为您在问题中发布的数据提供解决方案，其中每个子目录中内部列表的键以从1开始的递增数字结尾，则可以使用enumerate生成此类递增数字：

list(chain.from_iterable(d['inner_list_%d' % n] for n, d in enumerate(obj['outer_list'], 1)))

因此，鉴于：

obj = {
    "outer_list": [
        {
            "inner_list": ["string1", "string2"]
        },
        {
            "inner_list": ["string3", "string4"]
        }
    ]
}

obj = {
    "outer_list": [
        {
            "inner_list_1": ["string1", "string2"]
        },
        {
            "inner_list_2": ["string3", "string4"]
        }
    ]
}

这将返回：

['string1', 'string2', 'string3', 'string4']

['string1', 'string2', 'string3', 'string4']

---

您可以使用“理解”来执行此操作，但它会因内部对象的不同而存在一些风险：

resultList = [ stringVal for stringVal in x for x in y.values() for y in obj['outer_list']]
>>> resultList
['string3', 'string3', 'string4', 'string4']

您可以使用reduce来实现这一点

from functools import reduce
result = list(reduce(lambda x,y: x['inner_list']+y['inner_list'], obj['outer_list']))

[对象中的内部目录项[列表中的外部目录]列表中的项目内部目录值[0]]

列表理解由两部分组成：表达式和循环。您可以将列表理解视为listget_项的简写，其中get_项定义为

def get_items():
       loop:
            yield(expression)

在本例中，循环是

而表达式是项

因此，列表理解的格式是首先写下在本例中产生的内容，item，然后写循环，循环迭代以获得这些结果

如果您愿意，您可以尝试：

def get_items():              
   for inner_dict in obj["outer_list"]:
       for item in list(inner_dict.values())[0]:
           yield(item)
list(get_items())

循环也可以写成

for inner_dict in obj["outer_list"]:
    for inner_list in list(inner_dict.values()):
        for item in inner_list:
            yield(item)

这将导致列表的理解

---

[obj中的内部目录项[outer_list]中的内部目录项[outer_list]中的内部目录项。内部目录项的值]

可以在一行中完成，但无法读取。有不同的键，它不是内部目录项。OP提出的真正问题是如何将嵌套循环重写为一行，嵌套循环有一个固定的子目录键。非常好的解决方案！关于不同的键，您仍然可以用双循环字典值替换它，它适用于静态字典模式的任何示例：listchain.from_iterableval for d in obj['outer_list']for val in d.values我已经用OP中给定输入数据的解决方案更新了我的答案，其中，内部列表的键以递增的数字结尾。内部列表编号为：内部列表1和内部列表2。尝试在密钥内部_列表中馈送无效。您必须从最大到最小，而不是从最小到最大：[stringVal for y in obj['outer_list']for x in y.stringVal in x的值]