La función numpy.meshgrid se utiliza para crear una cuadrícula rectangular a partir de dos arrays unidimensionales dadas que representan la indexación cartesiana o la indexación matricial. La función Meshgrid está algo inspirada en MATLAB.
Considere la figura anterior con un eje X que va de -4 a 4 y un eje Y que va de -5 a 5. Por lo tanto, hay un total de (9 * 11) = 99 puntos marcados en la figura, cada uno con una coordenada X y una coordenada Y. Para cualquier línea paralela al eje X, las coordenadas X de los puntos marcados son respectivamente -4, -3, -2, -1, 0, 1, 2, 3, 4. Por otro lado, para cualquier línea paralelas al eje Y, las coordenadas Y de los puntos marcados de abajo hacia arriba son -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5. El numpy. La función meshgrid devuelve dos arrays bidimensionales que representan las coordenadas X e Y de todos los puntos.
Ejemplos:
Input : x = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
y = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
Output :
x_1 = array([[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.],
[-4., -3., -2., -1., 0., 1., 2., 3., 4.]])
y_1 = array([[-5., -5., -5., -5., -5., -5., -5., -5., -5.],
[-4., -4., -4., -4., -4., -4., -4., -4., -4.],
[-3., -3., -3., -3., -3., -3., -3., -3., -3.],
[-2., -2., -2., -2., -2., -2., -2., -2., -2.],
[-1., -1., -1., -1., -1., -1., -1., -1., -1.],
[ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[ 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[ 2., 2., 2., 2., 2., 2., 2., 2., 2.],
[ 3., 3., 3., 3., 3., 3., 3., 3., 3.],
[ 4., 4., 4., 4., 4., 4., 4., 4., 4.],
[ 5., 5., 5., 5., 5., 5., 5., 5., 5.]])
Input : x = [0, 1, 2, 3, 4, 5]
y = [2, 3, 4, 5, 6, 7, 8]
Output :
x_1 = 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.],
[0., 1., 2., 3., 4., 5.]])
y_1 = array([[2., 2., 2., 2., 2., 2.],
[3., 3., 3., 3., 3., 3.],
[4., 4., 4., 4., 4., 4.],
[5., 5., 5., 5., 5., 5.],
[6., 6., 6., 6., 6., 6.],
[7., 7., 7., 7., 7., 7.],
[8., 8., 8., 8., 8., 8.]]
A continuación se muestra el código:
Python3
# Sample code for generation of first example
import numpy as np
# from matplotlib import pyplot as plt
# pyplot imported for plotting graphs
x = np.linspace(-4, 4, 9)
# numpy.linspace creates an array of
# 9 linearly placed elements between
# -4 and 4, both inclusive
y = np.linspace(-5, 5, 11)
# The meshgrid function returns
# two 2-dimensional arrays
x_1, y_1 = np.meshgrid(x, y)
print("x_1 = ")
print(x_1)
print("y_1 = ")
print(y_1)
x_1 = [[-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.] [-4. -3. -2. -1. 0. 1. 2. 3. 4.]] y_1 = [[-5. -5. -5. -5. -5. -5. -5. -5. -5.] [-4. -4. -4. -4. -4. -4. -4. -4. -4.] [-3. -3. -3. -3. -3. -3. -3. -3. -3.] [-2. -2. -2. -2. -2. -2. -2. -2. -2.] [-1. -1. -1. -1. -1. -1. -1. -1. -1.] [ 0. 0. 0. 0. 0. 0. 0. 0. 0.] [ 1. 1. 1. 1. 1. 1. 1. 1. 1.] [ 2. 2. 2. 2. 2. 2. 2. 2. 2.] [ 3. 3. 3. 3. 3. 3. 3. 3. 3.] [ 4. 4. 4. 4. 4. 4. 4. 4. 4.] [ 5. 5. 5. 5. 5. 5. 5. 5. 5.]]
La salida de coordenadas por meshgrid también se puede usar para trazar funciones dentro del rango de coordenadas dado.
una elipse:
*** QuickLaTeX cannot compile formula: *** Error message: Error: Nothing to show, formula is empty
Python3
ellipse = xx * 2 + 4 * yy**2 plt.contourf(x_1, y_1, ellipse, cmap = 'jet') plt.colorbar() plt.show()
Producción:
Datos aleatorios:
Python3
random_data = np.random.random((11, 9)) plt.contourf(x_1, y_1, random_data, cmap = 'jet') plt.colorbar() plt.show()
Producción:
Una función seno:
*** QuickLaTeX cannot compile formula: *** Error message: Error: Nothing to show, formula is empty
Python3
sine = (np.sin(x_1**2 + y_1**2))/(x_1**2 + y_1**2) plt.contourf(x_1, y_1, sine, cmap = 'jet') plt.colorbar() plt.show()
Producción:
Observamos que x_1 es una array repetida por filas mientras que y_1 es una array repetida por columnas. Una fila de x_1 y una columna de y_1 son suficientes para determinar las posiciones de todos los puntos, ya que los demás valores se repetirán una y otra vez. Entonces podemos editar el código anterior de la siguiente manera:
x_1, y_1 = np.meshgrid(x, y, sparse = True)
Esto producirá el siguiente resultado:
x_1 = [[-4. -3. -2. -1. 0. 1. 2. 3. 4.]] y_1 = [[-5.] [-4.] [-3.] [-2.] [-1.] [ 0.] [ 1.] [ 2.] [ 3.] [ 4.] [ 5.]]
La forma de x_1 cambió de (11, 9) a (1, 9) y la de y_1 cambió de (11, 9) a (11, 1)
. Sin embargo, la indexación de Matrix es diferente. En realidad, es exactamente lo contrario de la indexación cartesiana.
Para la array que se muestra arriba, para una fila dada, la coordenada Y aumenta como 0, 1, 2, 3 de izquierda a derecha, mientras que para una columna dada, la coordenada X aumenta de arriba a abajo como 0, 1, 2.
Los dos 2- Los arreglos dimensionales devueltos por la indexación de Matrix serán la transposición de los arreglos generados por el programa anterior. El siguiente código se puede utilizar para obtener la indexación de Matrix:
Python3
# Sample code for generation of Matrix indexing
import numpy as np
x = np.linspace(-4, 4, 9)
# numpy.linspace creates an array
# of 9 linearly placed elements between
# -4 and 4, both inclusive
y = np.linspace(-5, 5, 11)
# The meshgrid function returns
# two 2-dimensional arrays
x_1, y_1 = np.meshgrid(x, y)
x_2, y_2 = np.meshgrid(x, y, indexing = 'ij')
# The following 2 lines check if x_2 and y_2 are the
# transposes of x_1 and y_1 respectively
print("x_2 = ")
print(x_2)
print("y_2 = ")
print(y_2)
# np.all is Boolean and operator;
# returns true if all holds true.
print(np.all(x_2 == x_1.T))
print(np.all(y_2 == y_1.T))
x_2 = [[-4. -4. -4. -4. -4. -4. -4. -4. -4. -4. -4.] [-3. -3. -3. -3. -3. -3. -3. -3. -3. -3. -3.] [-2. -2. -2. -2. -2. -2. -2. -2. -2. -2. -2.] [-1. -1. -1. -1. -1. -1. -1. -1. -1. -1. -1.] [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] [ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] [ 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2.] [ 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.] [ 4. 4. 4. 4. 4. 4. 4. 4. 4. 4. 4.]] y_2 = [[-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.] [-5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5.]] True True
Sparse = True también se puede agregar en la función meshgrid de la indexación Matrix. En este caso, la forma de x_2 cambiará de (9, 11) a (9, 1) y la de y_2 cambiará de (9, 11) a (1, 11).
Publicación traducida automáticamente
Artículo escrito por ArijitGayen y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA