# Single Line Nested For Loops

Wrote this function in python that transposes a matrix:

```    def transpose(m):
height = len(m)
width = len(m)
return [ [ m[i][j] for i in range(0, height) ] for j in range(0, width) ]
```

In the process I realized I don't fully understand how single line nested for loops execute. Please help me understand by answering the following questions:

1. What is the order in which this for loop executes?
2. If I had a triple nested for loop, what order would it execute?
3. What would be equal the equal unnested for loop?

Given,

```    [ function(i,j) for i,j in object ]
```
1. What type must object be in order to use this for loop structure?
2. What is the order in which i and j are assigned to elements in object?
3. Can it be simulated by a different for loop structure?
4. Can this for loop be nested with a similar or different structure for loop? And how would it look?

Additional information is appreciated as well.

The best source of information is the official Python tutorial on list comprehensions. List comprehensions are nearly the same as for loops (certainly any list comprehension can be written as a for-loop) but they are often faster than using a for loop.

Look at this longer list comprehension from the tutorial (the `if` part filters the comprehension, only parts that pass the if statement are passed into the final part of the list comprehension (here `(x,y)`):

```    >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
```

It's exactly the same as this nested for loop (and, as the tutorial says, note how the order of for and if are the same).

```    >>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
```

The major difference between a list comprehension and a for loop is that the final part of the for loop (where you do something) comes at the beginning rather than at the end.

What type must object be in order to use this for loop structure?

An iterable. Any object that can generate a (finite) set of elements. These include any container, lists, sets, generators, etc.

What is the order in which i and j are assigned to elements in object?

They are assigned in exactly the same order as they are generated from each list, as if they were in a nested for loop (for your first comprehension you'd get 1 element for i, then every value from j, 2nd element into i, then every value from j, etc.)

Can it be simulated by a different for loop structure?

```    [[ch for ch in word] for word in ("apple", "banana", "pear", "the", "hello")]