有人可以向我解释meshgridNumpy 中函数的目的是什么吗？我知道它为绘图创建了某种坐标网格，但我看不到它的直接好处。
我正在学习 Sebastian Raschka 的“Python 机器学习”，他正在使用它来绘制决策边界。请参见此处的输入 11 。
我也尝试过官方文档中的这段代码，但是，输出对我来说真的没有意义。
x = np.arange(-5, 5, 1)
y = np.arange(-5, 5, 1)
xx, yy = np.meshgrid(x, y, sparse=True)
z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
h = plt.contourf(x,y,z)
如果可能的话，请给我展示很多真实世界的例子。
的目的meshgrid是从 x 值数组和 y 值数组创建一个矩形网格。
因此，例如，如果我们要创建一个网格，其中在 x 和 y 方向上的每个整数值都在 0 到 4 之间有一个点。要创建一个矩形网格，我们需要x和y点的每个组合。
这将是25分，对吧？因此，如果我们想为所有这些点创建一个 x 和 y 数组，我们可以执行以下操作。
x[0,0] = 0 y[0,0] = 0
x[0,1] = 1 y[0,1] = 0
x[0,2] = 2 y[0,2] = 0
x[0,3] = 3 y[0,3] = 0
x[0,4] = 4 y[0,4] = 0
x[1,0] = 0 y[1,0] = 1
x[1,1] = 1 y[1,1] = 1
...
x[4,3] = 3 y[4,3] = 4
x[4,4] = 4 y[4,4] = 4
这将产生以下x和y矩阵，使得每个矩阵中对应元素的配对给出网格中一个点的 x 和 y 坐标。
x = 0 1 2 3 4 y = 0 0 0 0 0
0 1 2 3 4 1 1 1 1 1
0 1 2 3 4 2 2 2 2 2
0 1 2 3 4 3 3 3 3 3
0 1 2 3 4 4 4 4 4 4
然后我们可以绘制它们以验证它们是一个网格：
plt.plot(x,y, marker='.', color='k', linestyle='none')
显然，这变得非常乏味，尤其是对于大范围的x和y。相反，meshgrid实际上可以为我们生成这个：我们所要指定的只是唯一性x和y值。
xvalues = np.array([0, 1, 2, 3, 4]);
yvalues = np.array([0, 1, 2, 3, 4]);
现在，当我们调用 时meshgrid，我们会自动获得之前的输出。
xx, yy = np.meshgrid(xvalues, yvalues)
plt.plot(xx, yy, marker='.', color='k', linestyle='none')
创建这些矩形网格对许多任务很有用。在您在帖子中提供的示例中，这只是一种在和sin(x**2 + y**2) / (x**2 + y**2)的值范围内对函数 ( )进行采样的方法。xy
因为这个函数是在一个矩形网格上采样的，所以现在可以将这个函数可视化为一个“图像”。
此外，现在可以将结果传递给期望矩形网格上的数据的函数（即contourf）
由 Microsoft Excel 提供：
实际上np.meshgrid文档中已经提到了的目的：
从坐标向量返回坐标矩阵。
在给定一维坐标数组 x1、x2、...、xn 的情况下，制作 ND 坐标数组，用于在 ND 网格上对 ND 标量/矢量场进行矢量化评估。
所以它的主要目的是创建一个坐标矩阵。
你可能只是问自己：
使用 Python/NumPy 需要坐标矩阵的原因是坐标与值之间没有直接关系，除非坐标从零开始并且是纯正整数。然后你可以只使用数组的索引作为索引。但是，如果不是这种情况，您需要以某种方式将坐标与数据一起存储。这就是网格的用武之地。
假设您的数据是：
1 2 1
2 5 2
1 2 1
但是，每个值代表 3 x 2 公里的区域（水平 x 垂直）。假设您的原点是左上角，并且您想要表示可以使用的距离的数组：
import numpy as np
h, v = np.meshgrid(np.arange(3)*3, np.arange(3)*2)
其中 v 是：
array([[0, 0, 0],
[2, 2, 2],
[4, 4, 4]])
和 h：
array([[0, 3, 6],
[0, 3, 6],
[0, 3, 6]])
因此，如果你有两个索引，假设xand y（这就是为什么返回值meshgrid通常是xx或者xs而不是x在这种情况下我选择h水平！）然后你可以得到点的 x 坐标，点的 y 坐标和在这一点上的价值通过使用：
h[x, y] # horizontal coordinate
v[x, y] # vertical coordinate
data[x, y] # value
这使得跟踪坐标变得更加容易，并且（更重要的是）您可以将它们传递给需要知道坐标的函数。
但是，np.meshgrid它本身并不经常直接使用，大多只是使用类似对象之一np.mgrid或np.ogrid. 这里np.mgrid表示sparse=False和np.ogrid的sparse=True情况（我指的是 的sparse论点np.meshgrid）。请注意，
np.meshgridandnp.ogrid和之间存在显着差异np.mgrid：前两个返回值（如果有两个或更多）是相反的。通常这无关紧要，但您应该根据上下文给出有意义的变量名称。
例如，在 2D 网格的情况下，将返回的第一个项目命名为和第二个matplotlib.pyplot.imshow是有意义的，而对于and则相反。np.meshgrid xynp.mgridnp.ogrid
np.ogrid和稀疏网格>>> import numpy as np
>>> yy, xx = np.ogrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
如前所述，与 相比，输出是相反的np.meshgrid，这就是为什么我将其解压缩为yy, xx而不是xx, yy：
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6), sparse=True)
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
这已经看起来像坐标，特别是 2D 绘图的 x 和 y 线。
可视化：
yy, xx = np.ogrid[-5:6, -5:6]
plt.figure()
plt.title('ogrid (sparse meshgrid)')
plt.grid()
plt.xticks(xx.ravel())
plt.yticks(yy.ravel())
plt.scatter(xx, np.zeros_like(xx), color="blue", marker="*")
plt.scatter(np.zeros_like(yy), yy, color="red", marker="x")
np.mgrid和密集/充实的网格>>> yy, xx = np.mgrid[-5:6, -5:6]
>>> xx
array([[-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],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-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],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
此处同样适用：输出与以下内容相反np.meshgrid：
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6))
>>> xx
array([[-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],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-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],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
不像ogrid这些数组包含所有 xx和yy坐标在 -5 <= xx <= 5; -5 <= yy <= 5 格。
yy, xx = np.mgrid[-5:6, -5:6]
plt.figure()
plt.title('mgrid (dense meshgrid)')
plt.grid()
plt.xticks(xx[0])
plt.yticks(yy[:, 0])
plt.scatter(xx, yy, color="red", marker="x")
它不仅限于 2D，这些函数适用于任意维度（嗯，Python 中的函数有最大数量的参数以及 NumPy 允许的最大维度数量）：
>>> x1, x2, x3, x4 = np.ogrid[:3, 1:4, 2:5, 3:6]
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
x1
array([[[[0]]],
[[[1]]],
[[[2]]]])
x2
array([[[[1]],
[[2]],
[[3]]]])
x3
array([[[[2],
[3],
[4]]]])
x4
array([[[[3, 4, 5]]]])
>>> # equivalent meshgrid output, note how the first two arguments are reversed and the unpacking
>>> x2, x1, x3, x4 = np.meshgrid(np.arange(1,4), np.arange(3), np.arange(2, 5), np.arange(3, 6), sparse=True)
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
# Identical output so it's omitted here.
即使这些也适用于一维，也有两个（更常见的）一维网格创建函数：
除了startandstop参数，它还支持step参数（甚至是表示步骤数的复杂步骤）：
>>> x1, x2 = np.mgrid[1:10:2, 1:10:4j]
>>> x1 # The dimension with the explicit step width of 2
array([[1., 1., 1., 1.],
[3., 3., 3., 3.],
[5., 5., 5., 5.],
[7., 7., 7., 7.],
[9., 9., 9., 9.]])
>>> x2 # The dimension with the "number of steps"
array([[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.]])
您特别询问了目的，事实上，如果您需要坐标系，这些网格非常有用。
例如，如果您有一个计算二维距离的 NumPy 函数：
def distance_2d(x_point, y_point, x, y):
return np.hypot(x-x_point, y-y_point)
你想知道每个点的距离：
>>> ys, xs = np.ogrid[-5:5, -5:5]
>>> distances = distance_2d(1, 2, xs, ys) # distance to point (1, 2)
>>> distances
array([[9.21954446, 8.60232527, 8.06225775, 7.61577311, 7.28010989,
7.07106781, 7. , 7.07106781, 7.28010989, 7.61577311],
[8.48528137, 7.81024968, 7.21110255, 6.70820393, 6.32455532,
6.08276253, 6. , 6.08276253, 6.32455532, 6.70820393],
[7.81024968, 7.07106781, 6.40312424, 5.83095189, 5.38516481,
5.09901951, 5. , 5.09901951, 5.38516481, 5.83095189],
[7.21110255, 6.40312424, 5.65685425, 5. , 4.47213595,
4.12310563, 4. , 4.12310563, 4.47213595, 5. ],
[6.70820393, 5.83095189, 5. , 4.24264069, 3.60555128,
3.16227766, 3. , 3.16227766, 3.60555128, 4.24264069],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6. , 5. , 4. , 3. , 2. ,
1. , 0. , 1. , 2. , 3. ],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128]])
如果通过密集网格而不是开放网格，输出将是相同的。NumPys 广播使之成为可能！
让我们可视化结果：
plt.figure()
plt.title('distance to point (1, 2)')
plt.imshow(distances, origin='lower', interpolation="none")
plt.xticks(np.arange(xs.shape[1]), xs.ravel()) # need to set the ticks manually
plt.yticks(np.arange(ys.shape[0]), ys.ravel())
plt.colorbar()
这也是 NumPys变得非常方便的时候mgrid，ogrid因为它允许您轻松更改网格的分辨率：
ys, xs = np.ogrid[-5:5:200j, -5:5:200j]
# otherwise same code as above
但是，由于imshow不支持x和y输入，因此必须手动更改刻度。如果它接受xandy坐标，那真的很方便，对吧？
使用 NumPy 编写自然处理网格的函数很容易。此外，NumPy、SciPy、matplotlib 中有几个函数希望您通过网格。
我喜欢图片，所以让我们探索一下matplotlib.pyplot.contour：
ys, xs = np.mgrid[-5:5:200j, -5:5:200j]
density = np.sin(ys)-np.cos(xs)
plt.figure()
plt.contour(xs, ys, density)
请注意坐标是如何正确设置的！如果您只是通过density.
或者再举一个使用天体模型的有趣例子（这次我不太关心坐标，我只是用它们来创建一些网格）：
from astropy.modeling import models
z = np.zeros((100, 100))
y, x = np.mgrid[0:100, 0:100]
for _ in range(10):
g2d = models.Gaussian2D(amplitude=100,
x_mean=np.random.randint(0, 100),
y_mean=np.random.randint(0, 100),
x_stddev=3,
y_stddev=3)
z += g2d(x, y)
a2d = models.AiryDisk2D(amplitude=70,
x_0=np.random.randint(0, 100),
y_0=np.random.randint(0, 100),
radius=5)
z += a2d(x, y)
尽管这只是“外观”，但Scipy 等中与功能模型和拟合相关的几个功能（例如scipy.interpolate.interp2d，
scipy.interpolate.griddata甚至使用 显示示例）都需要网格。np.mgrid其中大多数适用于开放网格和密集网格，但有些仅适用于其中之一。
假设你有一个函数：
def sinus2d(x, y):
return np.sin(x) + np.sin(y)
例如，您想查看它在 0 到 2*pi 范围内的样子。你会怎么做？进来np.meshgrid：
xx, yy = np.meshgrid(np.linspace(0,2*np.pi,100), np.linspace(0,2*np.pi,100))
z = sinus2d(xx, yy) # Create the image on this grid
这样的情节看起来像：
import matplotlib.pyplot as plt
plt.imshow(z, origin='lower', interpolation='none')
plt.show()
所以np.meshgrid只是一种方便。原则上可以通过以下方式完成：
z2 = sinus2d(np.linspace(0,2*np.pi,100)[:,None], np.linspace(0,2*np.pi,100)[None,:])
但是你需要知道你的尺寸（假设你有两个以上......）和正确的广播。np.meshgrid为您完成所有这些。
如果您想要进行插值但排除某些值，meshgrid 还允许您将坐标与数据一起删除：
condition = z>0.6
z_new = z[condition] # This will make your array 1D
那么你现在将如何进行插值呢？你可以给x和y一个插值函数，scipy.interpolate.interp2d所以你需要一种方法来知道哪些坐标被删除了：
x_new = xx[condition]
y_new = yy[condition]
然后你仍然可以用“正确的”坐标进行插值（在没有网格网格的情况下尝试它，你会有很多额外的代码）：
from scipy.interpolate import interp2d
interpolated = interp2d(x_new, y_new, z_new)
原始网格网格允许您再次在原始网格上获得插值：
interpolated_grid = interpolated(xx[0], yy[:, 0]).reshape(xx.shape)
这些只是我使用的一些示例，meshgrid可能还有更多。
简短的回答
的目的meshgrid是通过 C NumPy 库中的向量化操作来帮助替换 Python 循环（慢解释代码）。
从这个网站借来的。
x = np.arange(-4, 4, 0.25)
y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
meshgrid用于创建 -4 和 +4 之间的坐标对，在每个方向 X 和 Y 上增量为 0.25。然后每对坐标用于从中找到 R 和 Z。这种准备“网格”坐标的方法经常用于绘制 3D 表面或为 2D 表面着色。
详细信息：Python for 循环与 NumPy 向量运算
举一个更简单的例子，假设我们有两个值序列，
a = [2,7,9,20]
b = [1,6,7,9]
我们想对每对可能的值执行一个操作，一个取自第一个列表，一个取自第二个列表。我们还想存储结果。例如，假设我们想要获取每个可能对的值的总和。
缓慢而费力的方法
c = []
for i in range(len(b)):
row = []
for j in range(len(a)):
row.append (a[j] + b[i])
c.append (row)
print (c)
结果：
[[3, 8, 10, 21],
[8, 13, 15, 26],
[9, 14, 16, 27],
[11, 16, 18, 29]]
Python 被解释，这些循环执行起来相对较慢。
快速简便的方法
meshgrid旨在从代码中删除循环。它返回两个数组（下面的 i 和 j），可以将它们组合起来扫描所有现有的对，如下所示：
i,j = np.meshgrid (a,b)
c = i + j
print (c)
结果：
[[ 3 8 10 21]
[ 8 13 15 26]
[ 9 14 16 27]
[11 16 18 29]]
引擎盖下的网格
准备的两个数组meshgrid是：
(array([[ 2, 7, 9, 20],
[ 2, 7, 9, 20],
[ 2, 7, 9, 20],
[ 2, 7, 9, 20]]),
array([[1, 1, 1, 1],
[6, 6, 6, 6],
[7, 7, 7, 7],
[9, 9, 9, 9]]))
这些数组是通过重复提供的值创建的。一个包含相同行中的值，另一个包含相同列中的其他值。行数和列数由另一个序列中的元素数决定。
因此，由 所创建的两个数组meshgrid对于向量操作是形状兼容的。想象一下页面顶部代码中的 x 和 y 序列具有不同数量的元素，X 和 Y 生成的数组无论如何都将是形状兼容的，不需要任何广播。
起源
numpy.meshgrid来自MATLAB，就像许多其他NumPy函数一样。所以你也可以研究 MATLAB 中的例子来看看meshgrid在使用中，3D 绘图的代码在 MATLAB 中看起来是一样的。
meshgrid 有助于从两个阵列中所有点对的两个一维阵列创建一个矩形网格。
x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 2, 3, 4])
现在，如果您已经定义了一个函数 f(x,y)，并且您想将此函数应用于数组“x”和“y”中所有可能的点组合，那么您可以这样做：
f(*np.meshgrid(x, y))
比如说，如果您的函数只产生两个元素的乘积，那么这就是实现笛卡尔积的方式，对于大型数组有效。
从这里引用
给定可能的 x 值 , xs（将它们视为绘图 x 轴上的刻度线）和可能的 y 值 ,ys生成meshgrid相应的 (x, y) 网格点集——类似于set((x, y) for x in xs for y in yx)。例如，如果xs=[1,2,3]和ys=[4,5,6]，我们会得到一组坐标{(1,4), (2,4), (3,4), (1,5), (2,5), (3,5), (1,6), (2,6), (3,6)}。
但是，meshgrid返回的表示在两个方面与上述表达式不同：
首先，meshgrid在 2d 数组中布置网格点：行对应于不同的 y 值，列对应于不同的 x 值——如list(list((x, y) for x in xs) for y in ys)，这将给出以下数组：
[[(1,4), (2,4), (3,4)],
[(1,5), (2,5), (3,5)],
[(1,6), (2,6), (3,6)]]
其次，meshgrid分别返回 x 和 y 坐标（即在两个不同的 numpy 2d 数组中）：
xcoords, ycoords = (
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]]),
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6]]))
# same thing using np.meshgrid:
xcoords, ycoords = np.meshgrid([1,2,3], [4,5,6])
# same thing without meshgrid:
xcoords = np.array([xs] * len(ys)
ycoords = np.array([ys] * len(xs)).T
注意，np.meshgrid也可以生成更高维度的网格。给定 xs、ys 和 zs，您将返回 xcoords、ycoords、zcoords 作为 3d 数组。meshgrid还支持维度的反向排序以及结果的稀疏表示。
为什么我们想要这种形式的输出？
在网格上的每个点应用一个函数：
一个动机是像 (+, -, *, /, **) 这样的二元运算符被重载为 numpy 数组作为元素操作。这意味着如果我有一个def f(x, y): return (x - y) ** 2适用于两个标量的函数，我也可以将它应用于两个 numpy 数组以获取元素结果数组：例如f(xcoords, ycoords)，或者f(*np.meshgrid(xs, ys))在上面的示例中给出以下内容：
array([[ 9, 4, 1],
[16, 9, 4],
[25, 16, 9]])
高维外积：我不确定这有多有效，但是您可以通过这种方式获得高维外积：np.prod(np.meshgrid([1,2,3], [1,2], [1,2,3,4]), axis=0).
matplotlib 中的等高线图：我meshgrid在研究使用 matplotlib 绘制等高线图以绘制决策边界时遇到。为此，您生成一个带有 的网格meshgrid，在每个网格点评估函数（例如，如上所示），然后将 xcoords、ycoords 和计算的 f 值（即 zcoords）传递给 contourf 函数。
大多数时候你只需要list(zip(X,Y))
在哪里X = np.linspace(x)和Y = np.linspace(y)