1. 通用函数

在上一篇文章《Python常用库(六):科学计算库Numpy[上篇]:创建、访问、赋值》中学习了Numpy的创建、访问、赋值。接下来学习数组的其他函数，Numpy提供了一系列操作数组的函数，通常称这种函数为通用函数(ufunc)； 可以直接作用在数组中的每个元素(无需遍历) 。

@注意: 通用函数（ufunc）是NumPy中的一个重要概念,而不是一个具体的库,ufunc是universal function的缩写。

2. 元素查找

2.1 np.where

numpy.where 根据给定条件返回数组中满足条件元素,对应的索引。它的语法如下：

numpy.where(condition[, x, y])

a. 参数说明:

• condition：一个布尔型数组或条件表达式，指定了要检查的条件。
• x：可选参数，表示满足条件的元素替换为该值，默认为None。
• y：可选参数，表示不满足条件的元素替换为该值，默认为None。

numpy.where 返回一个新的数组，其中满足条件的元素被替换为 x，不满足条件的元素被替换为 y。如果只传入 condition 参数，则返回满足条件的元素的索引。

b. 使用示例:

import numpy as np
if __name__ == '__main__':
    print("--------------------------- 在一维数组查询 ---------------------------")
    arr = np.random.randint(1, 12, 6)
    print("随机一维数组:", arr)
    # 在一维数组查询,返回满足条件元素对应的索引
    print("查询 >6,返回满足条件元素对应的索引: ", np.where(arr > 6))
    # 把满足条件的元素替换成:88,不满足替换成:-1
    replace_arr = np.where(arr > 6, 88, -1)
    print("把满足 arr>6 的元素,替换成:88,不满足替换成:-1 ", replace_arr)

    print("--------------------------- 在二维数组查询 ---------------------------")
    two_arr = np.random.randint(1, 12, (2, 3))
    print("随机二维数组:\n", two_arr)
    # 在二维数组查询
    print("查询>6,返回满足条件元素对应的索引: ", np.where(two_arr > 6))
    

"""
--------------------------- 在一维数组查询 ---------------------------
随机一维数组: [5 6 2 8 5 9]
查询 >6,返回满足条件元素对应的索引:  (array([3, 5], dtype=int64),)
把满足 arr>6 的元素,替换成:88,不满足替换成:-1  [-1 -1 -1 88 -1 88]
--------------------------- 在二维数组查询 ---------------------------
随机二维数组:
 [[9 3 1]
 [4 5 9]]
查询>6,返回满足条件元素对应的索引:  (array([0, 1], dtype=int64), array([0, 2], dtype=int64))
"""    

3. 逻辑判断

3.1 np.all

numpy.all() 函数用于检查数组中的所有元素是否满足给定条件。如果数组中的所有元素都满足条件，则返回 True，否则返回 False。语法如下：

numpy.all(condition, axis=None)

a. 参数说明:

• condition：一个条件表达式，可以是比较运算、逻辑运算等。
• axis 参数是可选的，用于指定沿着哪个轴进行计算.

b. 使用示例:

import numpy as np

if __name__ == '__main__':
    arr = np.arange(10)
    print("一维数组:", arr)
    print("arr所有元素 >6:", np.all(arr > 6))
    two_arr = np.array([
        [5, 19, 7],
        [7, 34, 8],
        [12, 14, 30],
    ])
    print("二维数组:\n", two_arr)
    print("two_arr数组所有元素 >4:", np.all(two_arr > 4))
    print("two_arr数组所有行(横轴)元素 >10:", np.all(two_arr > 10, axis=1))
    print("two_arr数组所有列(纵轴)元素 >10:", np.all(two_arr > 10, axis=0))
    
"""
一维数组: [0 1 2 3 4 5 6 7 8 9]
arr所有元素 >6: False
二维数组:
 [[ 5 19  7]
 [ 7 34  8]
 [12 14 30]]
two_arr数组所有元素 >4: True
two_arr数组所有行(横轴)元素 >10: [False False  True]
two_arr数组所有列(纵轴)元素 >10: [False  True False]
"""    

3.2 np.any

np.any函数用于判断数组中是否存在满足某个条件的元素。它返回一个布尔值，如果存在满足条件的元素，则返回True，否则返回False。
np.any函数的语法如下：

numpy.any(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)

a. 参数说明:

• axis：沿着指定的轴进行操作，默认为None，表示对整个数组进行操作。
• out：指定输出结果的数组。
• keepdims：如果设置为True,则保持原始数组的维度不变；如果设置为False，则将缩减的维度删除。
• where：可选参数，用于指定额外的条件。

b. 使用示例:

import numpy as np

if __name__ == '__main__':
    arr = np.arange(10)
    print("一维数组:", arr)
    print("arr所有元素 >6:", np.any(arr > 6))
     two_arr = np.array([
        [5, 9, 7],
        [7, 8, 43],
        [12, 4, 13],
    ])
    print("二维数组:\n", two_arr)
    print("two_arr数组所有元素 >12:", np.any(two_arr > 12))
    print("two_arr数组所有行(横轴)元素 >40:", np.any(two_arr > 40, axis=1))
    print("two_arr数组所有列(纵轴)元素 >12:", np.any(two_arr > 12, axis=0))


"""
一维数组: [0 1 2 3 4 5 6 7 8 9]
arr所有元素 >6: True
二维数组:
 [[ 5  9  7]
 [ 7  8 43]
 [12  4 13]]
two_arr数组所有元素 >12: True
two_arr数组所有行(横轴)元素 >40: [False  True False]
two_arr数组所有列(纵轴)元素 >12: [False False  True]
"""    

4. 数组排序

4.1 sort

np.sort() 用于对数组进行排序。返回原始数组的已排序副本，并且不会改变原始数组的顺序。

sort(a, axis=-1, kind=None, order=None)

a. 参数说明:

• axis: 表示沿着指定轴排序，默认值为 -1，表示沿着最后一个轴进行排序。
• kind: 表示使用哪种算法进行排序,默认快速排序算法(quicksort),也可以选择其他算法(mergesort:归并排序、heapsort:堆排序)。
• order: 当数组是结构化或复合类型时，可以指定排序的字段，默认None：表示按照数组中的元素正序排序

b. 使用示例:

import numpy as np

if __name__ == '__main__':
    print("------------------ 普通数组示例 ------------------")
    one_arr = np.array([4, 1, 3, 2])
    print("待排序一维数组:", one_arr)
    print("默认正序:", np.sort(one_arr))
    print("倒序:", np.sort(one_arr)[::-1])

    two_arr = np.array([
        [15, 11, 6],
        [7, 5, 1],
        [14, 21, 12],
    ])
    print("待排序-二维数组:\n", two_arr)
    print("二维数组-默认排序:\n", np.sort(two_arr))
    print("二维数组-axis=0:\n", np.sort(two_arr, axis=0))
    print("二维数组-axis=1:\n", np.sort(two_arr, axis=1))
    print("------------------ 结构数组示例 ------------------")
    # 定义结构化数组数据类型
    dt = np.dtype([("name", "U10"), ("age", int), ("score", float)])
    # 创建结构化数组
    arr = np.array([
        ("张三", 20, 68.5),
        ("李四", 22, 80),
        ("王麻子", 25, 95.5),
    ], dtype=dt)
    print("结构化数组: ", arr)
    sort_arr = np.sort(arr, order='age')
    print("结构化数组-根据age排序: ", arr)
    print("结构化数组-根据age倒序: ", arr[::-1])
    
"""
------------------ 普通数组示例 ------------------
待排序一维数组: [4 1 3 2]
默认正序: [1 2 3 4]
倒序: [4 3 2 1]
待排序-二维数组:
 [[15 11  6]
 [ 7  5  1]
 [14 21 12]]
二维数组-默认排序:
 [[ 6 11 15]
 [ 1  5  7]
 [12 14 21]]
二维数组-axis=0:
 [[ 7  5  1]
 [14 11  6]
 [15 21 12]]
二维数组-axis=1:
 [[ 6 11 15]
 [ 1  5  7]
 [12 14 21]]
------------------ 结构数组示例 ------------------
结构化数组:  [('张三', 20, 68.5) ('李四', 22, 80. ) ('王麻子', 25, 95.5)]
结构化数组-根据age排序:  [('张三', 20, 68.5) ('李四', 22, 80. ) ('王麻子', 25, 95.5)]
结构化数组-根据age倒序:  [('王麻子', 25, 95.5) ('李四', 22, 80. ) ('张三', 20, 68.5)]
"""    

5. 数组分割

5.1 np.array_split

np.array_split : 用于将一个数组分割成多个子数组。函数的语法如下：

numpy.array_split(arr, indices_or_sections, axis=0)

a.参数说明:

• arr：要分割的数组。
• indices_or_sections：指定分割点的位置。可以是一个整数，表示要分成几个等份；也可以是一个由分割点位置组成的列表，表示按照这些位置进行分割。
• axis：指定在哪个轴上进行分割，行(0)、列(1) ;默认为 0，表示按行进行分割。

b.使用示例:

import numpy as np

if __name__ == '__main__':
    print("------------------------ 分割一维数组 ----------------------------------")
    # 创建一个一维数组
    one_arr = np.arange(11)
    print("原始一维数组: ", one_arr)
    # 将数组分割成两个子数组
    print("分割成2个子数组: ", np.array_split(one_arr, 2))
    print("分割成3个子数组: ", np.array_split(one_arr, 3))
    print("由分割点分割子数组: ", np.array_split(one_arr, [3, 6]))

    print("------------------------ 分割二维数组 ----------------------------------")
    # 创建一个二维数组
    two_arr = np.arange(6).reshape((2, 3))
    print("原始二维数组: \n", two_arr)
    # 按列分割数组
    result = np.array_split(two_arr, 3, axis=1)
    print("按列分割数组: \n", result)

    # 按行分割数组
    result = np.array_split(two_arr, 2, axis=0)
    print("按行分割数组: \n", result)
    
""" 
------------------------ 分割一维数组 ----------------------------------
原始一维数组:  [ 0  1  2  3  4  5  6  7  8  9 10]
分割成2个子数组:  [array([0, 1, 2, 3, 4, 5]), array([ 6,  7,  8,  9, 10])]
分割成3个子数组:  [array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8,  9, 10])]
由分割点分割子数组:  [array([0, 1, 2]), array([3, 4, 5]), array([ 6,  7,  8,  9, 10])]
------------------------ 分割二维数组 ----------------------------------
原始二维数组: 
 [[0 1 2]
 [3 4 5]]
按列分割数组: 
 [array([[0],
       [3]]), array([[1],
       [4]]), array([[2],
       [5]])]
按行分割数组: 
 [array([[0, 1, 2]]), array([[3, 4, 5]])]
"""

5.2 np.dsplit

np.dsplit 函数可以将多维数组，以垂直方向(沿着行)进分割成多个子数组,函数签名如下：

numpy.dsplit(arr, indices_or_sections)

a. 参数说明:

• ary：要分割的多维数组。
• indices_or_sections：可以是整数或一组整数，用于指定分割的位置。如果是整数，表示将数组分成等长的子数组。如果是一组整数，表示具体的划分位置;如[1,3]:代表分割 [0,1）、[1、3)、[3、最后)

b. 使用示例:

import numpy as np

if __name__ == '__main__':
    # 创建一个二维数组
    two_arr = np.arange(12).reshape((1, 3, 4))
    print("原始三维数组: \n", two_arr)
    print("------------------------ 按照份数分割 ------------------------")
    res_arr = np.dsplit(two_arr, 4)
    print("切割结果res_arr:\n", res_arr)
    print("res_arr[0]:\n", res_arr[0])
    print("------------------------ 按照位置分割 ------------------------")
    a = np.dsplit(two_arr, [1, 3])
    print("a: \n", a)
    print("a[0]: \n", a[0])
    print("a[1]: \n", a[1])
    print("a[2]: \n", a[2])
    
"""
原始三维数组: 
 [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]]
------------------------ 按照份数分割 ------------------------
切割结果res_arr:
 [array([[[0],
        [4],
        [8]]]), array([[[1],
        [5],
        [9]]]), array([[[ 2],
        [ 6],
        [10]]]), array([[[ 3],
        [ 7],
        [11]]])]
res_arr[0]:
 [[[0]
  [4]
  [8]]]
------------------------ 按照位置分割 ------------------------
a: 
 [array([[[0],
        [4],
        [8]]]), array([[[ 1,  2],
        [ 5,  6],
        [ 9, 10]]]), array([[[ 3],
        [ 7],
        [11]]])]
a[0]: 
 [[[0]
  [4]
  [8]]]
a[1]: 
 [[[ 1  2]
  [ 5  6]
  [ 9 10]]]
a[2]: 
 [[[ 3]
  [ 7]
  [11]]]
"""    

5.3 np.hsplit

np.hsplit 函数可以将多维数组，以水平方向(沿着列)进分割成多个子数组,函数签名如下：

numpy.hsplit(ary, indices_or_sections)

a. 参数说明:

• ary：要分割的数组。
• indices_or_sections：可以是整数或一组整数，用于指定分割的位置。如果是整数，表示将数组分成等长的子数组。如果是一组整数，表示具体的划分位置。

b.使用示例:

import numpy as np

if __name__ == '__main__':
    # 创建一个二维数组
    arr = np.arange(12).reshape((1, 4, 3))
    print("原始三维数组: \n", arr)
    print("------------------------ 按照份数分割 ------------------------")
    res_arr = np.hsplit(arr, 4)
    print("切割结果res_arr:\n", res_arr)
    print("res_arr[0]:\n", res_arr[0])
    print("------------------------ 按照位置分割 ------------------------")
    # 第1行~第2行、第2行~第3行、第3行到最后
    a = np.hsplit(arr, [1, 2])
    print("a: \n", a)
    print("a[0]: \n", a[0])
    print("a[1]: \n", a[1])
    print("a[2]: \n", a[2])
    
"""
原始三维数组: 
 [[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]]]
------------------------ 按照份数分割 ------------------------
切割结果res_arr:
 [array([[[0, 1, 2]]]), array([[[3, 4, 5]]]), array([[[6, 7, 8]]]), array([[[ 9, 10, 11]]])]
res_arr[0]:
 [[[0 1 2]]]
------------------------ 按照位置分割 ------------------------
a: 
 [array([[[0, 1, 2]]]), array([[[3, 4, 5]]]), array([[[ 6,  7,  8],
        [ 9, 10, 11]]])]
a[0]: 
 [[[0 1 2]]]
a[1]: 
 [[[3 4 5]]]
a[2]: 
 [[[ 6  7  8]
  [ 9 10 11]]]
"""    

6. 数组拼接

6.1 np.dstack

np.dstack 函数可以将多个数组,按照列拼接成更高一维度的数组
b. 使用示例:

import numpy as np

if __name__ == '__main__':
    print("--------------------------- 拼接一维 ---------------------------")
    # 定义一维数组
    arr1 = np.array([1, 2, 3])
    arr2 = np.array([4, 5, 6])
    arr3 = np.array([7, 8, 9])
    # 拼接
    arr = np.dstack((arr1, arr2, arr3))
    print("拼接一维数组结果: \n", arr)
    # 定义元组
    tuple1 = (1, 1, 1)
    tuple2 = (2, 2, 2)
    arr = np.dstack((tuple1, tuple2))
    print("拼接元组结果: \n", arr)
    print("--------------------------- 拼接二维 ---------------------------")
    two1 = two2 = np.array([
        [1, 2, 3],
        [4, 5, 6]
    ])
    print("拼接二维结果:\n", np.dstack((two1, two2)))
    
"""
--------------------------- 拼接一维 ---------------------------
拼接一维数组结果: 
 [[[1 4 7]
  [2 5 8]
  [3 6 9]]]
拼接元组结果: 
 [[[1 2]
  [1 2]
  [1 2]]]
--------------------------- 拼接二维 ---------------------------
拼接二维结果:
 [[[1 1]
  [2 2]
  [3 3]]

 [[4 4]
  [5 5]
  [6 6]]]
"""

6.2 np.hstack

np.hstack 函数用于在水平方向（按列）堆叠数组，也就是将多个数组按列连接起来。

import numpy as np

if __name__ == '__main__':
    print("--------------------------- 拼接一维 ---------------------------")
    # 定义一维数组
    arr1 = np.array([1, 2, 3])
    arr2 = np.array([4, 5, 6])
    arr3 = np.array([7, 8, 9])
    # 拼接
    arr = np.hstack((arr1, arr2, arr3))
    print("拼接一维数组结果: \n", arr)
    # 定义元组
    tuple1 = (1, 1, 1)
    tuple2 = (2, 2, 2)
    arr = np.hstack((tuple1, tuple2))
    print("拼接元组结果: \n", arr)
    print("--------------------------- 拼接二维 ---------------------------")
    two1 = two2 = np.array([
        [1, 2, 3],
        [4, 5, 6]
    ])
    print("拼接二维结果:\n", np.hstack((two1, two2)))
    
"""
--------------------------- 拼接一维 ---------------------------
拼接一维数组结果: 
 [1 2 3 4 5 6 7 8 9]
拼接元组结果: 
 [1 1 1 2 2 2]
--------------------------- 拼接二维 ---------------------------
拼接二维结果:
 [[1 2 3 1 2 3]
 [4 5 6 4 5 6]]
"""      

7. 维度转换

7.1 一维转多维

• np.atleast_2d: 用于将输入的数组转成二维数组，如果输入数组是二维，则输出不变；
• np.atleast_3d: 用于将输入的数组转成三维数组，如果输入数组是三维，则输出不变；

import numpy as np

if __name__ == '__main__':
    arr = np.array([1, 2, 3, 4])
    two_arr = np.arange(6).reshape((2, 3))
    # 转成二维
    print("---------------------- 转成二维 --------------------------")
    tmp = np.atleast_2d(arr)
    two_tmp = np.atleast_2d(two_arr)
    print("一维转二维:{} 维度:{}".format(tmp, tmp.ndim))
    print("二维转二维: \n {} \n维度:{}".format(two_tmp, two_tmp.ndim))
    # 转成三维
    print("---------------------- 转成三维 --------------------------")

    three_arr = np.atleast_3d(arr)
    three_arr2 = np.atleast_3d(two_arr)
    print("一维转三维:\n{} \n维度:{}".format(three_arr, three_arr.ndim))
    print("二维转三维:\n{} \n维度:{}".format(three_arr2, three_arr2.ndim))
    
"""
---------------------- 转成二维 --------------------------
一维转二维:[[1 2 3 4]] 维度:2
二维转二维: 
 [[0 1 2]
 [3 4 5]] 
维度:2
---------------------- 转成三维 --------------------------
一维转三维:
[[[1]
  [2]
  [3]
  [4]]] 
维度:3
二维转三维:
[[[0]
  [1]
  [2]]

 [[3]
  [4]
  [5]]] 
维度:3
"""    

7.2 多维转一维

在NumPy中，你可以使用flatten()方法或ravel()方法来将二维或多维数组转换为一维数组。这两种方法的主要区别如下:

• flatten() 方法返回的是原始数组的副本，因此对返回的数组的修改不会影响原始数组。
• ravel() 方法返回的是原始数组的视图（引用），如果对返回的数组进行修改，可能会影响原始数组。

import numpy as np

if __name__ == '__main__':
    two_arr = np.arange(6).reshape((2, 3))
    three_arr = np.arange(8).reshape((2, 2, 2))
    print("原始二维数组:\n {}  \n原始三维数组:\n {} ".format(two_arr, three_arr))
    # 二维转一维
    print("二维转一维:", two_arr.flatten())

    # 三维转一维
    print("三维转一维:", three_arr.flatten())
    
"""
原始二维数组:
 [[0 1 2]
 [3 4 5]]  
原始三维数组:
 [[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]] 
二维转一维: [0 1 2 3 4 5]
三维转一维: [0 1 2 3 4 5 6 7]
"""