Myujth

I would like to append to a new list all elements of an existing list of lists after a specific point

m = [[1,2,3],[4,5,10],[6,2,1]]
specific point = m[0][2]
newlist = [3,4,5,10,6,2,1]

You can put a conditional in your iteration and only add based on that condition. Once you hit that specific index, make your condition true. Something like this:

m = [[1,2,3],[4,5,10],[6,2,1]]
specific_point = (0,2)
newlist = [3,4,5,10,6,2,1]


output = 
for i in range(len(m)):
 for j in range(len(m[i])):
 if (i,j) < specific_point:
 continue

 output.append(m[i][j])

output:

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

Here's a couple of functional approaches for efficiently iterating over your data.

If sublists are evenly sized, and you know the index from where to begin extracting elements, use chain + islice:

from itertools import chain, islice
n = 3 # Sublist size.
i,j = 0,2
newlist = list(islice(chain.from_iterable(m), i*n + j, None))

If you don't know the size of your sublists in advance, you can use next to discard the first portion of your data.

V = chain.from_iterable(m)
next(v for v in V if v == m[i][j])
newlist = list(V)
newlist.insert(m[i][j], 0)

This assumes there is no identical value earlier in the sequence.

You can directly slice off the remainder of the first target list and then add on all subsequent elements, eg:

m = [[1,2,3],[4,5,10],[6,2,1]]
y, x = 0, 2
new_list = m[y][x:] + [v for el in m[y+1:] for v in el]
# [3, 4, 5, 10, 6, 2, 1]

why not flatten the initial list and go from there

flat_list = [item for sublist in m for item in sublist]

would return [1,2,3,4,5,10,6,2,1] so now you're really on flat_list[2:]

Most of the answers only work for this specific shape of nested list, but it's also possible to create a solution that works with any shape of nested list.

def flatten_from(sequence, path=):
 start = path.pop(0) if path else 0
 for item in sequence[start:]:
 if isinstance(item, (list, tuple)):
 yield from flatten_from(item, path)
 else:
 yield item

With the example from the question

>>> list(flatten_from([[1, 2, 3], [4, 5, 10], [6, 2, 1]], [0, 2]))
[3, 4, 5, 10, 6, 2, 1]

It also works with any shape and level of nesting of the input data

m = [[1], [[2], [3, 4, 5, 6, 7]], 8, [9, [10, 11]]]

flatten_from(m, )) # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
flatten_from(m, [2]) # 8, 9, 10, 11
flatten_from(m, [1, 1, 3]) # 6, 7, 8, 9, 10, 11

This is a bit of a bastard algorithm, though. On one hand, it uses nice functional programming concepts: recursion and yield.

On the other hand it relies on the side effect of mutating the path argument with list.pop, so it's not a pure function.

Below solution will work for your case where your array is restricted to list of list and the size of 'sublist' is consistent throughout i.e "3" in your case

m = [[1,2,3],[4,5,10],[6,2,1]] #input 2D array
a, b = 0, 2 #user input --> specific point a and b
flat_list_m = [item for firstlist in m for item in firstlist] #flat the 2D list
print (flat_list_m[len(m[0])*a+b:]) #print from specific position a and b, considering your sublist length is consistent throughout.

I hope this helps! :)