本文以yolo系列代码为基础，在其中查找用到的numpy函数，包含近50个函数，本文花费多天，三万多字，通过丰富的函数原理和示例对这些函数进行详解。以帮助大家理解和使用。

np.array()

np.array()函数是NumPy库中创建数组的主要方法，它接受一组参数，每个参数都可以是数组，公开数组接口的任何对象，或者任何（嵌套）序列。

np.array()函数的作用是将输入的对象（或对象序列）转换为一个新的NumPy数组。

函数原型：
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

参数详解：

object：可以是一个列表、元组、字典或者另一个 NumPy 数组。也可以是公开数组接口的任何对象，或者任何（嵌套）序列。
dtype：可选参数，用来指定数组元素的类型。例如，np.array([1, 2, 3]) 默认情况下元素的类型是 int，但如果你指定了 dtype=np.float32，那么元素类型就会变成 float32。
copy：可选参数，默认为 True。如果为 True，那么会创建一个新的数组，复制输入的对象。如果为 False，那么可能会共享数据，即改变原数据也会影响返回的数组。
order：可选参数，默认为 'K'。这决定了数据的存储顺序。'K' 代表 Fortran 的存储顺序（行优先），'C' 代表 C 的存储顺序（列优先）。
subok：可选参数，默认为 False。如果为 True，那么返回的数组将是输入对象的子类。如果为 False，那么返回的数组将是基类数组。
ndmin：可选参数，默认为 0。这决定了返回的数组的最小维度数。例如，如果你指定了 ndmin=2，那么即使输入的是一个标量，也会返回一个一维数组。

运行示例

import numpy as np

# 从列表创建数组
a = np.array([1, 2, 3])
print(a)  # 输出：[1 2 3]

# 从元组创建数组
b = np.array((1, 2, 3))
print(b)  # 输出：[1 2 3]

# 从字典创建数组（假设所有的键都是相同的值）
my_dict = {'a': 1, 'b': 2, 'c': 3}
c = np.array(list(my_dict.values()))
print(c)  # 输出：[1 1 1]

# 从另一个 NumPy 数组创建数组
d = np.array([a, b, c])
print(d)  # 输出：[array([1, 2, 3]) array([1, 2, 3]) array([1, 1, 1])]

# 使用 dtype 参数指定元素类型
e = np.array([1, 2, 3], dtype=np.float32)
print(e)  # 输出：[1. 2. 3.]

np.asarray()

np.asarray 是 NumPy 库中的一个函数，用于将一个具有不同类型的数据集合（例如 Python 列表、元组或 NumPy 数组）转换为一个 NumPy 数组。

函数解析

函数原型:
numpy.asarray(a)

参数:
a：一个可迭代对象（例如 Python 列表、元组或其他 NumPy 数组）。

返回值:
返回一个新的 NumPy 数组，其中包含 a 中的数据，但以 NumPy 数组的形式表示。

注意事项:

如果 a 已经是一个 NumPy 数组，那么 np.asarray 不会进行任何转换，直接返回该数组。
如果 a 是一个 Python 列表或其他不可直接转换为 NumPy 数组的对象，np.asarray 会尝试将其转换为 NumPy 数组。
如果 a 是一个可迭代对象，但其中的元素不是同一种类型，那么 np.asarray 将返回一个 object 类型的数组，其中包含原始对象的引用。

运行示例

列表转换为 NumPy 数组

import numpy as np
list1 = [1, 2, 3, 4, 5]
arr1 = np.asarray(list1)
print(arr1)

输出：

[1 2 3 4 5]

元组转换为 NumPy 数组

import numpy as np

tuple1 = (1, 2, 3, 4, 5)
arr2 = np.asarray(tuple1)
print(arr2)

输出：

[1 2 3 4 5]

np.random.uniform()

np.random.uniform() 是 NumPy 库中的一个函数，用于生成一个指定形状的数组，数组元素的值均匀分布在指定的范围内。

函数解析

函数原型：
np.random.uniform(low, high, size)

参数详解：
low：生成随机数的最小值（含）。默认为0。
high：生成随机数的最大值（不含）。不能小于 low。默认为1。
size：生成的随机数数组的形状。可以是正整数、负整数或零，分别代表的形状为(n,),(n,n),(n,n,n)等。默认为None，代表生成的随机数数组形状为一个。
返回值：生成的随机数数组。

运行示例

（1）生成一个元素范围在0到1之间的随机数数组，形状为(3,)：

import numpy as np
print(np.random.uniform(0, 1, 3))

输出的一种：

[0.59394381 0.64440999 0.91008711]

（2）生成一个元素范围在1到10之间的随机数数组，形状为(2,2)：

import numpy as np
print(np.random.uniform(1, 10, (2, 2)))

输出的一种：

[[7.2666767  6.93297231]
 [9.65006062 8.67068568]]

np.arange()

np.arange() 是 NumPy 库中的一个函数，用于生成一个包含一定范围内整数的数组。这个函数在 Python 的内置 range() 函数的基础上提供了更多的灵活性和功能。

函数解析

函数原型为：
np.arange([start,] stop[, step,], dtype=None)

参数详解：

start：起始值。默认为0。
stop：结束值。生成的数组将包含到此值之前的所有整数。请注意，数组的最后一个元素将是 stop-1。
step：步长。默认为1。生成的数组的每个元素之间的差值就是这个步长。
dtype：可选参数，生成的数组的数据类型。如果未指定，则默认为当前 NumPy 数据类型。

返回值：一个包含一定范围内整数的 NumPy 数组。

运行示例

(1)生成从0到9（包含0，不包含10）的整数数组，步长为2：

import numpy as np
print(np.arange(0, 10, 2))

输出：

[0 2 4 6 8]

(2)生成一个长度为10的数组，元素从1开始，到100结束（不包含100），步长为10：

import numpy as np
print(np.arange(1, 100, 10))

输出：

[ 1 11 21 31 41 51 61 71 81 91]

np.clip()

np.clip()是NumPy库中的一个函数，它用于将数组中的元素限制在指定的范围内。这个函数接受两个参数，即最小值和最大值，所有超过这个范围的元素都会被限制在这个范围内。

函数解析

函数原型为：
np.clip(a, a_min, a_max)

参数详解：

a：输入数组。
a_min：限制下限。所有小于a_min的a中的元素将被替换为a_min。
a_max：限制上限。所有大于a_max的a中的元素将被替换为a_max。
返回值：一个新的数组，其中的元素被限制在a_min和a_max之间。

运行示例

import numpy as np

# 创建一个随机数组
arr = np.random.rand(5) * 100
print("Original array:", arr)

# 使用np.clip()将数组中的元素限制在0到10之间
clipped_arr = np.clip(arr, 0, 10)
print("Clipped array:", clipped_arr)

输出：

Original array: [89.01030861  7.78381296 52.43930124 70.35602011 62.99517335]
Clipped array: [10.          7.78381296 10.         10.         10.        ]

在这个示例中，原始数组中的元素被限制在0到10之间。所有超过这个范围的元素都被替换为对应的边界值（小于0的元素被替换为0，大于10的元素被替换为10）。

np.append()

np.append() 是 NumPy 库中的一个函数，它用于将一个或多个数组添加到另一个数组的末尾。这个函数不会改变原始数组，而是返回一个新的数组。

函数解析

函数原型为：
np.append(arr, values[, axis])

参数详解：
arr：要添加其他数组的数组。
values：要添加到 arr 的数组或列表。这可以是多个数组或列表。
axis：可选参数，定义了 values 中的数组沿着哪个轴添加到 arr 中。默认值为 None，这意味着 values 中的数组将被展平并添加到 arr 的末尾。如果指定了 axis，则 values 中的数组将被添加到 arr 的指定轴上。

运行示例

不使用 axis 参数：

import numpy as np

arr = np.array([1, 2, 3])
values = np.array([4, 5, 6])

appended_arr = np.append(arr, values)
print(appended_arr) 

输出：

[1 2 3 4 5 6]

使用 axis =0：

import numpy as np

arr = np.array([[1, 2], [3, 4]])
values = np.array([5, 6])

# 将 values 转换为二维数组
values_2d = np.reshape(values, (1, -1))

appended_arr = np.append(arr, values_2d, axis=0)
print(appended_arr)  

输出：

[[1 2]
 [3 4]
 [5 6]]

使用 axis =1

import numpy as np

arr = np.array([[1, 2], [3, 4]])
values = np.array([5, 6])

# 将 values 转换为二维数组
values_2d = np.reshape(values, (-1, 1))

appended_arr = np.append(arr, values_2d, axis=1)
print(appended_arr)

输出：

[[1 2 5]
 [3 4 6]]

注意：按照行或列拼接时注意要相同的维度，0是行拼接，1是列。

np.mod()

np.mod() 是 NumPy 库中的一个函数，它用于计算两个数的模（余数）。该函数的语法为 np.mod(x, y)，其中 x 和 y 是要计算模的两个数。

函数解析

函数的工作方式与 Python 内置的 % 运算符类似，但有一个重要的区别：np.mod() 函数可以处理浮点数和非整数，而 Python 的 % 运算符只能处理整数。

运行示例

import numpy as np

x1 = np.array([10, 10.5])
x2 = np.array([3, 3.2])

result = np.mod(x1, x2)
print(result)

输出：

[1.  0.9]

在上面的示例中，我们使用 np.mod() 函数计算了 x1 对 x2 的模，并将结果存储在 result 数组中。

np.eye()

函数解析

函数原型：
np.eye(n, m=None, k=0, dtype=<class 'NoneType'>)

参数：

n：整数，表示要生成的单位矩阵的行数或列数，取决于是否指定了m参数。如果m未指定，则n既是行数也是列数。
m：整数，表示要生成的单位矩阵的列数或行数，取决于是否指定了n参数。如果n未指定，则m既是列数也是行数。
k：整数，表示对角线偏离中心的偏移量。默认值为0，表示对角线居中。
dtype：数据类型，默认为None。如果指定了数据类型，则生成矩阵的数据类型将被指定为该类型。
该函数返回一个单位矩阵，其中对角线上的元素为1，其他位置的元素为0。通过调用 np.eye()，我们可以创建不同大小和维度的单位矩阵。

运行示例

创建2*2矩阵

mport numpy as np

identity_matrix = np.eye(2)
print(identity_matrix)

输出：

[[1. 0.]
 [0. 1.]]

创建4*5矩阵

import numpy as np

identity_matrix = np.eye(4, 5,dtype=np.float32)
print(identity_matrix)

输出：

[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]]

np.zeros()

np.zeros() 是 NumPy 库中的一个函数，用于创建一个形状和大小都为零的数组。该函数的主要参数是形状，可以接受的形式有：一个整数，一个元组，或者一个表示形状的数组。

函数解析

函数的详细解释如下：

np.zeros(shape)
shape：一个整数或一个元组，指定要创建的数组的形状。例如，np.zeros(3) 会创建一个长度为3的零向量，np.zeros((2,3)) 会创建一个2行3列的全零矩阵。
函数返回的是一个填充了0的数组。

运行示例

import numpy as np

# 创建一个长度为10的零向量
v = np.zeros(10)
print(v)
# 结果：[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

# 创建一个3行2列的全零矩阵
m = np.zeros((3,2))
print(m)
# 结果：[[0. 0.] [0. 0.] [0. 0.]]

# 创建一个复杂的多维数组
n = np.zeros((2,3,4))
print(n)
# 结果：[[[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]] [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]]

输出：

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[[0. 0.]
 [0. 0.]
 [0. 0.]]
[[[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]]

np.ones()

np.ones() 是 NumPy 库中的一个函数，用于创建一个全为1的数组。该函数的主要参数是形状，可以接受的形式有：一个整数，一个元组，或者一个表示形状的数组。

函数解析

与np.zeros()函数类似

np.ones(shape)

shape：一个整数或一个元组，指定要创建的数组的形状。例如，np.ones(3) 会创建一个长度为3的全1向量，np.ones((2,3)) 会创建一个2行3列的全1矩阵。
函数返回的是一个填充了1的数组。

运行示例

import numpy as np

# 创建一个长度为10的全1向量
v = np.ones(10)
print(v)
# 结果：[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# 创建一个3行2列的全1矩阵
m = np.ones((3,2))
print(m)
# 结果：[[1. 1.] [1. 1.] [1. 1.]]

# 创建一个复杂的多维数组
n = np.ones((2,3,4))
print(n)
# 结果：[[[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]] [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]]

输出：

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[[1. 1.]
 [1. 1.]
 [1. 1.]]
[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]

np.concatenate()

np.concatenate() 是 NumPy 库中的一个函数，用于将两个或更多的数组连接在一起。这个函数接受一个元组作为输入，该元组中的每个元素都是一个要连接的数组。

函数解析

np.concatenate((a1, a2, ...), axis=0)

a1, a2, ...：一个或多个要连接的数组。
axis：连接操作沿着哪个轴进行。如果 axis=0，那么数组将会在第一个轴上进行连接，这是默认值。如果 axis=1，那么数组将会在第二个轴上进行连接，以此类推。注意，axis 参数必须是整数。

函数返回一个新的数组，该数组包含所有输入数组在指定轴上的连接。

运行示例

import numpy as np

# 创建两个一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
#按行拼接
# 在第一个轴（默认）上连接这两个数组
c = np.concatenate((a, b))
print(c)

print("*************")
#按列拼接
# 创建两个二维数组
a2 = np.array([[1, 2], [3, 4]])
b2 = np.array([[5, 6], [7, 8]])
# 按列拼接这两个数组
c2 = np.concatenate((a2, b2), axis=1)
print(c2)

输出：

[1 2 3 4 5 6]
*************
[[1 2 5 6]
 [3 4 7 8]]

np.random.beta()

np.random.beta() 是 NumPy 库中的一个函数，用于生成服从 Beta 分布的随机数。Beta 分布是一种连续概率分布，通常用于描述在一定范围内介于两个值之间的随机变量。

函数解析

函数：

np.random.beta(a, b)

a：代表 Alpha 分布的参数，也称作形状参数1。
b：代表 Beta 分布的参数，也称作形状参数2。

返回值：
从 Beta 分布中抽取的随机样本。

运行示例

import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子以确保结果可复现
np.random.seed(0)

# 设置参数 a 和 b
a = 2.0
b = 5.0

# 生成服从 Beta 分布的随机数
samples = np.random.beta(a, b, 1000)

# 使用 matplotlib 绘制 Beta 分布图
plt.hist(samples, bins=30, density=True, alpha=0.6, color='g')
plt.xlabel('Value')
plt.ylabel('Probability Density')
plt.title('Beta Distribution')
plt.show()

在上面的示例中，我们设置了 a=2.0 和 b=5.0 作为 Beta 分布的参数，生成了 1000 个服从该分布的随机数，并使用 Matplotlib 绘制了它们的直方图。

np.maximum()

np.maximum() 是 NumPy 库中的一个函数，用于比较两个或更多个数组元素，并返回每个元素的最大值。

函数解析

函数原型：
np.maximum(x1, x2, *args)

参数：
x1, x2, *args：要进行比较的数值或数组。可以输入任意数量的参数。

返回值：
返回一个相同的形状和类型与输入参数的数组，其中每个元素都是输入参数在该位置上的最大值。

运行示例

import numpy as np

# 对于两个数值
print(np.maximum(3, 4))  

# 对于numpy数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([3, 2, 1])

print(np.maximum(arr1, arr2)) 

输出：

4
[3 2 3]

在上面的示例中，我们看到 np.maximum() 函数可以用于两个数值或两个numpy数组。对于两个数值，它返回较大的那个数值。对于numpy数组，它在每个位置上比较两个数组的元素，并返回一个新数组，其中每个元素都是输入数组在该位置上的最大值。

np.maximum.accumulate()

np.maximum.accumulate 是 NumPy 库中的一个函数，它用于计算输入数组中元素的累积最大值。这个函数接受一个输入数组，然后返回一个累积最大值数组。

函数解析

函数原型为：

numpy.maximum.accumulate(array)
其中 array 是输入的数组。

运行示例

例子1

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
result = np.maximum.accumulate(arr)
print(result)

输出结果：

[1 2 3 4 5]

这个例子中，输入数组 [1, 2, 3, 4, 5] 的累积最大值数组仍然是 [1, 2, 3, 4, 5]，因为每个元素本身都是它之前的最大值。

例子2

import numpy as np

arr = np.array([5, 3, 8, 9, 6])
result = np.maximum.accumulate(arr)
print(result)

输出：

[5 5 8 9 9]

np.minimum()

该函数与np.maximum()原理类似，是 NumPy 库中的一个函数，用于比较两个或更多个数组元素，并返回每个元素的最小值。

函数解析

函数原型：
np.minimum(x1, x2, *args)

参数：
x1, x2, *args：要进行比较的数值或数组。可以输入任意数量的参数。

返回值：
返回一个相同的形状和类型与输入参数的数组，其中每个元素都是输入参数在该位置上的最小值。

运行示例

import numpy as np

# 对于两个数值
print(np.minimum(3, 4))  

# 对于numpy数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([3, 2, 1])
print(np.minimum(arr1, arr2)) 

输出：

3
[1 2 1]

在上面的示例中，我们看到 np.minimum() 函数可以用于两个数值或两个numpy数组。对于两个数值，它返回较小的那个数值。对于numpy数组，它在每个位置上比较两个数组的元素，并返回一个新数组，其中每个元素都是输入数组在该位置上的最小值。

np.full()

np.full() 是 NumPy 库中的一个函数，用于创建一个具有指定形状和填充值的数组。

函数解析

函数原型：
np.full(shape, fill_value, dtype=None)

参数：
shape：一个表示数组形状的元组或整数。例如，(3, 4) 表示一个 3 行 4 列的二维数组。
fill_value：要填充在数组中的值。可以是任何 NumPy 数据类型。
dtype：可选参数，表示数组的数据类型。如果未指定，则默认为 None，即根据 fill_value 的类型进行推断。

返回值：
返回一个具有指定形状和填充值的 NumPy 数组。

运行示例

import numpy as np

# 创建一个形状为 (3, 4) 的二维数组，填充值为 0
arr = np.full((3, 4), 0)
print(arr)

# 创建一个形状为 (2, 3) 的二维数组，填充值为 1.5，数据类型为 float
arr = np.full((2, 3), 1.5, dtype=float)
print(arr)

输出：

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
[[1.5 1.5 1.5]
 [1.5 1.5 1.5]]

在上面的示例中，我们看到 np.full() 函数可以用于创建一个具有指定形状和填充值的数组。第一个示例中，我们创建了一个形状为 (3, 4) 的二维数组，并将所有元素填充为 0。第二个示例中，我们创建了一个形状为 (2, 3) 的二维数组，并将所有元素填充为 1.5，并指定了数据类型为 float。

np.ascontiguousarray()

np.ascontiguousarray() 是 NumPy 库中的一个函数，用于将输入的数组重新构造为连续的内存块。这个函数在处理需要连续内存的函数（如 np.dot() 或 np.fft.fft2()）时非常有用。

函数解析

函数原型：
np.ascontiguousarray(a, dtype=None)

参数：
a：输入数组。可以是任何形状和类型的数组。
dtype：可选参数，表示返回数组的数据类型。如果未指定，则默认为 None，即使用与输入数组相同的类型。

返回值：
返回一个连续的内存块表示的数组，与输入数组 a 具有相同的形状和值。

运行示例

import numpy as np

# 创建一个形状为 (3, 4) 的二维数组，填充值为 0
arr = np.zeros((3, 4))
print("Original array:")
print(arr)

# 使用 np.ascontiguousarray() 重构数组
arr_contiguous = np.ascontiguousarray(arr)
print("Reconstructed array:")
print(arr_contiguous)

输出：

Original array:
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
Reconstructed array:
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

在上面的示例中，我们首先创建了一个形状为 (3, 4) 的二维数组，并将所有元素填充为 0。然后，我们使用 np.ascontiguousarray() 函数将该数组重构为连续的内存块表示。可以看到，返回的数组与原始数组具有相同的形状和值。

np.random.seed()

np.random.seed() 是 NumPy 库中的一个函数，用于设置随机数生成器的种子。种子是一个整数或一个整数序列，用于控制随机数生成器的行为，以确保生成的随机数序列是可重复的。

函数解析

函数原型：
np.random.seed(seed)

参数：
seed：可选参数，用于设置随机数生成器的种子。可以是整数或一个整数序列。如果未指定，则默认为 None，此时随机数生成器会生成一个随机种子。

返回值：
该函数没有返回值。

运行示例

import numpy as np

# 设置随机数生成器的种子为 100
np.random.seed(100)

# 生成一个随机数
random_number = np.random.rand()
print("Random number:", random_number)

# 设置随机数生成器的种子为 None（默认）
np.random.seed()

# 再次生成一个随机数
random_number = np.random.rand()
print("Random number:", random_number)

输出：

Random number: 0.5434049417909654
Random number: 0.7352229465659721

在上面的示例中，我们首先使用 np.random.seed(100) 设置随机数生成器的种子为 100，并生成一个随机数。然后，我们使用 np.random.seed() 将种子重置为默认值（None），并再次生成一个随机数。可以看到，由于种子不同，生成的随机数也不同。因此，通过设置种子，我们可以确保在多次运行程序时得到相同的随机数序列。

np.stack()

np.stack() 是 NumPy 库中的一个函数，用于将一个或多个数组沿着新的维度堆叠在一起。这个函数返回一个新数组，其中包含原始数组中的所有元素，但它们沿着新的维度排列。

函数解析

函数原型：
np.stack(arrays, axis=0)

参数：
arrays：一个或多个数组，这些数组将被堆叠在一起。
axis：可选参数，表示沿着哪个维度进行堆叠。默认为 0，表示在第一个维度（行）上进行堆叠。

返回值：
返回一个新的 NumPy 数组，其中包含原始数组中的所有元素，但它们沿着新的维度排列。

运行示例

import numpy as np

# 创建两个一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 使用 np.stack() 将它们堆叠在一起，得到一个二维数组
c = np.stack((a, b))
print("Stacked array:")
print(c)

#按列堆叠
c1 = np.stack((a, b),axis=1)
print("Stacked array1:")
print(c1)

输出：

Stacked array:
[[1 2 3]
 [4 5 6]]
Stacked array1:
[[1 4]
 [2 5]
 [3 6]]

在上面的示例中，我们创建了两个一维数组 a 和 b，然后使用 np.stack() 将它们堆叠在一起，得到一个二维数组 c。可以看到，c 是一个二维数组，其中包含了 a 和 b 中的所有元素，但它们沿着新的维度排列。

np.unique

np.unique 是 NumPy 库中的一个函数，用于从数组中返回唯一值，并按升序排序。它返回一个包含唯一值的数组，以及一个包含这些唯一值在原数组中首次出现的索引的数组。

函数解析

函数原型：
np.unique(arr, return_index=False, return_inverse=False)

参数：
arr：输入数组，可以是多维数组。
return_index：可选参数，如果为 True，则除了返回唯一值之外，还返回这些唯一值在原数组中首次出现的索引。默认为 False。
return_inverse：可选参数，如果为 True，则除了返回唯一值之外，还返回一个索引数组，该数组可用于将唯一值数组重新构造为原始数组。默认为 False。

返回值：
返回一个包含唯一值的数组，以及可选的索引数组或索引数组的组合（根据参数 return_index 和 return_inverse 的设置）。

运行示例

import numpy as np

# 创建一个一维数组
arr = np.array([2, 5, 1, 2, 4, 3, 5])

# 使用 np.unique() 找到唯一值并按升序排序
unique_values = np.unique(arr)
print("Unique values:", unique_values)

# 使用 np.unique() 找到唯一值并按升序排序，并返回首次出现的索引
unique_values, indices = np.unique(arr, return_index=True)
print("Unique values:", unique_values)
print("Indices:", indices)


# 使用 np.unique() 找到唯一值并按升序排序，并返回一个索引数组，用于重新构造原始数组
unique_values, inverse = np.unique(arr, return_inverse=True)
print("Unique values:", unique_values)
print("Inverse:", inverse)

输出：

Unique values: [1 2 3 4 5]
Unique values: [1 2 3 4 5]
Indices: [2 0 5 4 1]
Unique values: [1 2 3 4 5]
Inverse: [1 4 0 1 3 2 4]

在上面的示例中，我们首先创建了一个包含重复值的一维数组 arr。然后使用 np.unique() 找到 arr 中的唯一值并按升序排序，将结果存储在变量 unique_values 中。接下来，我们使用 return_index=True 和 return_inverse=True 参数来获取更多信息。当 return_index=True 时，函数返回一个包含唯一值及其在原数组中首次出现的索引的元组。当 return_inverse=True 时，函数返回一个索引数组，该数组可用于将唯一值数组重新构造为原始数组（根据原数组中的值在排序中的位置，如原数组中第一个值2，在排序中是在第二个位置，则最后生成的索引则为1，即得到的新数组第一个值为1）。

np.zeros_like

np.zeros_like 是一个 NumPy 函数，它创建一个与给定数组形状相同、元素值全为零的新数组。这个函数对于快速复制形状并填充零非常有用。

函数解析

函数原型：
np.zeros_like(a, dtype=None, order='K', subok=False)

参数解释：
a: 输入数组。函数将创建与这个数组形状相同的新数组。
dtype: 数据类型，可选参数。如果未指定，则默认为 None，这意味着新数组的数据类型将与输入数组相同。
order: 排序方式，可选参数。如果为 'K'，则按照输入数组的内存顺序创建新数组。如果为 'C'，则使用行优先方式创建数组。默认值为 'K'。
subok: 如果为 True，则允许创建子类的实例。默认值为 False。

返回值：
返回一个新数组，其形状与输入数组相同，所有元素值都为零。

运行示例

import numpy as np

# 创建一个形状为 (3, 3) 的随机数组
a = np.random.rand(3, 3)
print("Original array:", a)

# 创建一个与 a 形状相同、元素值全为零的新数组
b = np.zeros_like(a)
print("Zero array:", b)

输出：

Original array:
 [[0.03055982 0.10393955 0.52521327]
 [0.24149545 0.23694233 0.41798272]
 [0.72414372 0.26958905 0.2894202 ]]
Zero array:
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

这段代码将首先创建一个形状为 (3, 3) 的随机数组 a，然后使用 np.zeros_like 函数创建一个与 a 形状相同、元素值全为零的新数组 b。

np.save （）

np.save() 是 NumPy 库中的一个函数，用于将数组保存到 .npy 文件中。这种文件格式可以用于在之后重新加载数组。

函数解析

函数原型：
numpy.save(file, arr, allow_pickle=True, fix_imports=True, do_compression=False)

参数：
file：要保存到的 .npy 文件的路径。
arr：要保存的数组。
allow_pickle：布尔值，决定是否允许 pickling 数据。默认为 True。
fix_imports：布尔值，决定是否应该尝试修复不兼容的导入。默认为 True。
do_compression：布尔值，决定是否应该对文件进行压缩。默认为 False。

运行示例

import numpy as np

# 创建一个数组
arr = np.array([[1, 2], [3, 4]])

# 将数组保存到 .npy 文件
np.save('my_array.npy', arr)

同级别文件夹中生成了一个“my_array.npy”文件，内容为：

用记事本打开有些乱码。

np.load （）

np.load 是 NumPy 库中的一个函数，用于从 .npy 文件中加载数组。这种文件是由 np.save 函数创建的。np.load 函数非常适合用于恢复之前保存的数组，以便可以在之后的代码中使用。

函数解析

函数原型：
numpy.load(file, mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')

参数：
file：要加载的 .npy 文件的路径。
mmap_mode：可选参数，用于指定内存映射模式的文件加载。默认值是 None。
allow_pickle：布尔值，决定是否允许加载 pickle 数据。默认为 True。
fix_imports：布尔值，决定是否应该尝试修复不兼容的导入。默认为 True。
encoding：字符串，用于指定编码方式。默认为 'ASCII'。

运行示例

import numpy as np

# 创建一个数组
arr = np.array([[1, 2], [3, 4]])

# 将数组保存到 .npy 文件
np.save('my_array.npy', arr)
# 加载 .npy 文件
loaded_arr = np.load('my_array.npy')

# 打印加载的数组
print(loaded_arr)

输出：

[[1 2]
 [3 4]]

np.floor()

np.floor() 是 NumPy 库中的一个函数，用于对输入的数字或数组进行向下取整。具体来说，np.floor(x) 会返回不大于 x 的最大整数。如果 x 是一个数组，那么 np.floor(x) 会返回一个新的数组，其中每个元素都是 x 中相应元素的最大整数。

函数解析

函数原型为：
numpy.floor(x)
其中 x 是输入的数字或数组。

运行示例

import numpy as np

# 对单个数字进行向下取整
print(np.floor(3.14))  
print("**********")
print(np.floor(3)) 
print("**********")

# 对数组进行向下取整
print(np.floor([3.14, 2.71, 1.41]))  
print("**********")
print(np.floor([[3.14, 2.71], [1.41, 1.69]]))  

输出：

3.0
**********
3.0
**********
[3. 2. 1.]
**********
[[3. 2.]
 [1. 1.]]

np.ceil()

np.ceil() 是 NumPy 库中的一个函数，用于对输入的数字或数组进行向上取整。具体来说，np.ceil(x) 会返回大于等于 x 的最小整数。如果 x 是一个数组，那么 np.ceil(x) 会返回一个新的数组，其中每个元素都是 x 中相应元素的最小整数。

函数解析

函数原型为：
numpy.ceil(x)
其中 x 是输入的数字或数组。

运行示例

import numpy as np
# 对单个数字进行向上取整
print(np.ceil(3.14)) 
print("**********")
print(np.ceil(3)) 
print("**********")

# 对数组进行向上取整
print(np.ceil([3.14, 2.71, 1.41]))  
print("**********")
print(np.ceil([[3.14, 2.71], [1.41, 1.69]]))  

输出：

4.0
**********
3.0
**********
[4. 3. 2.]
**********
[[4. 3.]
 [2. 2.]]

np.flipud()

np.flipud() 是 NumPy 库中的一个函数，用于沿着垂直轴翻转数组。具体来说，np.flipud(a) 会返回一个新数组，其中原数组 a 的每一行都被翻转。

函数解析

函数原型为：
numpy.flipud(a)
其中 a 是输入的数组。

运行示例

import numpy as np

# 创建一个 3x3 的二维数组
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original array:")
print(a)

# 使用 np.flipud() 翻转数组
b = np.flipud(a)
print("Flipped array:")
print(b)

输出：

Original array:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
Flipped array:
[[7 8 9]
 [4 5 6]
 [1 2 3]]

np.fliplr()

np.fliplr() 是 NumPy 库中的一个函数，用于沿着水平轴翻转数组。具体来说，np.fliplr(a) 会返回一个新数组，其中原数组 a 的每一列都被翻转。

函数解析

函数原型为：
numpy.fliplr(a)
其中 a 是输入的数组。

运行示例

import numpy as np

# 创建一个 3x3 的二维数组
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original array:")
print(a)

# 使用 np.fliplr() 翻转数组
b = np.fliplr(a)
print("Flipped array:")
print(b)

输出结果：

Original array:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
Flipped array:
[[3 2 1]
 [6 5 4]
 [9 8 7]]

np.hstack()

np.hstack() 是 NumPy 库中的一个函数，用于将两个或更多的数组沿着水平轴（即列）连接起来。这个函数会沿着水平轴（即列）将输入的数组堆叠起来。这意味着输出的数组的列数将是输入数组的列数之和，而行数将是输入数组中最大行数的值。

函数解析

函数原型为：
numpy.hstack(tup)
其中 tup 是一个元组，包含了你想要堆叠的数组。

运行示例

一维数组

import numpy as np

# 创建两个一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 使用 np.hstack() 将它们堆叠起来
c = np.hstack((a, b))
print(c)  

输出：

[1 2 3 4 5 6]

二维数组

import numpy as np

# 创建两个二维数组
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

# 使用 np.hstack() 将它们堆叠起来
c = np.hstack((a, b))

print(c)

输出：

[[1 2 5 6]
 [3 4 7 8]]

np.vstack()

在NumPy中，用于按行堆叠（即在水平方向上堆叠）的函数是np.vstack()。这个函数将两个或更多的数组沿着垂直轴（即行）堆叠起来。

函数解析

数原型为：
numpy.vstack(tup)
其中tup是一个元组，包含了你想要堆叠的数组。

运行示例

import numpy as np

# 创建两个二维数组
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
# 使用 np.vstack() 将它们堆叠起来
c = np.vstack((a, b))
print("按行堆叠:")
print(c)

输出：

按行堆叠:
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

np.bincount()

np.bincount()函数是NumPy库中的一个函数，用于统计数组中每个元素出现的次数。

函数解析

函数原型为：
numpy.bincount(x[, minlength])
参数：
x：一个数组，其中包含要统计的元素。
minlength：可选参数，指定返回结果的长度。如果指定了此参数，那么当x的长度小于minlength时，将会用0补充结果。

返回值：
这个函数会返回一个长度与x中不同元素个数相同的数组，其中每个元素表示相应元素在x中出现的次数。

运行示例

import numpy as np

# 创建一个一维数组
arr = np.array([0, 1, 1, 2, 3, 3, 3, 2])

# 使用 np.bincount() 统计每个元素出现的次数
counts = np.bincount(arr)

print("元素出现的次数：")
print(counts)

输出：

元素出现的次数：
[1 2 2 3]

np.argmax()

np.argmax() 是 NumPy 库中的一个函数，它返回输入数组中最大值的索引。这是一个非常实用的函数，特别是在处理多维数组时。

函数解析

函数原型为：
numpy.argmax(a, axis=None)

参数：
a：输入的数组。
axis：可选参数，表示沿着哪个轴进行操作。如果 axis 为 None，则函数会返回输入数组中最大值的索引。如果指定了 axis，则函数会返回该轴上最大值的索引。例如，如果 axis 等于 1，函数会返回每一行中最大值的索引。

运行示例

一维数组

import numpy as np

# 创建一个一维数组
arr = np.array([1, 3, 5, 2, 4])
# 使用 np.argmax() 找到最大值的索引
max_index = np.argmax(arr)

print("最大值的索引：", max_index)

输出：

最大值的索引： 2

二维数组（默认行为）

import numpy as np

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 使用 np.argmax() 找到最大值的索引（默认行为是沿着最后一维）
max_index = np.argmax(arr)

print("最大值的索引：", max_index) 

输出：

最大值的索引： 8

二维数组（指定轴）

0是列，1是行

import numpy as np

# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [2, 8, 9]])

# 使用 np.argmax() 沿着第一维找到最大值的索引（axis=0）
max_index_axis0 = np.argmax(arr, axis=0)
print("沿着第一维最大值的索引：", max_index_axis0)

# 使用 np.argmax() 沿着第二维找到最大值的索引（axis=1）
max_index_axis1 = np.argmax(arr, axis=1)
print("沿着第二维最大值的索引：", max_index_axis1)

输出：

沿着第一维最大值的索引： [1 2 2]
沿着第二维最大值的索引： [2 2 2]

np.argmin()

np.argmin() 是 NumPy 库中的一个函数，它返回输入数组中最小元素的索引。该函数的行为会根据输入数组的维度而变化。

函数解析

运行示例

一维数组

import numpy as np

# 创建一个一维数组
arr = np.array([1, 3, 5, 2, 4])
# 使用 np.argmin() 找到最小值的索引
min_index = np.argmin(arr1)

print("最大值的索引：", max_index)

输出：

最小值的索引： 0

二维数组（默认行为）

import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 使用 np.argmin() 找到最小值的索引（默认行为是沿着最后一维）
min_index = np.argmin(arr)

print("最小值的索引：", min_index)  

输出：

最大值的索引： 0

二维数组（指定轴）

0是列，1是行

import numpy as np

# 创建一个二维数组
arr2 = np.array([[3, 2, 1], [1, 5, 6], [7, 8, 9]])

# 使用 np.argmin() 沿着第一维找到最小值的索引（axis=0）
min_index_axis0 = np.argmin(arr2, axis=0)
print("沿着第一维最小值的索引：", min_index_axis0)

# 使用 np.argmin() 沿着第二维找到最小值的索引（axis=1）
min_index_axis1 = np.argmin(arr2, axis=1)
print("沿着第二维最小值的索引：", min_index_axis1)  

输出：

沿着第一维最小值的索引： [1 0 0]
沿着第二维最小值的索引： [2 0 0]

np.argsort()

np.argsort() 是 NumPy 库中的一个函数，它返回输入数组中元素的排序索引。这个函数非常有用，特别是在需要排序数组并获取排序索引时。

函数解析

函数原型为：
numpy.argsort(a, kind='quicksort', axis=-1, order=None)

参数：
a：输入的数组。
kind：排序算法的类型。可以是 'quicksort'、'heapsort'、'stable' 等。默认是 'quicksort'。
axis：沿着哪个轴进行排序。默认是 -1，表示在最后一个轴上排序。
order：排序的顺序。可以是 'ascending'（升序）或 'descending'（降序）。

这个函数返回一个整数数组，表示输入数组中每个元素在排序后数组中的索引位置。这个数组可以用于重新构造排序后的数组，或者用于其他需要排序索引的操作。默认是升序

运行示例

一维数组排序索引

import numpy as np

# 创建一个一维数组
arr = np.array([3, 1, 2])

# 使用 np.argsort() 获取排序索引
sort_index = np.argsort(arr)

print("排序索引：", sort_index)  

输出：

排序索引： [1 2 0]

二维数组排序索引

import numpy as np

# 创建一个二维数组
arr = np.array([[3, 1, 2], [5, 4, 7], [6, 8, 9]])

# 使用 np.argsort() 沿着最后一维获取排序索引
sort_index = np.argsort(arr, axis=-1)

print("排序索引：", sort_index) 

输出：

排序索引： [[1 2 0]
 [1 0 2]
 [0 1 2]]

使用排序索引重新构造数组

import numpy as np

# 创建一个二维数组
arr = np.array([[3, 1, 2], [5, 4, 7], [6, 8, 9]])

# 使用 np.argsort() 沿着最后一维获取排序索引
sort_index = np.argsort(arr, axis=-1)
print("重新构造的数组：", sort_index )

# 使用排序索引重新构造数组
sorted_arr = arr[np.argsort(sort_index)]

print("重新构造的数组：", sorted_arr)

输出：

重新构造的数组： [[1 2 0]
 [1 0 2]
 [0 1 2]]
重新构造的数组： [[[6 8 9]
  [3 1 2]
  [5 4 7]]

 [[5 4 7]
  [3 1 2]
  [6 8 9]]

 [[3 1 2]
  [5 4 7]
  [6 8 9]]]

np.set_printoptions()

np.set_printoptions 是 NumPy 库中的一个函数，它用于设置打印数组时的默认选项。这可以帮助你控制 NumPy 打印输出的格式和精度。

函数解析

函数原型：
numpy.set_printoptions(precision, threshold, edgeitems, linewidth, max_line_width)

参数:
precision：控制浮点数的精度，即小数点后的位数。默认值是 None，表示使用默认精度。
threshold：控制数组元素的总数，当元素数量大于该阈值时，会使用省略号表示。默认值是 None，表示不使用省略号。
edgeitems：控制数组边缘的元素数量，当数组边缘的元素数量小于该值时，会在边缘添加省略号。默认值是 3。
linewidth：控制每行的最大字符数，超过该值的元素会被分割到下一行。默认值是 75。
max_line_width：控制每行的最大行数，超过该值的元素会被分割到多行。默认值是 None，表示不进行分割。

返回值:
该函数没有返回值。

运行示例

设置浮点数的精度

import numpy as np

np.set_printoptions(precision=4)
print(np.array([1.23456789]))

输出：

[1.2346]

设置数组元素的阈值

当元素个数大于10时，使用省略号。

import numpy as np
#控制元素个数
np.set_printoptions(threshold=10)
print(np.arange(20))

[ 0  1  2 ... 17 18 19]

设置每行的最大字符数

最大字符数设置为10

import numpy as np

np.set_printoptions(linewidth=10)
print(np.array([1, 2, 3, 4, 5]))

输出：

[1 2 3 4
 5]

np.loadtxt()

np.loadtxt 是 NumPy 库中的一个函数，用于从文本文件中加载数据并返回一个 NumPy 数组。

函数解析

函数原型：
numpy.loadtxt(filename, dtype=float, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)

参数：
filename：要加载数据的文件名，可以是字符串类型。
dtype：返回的数组的数据类型，默认为浮点型（float）。也可以传入其他 NumPy 数据类型，如 int、str 等。
delimiter：指定分隔符，用于将文本文件中的数据拆分为不同列。默认为 None，表示根据输入文件的数据类型进行自动推断。常见的分隔符包括逗号（','）、制表符('\t')等。
converters：一个字典，用于指定某些列数据的转换函数。字典的键为列索引，值为转换函数。例如，设置 converters={0: lambda x: int(x)} 将第一列数据转换为整数类型。
skiprows：要跳过的行数，用于忽略文件开头的注释或无关数据。默认为 0，表示不跳过任何行。
usecols：一个切片对象，用于指定要加载的列范围。例如，设置 usecols=(0, 2, 4) 将只加载第一、第三和第五列数据。
unpack：布尔值，用于指示是否将返回的数组解包为单独的变量。默认为 False，表示不解包。
ndmin：指定返回的数组的维度最小值。默认为 0，表示根据数据自动推断数组维度。

data.csv文件内容为：

运行示例

用.号分隔数据的文本文件

import numpy as np
data = np.loadtxt('data.csv', delimiter='.')
print(data)

输出：

[ 6.  8. 10.  1. 12. 45. 23. 14.]

加载包含注释的文本文件，并跳过前三行

import numpy as np

data = np.loadtxt('data.csv', skiprows=3)
print(data)

输出：

[ 1. 12. 45. 23. 14.]

np.linspace()

np.linspace 是 NumPy 库中的一个函数，用于在指定的间隔内生成等间距的数值序列。它返回一个 NumPy 数组，其中包含指定数量的数字，这些数字沿着标准数轴均匀分布。

函数解析

函数原型：
np.linspace(start, stop, num, endpoint=True, retstep=False, dtype=None)

参数说明：
start：序列的起始值。默认值为 0。
stop：序列的终止值。这是唯一必需的参数。
num：生成的数字序列中元素的数量。默认值为 50。
endpoint：如果为 True，stop 值将被包含在结果中。默认值为 True。
retstep：如果为 True，返回 (num, start, stop, endpoint) 的元组。默认值为 False。

运行示例

import numpy as np

arr = np.linspace(0, 1, 10)
print(arr)

arr1 = np.linspace(0, 1, 10, endpoint=True)
print(arr1)  

arr2 = np.linspace(2, 10, num=5, endpoint=True)
print(arr2)  

输出：

[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
[ 2.  4.  6.  8. 10.]

np.copy()

np.copy 是 NumPy 库中的一个函数，用于创建指定数组的副本。这个函数返回的是输入数组的一个拷贝，而不是对原始数组的引用。这意味着对返回的拷贝进行的任何更改不会影响到原始数组。

函数解析

函数原型：
numpy.copy(arr)

参数：
arr：要复制的数组。

返回值：
返回输入数组的副本。返回的数组是原始数组的一个全新副本，对它的更改不会影响原始数组。

运行示例

import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
print("原始数组：")
print(arr)

# 使用 np.copy 复制数组
arr_copy = np.copy(arr)
print("复制的数组：")
print(arr_copy)

# 修改复制的数组
arr_copy[0] = 100
print("修改后的复制数组：")
print(arr_copy)

# 原始数组未受影响
print("原始数组：")
print(arr)

输出：

原始数组：
[1 2 3 4 5]
复制的数组：
[1 2 3 4 5]
修改后的复制数组：
[100   2   3   4   5]
原始数组：
[1 2 3 4 5]

np.interp()

np.interp 是 NumPy 库中的一个函数，用于执行一维线性插值。它可以在已知的数据点之间进行插值，生成新的数据点。

函数解析

函数原型：
numpy.interp(x, xp, fp)

参数：
x：要进行插值的数据点，可以是一个一维数组或一个单独的数值。
xp：已知的数据点，是一个一维数组，表示 x 的值。
fp：已知的数据点的函数值，是一个一维数组，与 xp 具有相同的长度，表示对应于每个 x 的函数值。

返回值：
返回插值后得到的新数据点的函数值。

np.interp通过获取xp与fp之间的对应线性函数关系，估计x处的对应值来进行线性插值。

运行示例

import numpy as np

# 已知数据点
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 3, 5, 7, 11])

# 进行插值，得到新的数据点对应的函数值
x_new = np.array([1.5, 2.5, 3.5])
y_new = np.interp(x_new, x, y)

print(y_new)  # 输出 [2.5 4.  6. ]

输出：

[2.5 4.  6. ]

np.ndarray()

np.ndarray 是 NumPy 库中的一个类，用于创建和操作多维数组对象。np.ndarray 可以包含不同类型的数据，例如整数、浮点数、字符串等。

函数解析

class numpy.ndarray:
    def __init__(self, shape, dtype=float, buffer=None, offset=0, strides=None, order=None):
        # 构造函数，用于创建 ndarray 对象
        self.shape = shape  # 数组的形状
        self.dtype = dtype  # 数组的数据类型
        self.buffer = buffer  # 数组数据的内存块
        self.offset = offset  # 数组数据在内存块中的偏移量
        self.strides = strides  # 数组每个维度在内存中的跨度
        self.order = order  # 数组数据的存储方式（默认值：None）
常用参数：
shape：返回数组的形状。例如：arr.shape = (3,4) 表示数组是一个 3 行 4 列的二维数组。
dtype：返回数组的数据类型。例如：arr.dtype = int 表示数组中的元素都是整数类型。

运行示例

 import numpy as np

# 创建一个 2x3x4 的三维数组
data = np.ndarray((2, 3, 4), dtype=int)

# 为数组元素赋值
for i in range(data.shape[0]):
    for j in range(data.shape[1]):
        for k in range(data.shape[2]):
            data[i, j, k] = i + j + k

print("三维数组：")
print(data)

输出：

[[[0 1 2 3]
  [1 2 3 4]
  [2 3 4 5]]

 [[1 2 3 4]
  [2 3 4 5]
  [3 4 5 6]]]

np.fromfile()

np.fromfile() 是 NumPy 库中的一个函数，它从一个二进制文件中读取数据并返回一个数组。这个函数特别适合处理大型数据集，因为它可以直接从文件中读取数据，而不需要将整个文件加载到内存中。

函数解析

函数原型：

函数原型：
numpy.fromfile(file, dtype=float, count=-1, sep='')

参数解释：
file：需要读取的二进制文件。
dtype：期望的数据类型。例如，np.int32、np.float64 等。默认值是 float。
count：要读取的元素数量。如果设置为 -1，将读取所有剩余的元素。默认值是 -1。
sep：元素之间的分隔符。在 NumPy 中，默认分隔符是 None，表示根据数据类型确定分隔符。

运行示例

import numpy as np

# 创建一个包含数据的二进制文件
data = np.array([1, 2, 3, 4, 5], dtype=np.int32).tofile('data.bin')

# 从文件中读取数据并存储为 NumPy 数组
arr = np.fromfile('data.bin', dtype=np.int32)
print(arr)  

arr1 = np.fromfile('data.bin', dtype=np.int32, count=3)
print(arr1)  

输出：

[1 2 3 4 5]
[1 2 3]

np.convolve()

np.convolve 是 NumPy 库中的一个函数，用于执行卷积运算。卷积是一种在信号处理、图像处理和机器学习等领域广泛应用的运算。

函数解析

函数原型：
numpy.convolve(in1, in2, mode='full', axis=-1)

参数：
in1：第一个输入数组。
in2：第二个输入数组。
mode：卷积的模式，有四种模式可选：'full'、'valid'、'same'、'linear'。默认为 'full'。
'full'：输出是完整的重叠区域。
'valid'：输出仅包含完全重叠的点。
'same'：输出是输入的长度相同的中央部分。
'linear'：使用线性滤波器，输出是输入的长度相同的中央部分，但边缘效应被线性滤波器处理。
axis：进行卷积操作的轴。默认为 -1，表示在最后一个轴上操作。

运行示例

卷积运算

import numpy as np

vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])
convolution = np.convolve(vector1, vector2, mode='full')
print(convolution) 

输出：

 [ 4 13 28 27 18]

np.trapz()

np.trapz 是 NumPy 库中的一个函数，用于计算梯形积分。这个函数在数值积分中非常有用，特别是在那些不能轻易找到解析解的问题中。

梯形法是一种数值积分方法，其基本思想是在被积函数曲线的下方“画梯形”，然后用梯形的面积近似代替所求的积分。

函数解析

可以这样形象地理解 np.trapz：想象你在平面上铺设了多个“梯形”小块（由函数在特定点的取值决定），这些梯形的宽度都是 dx ，高度就是函数的取值。然后，把这些梯形的面积加起来，就得到了这个函数在该区间上的积分值。

函数原型：
numpy.trapz(x, y=None, dx=1.0)

参数说明：
x：一维的数组或者列表，作为积分的下限。
y：一维的数组或者列表，作为积分的上限。如果未提供，默认为 None，此时函数会返回从 x[0] 到 x[-1] 的积分。
dx：间距的长度，如果 x 是等间隔的，那么 dx 应该被设定为 1.0。默认值为 1.0。

返回值：
返回一个浮点数，表示所求的梯形积分值。

运行示例

import numpy as np
x = np.linspace(0, 3, 100)  # 创建一个等间隔的数组，作为积分的下限和上限
y = x**2  # 定义函数 f(x) = x^2 在每个点的取值

integral = np.trapz(y, x)  # 计算积分
print(f"The integral of f(x) = x^2 from 0 to 3 is: {integral}")  # 输出积分的结果

输出:

The integral of f(x) = x^2 from 0 to 3 is: 9.000459136822775

上述示例中，我们使用了 np.linspace(0, 3, 100) 来生成等间隔的数组 x，这只是为了方便我们手动构造一个具体的函数。在实际应用中，你可能会直接使用函数在其他点的取值作为 y。

np.where()

np.where() 是一个非常有用的函数，它返回输入数组中满足给定条件的元素的索引。这个函数在很多情况下都非常有用，比如在数据分析和处理中进行条件判断。

函数解析

函数原型：
numpy.where(condition[, x, y])

参数说明：
condition：当只使用一个条件时，它是一个用于测试每个元素的布尔（真/假）数组。当使用两个条件时，它是一个（n，2）数组，每行包含一个布尔测试。
x, y：当只使用一个条件时，x 和 y 是用于替换满足和不满足条件的元素的数组。当使用两个条件时，x 和 y 是用于替换每行的元素的数组。

返回值：
当只使用一个条件时，返回一个包含满足条件的元素的数组。当使用两个条件时，返回一个包含替换每行元素的数组。

运行示例

单条件

import numpy as np

# 创建一个随机数组
arr = np.random.randint(0, 10, size=(5,))
print("Original array:", arr)

# 使用np.where()找出所有大于5的元素，并用9替换它们
new_arr = np.where(arr > 5, 9, arr)
print("New array with replaced values:", new_arr)

输出：

Original array: [2 2 6 1 9]
New array with replaced values: [2 2 9 1 9]

多条件

import numpy as np

# 创建一个随机数组
arr = np.random.randint(0, 10, size=(5,2))
print("Original array:", arr)

# 使用np.where()找出第一列大于5的元素，并用9替换它们；同时找出第二列小于6的元素，并用11替换它们
new_arr = np.where(np.c_[arr[:,0] > 5, arr[:,1] < 6], [9, 11], arr)
print("New array with replaced values:", new_arr)

输出：

Original array: [[8 3]
 [3 6]
 [3 1]
 [5 0]
 [2 3]]
New array with replaced values: [[ 9 11]
 [ 3  6]
 [ 3 11]
 [ 5 11]
 [ 2 11]]

np.sum()

np.sum() 是 NumPy 库中的一个函数，用于计算数组中元素的总和。它接受一个或多个数组作为输入，并返回这些数组元素的和。

函数解析

函数原型：
numpy.sum(array, axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)

参数说明：
array：输入的数组。可以是标量（在调用 np.sum() 时将计算其和），也可以是 NumPy 数组。
axis：可选参数，表示沿哪个轴进行求和。默认值是 None，表示对整个数组进行求和。如果输入的是一个标量，则该参数无效。
dtype：可选参数，表示返回的数组的数据类型。默认值是 None，表示使用与输入数组相同的数据类型。
out：可选参数，表示输出的数组。如果提供了一个 out 参数，则求和操作将在这个数组中进行，而不是创建一个新的数组。
keepdims：可选参数，表示是否保持被求和的维度。如果为 True，则返回的数组将保留被求和的维度，这些维度的长度为 1。
initial：可选参数，表示在求和操作中添加到每个元素之前的初始值。默认值是 0。
where：可选参数，表示一个布尔掩码，决定哪些元素应该被包括在求和操作中。默认值是 True，表示对所有元素进行求和。

返回值：
返回一个 NumPy 数组，其中包含输入数组的元素的和。如果 axis 参数为 None，则返回一个标量。

运行示例

import numpy as np

#对一个 NumPy 数组进行求和：
arr = np.array([1, 2, 3, 4, 5])
result = np.sum(arr)
print(result)  

#对多个 NumPy 数组进行求和：
import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result1 = np.sum([arr1, arr2])
print(result1)  

#沿着某个轴进行求和：
import numpy as np

arr3 = np.array([[1, 2], [3, 4]])
result3 = np.sum(arr3, axis=0)
print(result3)  

输出：

15
21
[4 6]

np.nan()

函数解析

np.nan 是 NumPy 库中的一个特殊值，表示“非数字”（Not a Number）。它是 NaN 的缩写，是一个IEEE标准，用于表示结果无法定义或无法表示的数学运算。

使用方法：
创建 NaN 值的常用方法就是调用 np.nan 函数。

运行示例

import numpy as np

# 使用 np.nan 创建 NaN 数组
nan_array = np.array([1, 2, np.nan, 4])
print(nan_array)

输出：

[ 1.  2. nan  4.]

np.log()

np.log() 是 NumPy 库中的一个函数，用于计算自然对数（以 e 为底）。

函数解析

函数原型：
numpy.log(x)

参数说明：
x：一个数值或 NumPy 数组，表示要计算其自然对数的值。

返回值：
返回输入值的自然对数。

运行示例

import numpy as np

# 计算数字 10 的自然对数
result = np.log(10)
print(result)  

array = np.array([-1, 10, 100, 1000])
# 计算这个数组中每个数字的自然对数
result1 = np.log(array)

print(result1)  

输出：

2.302585092994046
[       nan 2.30258509 4.60517019 6.90775528]
C:\Users\SW\Desktop\suishoulian\csdn\numpy_ceshi.py:776: RuntimeWarning: invalid value encountered in log
  result1 = np.log(array)

在这个示例中，如果输入数组中的值是负数或零，那么返回的将是 NaN（因为负数和零的自然对数是未定义的）。

np.linalg.lstsq()

np.linalg.lstsq() 是 NumPy 库中的一个函数，用于执行最小二乘法拟合线性方程组。它可以找到一个向量 b，使得对于给定的矩阵 A，np.dot(A, b) 尽可能接近 y。

函数解析

函数原型：
numpy.linalg.lstsq(A, y, rcond=None, overwrite_A=False, overwrite_b=False, check_finite=True, det_A=None, normed=True)

参数说明：
A：一个 n×m 的矩阵，其中 n 是线性方程组的未知数的数量，m 是方程的数量。
y：一个 n×1 的向量，表示等式右边的值。
rcond：一个可选参数，用于指定奇异值阈值。如果指定了该参数，那么当使用奇异值分解时，奇异值小于 rcond * sigma_max 的值将被截断为零，其中 sigma_max 是最大的奇异值。
overwrite_A：一个布尔值，表示是否覆盖输入的矩阵 A。
overwrite_b：一个布尔值，表示是否覆盖输入的向量 y。
check_finite：一个布尔值，表示是否检查矩阵 A 和向量 y 中的元素是否为有限值。
det_A：一个可选参数，表示矩阵 A 的行列式值的估计。
normed：一个布尔值，表示是否对解向量 b 进行归一化。

返回值：
返回一个元组 (x, residuals, rank, s = singular_values, rcond)，其中：
x：一个 m×1 的向量，表示最小二乘解。
residuals：一个 1-D 数组，表示残差平方和。
rank：矩阵 A 的秩。
s：一个 1-D 数组，表示 A 的奇异值。
rcond：如果指定了该参数，那么就是使用的奇异值的倒数阈值；否则为 None。

运行示例

import numpy as np

# 定义一个矩阵 A 和一个向量 y
A = np.array([[3, 2], [1, 7]])
y = np.array([9, 1])

# 使用 np.linalg.lstsq() 求解最小二乘解
x, residuals, rank, s = np.linalg.lstsq(A, y)

# 输出结果
print("最小二乘解：", x)

输出：

最小二乘解： [ 3.21052632 -0.31578947]

这个示例中，我们有一个 2×2 的矩阵 A 和一个 2×1 的向量 y。我们使用 np.linalg.lstsq() 函数来找到一个向量 x，使得 np.dot(A, x) 最接近 y。输出结果将显示找到的最小二乘解

np.empty()

np.empty() 是 NumPy 库中的一个函数，用于创建一个指定形状和数据类型的空数组。这个函数不初始化数组元素，因此返回的数组中元素的值是不确定的。

函数解析

函数原型：
numpy.empty(shape, dtype=float, order='C')

参数说明：
shape：一个表示数组形状的元组。例如，(3, 4) 表示一个 3 行 4 列的二维数组。
dtype：一个可选参数，表示创建的数组的数据类型。默认值是 float。其他常用的数据类型包括 int、str 等。
order：一个可选参数，表示数组在内存中的存储方式。默认值是 'C'，表示按行优先存储（类似于 C 语言中的数组）。如果指定为 'F'，则表示按列优先存储（类似于 Fortran 语言中的数组）。

返回值：
np.empty() 返回一个新的数组对象，该对象是一个指定形状和数据类型的空数组。返回的数组中的元素值不确定，因此需要在使用之前进行初始化。

运行示例

import numpy as np

# 创建一个形状为 (3, 4) 的空数组，数据类型为 float
empty_array = np.empty((3, 4), dtype=float)
print(empty_array)

输出：

[[6.23042070e-307 7.56587584e-307 1.37961302e-306 6.23053614e-307]
 [1.69121639e-306 1.05701279e-307 1.60220393e-306 6.23037996e-307]
 [6.23053954e-307 9.34603679e-307 2.22522596e-306 2.56765117e-312]]

结束语

因搜集来源有限，写的可能不全，欢迎大家评论补充，后期不定时更新。