NumPy meshgrid()

The meshgrid() method takes two or more 1D arrays representing coordinate values and returns a rectangular grid of a pair of 2D arrays.

Example

import numpy as np

# 1D arrays as x and y coordinates 
x = np.array([1, 2, 3])
y = np.array([10, 20])

# create a 2D grid using meshgrid X, Y = np.meshgrid(x, y)
# print the created grid print("X values:\n", X) print("\nY values:\n", Y) ''' Output: X values: [[1 2 3] [1 2 3]] Y values: [[10 10 10] [20 20 20]] '''

Given two arrays x and y, meshgrid() returns an array of all possible coordinate points (xi, yi) for all xi in x and yi in y.


meshgrid() Syntax

The syntax of meshgrid() is:

numpy.meshgrid(*xi, copy = True, sparse = False, indexing = 'xy')

meshgrid() Argument

The meshgrid() method takes the following arguments:

  • *xi- 1D arrays representing the coordinates of a grid
  • indexing(optional)- specifies index of the grid ('xy'(Cartesian, default) or 'ij'(matrix) )
  • sparse(optional)- a bool value, if True a sparse grid is returned
  • copy(optional)- create a copy if True(default) and return view if False

meshgrid() Return Value

The meshgrid() method returns coordinate matrices from coordinate vectors.


Example 1: Create a 2-D Grid

import numpy as np

# create 1D arrays
x = np.array([1, 2, 3])
y = np.array([1, 2, 3])

# create a 2D grid using meshgrid X, Y = np.meshgrid(x, y)
# print the created grid print("X values:\n", X) print("Y values:\n", Y)

Output

X values:
[[1 2 3]
 [1 2 3]
 [1 2 3]]
Y values:
 [[1 1 1]
 [2 2 2]
 [3 3 3]]

The code creates a 2D grid where the values of X and Y represent the coordinates of the grid points.

The X array represents the x-coordinates of the grid points, where each row contains the same x values [1, 2, 3]. The Y array represents the y-coordinates of the grid points, where each column contains the same y values [1, 2, 3].

To visualize the result of meshgrid(), we can use matplotlib.

import numpy as np
import matplotlib.pyplot as plt

# create 1D arrays
x = np.array([1, 2, 3])
y = np.array([1, 2, 3])

# create a 2D grid using meshgrid X, Y = np.meshgrid(x, y)
# create a scatter plot plt.scatter(X, Y) # set labels and title plt.xlabel('X') plt.ylabel('Y') plt.title('meshgrid() to create grid') # show the plot plt.show()

Output

2D plot showing meshgrid in NumPy
2-D Grid Using NumPy Meshgrid

Example 2: Index in a 2-D Grid

In NumPy's meshgrid() method, the indexing parameter allows you to specify the indexing scheme used.

meshgrid() has two indexing options: 'xy' and 'ij'.

In the xy indexing approach, the first index refers to the row (y-coordinate) and the second index refers to the column (x-coordinate).

In the ij indexing approach, the first index refers to the column (i-coordinate) and the second index refers to the row (j-coordinate)

Lets look at an example.

import numpy as np

# create 1D arrays
x = np.array([1, 2, 3])
y = np.array([10, 20])

# using xy indexing in meshgrid
XX, YY = np.meshgrid(x, y, indexing='xy')
print("Using xy indexing:") print("XX values:\n", XX) print("YY values:\n", YY) print() # using ij indexing in meshgrid
XX, YY = np.meshgrid(x, y, indexing='ij')
print("Using ij indexing:") print("XX values:\n", XX) print("YY values:\n", YY)

Output

Using xy indexing:
XX values:
[[1 2 3]
 [1 2 3]]
YY values:
 [[10 10 10]
 [20 20 20]]

Using ij indexing:
XX values:
 [[1 1]
 [2 2]
 [3 3]]
YY values:
 [[10 20]
 [10 20]
 [10 20]]

With indexing='xy', the first array XX corresponds to the x-coordinates and the second array YY corresponds to the y-coordinates.

With indexing='ij', the first array XX corresponds to the i-coordinates and the second array YY corresponds to the j-coordinates.


Example 3: Using sparse Argument in meshgrid

You can create sparse output arrays to save memory and computation time.

import numpy as np

# create 1D arrays
x = np.array([1, 2, 4])
y = np.array([10, 20, 30, 40])

# create a grid XX, YY = np.meshgrid(x, y)
print("Grid: ") print("XX values:\n", XX) print("YY values:\n", YY)
# create a sparse grid XX, YY = np.meshgrid(x, y, sparse=True)
print("Sparse Grid: ") print("XX values:\n", XX) print("YY values:\n", YY)

Output

Grid: 
XX values:
[[1 2 4]
 [1 2 4]
 [1 2 4]
 [1 2 4]]
YY values:
 [[10 10 10]
 [20 20 20]
 [30 30 30]
 [40 40 40]]

Sparse Grid: 
XX values:
 [[1 2 4]]
YY values:
 [[10]
 [20]
 [30]
 [40]]

Related topics:

  • ogrid(): A NumPy function that creates a sparse multi-dimensional grid of values after you specify the start, stop, and step values for each dimension.
  • mgrid(): A NumPy function that creates a dense multi-dimensional grid of values after you specify the start, stop, and step values for each dimension.
Let's look at an example.

import numpy as np

# using mgrid to create a dense multi-dimensional grid mGridX, mGridY = np.mgrid[0:10:2, 0:5]
print('For mgrid,') print('X values:\n', mGridX) print('Y values:\n', mGridY)
# using ogrid to create an open multi-dimensional grid oGridX, oGridY = np.ogrid[0:10:2, 0:5]
print('\nFor ogrid,') print('X values:\n', oGridX) print('Y values:\n', oGridY)

Output

For mgrid,
X values:
[[0 0 0 0 0]
 [2 2 2 2 2]
 [4 4 4 4 4]
 [6 6 6 6 6]
 [8 8 8 8 8]] 
Y values:
 [[0 1 2 3 4]
 [0 1 2 3 4]
 [0 1 2 3 4]
 [0 1 2 3 4]
 [0 1 2 3 4]]

For ogrid,
X values:
[[0]
 [2]
 [4]
 [6]
 [8]] 
Y values:
 [[0 1 2 3 4]]

Our premium learning platform, created with over a decade of experience and thousands of feedbacks.

Learn and improve your coding skills like never before.

Try Programiz PRO
  • Interactive Courses
  • Certificates
  • AI Help
  • 2000+ Challenges