np.tile、np.meshgrid、np.where学习总结

最近看代码的时候又碰到了几个关于numpy的用法，在这里总结记录一下，尽可能简洁，我的上一篇关于numpy的用法是： python numpy学习总结
PS：以下官网对应的都是numpy1.17版本的

一、numpy.tile()

首先，tile就是地砖，铺砖的意思，所以这个函数就是来像一片片铺砖贴瓦一样，对np.ndarray数组进行扩展广播。
numpy.tile(A, reps)

• 输入数组A，reps指定沿A各个轴axis扩展的倍数，输出矩阵维数是max(d, A.ndim)，其中d是reps的长度
• 当d与A.ndim的维数不相等的时候，就把那个维数小的一方前面插入维度，值为1，然后A沿第一个轴方向到最后的轴，对应reps里面的值进行对应axis的扩展，注意：这里不是单行单列的repeat，而是整体的扩展，可以对照numpy.repeat学习

>>> a = np.array([0, 1, 2])
>>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2])
>>> np.tile(a, (2, 3)) # 先把[0,1,2]升维成[[0,1,2]]
array([[0, 1, 2, 0, 1, 2, 0, 1, 2],
       [0, 1, 2, 0, 1, 2, 0, 1, 2]])
>>> np.tile(a, (2, 1, 3))
array([[[0, 1, 2, 0, 1, 2, 0, 1, 2]],
       [[0, 1, 2, 0, 1, 2, 0, 1, 2]]])
>>> b = np.array([[1, 2], [3, 4]])
>>> np.tile(b, (2, 1))
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])
# 注意不是下面的这个结果,即上面红色字体提示：
# array([[1, 2],
#        [1, 2],
#        [3, 3],
#        [3, 4]])

官网强烈建议使用numpy.broadcast_to来进行广播

二、numpy.meshgrid()

numpy.meshgrid(*xi, **kwargs)

• 输入是一些列1-D的array：x1, x2,…, xn。有几个最后的格点网格就是几维的，一般我们都是输入x和y，所以生成的是一张二维平面的网格
• 有一些可选参数，例如indexing : {‘xy’, ‘ij’}坐标系In the 2-D case with inputs of length M and N, the outputs are of shape (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing，即返回的索引顺序会不一样，sparse : bool，copy : bool

>>> nx = 5
>>> ny = 3
>>> x = np.arange(nx) - (nx - 1) / 2
>>> x
array([-2., -1.,  0.,  1.,  2.])
>>> y = np.arange(ny) - (ny - 1) / 2
>>> y
array([-1.,  0.,  1.])
>>> xv, yv = np.meshgrid(x, y) #默认indexing='xy',所以输入(5,3),输出(3,5)
>>> xv
array([[-2., -1.,  0.,  1.,  2.],
       [-2., -1.,  0.,  1.,  2.],
       [-2., -1.,  0.,  1.,  2.]])
>>> yv
array([[-1., -1., -1., -1., -1.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 1.,  1.,  1.,  1.,  1.]])
>>> xv, yv = np.meshgrid(x, y, sparse=True)  # make sparse output arrays
>>> xv
array([[-2., -1.,  0.,  1.,  2.]])
>>> yv
array([[-1.],
       [ 0.],
       [ 1.]])
>>> xv, yv = np.meshgrid(x, y, indexing='ij')
>>> xv
array([[-2., -2., -2.],
       [-1., -1., -1.],
       [ 0.,  0.,  0.],
       [ 1.,  1.,  1.],
       [ 2.,  2.,  2.]])
>>> yv
array([[-1.,  0.,  1.],
       [-1.,  0.,  1.],
       [-1.,  0.,  1.],
       [-1.,  0.,  1.],
       [-1.,  0.,  1.]])

对于2-D的情况，记忆可以这样：现根据输入推出输出的shape，然后x一行一行填入，y一列一列按顺序添入就行

三、numpy.where()

numpy.where(condition, x, y)

• 输入condition，如果为真，就返回x；反之就返回y。condition, x, y要能广播到相同的某个shape
• 但只有一个输入参数condition的时候，用法如numpy.nonzero
  这个函数的用法要分两种情况：1)就是condition, x, y三个参数都给出的时候；2)只给出condition一个参数的时候，下面分情况讨论：
  情况1我是这样记忆的：一维的基本挨个看满不满足条件，还是简单的；多维情况下一般condition, x, y是同样的shape的，那就element-wise的对照条件，也就返回对应位置上的值，条件为真就返回前面那个对应位置上的值，条件为假就返回后面那个对应位置上的值

# 情况 1)
# [xv if c else yv
#  for c, xv, yv in zip(condition, x, y)] 对于所有数组都是1-D的时候
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.where(a < 5, a, 10*a)
array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])
>>> np.where([[True, False], [True, True]],
...          [[1, 2], [3, 4]],
...          [[9, 8], [7, 6]])
array([[1, 8],
       [3, 4]])

情况2当输入参数只有condition时，返回的是满足条件 (即非0) 元素的索引，以元组tuple的形式返回，因为返回的是索引，所以输入condition有N维时，返回的tuple长度也就是N，看例子

# 情况 2)
>>> np.where(a > 5)
(array([3, 4], dtype=int64),)
>>> a[np.where(a > 5)]
array([6, 7])
>>> a = np.arange(8).reshape(2,2,2)
>>> a
array([[[0, 1],
        [2, 3]],

       [[4, 5],
        [6, 7]]])
>>> np.where(a > 4)
(array([1, 1, 1], dtype=int64), 
 array([0, 1, 1], dtype=int64), 
 array([1, 0, 1], dtype=int64))
 # 返回的第一列[1,0,1]位置就是5，第二列[1,1,0]就是6的位置
 # 第三列[1,1,1]就是7的位置，所以就是满足条件（非零）的索引