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. 使用示例:

importnumpyasnp
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))


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

3. 逻辑判断

3.1 np.all

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

numpy.all(condition,axis=None)

a. 参数说明:

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

b. 使用示例:

importnumpyasnp

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))

"""
一维数组:[0123456789]
arr所有元素>6:False
二维数组:
[[5197]
[7348]
[121430]]
two_arr数组所有元素>4:True
two_arr数组所有行(横轴)元素>10:[FalseFalseTrue]
two_arr数组所有列(纵轴)元素>10:[FalseTrueFalse]
"""

3.2 np.any

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

np.any函数的语法如下：

numpy.any(a,axis=None,out=None,keepdims=,*,where=)

a. 参数说明:

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

b. 使用示例:

importnumpyasnp

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))


"""
一维数组:[0123456789]
arr所有元素>6:True
二维数组:
[[597]
[7438]
[12413]]
two_arr数组所有元素>12:True
two_arr数组所有行(横轴)元素>40:[FalseTrueFalse]
two_arr数组所有列(纵轴)元素>12:[FalseTrueTrue]
"""

3. 数组排序

3.1 sort

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

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

a. 参数说明:

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

b. 使用示例:

importnumpyasnp

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

"""
------------------普通数组示例------------------
待排序一维数组:[4132]
默认正序:[1234]
倒序:[4321]
待排序-二维数组:
[[15116]
[751]
[142112]]
二维数组-默认排序:
[[61115]
[157]
[121421]]
二维数组-axis=0:
[[751]
[14116]
[152112]]
二维数组-axis=1:
[[61115]
[157]
[121421]]
------------------结构数组示例------------------
结构化数组:[('张三',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)]
"""

4. 数组分割

4.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.使用示例:

importnumpyasnp

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)

"""
------------------------分割一维数组----------------------------------
原始一维数组:[012345678910]
分割成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])]
------------------------分割二维数组----------------------------------
原始二维数组:
[[012]
[345]]
按列分割数组:
[array([[0],
[3]]),array([[1],
[4]]),array([[2],
[5]])]
按行分割数组:
[array([[0,1,2]]),array([[3,4,5]])]
"""

4.2 np.dsplit

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

numpy.dsplit(arr,indices_or_sections)

a. 参数说明:

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

b. 使用示例:

importnumpyasnp

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

"""
原始三维数组:
[[[0123]
[4567]
[891011]]]
------------------------按照份数分割------------------------
切割结果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]:
[[[12]
[56]
[910]]]
a[2]:
[[[3]
[7]
[11]]]
"""

4.3 np.hsplit

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

numpy.hsplit(ary,indices_or_sections)

a. 参数说明:

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

b.使用示例:

importnumpyasnp

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

"""
原始三维数组:
[[[012]
[345]
[678]
[91011]]]
------------------------按照份数分割------------------------
切割结果res_arr:
[array([[[0,1,2]]]),array([[[3,4,5]]]),array([[[6,7,8]]]),array([[[9,10,11]]])]
res_arr[0]:
[[[012]]]
------------------------按照位置分割------------------------
a:
[array([[[0,1,2]]]),array([[[3,4,5]]]),array([[[6,7,8],
[9,10,11]]])]
a[0]:
[[[012]]]
a[1]:
[[[345]]]
a[2]:
[[[678]
[91011]]]
"""

5. 数组拼接

5.1 np.dstack

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

b. 使用示例:

importnumpyasnp

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)))

"""
---------------------------拼接一维---------------------------
拼接一维数组结果:
[[[147]
[258]
[369]]]
拼接元组结果:
[[[12]
[12]
[12]]]
---------------------------拼接二维---------------------------
拼接二维结果:
[[[11]
[22]
[33]]

[[44]
[55]
[66]]]
"""

5.2 np.hstack

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

importnumpyasnp

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)))

"""
---------------------------拼接一维---------------------------
拼接一维数组结果:
[123456789]
拼接元组结果:
[111222]
---------------------------拼接二维---------------------------
拼接二维结果:
[[123123]
[456456]]
"""

6. 维度转换

6.1 一维转多维

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

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))

"""
----------------------转成二维--------------------------
一维转二维:[[1234]]维度:2
二维转二维:
[[012]
[345]]
维度:2
----------------------转成三维--------------------------
一维转三维:
[[[1]
[2]
[3]
[4]]]
维度:3
二维转三维:
[[[0]
[1]
[2]]

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

6.2 多维转一维

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

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

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())

"""
原始二维数组:
[[012]
[345]]
原始三维数组:
[[[01]
[23]]

[[45]
[67]]]
二维转一维:[012345]
三维转一维:[01234567]
"""

本文由 mdnice 多平台发布