slicing behaviour question of a list of lists

Question

I got a function like

def f():
    ...
    ...
    return [list1, list2]

this returns a list of lists

[[list1.item1,list1.item2,...],[list2.item1,list2.item2,...]]

now when I do the following:

for i in range(0,2):print f()[i][0:10]

it works and print the lists sliced

but if i do

print f()[0:2][0:10]

then it prints the lists ignoring the [0:10] slicing.

Is there any way to make the second form work or do I have to loop every time to get the desired result?

Answer 1

A pythonic loop would be:

for list in f()[0:2]:
    print list[0:10]

But depending on what you want to achieve, list comprehension might be even better.

Or you make use of Pythons map() function:

def print_sub(x):
    print x[0:10]

map(print_sub, f()[0:2])

One way or the other, there is no way to not iterate over the list and achieve the desired result.

Answer 2

The second slice slices the sequence returned from the first slice, so yes, you will have to loop somehow in order to slice within:

[x[0:10] for x in f()[0:2]]

Answer 3

The reason why these two behave differently is because f()[0:2][0:10] works like this:

1. f() gives you a list of lists.
2. [0:2] gives you a list containing the first two elements in the list of lists. Since the elements in the list of lists are lists, this is also a list of lists.
3. [0:10] gives you a list containing the first ten elements in the list of lists that was produced in step 2.

In other words, f()[0:2][0:10] starts with a list of lists, then takes a sublist of that list of lists (which is also a list of lists), and then takes a sublist of the second list of lists (which is also a list of lists).

In contrast, f()[i] actually extracts the i-th element out of your list of lists, which is just a simple list (not a list of lists). Then, when you apply [0:10], you are applying it to the simple list that you got from f()[i] and not to a list of lists.

The bottom line is that any solution that gives the desired behavior will have to access a single array element like [i] at some point, rather than working only with slices like [i:j].