You can use np.mgrid for this, it's often more convenient than np.meshgrid because it creates the arrays in one step:
import numpy as np
X,Y = np.mgrid[-5:5.1:0.5, -5:5.1:0.5]
For linspace-like functionality, replace the step (i.e. 0.5) with a complex number whose magnitude specifies the number of points you want in the series. Using this syntax, the same arrays as above are specified as:
X, Y = np.mgrid[-5:5:21j, -5:5:21j]
You can then create your pairs as:
xy = np.vstack((X.flatten(), Y.flatten())).T
As @ali_m suggested, this can all be done in one line:
xy = np.mgrid[-5:5.1:0.5, -5:5.1:0.5].reshape(2,-1).T
Best of luck!
Answer from farenorth on Stack OverflowNumPy
numpy.org › doc › stable › reference › generated › numpy.arange.html
numpy.arange — NumPy v2.4 Manual
The built-in range generates Python built-in integers that have arbitrary size, while numpy.arange produces numpy.int32 or numpy.int64 numbers. This may result in incorrect results for large integer values: >>> power = 40 >>> modulo = 10000 >>> x1 = [(n ** power) % modulo for n in range(8)] >>> x2 = [(n ** power) % modulo for n in np.arange(8)] >>> print(x1) [0, 1, 7776, 8801, 6176, 625, 6576, 4001] # correct >>> print(x2) [0, 1, 7776, 7185, 0, 5969, 4816, 3361] # incorrect
Top answer 1 of 13
117
You can use np.mgrid for this, it's often more convenient than np.meshgrid because it creates the arrays in one step:
import numpy as np
X,Y = np.mgrid[-5:5.1:0.5, -5:5.1:0.5]
For linspace-like functionality, replace the step (i.e. 0.5) with a complex number whose magnitude specifies the number of points you want in the series. Using this syntax, the same arrays as above are specified as:
X, Y = np.mgrid[-5:5:21j, -5:5:21j]
You can then create your pairs as:
xy = np.vstack((X.flatten(), Y.flatten())).T
As @ali_m suggested, this can all be done in one line:
xy = np.mgrid[-5:5.1:0.5, -5:5.1:0.5].reshape(2,-1).T
Best of luck!
2 of 13
50
This is just what you are looking for:
matr = np.linspace((1,2),(10,20),10)
This means:
For the first column; from 1 of (1,2) to 10 of (10,20), put the increasing 10 numbers.
For the second column; from 2 of (1,2) to 20 of (10,20), put the incresing 10 numbers.
And the result will be:
[[ 1. 2.]
[ 2. 4.]
[ 3. 6.]
[ 4. 8.]
[ 5. 10.]
[ 6. 12.]
[ 7. 14.]
[ 8. 16.]
[ 9. 18.]
[10. 20.]]
You may also keep only one column's values increasing, for example, if you say that:
matr = np.linspace((1,2),(1,20),10)
The first column will be from 1 of (1,2) to 1 of (1,20) for 10 times which means that it will stay as 1 and the result will be:
[[ 1. 2.]
[ 1. 4.]
[ 1. 6.]
[ 1. 8.]
[ 1. 10.]
[ 1. 12.]
[ 1. 14.]
[ 1. 16.]
[ 1. 18.]
[ 1. 20.]]
DataCamp
campus.datacamp.com › courses › introduction-to-python-for-finance › arrays-in-python
2D arrays and functions | Python
Another useful numpy function is arange(). You can use arange() to create an array of continuous numbers as shown here. The function arange() creates a numeric array given a start, end, and an optional step argument. Thus, arange with inputs 1 and 13 would create an array consisting of numbers ...
Real Python
realpython.com › how-to-use-numpy-arange
NumPy arange(): How to Use np.arange() – Real Python
July 31, 2023 - In this step-by-step tutorial, you'll learn how to use the NumPy arange() function, which is one of the routines for array creation based on numerical ranges. np.arange() returns arrays with evenly spaced values.
Finxter
blog.finxter.com › numpy-arange
NumPy arange(): A Simple Illustrated Guide – Be on the Right Side of Change
NumPy is mostly about multi-dimensional matrices. It is common to create a 1D NumPy array with the NumPy arange function and to transform it immediately into a 2D array using the np.reshape() function.
Top answer 1 of 4
5
To do the first one with numpy:
>>> a = np.arange(11)
>>> a[:,None]+a
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
[ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
[ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
[ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
[ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
[ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
[ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
[ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]])
For the second array, @Divakar has a good approach. Maybe a bit simpler syntax to do this:
>>> (a%a[:,None])==0
array([[ True, True, True, True, True, True, True, True, True, True, True],
[ True, True, True, True, True, True, True, True, True, True, True],
[ True, False, True, False, True, False, True, False, True, False, True],
[ True, False, False, True, False, False, True, False, False, True, False],
[ True, False, False, False, True, False, False, False, True, False, False],
[ True, False, False, False, False, True, False, False, False, False, True],
[ True, False, False, False, False, False, True, False, False, False, False],
[ True, False, False, False, False, False, False, True, False, False, False],
[ True, False, False, False, False, False, False, False, True, False, False],
[ True, False, False, False, False, False, False, False, False, True, False],
[ True, False, False, False, False, False, False, False, False, False, True]], dtype=bool)
2 of 4
4
Per your first question:
np.add(*np.indices((nrow, ncol)))
For nrow=5, ncol=6 you get
array([[0, 1, 2, 3, 4, 5],
[1, 2, 3, 4, 5, 6],
[2, 3, 4, 5, 6, 7],
[3, 4, 5, 6, 7, 8],
[4, 5, 6, 7, 8, 9]])
This method doesn't use the numpy.arange function, though I find it more readable. Moreover, it supports cases when nrow != ncol.
Python Guides
pythonguides.com › python-numpy-2d-array
Create A 2D NumPy Array In Python (5 Simple Methods)
May 16, 2025 - import numpy as np # Create a 1D array with sequential numbers numbers = np.arange(12) # Creates [0, 1, 2, ..., 11] # Reshape it into a 2D array reshaped_array = numbers.reshape(4, 3) # You can also do this in one step direct_reshaped = np.arange(15).reshape(3, 5) print("Original 1D array:", numbers) print("\nReshaped to 2D (4×3):\n", reshaped_array) print("\nDirect reshape (3×5):\n", direct_reshaped)
Medium
medium.com › @bouimouass.o › what-does-a-numpy-2d-array-look-like-in-python-38752ccde895
What does a numpy 2D array look like in python? | by Omar | Medium
July 23, 2023 - For example, the following code creates a 2D NumPy array with 3 rows and 4 columns using the arange() and reshape() functions: import numpy as np # Create a sequence of numbers numbers = np.arange(12) # Reshape the sequence into a 2D array array = numbers.reshape(3, 4) # Print the array print(array)
GeeksforGeeks
geeksforgeeks.org › numpy-arrange-in-python
numpy.arange() in Python - GeeksforGeeks
January 24, 2025 - numpy.arange() function creates an array of evenly spaced values within a given interval. It is similar to Python's built-in range() function but returns a NumPy array instead of a list.
NumPy
numpy.org › devdocs › user › quickstart.html
NumPy quickstart — NumPy v2.5.dev0 Manual
>>> a = np.arange(6) # 1d array >>> print(a) [0 1 2 3 4 5] >>> >>> b = np.arange(12).reshape(4, 3) # 2d array >>> print(b) [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] >>> >>> c = np.arange(24).reshape(2, 3, 4) # 3d array >>> print(c) [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]] See below to get more details on reshape.
Note.nkmk.me
note.nkmk.me › home › python › numpy
NumPy: arange() and linspace() to generate evenly spaced values | note.nkmk.me
February 2, 2024 - Like range(), np.arange() generates an ndarray with evenly spaced values according to the specified arguments:
w3resource
w3resource.com › python-exercises › numpy › basic › numpy-basic-exercise-46.php
NumPy: Create a two-dimensional array of specified format - w3resource
print(np.arange(1, 151).reshape(15, -1)): This statement creates a NumPy array with integers from 1 to 150. It then reshapes it into a matrix with 15 rows, and the number of columns is inferred automatically (indicated by -1). In this case, ...
Top answer 1 of 4
5
You can use numpy.mgrid or numpy.meshgrid():
np.mgrid[0:6, 0:6]
# array([[[0, 0, 0, 0, 0, 0],
# [1, 1, 1, 1, 1, 1],
# [2, 2, 2, 2, 2, 2],
# [3, 3, 3, 3, 3, 3],
# [4, 4, 4, 4, 4, 4],
# [5, 5, 5, 5, 5, 5]],
#
# [[0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5]]])
np.meshgrid(np.arange(6), np.arange(6))
# [array([[0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5],
# [0, 1, 2, 3, 4, 5]]),
# array([[0, 0, 0, 0, 0, 0],
# [1, 1, 1, 1, 1, 1],
# [2, 2, 2, 2, 2, 2],
# [3, 3, 3, 3, 3, 3],
# [4, 4, 4, 4, 4, 4],
# [5, 5, 5, 5, 5, 5]])]
and simply unpack the result
a, b = np.mgrid[0:6, 0:6]
2 of 4
4
You just need numpy.reshape and numpy.repeat. Use this:
import numpy as np
n_columns = 6
a = np.repeat(np.arange(6), n_columns)
a = a.reshape(6,n_columns)
array([[0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1],
[2, 2, 2, 2, 2, 2],
[3, 3, 3, 3, 3, 3],
[4, 4, 4, 4, 4, 4],
[5, 5, 5, 5, 5, 5]])
b = a.T
array([[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5]])
This code will work for any n_columns value.
Our Coding Club
ourcodingclub.github.io › tutorials › numpy
Numbers in Python with NumPy
You can create 2D, 3D or any-D arrays, by creating a 1D array, and reshaping it. Try entering the code below in Python. a = np.arange(9.0).reshape(3,3) print(a.shape) a will be a 2D array of size 3x3. The rows will be [0., 1., 2.], [3., 4., 5.], [6., 7., 8.]. The print statement should return a tuple (3, 3).
w3resource
w3resource.com › python-exercises › numpy › python-numpy-exercise-74.php
NumPy: Combine a one and a two dimensional array together and display their elements - w3resource
np.arange(8).reshape(2,4): This line creates a 1D NumPy array with integers from 0 to 7 and then reshapes it into a 2x4 2D array y.
NumPy
numpy.org › doc › 2.1 › reference › generated › numpy.arange.html
numpy.arange — NumPy v2.1 Manual
The built-in range generates Python built-in integers that have arbitrary size, while numpy.arange produces numpy.int32 or numpy.int64 numbers. This may result in incorrect results for large integer values: >>> power = 40 >>> modulo = 10000 >>> x1 = [(n ** power) % modulo for n in range(8)] >>> x2 = [(n ** power) % modulo for n in np.arange(8)] >>> print(x1) [0, 1, 7776, 8801, 6176, 625, 6576, 4001] # correct >>> print(x2) [0, 1, 7776, 7185, 0, 5969, 4816, 3361] # incorrect
Note.nkmk.me
note.nkmk.me › home › python
Convert 1D Array to 2D Array in Python (numpy.ndarray, list) | note.nkmk.me
May 15, 2023 - import numpy as np a = np.arange(6) print(a) # [0 1 2 3 4 5] print(a.reshape(2, 3)) # [[0 1 2] # [3 4 5]] print(a.reshape(-1, 3)) # [[0 1 2] # [3 4 5]] print(a.reshape(2, -1)) # [[0 1 2] # [3 4 5]]
CodingNomads
codingnomads.com › arrays-in-numpy-ndarray
Arrays in NumPy: ndarray, np.empty, np.arange, np.linspace
There are a number of ways to create NumPy arrays, for example, from simply passing it a Python list (like we did above) to using automatic methods such as arange, linspace, etc. Let's go over some examples: # already did this a = np.array([1, 2, 3, 4, 5]) # now using floats b = np.array([1.0, 2.0, 3.0, 4.0, 5.0]) print(b.dtype) # 2D array multi_list_a = np.array([[1, 2, 3], [4, 5, 6]]) print(multi_list_a) print() # 2D array but with floats and using tuples multi_list_b = np.array([(1.5, 2.1, 3), (4, 5, 6)]) print(multi_list_b)
NumPy
numpy.org › doc › stable › user › quickstart.html
NumPy quickstart — NumPy v2.4 Manual
>>> a = np.arange(6) # 1d array >>> print(a) [0 1 2 3 4 5] >>> >>> b = np.arange(12).reshape(4, 3) # 2d array >>> print(b) [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] >>> >>> c = np.arange(24).reshape(2, 3, 4) # 3d array >>> print(c) [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]] See below to get more details on reshape.
NumPy
numpy.org › doc › 2.0 › reference › generated › numpy.ma.arange.html
numpy.ma.arange — NumPy v2.0 Manual
The built-in range generates Python built-in integers that have arbitrary size, while numpy.arange produces numpy.int32 or numpy.int64 numbers. This may result in incorrect results for large integer values: >>> power = 40 >>> modulo = 10000 >>> x1 = [(n ** power) % modulo for n in range(8)] >>> x2 = [(n ** power) % modulo for n in np.arange(8)] >>> print(x1) [0, 1, 7776, 8801, 6176, 625, 6576, 4001] # correct >>> print(x2) [0, 1, 7776, 7185, 0, 5969, 4816, 3361] # incorrect