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

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

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 = [, , , , ]
result = []
for sublist in l:
for item in sublist:
result.append(item)

print(result)
``````

To Make A Single list from a Nested List in python we can simply do this :

``````from functools import reduce

some_list = [, [215, 383, 87], , , [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]`

``````from nltk import flatten

example_list = [1, [2, 3], 3]
flattened_list = flatten(example_list)
print(flattened_list)

``````

Output: [1, 2, 3, 3]

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

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

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

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

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.

``````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.

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

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

Use the pipe package

``````from pipe import chain

lst=[[1,2], [3,4], [5,6]]

list(lst|chain)
``````

[1, 2, 3, 4, 5, 6]

``````list1 = [[1,2,3], 2, 4,[4,5,6],[7,8,9]]
flat_list = []
for item in list1:
if type(item) == list:
flat_list = flat_list+item
else:
flat_list.append(item)
``````

output: [1, 2, 3, 2, 4, 4, 5, 6, 7, 8, 9]