Python库学习(八):Numpy[续篇二]:数组操作
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))
"""
--------------------------- 在一维数组查询 ---------------------------
随机一维数组: [ 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]))
"""
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=, *, where=)
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]
"""
3. 数组排序
3.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)]
"""
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.使用示例:
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]])]
"""
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. 使用示例:
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]]]
"""
4.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]]]
"""
5. 数组拼接
5.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]]]
"""
5.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]]
"""
6. 维度转换
6.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
"""
6.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]
"""
本文由 mdnice 多平台发布