單行嵌套在Python中的循環

Question

我有一個看起來像這樣的對象：

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

我想創建一個包含兩個內部列表的新列表：

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

目前，我有這樣的事情：

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

我想知道如何在一行中編寫該嵌套循環。

result = [...]

Answer 1

您可以使用itertools.chain.from_iterables ：

from itertools import chain
list(chain.from_iterable(d['inner_list'] for d in obj['outer_list']))

因此，給定：

obj = {
    "outer_list": [
        {
            "inner_list": ["string1", "string2"]
        },
        {
            "inner_list": ["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_1": ["string1", "string2"]
        },
        {
            "inner_list_2": ["string3", "string4"]
        }
    ]
}

返回：

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

Answer 2

Python中的嵌套符號是我見過的最奇怪的符號。 它的構造[x for y in z for x in y]

result = [ my_str for  inner_object in obj['outer_list'] for my_str in inner_object ['inner_list']]

Answer 3

嘗試這個 ：

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]

輸出 ：

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

Answer 4

如果我不得不一行來做，那么我可能會這樣做。

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

產量

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

但是您已經想出的解決方案要好得多。

Answer 5

您可以使用理解來做到這一點，但它會因內部對象而帶來一些風險：

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

Answer 6

您可以使用reduce來實現

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

Answer 7

[item for inner_dict in obj["outer_list"] for item in list(inner_dict.values())[0]]

列表理解由兩部分組成：表達式和循環。 您可以認為列表理解是list(get_items())簡寫，其中get_items定義為

def get_items():
       loop:
            yield(expression)

在這種情況下， loop是

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

expression是item 。

因此，列表推導的格式是首先編寫要yield （在本例中為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)

這會導致列表理解

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