# Transposing a 1D NumPy array

Each Answer to this Q is separated by one/two green lines.

I use Python and NumPy and have some problems with “transpose”:

``````import numpy as np
a = np.array([5,4])
print(a)
print(a.T)
``````

Invoking `a.T` is not transposing the array. If `a` is for example `[[],[]]` then it transposes correctly, but I need the transpose of `[...,...,...]`.

It’s working exactly as it’s supposed to. The transpose of a 1D array is still a 1D array! (If you’re used to matlab, it fundamentally doesn’t have a concept of a 1D array. Matlab’s “1D” arrays are 2D.)

If you want to turn your 1D vector into a 2D array and then transpose it, just slice it with `np.newaxis` (or `None`, they’re the same, `newaxis` is just more readable).

``````import numpy as np
a = np.array([5,4])[np.newaxis]
print(a)
print(a.T)
``````

Generally speaking though, you don’t ever need to worry about this. Adding the extra dimension is usually not what you want, if you’re just doing it out of habit. Numpy will automatically broadcast a 1D array when doing various calculations. There’s usually no need to distinguish between a row vector and a column vector (neither of which are vectors. They’re both 2D!) when you just want a vector.

Use two bracket pairs instead of one. This creates a 2D array, which can be transposed, unlike the 1D array you create if you use one bracket pair.

``````import numpy as np
a = np.array([[5, 4]])
a.T
``````

More thorough example:

``````>>> a = [3,6,9]
>>> b = np.array(a)
>>> b.T
array([3, 6, 9])         #Here it didn't transpose because 'a' is 1 dimensional
>>> b = np.array([a])
>>> b.T
array([,              #Here it did transpose because a is 2 dimensional
,
])
``````

Use numpy’s `shape` method to see what is going on here:

``````>>> b = np.array([10,20,30])
>>> b.shape
(3,)
>>> b = np.array([[10,20,30]])
>>> b.shape
(1, 3)
``````

For 1D arrays:

``````a = np.array([1, 2, 3, 4])
a = a.reshape((-1, 1)) # <--- THIS IS IT

print a
array([,
,
,
])
``````

Once you understand that -1 here means “as many rows as needed”, I find this to be the most readable way of “transposing” an array. If your array is of higher dimensionality simply use `a.T`.

You can convert an existing vector into a matrix by wrapping it in an extra set of square brackets…

``````from numpy import *
v=array([5,4]) ## create a numpy vector
array([v]).T ## transpose a vector into a matrix
``````

numpy also has a `matrix` class (see array vs. matrix)…

``````matrix(v).T ## transpose a vector into a matrix
``````

numpy 1D array –> column/row matrix:

``````>>> a=np.array([1,2,4])
>>> a[:, None]    # col
array([,
,
])
>>> a[None, :]    # row, or faster `a[None]`
array([[1, 2, 4]])
``````

And as @joe-kington said, you can replace `None` with `np.newaxis` for readability.

To ‘transpose’ a 1d array to a 2d column, you can use `numpy.vstack`:

``````>>> numpy.vstack(numpy.array([1,2,3]))
array([,
,
])
``````

It also works for vanilla lists:

``````>>> numpy.vstack([1,2,3])
array([,
,
])
``````

You can only transpose a 2D array. You can use `numpy.matrix` to create a 2D array. This is three years late, but I am just adding to the possible set of solutions:

``````import numpy as np
m = np.matrix([2, 3])
m.T
``````

instead use `arr[:,None]` to create column vector

Basically what the transpose function does is to swap the shape and strides of the array:

``````>>> a = np.ones((1,2,3))

>>> a.shape
(1, 2, 3)

>>> a.T.shape
(3, 2, 1)

>>> a.strides
(48, 24, 8)

>>> a.T.strides
(8, 24, 48)
``````

In case of 1D numpy array (rank-1 array) the shape and strides are 1-element tuples and cannot be swapped, and the transpose of such an 1D array returns it unchanged. Instead, you can transpose a “row-vector” (numpy array of shape `(1, n)`) into a “column-vector” (numpy array of shape `(n, 1)`). To achieve this you have to first convert your 1D numpy array into row-vector and then swap the shape and strides (transpose it). Below is a function that does it:

``````from numpy.lib.stride_tricks import as_strided

def transpose(a):
a = np.atleast_2d(a)
return as_strided(a, shape=a.shape[::-1], strides=a.strides[::-1])
``````

Example:

``````>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> transpose(a)
array([,
,
])

>>> a = np.arange(1, 7).reshape(2,3)
>>> a
array([[1, 2, 3],
[4, 5, 6]])

>>> transpose(a)
array([[1, 4],
[2, 5],
[3, 6]])
``````

Of course you don’t have to do it this way since you have a 1D array and you can directly reshape it into `(n, 1)` array by `a.reshape((-1, 1))` or `a[:, None]`. I just wanted to demonstrate how transposing an array works.

Another solution…. 🙂

``````import numpy as np

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

[1, 2, 4]

``````b = np.array([a]).T
``````

array([,
,
])

I am just consolidating the above post, hope it will help others to save some time:

The below array has `(2, )`dimension, it’s a 1-D array,

``````b_new = np.array([2j, 3j])
``````

There are two ways to transpose a 1-D array:

slice it with “np.newaxis” or none.!

``````print(b_new[np.newaxis].T.shape)
print(b_new[None].T.shape)
``````

other way of writing, the above without `T` operation.!

``````print(b_new[:, np.newaxis].shape)
print(b_new[:, None].shape)
``````

Wrapping [ ] or using np.matrix, means adding a new dimension.!

``````print(np.array([b_new]).T.shape)
print(np.matrix(b_new).T.shape)
``````

There is a method not described in the answers but described in the documentation for the `numpy.ndarray.transpose` method:

For a 1-D array this has no effect, as a transposed vector is simply the same vector. To convert a 1-D array into a 2D column vector, an additional dimension must be added. np.atleast2d(a).T achieves this, as does a[:, np.newaxis].

One can do:

``````import numpy as np
a = np.array([5,4])
print(a)
print(np.atleast_2d(a).T)
``````

Which (imo) is nicer than using `newaxis`.

The transpose of

``````x = [[0 1],
[2 3]]
``````

is

``````xT = [[0 2],
[1 3]]
``````

well the code is:

``````import numpy as np
a = [[0, 1],[2, 3]]
x = np.array(a);
np.transpose(x)
``````

Or the simple way:

``````x.T
``````

** Transposing a 1-D array returns an unchanged view of the original array. Try this for 1D array:

``````b = np.array([a])
``````

As some of the comments above mentioned, the transpose of 1D arrays are 1D arrays, so one way to transpose a 1D array would be to convert the array to a matrix like so:

``````np.transpose(a.reshape(len(a), 1))
``````

The name of the function in `numpy` is column_stack.

``````>>>a=np.array([5,4])
>>>np.column_stack(a)
array([[5, 4]])
``````

The way I’ve learned to implement this in a compact and readable manner for 1-D arrays, so far:

``````h = np.array([1,2,3,4,5])

v1 = np.vstack(h)
v2 = np.c_[h]

h1 = np.hstack(v1)
h2 = np.r_[v2[:,0]]
``````

numpy.r_ and numpy.c_ translate slice objects to concatenation along the first and second axis, respectively. Therefore the slicing v2[:,0] in transposing back the vertical array v2 into the horizontal array h2

numpy.vstack is equivalent to concatenation along the first axis after 1-D arrays of shape (N,) have been reshaped to (1,N). Rebuilds arrays divided by vsplit.

To transpose a 1-D array (flat array) as you have in your example, you can use the `np.expand_dims()` function:

``````>>> a = np.expand_dims(np.array([5, 4]), axis=1)
array([,
])
``````

`np.expand_dims()` will add a dimension to the chosen axis. In this case, we use `axis=1`, which adds a column dimension, effectively transposing your original flat array. The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .