Python库学习Numpy:数组操作_python numpy数组统一操作

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

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

2. 元素查找

2.1 np.where

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

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

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

3. 逻辑判断

3.1 np.all

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

numpy.all(condition, axis=None)   
1

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]   """`    
1

3.2 np.any

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

np.any函数的语法如下：

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

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, 43, 8],           [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 43  8]    [12  4 13]]   two_arr数组所有元素 >12: True   two_arr数组所有行(横轴)元素 >40: [False  True False]   two_arr数组所有列(纵轴)元素 >12: [False  True  True]   """`    
1

4. 数组排序

4.1 sort

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

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

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)]   """`    
1

5. 数组分割

5.1 np.array_split

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

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

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]])]   """   
1

5.2 np.dsplit

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

numpy.dsplit(arr, indices_or_sections)   
1

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]]]   """`    
1

5.3 np.hsplit

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

numpy.hsplit(ary, indices_or_sections)   
1

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]]]   """`    
1

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]]]   """   
1

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]]   """`    
1

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   """`    
1

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]   """`    
1

---------------------------END---------------------------

题外话

感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。