一、数组的广播机制
通常情况下，为了进行元素级的算术运算，两个数组的形状必须完全一致，Numpy的广播机制，它提供了一种规则，能够将不同形状的两个计算数 组广播到相同形状，然后再去进行元素级的算术运算，这种规则使得形状不完全匹配 的数组也能相互运算。通过这个机制，Numpy能够在保持效率的同时，扩展数组的 操作范围，从而无需显式地扩展数组维度或进行循环遍历以实现元素级的计算，极大的增强了数组的处理能力。
具体规则为：
如果两个数组的维数不同，形状较小的数组会在前面补1。
如果两个数组的形状在某个维度上不匹配，且其中一个维度长度为1，则会沿该 维度复制扩展以匹配另一个数组的形状。
如果在任一维度上不匹配且没有维度等于1，则会引发异常。
举例：arr = np.array([[1, 2, 3], [4, 5, 6]])
arr和标量2进行相加
标量 2 的形状可以看作是（），而二维数组 arr的形状是（2, 3）。根据广播 规则，维度较低的标量会在其形状左边添加与高维数组相同的维度数，使其维度与高 维数组相同。这里标量 2 被扩展为形状（1,1）的数组，再进一步扩展为形状（2,3） 的数组，即 [[2,2,2],[2,2,2]]。然后，这个扩展后的数组与原二维数组 arr进行 对应元素的运算。所以最终结果为：
arr + 2 = [[1+2,2+2,3+2],[4+2,5+2,6+2]] = [[3,4,5],[6,7,8]]
二、数组的运算
2.1、标量和数组的运算
2.1.1、加法运算
python
import numpy as np
# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr + 2
print('original: \n', arr)
print('new: \n', b)
'''
original:
[[1 2 3]
[4 5 6]]
new:
[[3 4 5]
[6 7 8]]
'''2.1.2、减法运算
python
import numpy as np
# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr - 2
print('original: \n', arr)
print('new: \n', b)
'''
original:
[[1 2 3]
[4 5 6]]
new:
[[-1 0 1]
[ 2 3 4]]
'''2.1.3、乘法运算
python
import numpy as np
# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr * 2
print('original: \n', arr)
print('new: \n', b)
'''
original:
[[1 2 3]
[4 5 6]]
new:
[[ 2 4 6]
[ 8 10 12]]
'''2.1.4、除法运算
python
import numpy as np
# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr / 2
print('original: \n', arr)
print('new: \n', b)
'''
original:
[[1 2 3]
[4 5 6]]
new:
[[0.5 1. 1.5]
[2. 2.5 3. ]]
'''2.2、数组和数组的运算
2.2.1、加法运算
2.2.1.1、符号
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = arr1 + arr2
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[12 14 16]
[18 20 22]]
'''2.2.1.2、函数
python
numpy.add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)| 函数 | 说明 |
| x1 | 第一个输入数组或标量 |
| x2 | 第二个输入数组或标量 |
| out | 输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出 相同形状的适当类型来接收结果 |
| where | 表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果 设置为False，则在相应位置不进行计算 |
| casting | 定义如何处理数据类型转换，例如 'no', 'equiv', 'safe', 'same_kind', 'unsafe' |
| order | 指定结果的内存布局，'C' 表示 C 风格，'F' 表示 Fortran 风格，'A' 表示原 数组样式，'K' 表示元素在内存中的出现顺序 |
| dtype | 指定输出数组的类型 |
| subok | 控制返回数组是否可以是输入数组的子类 |
|---|
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = np.add(arr1,arr2)
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[12 14 16]
[18 20 22]]
'''2.2.2、减法运算
2.2.2.1、符号
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = arr1 - arr2
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[10 10 10]
[10 10 10]]
'''2.2.2.2、函数
python
numpy.subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)| 函数 | 说明 |
| x1 | 第一个输入数组或标量 |
| x2 | 第二个输入数组或标量 |
| out | 输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出 相同形状的适当类型来接收结果 |
| where | 表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果 设置为False，则在相应位置不进行计算 |
| casting | 定义如何处理数据类型转换，例如 'no', 'equiv', 'safe', 'same_kind', 'unsafe' |
| order | 指定结果的内存布局，'C' 表示 C 风格，'F' 表示 Fortran 风格，'A' 表示原 数组样式，'K' 表示元素在内存中的出现顺序 |
| dtype | 指定输出数组的类型 |
| subok | 控制返回数组是否可以是输入数组的子类 |
|---|
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = np.subtract(arr1,arr2)
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[10 10 10]
[10 10 10]]
'''2.2.3、乘法运算
2.2.3.1、符号
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = arr1 * arr2
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[11 24 39]
[56 75 96]]'''2.2.3.2、函数
python
numpy.multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)| 函数 | 说明 |
| x1 | 第一个输入数组或标量 |
| x2 | 第二个输入数组或标量 |
| out | 输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出 相同形状的适当类型来接收结果 |
| where | 表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果 设置为False，则在相应位置不进行计算 |
| casting | 定义如何处理数据类型转换，例如 'no', 'equiv', 'safe', 'same_kind', 'unsafe' |
| order | 指定结果的内存布局，'C' 表示 C 风格，'F' 表示 Fortran 风格，'A' 表示原 数组样式，'K' 表示元素在内存中的出现顺序 |
| dtype | 指定输出数组的类型 |
| subok | 控制返回数组是否可以是输入数组的子类 |
|---|
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = np.multiply(arr1,arr2)
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[11 24 39]
[56 75 96]]
'''2.2.4、除法运算
2.2.4.1、符号
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = arr1 / arr2
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[11. 6. 4.33333333]
[ 3.5 3. 2.66666667]]
'''2.2.4.2、函数
python
numpy.divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)| 函数 | 说明 |
| x1 | 第一个输入数组或标量 |
| x2 | 第二个输入数组或标量 |
| out | 输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出 相同形状的适当类型来接收结果 |
| where | 表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果 设置为False，则在相应位置不进行计算 |
| casting | 定义如何处理数据类型转换，例如 'no', 'equiv', 'safe', 'same_kind', 'unsafe' |
| order | 指定结果的内存布局，'C' 表示 C 风格，'F' 表示 Fortran 风格，'A' 表示原 数组样式，'K' 表示元素在内存中的出现顺序 |
| dtype | 指定输出数组的类型 |
| subok | 控制返回数组是否可以是输入数组的子类 |
|---|
python
import numpy as np
arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
arr3 = np.divide(arr1,arr2)
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[11 12 13]
[14 15 16]]
[[1 2 3]
[4 5 6]]
运算的结果为：
[[11. 6. 4.33333333]
[ 3.5 3. 2.66666667]]
'''2.2.5、开根号
2.2.5.1、符号
python
import numpy as np
# 生成一个2行3列的数组
arr1 = np.array([[4, 9, 16], [25, 36, 49]])
# 开根号操作就是让一个数组进行0.5次方的幂运算
arr2 = arr1 ** 0.5
print(arr1)
print('运算的结果为：\n', arr2)
'''
[[ 4 9 16]
[25 36 49]]
运算的结果为：
[[2. 3. 4.]
[5. 6. 7.]]
'''2.2.5.2、函数
python
numpy.power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)| 函数 | 说明 |
| x1 | 第一个输入数组或标量 |
| x2 | 第二个输入数组或标量 |
| out | 输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出 相同形状的适当类型来接收结果 |
| where | 表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果 设置为False，则在相应位置不进行计算 |
| casting | 定义如何处理数据类型转换，例如 'no', 'equiv', 'safe', 'same_kind', 'unsafe' |
| order | 指定结果的内存布局，'C' 表示 C 风格，'F' 表示 Fortran 风格，'A' 表示原 数组样式，'K' 表示元素在内存中的出现顺序 |
| dtype | 指定输出数组的类型 |
| subok | 控制返回数组是否可以是输入数组的子类 |
|---|
python
import numpy as np
# 生成一个2行3列的数组
arr1 = np.array([[4, 9, 16], [25, 36, 49]])
# 开根号操作就是让一个数组进行0.5次方的幂运算
arr2 = np.pow(arr1,0.5)
print(arr1)
print('运算的结果为：\n', arr2)
'''
[[ 4 9 16]
[25 36 49]]
运算的结果为：
[[2. 3. 4.]
[5. 6. 7.]]
'''2.2.6、点积
行*列
| 函数 | 说明 |
| a | 第一个输入数组 |
| b | 第二个输入数组 |
| out | 可选输出数组，用于放置运算结果 |
|---|
python
import numpy as np
# 生成两个2行3列的数组
arr1 = np.array(
[
[1,2,3],
[4,5,6],
[7,8,9]
]
)
arr2 = np.array(
[
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
)
# power会使arr1中的每个元素为底数，arr2中的对应位置的元素为指数进行运算
arr3 = np.dot(arr1, arr2)
print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)
'''
[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 2 3]
[4 5 6]
[7 8 9]]
运算的结果为：
[[ 30 36 42]
[ 66 81 96]
[102 126 150]]
'''三、统计计算
3.1、mean
该函数用于计算数组中元素的平均值。它可以计算整个数组的平均值，也可以沿着指 定的轴（axis）计算平均值。
python
numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)| 函数 | 说明 |
| a | 输入数组，可以是任何形状的数组。 |
| axis | 可选参数，用于指定计算平均值的轴。如果没有指定，则计算整个数组 的平均值。如果指定了轴，则计算该轴上元素的平均值。 |
| dtype | 可选参数，用于指定返回的平均值的数据类型。如果没有指定，则通常 返回与输入数组相同的数据类型。 |
| out | 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 |
| keepdims | 可选参数，如果设置为 True，则计算后的和会保留原始数组的维度，其值默认为False |
|---|
python
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])
# 计算整个数组的平均值
mean_arr = np.mean(arr)
# 输出结果
print(mean_arr)
# 创建一个二维数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr_2d)
# 计算整个二维数组的平均值
mean_arr_2d = np.mean(arr_2d)
# 输出结果
print(mean_arr_2d)
# 计算二维数组沿着列的平均值
mean_arr_2d_col = np.mean(arr_2d, axis=0)
# 输出结果
print(mean_arr_2d_col)
# 计算二维数组沿着行的平均值
mean_arr_2d_row = np.mean(arr_2d, axis=1)
# 输出结果
print(mean_arr_2d_row)
# 使用 keepdims=True 保留维度
mean_arr_2d_row_keepdims = np.mean(arr_2d, axis=1, keepdims=True)
# 输出结果
print(mean_arr_2d_row_keepdims)
a = np.array([np.nan, 1, 2, 3])
b = np.mean(a)
print(b)
'''
3.0
[[1 2 3]
[4 5 6]
[7 8 9]]
5.0
[4. 5. 6.]
[2. 5. 8.]
[[2.]
[5.]
[8.]]
nan
'''3.2、sum
该函数用于计算数组中所有元素的和，或者沿指定轴计算元素的和。
python
numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)| 函数 | 说明 |
| a | 输入数组，可以是任何形状的数组。 |
| axis | 可选参数，用于指定计算和的轴。如果没有指定，则计算整个数组的 和。如果指定了轴，则计算该轴上元素的和。可以是整数或元组，用于指定多个 轴。 |
| dtype | 可选参数，指定返回和的数据类型。如果未指定，则通常与输入数组的 类型相同，除非输入数组为布尔型，此时默认返回 int64 或 int32。 |
| out | 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 |
| keepdims | 可选参数，如果设置为 True，则计算后的和会保留原始数组的维度，其值默认为False |
| initial | 可选参数，如果提供，则用于指定当数组为空时的初始值。 |
| where | 可选参数，用于指定计算和的条件。 |
|---|
python
import numpy as np
arr = np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
print(arr)
# 计算整个数组的和
total_sum = np.sum(arr)
print(total_sum)
# 计算每一列的和
sum_col = np.sum(arr, axis=0, keepdims=True)
print(sum_col)
# 计算每一行的和
sum_row = np.sum(arr, axis=1)
print(sum_row)
# 保留原始维度
sum_row_keep = np.sum(arr, axis=1, keepdims=True)
print(sum_row_keep)
'''
[[1 2 3]
[4 0 6]
[7 8 9]]
40
[[12 10 18]]
[ 6 10 24]
[[ 6]
[10]
[24]]
'''3.3、max和min
numpy.max 和 numpy.min 是 NumPy 库中用于计算数组中元素最大值和最小值的函数
python
numpy.max(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
numpy.min(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)| 函数 | 说明 |
| a | 输入数组，可以是任何形状的数组。 |
| axis | 可选参数，用于指定计算最小值、最大值的轴。如果没有指定，则计算整个数组 的最小值、最大值。如果指定了轴，则计算该轴上元素的最小值、最大值。 |
| out | 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 |
| keepdims | 可选参数，如果设置为 True，则计算后的最小值、最大值会保留原始数组的维度，其默认值为False |
| initial | 可选参数，如果提供，则用于指定当数组为空时的初始值。 |
| where | 可选参数，用于指定计算最小值、最大值的条件。 |
|---|
python
import numpy as np
arr = np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
print(arr)
# 计算整个数组的最大值
max_val = np.min(arr)
print(max_val)
# 计算每一列的最大值
max_val_col = np.min(arr, axis=0)
print(max_val_col)
# 计算每一行的最大值
max_val_row = np.min(arr, axis=1)
print(max_val_row)
'''
[[1 2 3]
[4 0 6]
[7 8 9]]
0
[1 0 3]
[1 0 7]
'''3.4、var
numpy.var 用于计算数组中所有元素或沿指定轴的方差。方差是衡量一组数值分散 程度的统计量，它是各个数值与其平均数差的平方的平均数。
python
numpy.var(a, axis=None, dtype=None, out=None, keepdims=<no value>)| 函数 | 说明 |
| a | 输入数组，可以是任何形状的数组。 |
| axis | 可选参数，用于指定计算方差的轴。如果没有指定，则计算整个数组的 方差。如果指定了轴，则计算该轴上元素的方差。可以是整数或元组，用于指定 多个轴。 |
| dtype | 可选参数，指定返回方差的数据类型。如果未指定，则通常与输入数组 的类型相同。 |
| out | 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 |
| keepdims | 可选参数，如果设置为True,则计算后的方差会保留原始数组的维度，其值默认为False |
|---|
python
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr)
# 计算整个数组的方差
total_var = np.var(arr)
print(total_var)
# 计算每一列的方差
var_col = np.var(arr, axis=0)
print(var_col)
# 计算每一行的方差
var_row = np.var(arr, axis=1)
print(var_row)
'''
[[1 2 3]
[4 5 6]
[7 8 9]]
6.666666666666667
[6. 6. 6.]
[0.66666667 0.66666667 0.66666667]
'''3.5、std
numpy.std 用于计算数组中所有元素的标准差，或者沿着指定轴计算标准差。标准 差是方差的平方根，它也是一种衡量数据分散程度的统计量。
python
numpy.std(a, axis=None, dtype=None, out=None, keepdims=<no value>)| 函数 | 说明 |
| a | 输入数组，可以是任何形状的数组。 |
| axis | 可选参数，用于指定计算标准差的轴。如果没有指定，则计算整个数组 的标准差。如果指定了轴，则计算该轴上元素的标准差。可以是整数或元组，用 于指定多个轴。 |
| dtype | 可选参数，指定返回标准差的数据类型。如果未指定，则通常与输入数 组的类型相同。 |
| out | 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 |
| keepdims | 可选参数，如果设置为True,则计算后的标准差会保留原始数组的维度，其值默认为False |
|---|
python
import numpy as np
arr = np.array([[1, 2, 3]])
total_var = np.var(arr)
print(total_var)
# 计算整个数组的标准差
total_std = np.std(arr)
print(total_std)
# 计算每一列的标准差
std_col = np.std(arr, axis=0)
# 计算每一行的标准差
std_row = np.std(arr, axis=1)
print(std_col)
print(std_row)
'''
0.6666666666666666
0.816496580927726
[0. 0. 0.]
[0.81649658]
'''3.6、argmax和argmin
numpy.argmax 和 numpy.argmin 是 NumPy 库中的两个函数，它们分别用于找出 数组中最大值和最小值的索引位置。
python
numpy.argmax(a, axis=None, out=None)
numpy.argmin(a, axis=None, out=None)| 函数 | 说明 |
| a | 输入数组。如果数组是多维的，则沿着指定的轴搜索最大值或最小值。 |
| axis | 可选参数，用于指定搜索最大值或最小值的轴。如果没有指定，则在展 平的数组中进行搜索。如果指定了轴，则沿着该轴搜索，并返回该轴上的索引位 置。 |
| out | 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 |
|---|
python
import numpy as np
arr = np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
# 找出整个数组中的最大值和最小值的索引位置
max_index = np.argmax(arr)
min_index = np.argmin(arr)
print(max_index)
print(min_index)
# 找出每一列中的最大值和最小值的索引位置
max_index_col = np.argmax(arr, axis=0)
min_index_col = np.argmin(arr, axis=0)
print(max_index_col)
print(min_index_col)
# 找出每一行中的最大值和最小值的索引位置
max_index_row = np.argmax(arr, axis=1)
min_index_row = np.argmin(arr, axis=1)
print(max_index_row)
print(min_index_row)
'''
8
4
[2 2 2]
[0 1 0]
[2 2 2]
[0 1 0]
'''四、where函数
numpy.where 是 NumPy 库中的一个非常有用的函数，它可以根据指定的条件返回 满足该条件的元素的索引。
当 numpy.where 接受一个条件作为参数时，它会返回一个元组，其中包含满足该条 件的元素的索引。
python
numpy.where(condition)| 函数 | 说明 |
| condition | 一个布尔数组或条件表达式。 |
|---|
| 返回值 | |
| 一个元组，其中包含满足条件的元素的索引。 |
|---|
python
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
condition = arr > 5
print(arr)
result = np.where(condition)
print(result)
'''
[1 2 3 4 5 6 7 8 9]
(array([5, 6, 7, 8]),)
'''五、思维导图
