# Convert a 1D array to a 2D array in numpy

## Question:

I want to convert a 1-dimensional array into a 2-dimensional array by specifying the number of columns in the 2D array. Something that would work like this:

``````> import numpy as np
> A = np.array([1,2,3,4,5,6])
> B = vec2matrix(A,ncol=2)
> B
array([[1, 2],
[3, 4],
[5, 6]])
``````

Does numpy have a function that works like my made-up function “vec2matrix”? (I understand that you can index a 1D array like a 2D array, but that isn’t an option in the code I have – I need to make this conversion.)

You want to `reshape` the array.

``````B = np.reshape(A, (-1, 2))
``````

where `-1` infers the size of the new dimension from the size of the input array.

Try something like:

``````B = np.reshape(A,(-1,ncols))
``````

You’ll need to make sure that you can divide the number of elements in your array by `ncols` though. You can also play with the order in which the numbers are pulled into `B` using the `order` keyword.

You have two options:

• If you no longer want the original shape, the easiest is just to assign a new shape to the array

``````a.shape = (a.size//ncols, ncols)
``````

You can switch the `a.size//ncols` by `-1` to compute the proper shape automatically. Make sure that `a.shape*a.shape=a.size`, else you’ll run into some problem.

• You can get a new array with the `np.reshape` function, that works mostly like the version presented above

``````new = np.reshape(a, (-1, ncols))
``````

When it’s possible, `new` will be just a view of the initial array `a`, meaning that the data are shared. In some cases, though, `new` array will be acopy instead. Note that `np.reshape` also accepts an optional keyword `order` that lets you switch from row-major C order to column-major Fortran order. `np.reshape` is the function version of the `a.reshape` method.

If you can’t respect the requirement `a.shape*a.shape=a.size`, you’re stuck with having to create a new array. You can use the `np.resize` function and mixing it with `np.reshape`, such as

``````>>> a =np.arange(9)
>>> np.resize(a, 10).reshape(5,2)
``````

You can use`flatten()` from the numpy package.

``````import numpy as np
a = np.array([[1, 2],
[3, 4],
[5, 6]])
a_flat = a.flatten()
print(f"original array: {a} nflattened array = {a_flat}")
``````

Output:

``````original array: [[1 2]
[3 4]
[5 6]]
flattened array = [1 2 3 4 5 6]
``````

Change 1D array into 2D array without using Numpy.

``````l = [i for i in range(1,21)]
part = 3
new = []
start, end = 0, part

while end <= len(l):
temp = []
for i in range(start, end):
temp.append(l[i])
new.append(temp)
start += part
end += part
print("new values:  ", new)

# for uneven cases
temp = []
while start < len(l):
temp.append(l[start])
start += 1
new.append(temp)
print("new values for uneven cases:   ", new)
``````
``````import numpy as np
array = np.arange(8)
print("Original array : n", array)
array = np.arange(8).reshape(2, 4)
print("New array : n", array)
``````

If your sole purpose is to convert a 1d array X to a 2d array just do:

``````X = np.reshape(X,(1, X.size))
``````
``````some_array.shape = (1,)+some_array.shape
``````

or get a new one

``````another_array = numpy.reshape(some_array, (1,)+some_array.shape)
``````

This will make dimensions +1, equals to adding a bracket on the outermost

There is a simple way as well, we can use the reshape function in a different way:

``````A_reshape = A.reshape(No_of_rows, No_of_columns)
``````

convert a 1-dimensional array into a 2-dimensional array by adding new axis.

``````a=np.array([10,20,30,40,50,60])

b=a[:,np.newaxis]--it will convert it to two dimension.
``````
Categories: questions
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.