I would like to understand how one goes about manipulating the elements of a 2D array.

If I have for example:

```
a= ( a11 a12 a13 ) and b = (b11 b12 b13)
a21 a22 a23 b21 b22 b23
```

I have defined them in python as for example:

```
a=[[1,1],[2,1],[3,1]]
b=[[1,2],[2,2],[3,2]]
```

I saw that I cannot refer to `a[1][1]`

but to `a[1]`

which gives me a result of `[2,1]`

.
So, I don't understand how do I access the second row of these arrays? That would be `a21, a22, a23, b21, b22, b23`

?
And how would I do in order to multiply them as `c1 = a21*b21, c2 = a22*b22`

, etc ?

This question is related to
`python`

`list`

`multidimensional-array`

If you have this :

```
a = [[1, 1], [2, 1],[3, 1]]
```

You can easily access this by using :

```
print(a[0][2])
a[0][1] = 7
print(a)
```

Look carefully how many brackets does your array have. I met an example when function returned answer with extra bracket, like that:

```
>>>approx
array([[[1192, 391]],
[[1191, 409]],
[[1209, 438]],
[[1191, 409]]])
```

And this didn't work

```
>>> approx[1,1]
IndexError: index 1 is out of bounds for axis 1 with size 1
```

This could open the brackets:

```
>>> approx[:,0]
array([[1192, 391],
[1191, 409],
[1209, 438],
[1191, 409]])
```

Now it is possible to use an ordinary element access notation:

```
>>> approx[:,0][1,1]
409
```

`a[1][1]`

does work as expected. Do you mean a11 as the first element of the first row? Cause that would be a[0][0].

If you want do many calculation with 2d array, you should use NumPy array instead of nest list.

for your question, you can use:zip(*a) to transpose it:

```
In [55]: a=[[1,1],[2,1],[3,1]]
In [56]: zip(*a)
Out[56]: [(1, 2, 3), (1, 1, 1)]
In [57]: zip(*a)[0]
Out[57]: (1, 2, 3)
```

Seems to work here:

```
>>> a=[[1,1],[2,1],[3,1]]
>>> a
[[1, 1], [2, 1], [3, 1]]
>>> a[1]
[2, 1]
>>> a[1][0]
2
>>> a[1][1]
1
```

Source: Stackoverflow.com