Python----数据分析（Numpy四：广播机制，数组的运算，统计计算，where函数）

发布于：2025-02-28 ⋅ 阅读:(21) ⋅ 点赞:(0)

一、数组的广播机制

        通常情况下，为了进行元素级的算术运算，两个数组的形状必须完全一致，Numpy的广播机制，它提供了一种规则，能够将不同形状的两个计算数 组广播到相同形状，然后再去进行元素级的算术运算，这种规则使得形状不完全匹配 的数组也能相互运算。通过这个机制，Numpy能够在保持效率的同时，扩展数组的 操作范围，从而无需显式地扩展数组维度或进行循环遍历以实现元素级的计算，极大的增强了数组的处理能力。

具体规则为：

        1. 如果两个数组的维数不同，形状较小的数组会在前面补1。

        2. 如果两个数组的形状在某个维度上不匹配，且其中一个维度长度为1，则会沿该 维度复制扩展以匹配另一个数组的形状。

        3. 如果在任一维度上不匹配且没有维度等于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、加法运算

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、减法运算

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、乘法运算

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、除法运算

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、符号
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、函数
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 控制返回数组是否可以是输入数组的子类 
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、符号
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、函数
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 控制返回数组是否可以是输入数组的子类 
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、符号
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、函数
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 控制返回数组是否可以是输入数组的子类 
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、符号
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、函数
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 控制返回数组是否可以是输入数组的子类 
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、符号
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、函数
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 控制返回数组是否可以是输入数组的子类 
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 可选输出数组，用于放置运算结果 
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）计算平均值。

numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)
函数 说明
a 输入数组，可以是任何形状的数组。
axis 可选参数，用于指定计算平均值的轴。如果没有指定，则计算整个数组 的平均值。如果指定了轴，则计算该轴上元素的平均值。
dtype 可选参数，用于指定返回的平均值的数据类型。如果没有指定，则通常 返回与输入数组相同的数据类型。
out 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。
keepdims 可选参数，如果设置为 True，则计算后的和会保留原始数组的维度，其值默认为False 
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

        该函数用于计算数组中所有元素的和，或者沿指定轴计算元素的和。

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 可选参数，用于指定计算和的条件。 
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 库中用于计算数组中元素最大值和最小值的函数

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 可选参数，用于指定计算最小值、最大值的条件。 
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 用于计算数组中所有元素或沿指定轴的方差。方差是衡量一组数值分散 程度的统计量，它是各个数值与其平均数差的平方的平均数。

numpy.var(a, axis=None, dtype=None, out=None, keepdims=<no value>)
函数 说明
a 输入数组，可以是任何形状的数组。
axis 可选参数，用于指定计算方差的轴。如果没有指定，则计算整个数组的 方差。如果指定了轴，则计算该轴上元素的方差。可以是整数或元组，用于指定 多个轴。
dtype 可选参数，指定返回方差的数据类型。如果未指定，则通常与输入数组 的类型相同。
out 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。
keepdims 可选参数，如果设置为True,则计算后的方差会保留原始数组的维度，其值默认为False 
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 用于计算数组中所有元素的标准差，或者沿着指定轴计算标准差。标准 差是方差的平方根，它也是一种衡量数据分散程度的统计量。

numpy.std(a, axis=None, dtype=None, out=None, keepdims=<no value>)
函数 说明
a 输入数组，可以是任何形状的数组。
axis 可选参数，用于指定计算标准差的轴。如果没有指定，则计算整个数组 的标准差。如果指定了轴，则计算该轴上元素的标准差。可以是整数或元组，用 于指定多个轴。
dtype 可选参数，指定返回标准差的数据类型。如果未指定，则通常与输入数 组的类型相同。
out 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。
keepdims 可选参数，如果设置为True,则计算后的标准差会保留原始数组的维度，其值默认为False 
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 库中的两个函数，它们分别用于找出 数组中最大值和最小值的索引位置。

numpy.argmax(a, axis=None, out=None)
numpy.argmin(a, axis=None, out=None)
函数 说明
a 输入数组。如果数组是多维的，则沿着指定的轴搜索最大值或最小值。
axis 可选参数，用于指定搜索最大值或最小值的轴。如果没有指定，则在展 平的数组中进行搜索。如果指定了轴，则沿着该轴搜索，并返回该轴上的索引位 置。
out 可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有 正确的形状。 
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 接受一个条件作为参数时，它会返回一个元组，其中包含满足该条 件的元素的索引。

numpy.where(condition)
函数 说明
condition 一个布尔数组或条件表达式。
返回值
一个元组，其中包含满足条件的元素的索引。 
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]),)
'''

五、思维导图

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布