问题
I tried everything (in my knowledge) from splitting the array and joining them up together and even using itertools:
import itertools
def oneDArray(x):
return list(itertools.chain(*x))
The result I want:
a) print oneDArray([1,[2,2,2],4]) == [1,2,2,2,4]
Strangely, it works for
b) print oneDArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [1, 2, 3, 4, 5, 6, 7, 8, 9]
Question 1) How do I get part a to work the way I want (any hints?)
Question 2) Why does the following code above work for part b and not part a??
回答1:
You need to recursively loop over the list and check if an item is iterable(strings are iterable too, but skip them) or not.
itertools.chain will not work for [1,[2,2,2],4] because it requires all of it's items to be iterable, but 1 and 4 (integers) are not iterable. That's why it worked for the second one because it's a list of lists.
>>> from collections import Iterable
def flatten(lis):
for item in lis:
if isinstance(item, Iterable) and not isinstance(item, str):
for x in flatten(item):
yield x
else:
yield item
>>> lis = [1,[2,2,2],4]
>>> list(flatten(lis))
[1, 2, 2, 2, 4]
>>> list(flatten([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Works for any level of nesting:
>>> a = [1,[2,2,[2]],4]
>>> list(flatten(a))
[1, 2, 2, 2, 4]
Unlike other solutions, this will work for strings as well:
>>> lis = [1,[2,2,2],"456"]
>>> list(flatten(lis))
[1, 2, 2, 2, '456']
回答2:
If you're using python < 3 then you can do the following:
from compiler.ast import flatten
list = [1,[2,2,2],4]
print flatten(list)
The manual equivalent in python 3.0 would be (taken from this answer):
def flatten(x):
result = []
for el in x:
if hasattr(el, "__iter__") and not isinstance(el, str):
result.extend(flatten(el))
else:
result.append(el)
return result
print(flatten(["junk",["nested stuff"],[],[[]]]))
You could even do the same in a list comprehension:
list = [1,[2,2,2],4]
l = [item for sublist in list for item in sublist]
Which is the equivalent of:
l = [[1], [2], [3], [4], [5]]
result = []
for sublist in l:
for item in sublist:
result.append(item)
print(result)
回答3:
To Make A Single list from a Nested List in python we can simply do this :
from functools import reduce
some_list = [[14], [215, 383, 87], [298], [374], [2,3,4,5,6,7]]
single_list = reduce(lambda x,y: x+y, some_list)
print(single_list)
Output:
[14, 215, 383, 87, 298, 374, 2, 3, 4, 5, 6, 7]
回答4:
itertools.chain() iterates through each item in the inputted list (refer to the docs I linked). Because you can't iterate through integers, the error is raised. That is why in the second example, you only have lists in the list and no integers alone, thus no integers are actually being iterated through.
To get it working, you can use recursion:
>>> from collections import Iterable
>>> def flat(lst):
... for parent in lst:
... if not isinstance(i, Iterable):
... yield parent
... else:
... for child in flat(parent):
... yield child
...
>>> list(flat(([1,[2,2,2],4]))
[1, 2, 2, 2, 4]
回答5:
Use more_itertools
import more_itertools
nested_test1 = [[-1, -2], [1, 2, 3, [4, (5, [6, 7])]], (30, 40), [25, 35]]
nested_test2 = [1,[2,2,2],4]
lis = [1,[2,2,2],"456"]
print(list(more_itertools.collapse(nested_test1)))
print(list(more_itertools.collapse(nested_test2)))
print(list(more_itertools.collapse(lis)))
OUTPUT
[-1, -2, 1, 2, 3, 4, 5, 6, 7, 30, 40, 25, 35]
[1, 2, 2, 2, 4]
[1, 2, 2, 2, '456']
回答6:
It's actually quite easy without using itertools, you can simply iterate over a list and if the loop will encounter another list you will simply iterate over nested list. Here's the code:
def flatten(l):
flatList = []
for elem in l:
# if an element of a list is a list
# iterate over this list and add elements to flatList
if type(elem) == list:
for e in elem:
flatList.append(e)
else:
flatList.append(elem)
return flatList
a = [1,[2,2,2],4] # flatten(a) returns [1, 2, 2, 2, 4]
b = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # flatten(b) returns [1, 2, 3, 4, 5, 6, 7, 8, 9]
回答7:
If it is going to be only one level of list of lists, then the simplest solution is:
lis = [1,[2,2,2],"456"]
output = []
for item in lis:
if isinstance(item, (str, int, bool)):
output.append(item)
elif isinstance(item, dict):
for i in item.items():
output.extend(i)
else:
output.extend(list(item))
Why I used extend(list(item)) is that even if there is a set within your items, it will not cause any problem. This will handle items as string, integer, boolean, dictionary, list as well as a tuple.
回答8:
You may want to have a look here: http://caolanmcmahon.com/posts/flatten_for_python/ http://rightfootin.blogspot.de/2006/09/more-on-python-flatten.html
回答9:
old_list = [1,2,3,['a','b'],4,5,6,['c','d',[11,22,33,'aa','bb','cc',[111,222,333,['aaa','bbb','ccc',[1111,2222,['aaaa','bbbb',[11111,22222]]]]]],'e']]
new_list = []
def my_fun(temp_list):
for ele in temp_list:
if type(ele) == list:
my_fun(ele)
else:
new_list.append(ele)
my_fun(old_list)
print old_list
print new_list
output:
old_list = [1, 2, 3, ['a', 'b'], 4, 5, 6, ['c', 'd', [11, 22, 33, 'aa', 'bb', 'cc', [111, 222, 333, ['aaa', 'bbb', 'ccc', [1111, 2222, ['aaaa', 'bbbb', [11111, 22222]]]]]], 'e']]
new_list = [1, 2, 3, 'a', 'b', 4, 5, 6, 'c', 'd', 11, 22, 33, 'aa', 'bb', 'cc', 111, 222, 333, 'aaa', 'bbb', 'ccc', 1111, 2222, 'aaaa', 'bbbb', 11111, 22222, 'e']
Use recursion to convert multi nested list into single sliced list.
回答10:
from nltk import flatten
example_list = [1, [2, 3], 3]
flattened_list = flatten(example_list)
print(flattened_list)
Output: [1, 2, 3, 3]
回答11:
def flatten_out_nested_list(input_list):
if input_list is None:
return None
if not isinstance(input_list, (list, tuple)):
return None
flattened_list = []
for entry in input_list:
entry_list = None
if not isinstance(entry, list):
try:
entry_list = ast.literal_eval(entry)
except:
pass
if not entry_list:
entry_list = entry
if isinstance(entry_list, list):
flattened_entry = flatten_out_nested_list(entry_list)
if flattened_entry:
flattened_list.extend(flattened_entry)
else:
flattened_list.append(entry)
return flattened_list
nested_list = [[1,2,3,4,5],[6,7,8,9,10]]
flattened_list = flatten_out_nested_list(nested_list)
OUTPUT: [1,2,3,4,5,6,7,8,9,10]
回答12:
This flatten_nlevel function will flatten or converts the n-level nested list to one level. Try this out
def flatten_nlevel(list1, flat_list):
for sublist in list1:
if isinstance(sublist, type(list)):
flatten(sublist, flat_list)
else:
flat_list.append(sublist)
list1 = [1,[1,[2,3,[4,6]],4],5]
items = []
flatten(l,items)
print(items)
output:
[1, 1, 2, 3, 4, 6, 4, 5]
回答13:
You don't have to use append. just use extend
def flatten(nasted_list):
"""
input: nasted_list - this contain any number of nested lists.
------------------------
output: list_of_lists - one list contain all the items.
"""
list_of_lists = []
for item in nasted_list:
list_of_lists.extend(item)
return list_of_lists
test1 = flatten([[1,2,3],[4,5,6]])
print(test1)
output:
[1, 2, 3, 4, 5, 6]
来源：https://stackoverflow.com/questions/17485747/how-to-convert-a-nested-list-into-a-one-dimensional-list-in-python