【python】数值分析——NumPy进阶_python求二维数组平均值

创建矩阵

np.matrix()：NumPy 库中用于创建矩阵对象的函数

np.matrix(data, dtype=None)

参数 data 是要转换为矩阵的输入数据，可以是列表、元组、数组、字符串等。如果输入的数据为二维数组，则转换后的对象就是一个二维矩阵

#1.使用列表创建一个矩阵对象
lst = [[1, 2], [3, 4]]
mat = np.matrix(lst)
print(mat)
# 输出:
# [[1 2]
#  [3 4]]

#2.使用数组创建矩阵对象
arr = np.array([[1, 2], [3, 4]])
mat = np.matrix(arr)
print(mat)
# 输出:
# [[1 2]
#  [3 4]]

#3.使用字符串创建矩阵对象
s = '1 2; 3 4'		#每行之间用分号隔开，每行内的元素用空格或逗号隔开
mat = np.matrix(s)
print(mat)
# 输出:
# [[1 2]
#  [3 4]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运算

.mean() ：平均值

numpy.mean(a, axis=None, dtype=None, keepdims=False)
1

• a：要计算平均值的数组。
• axis：指定沿哪个轴计算平均值，默认为 None，表示计算整个数组的平均值。
• dtype：指定返回结果的数据类型，默认为 None，表示保持原有的数据类型。
• keepdims：是否保持结果的维度，默认为 False，表示降低维度。

#计算一维数组的平均值
arr = np.array([1, 2, 3, 4, 5])
avg = arr.mean()
print(avg)
# 输出: 3.0

#计算二维数组的平均值
arr = np.array([[1, 2], [3, 4]])
avg = arr.mean()
print(avg)
# 输出: 2.5

#沿指定轴计算平均值
arr = np.array([[1, 2], [3, 4]])
avg_axis_0 = arr.mean(axis=0)
print(avg_axis_0)
# 输出: [2. 3.]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

.var() ： 方差

在 NumPy 中，使用 .var() 方法可以计算数组中元素的方差。方差是衡量数据分散程度的统计指标，用于描述数据离散程度的大小。

numpy.var(a, axis=None, dtype=None, ddof=0, keepdims=False)
1

.std() ： 标准差

在 NumPy 中，使用 .std() 方法可以计算数组中元素的标准差。标准差是衡量数据离散程度的统计指标，用于描述数据的分散程度。

numpy.std(a, axis=None, dtype=None, ddof=0, keepdims=False)
1

• a：要计算方差的数组。
• axis：指定沿哪个轴计算方差，默认为 None，表示计算整个数组的方差。
• dtype：指定返回结果的数据类型，默认为 None，表示保持原有的数据类型。
• ddof：自由度参数（Delta Degrees of Freedom），用于计算无偏估计方差，即方差计算中除以 N - ddof，默认为 0，表示使用总体方差。
• keepdims：是否保持结果的维度，默认为 False，表示降低维度。

#一维数组的方差和标准差
arr = np.array([1, 2, 3, 4, 5])
variance = arr.var()
print(variance)
# 输出: 2.0
std_deviation = arr.std()
print(std_deviation)
# 输出: 1.4142135623730951

#二维数组的方差和标准差
arr = np.array([[1, 2], [3, 4]])
variance = arr.var()
print(variance)
# 输出: 1.25
std_deviation = arr.std()
print(std_deviation)
# 输出: 1.118033988749895

#沿指定轴计算方差和标准差
arr = np.array([[1, 2], [3, 4]])
var_axis_0 = arr.var(axis=0)
print(var_axis_0)
# 输出: [1. 1.]
std_dev_axis_0 = arr.std(axis=0)
print(std_dev_axis_0)
# 输出: [1. 1.]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

.cumsum()：累积和

从数组的第一个元素开始，逐个将当前元素与之前所有元素相加得到的结果

numpy.cumsum(a, axis=None, dtype=None, out=None)
1

.cumprod()：累积乘

从数组的第一个元素开始，逐个将当前元素与之前所有元素相乘得到的结果

numpy.cumprod(a, axis=None, dtype=None, out=None)
1

• a：要计算累积和的数组。
• axis：指定沿哪个轴计算累积和，默认为 None，表示将整个数组的元素相加。
• dtype：指定返回结果的数据类型，默认为 None，表示保持原有的数据类型。
• out：指定结果的输出数组，可以选择性地提供。

#一维数组的累积和、累积乘
arr = np.array([1, 2, 3, 4, 5])
cumulative_sum = arr.cumsum()
print(cumulative_sum)
# 输出: [ 1  3  6 10 15]
cumulative_product = arr.cumprod()
print(cumulative_product)
# 输出: [  1   2   6  24 120]

#二维数组的累积和、累积乘
arr = np.array([[1, 2], [3, 4]])
cumulative_sum = arr.cumsum()
print(cumulative_sum)
# 输出: [ 1  3  6 10]
cumulative_product = arr.cumprod()
print(cumulative_product)
# 输出: [ 1  2  6 24]

#沿指定轴计算累积和、累积乘
arr = np.array([[1, 2], [3, 4]])
cumulative_sum_axis_0 = arr.cumsum(axis=0)
print(cumulative_sum_axis_0)
# 输出: [[1 2]
#        [4 6]]
cumulative_product_axis_0 = arr.cumprod(axis=0)
print(cumulative_product_axis_0)
# 输出: [[1 2]
#        [3 8]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

.trace()：矩阵的迹

矩阵的迹是指矩阵主对角线上元素的和

numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)
1

• a：要计算迹的数组或矩阵。
• offset：指定主对角线相对于标准主对角线的偏移量，默认为 0，表示计算标准主对角线上的元素和。
• axis1、axis2：对于多维数组，指定用于计算迹的轴范围，默认为 (0, 1)，表示计算二维矩阵的迹。
• dtype：指定返回结果的数据类型，默认为 None，表示保持原有的数据类型。
• out：指定结果的输出数组，可以选择性地提供。

#二维矩阵的迹
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
trace_value = matrix.trace()
print(trace_value)	# 输出: 15

#多维数组的迹
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
trace_value = arr.trace(axis1=1, axis2=2)
print(trace_value)	# 输出: [ 5 13]
1
2
3
4
5
6
7
8
9

.flatten()、.ravel()：多维数组转换为一维数组

numpy.ndarray.flatten(order='C')
numpy.ndarray.ravel(order='C')
1
2

• order：指定展开数组的顺序，默认为 'C'，按行展开； 'F'，按列展开。

#二维数组展开成一维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
flattened_arr = arr.flatten()
print(flattened_arr)	# 输出: [1 2 3 4 5 6]
flattened_arr = arr.flatten(order='F')
print(flattened_arr)	# 输出: [1 4 2 5 3 6]
raveled_arr = arr.ravel()
print(raveled_arr)		# 输出: [1 2 3 4 5 6]


#三维数组到一维数组
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
flattened_arr = arr.flatten(order='F')
print(flattened_arr)	# 输出: [1 5 2 6 3 7 4 8]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

.flatten()与.ravel()的区别：

• .flatten() 方法返回展开后的一维数组的拷贝，不会对原始数组产生任何影响。
• .ravel() 方法返回一个视图（view），当修改展开后的数组时，原始数组也会发生相应改变。

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

# 使用 flatten() 方法
flattened_arr = arr.flatten()
flattened_arr[0] = 10
print(arr)
# 输出: [[1 2 3]
#       [4 5 6]]

# 使用 ravel() 方法
raveled_arr = arr.ravel()
raveled_arr[0] = 10
print(arr)
# 输出: [[10  2  3]
#       [ 4  5  6]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

.expand_dims()：指定的轴上扩展数组维度

在数组的指定位置插入一个新的轴，从而增加数组的维度

numpy.expand_dims(arr, axis)
1

• arr：要进行维度扩展的数组。
• axis：要插入新轴的位置。新轴将插入到该位置之前。可以是整数或者元组。如果是整数，则表示在指定的轴上插入一个新轴；如果是元组，则表示在多个轴上插入新轴。

#在一维数组中插入一个新的轴
arr = np.array([1, 2, 3])
expanded_arr = np.expand_dims(arr, axis=0)		#在一维数组 arr 的位置 0 插入了一个新的轴，将其转换为二维数组
print(expanded_arr)		# 输出: [[1 2 3]]

print(arr.shape)		#(3,)
print(expanded_arr.shape)	#(1, 3)


#在二维数组中插入新的轴
arr = np.array([[1, 2, 3], [4, 5, 6]])
expanded_arr = np.expand_dims(arr, axis=1)		#在二维数组 arr 的位置 1 插入了一个新的轴，将其转换为三维数组
print(expanded_arr)
# 输出:
# [[[1 2 3]]
#  [[4 5 6]]]

print(arr.shape)	#(2, 3)
print(expanded_arr.shape)	#(2, 1, 3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

.squeeze()：删除数组中长度为1的维度

numpy.squeeze(arr, axis)
1

• arr：要进行维度压缩的数组。
• axis（可选）：指定要删除的轴。如果指定了轴，则只会删除指定轴上长度为1的维度。如果不指定轴，则会删除所有长度为1的维度。

.set_printoptions()：打印函数

NumPy 中，默认情况下，当打印数组时，只会显示数组的部分内容

np.set_printoptions(**kwargs)
1

• precision：浮点数的打印精度。
• threshold：触发数组摘要而不是完全打印的总元素数阈值。
• edgeitems：每个维度边缘显示的数组元素数量。
• linewidth：每行打印字符的最大宽度。
• suppress：是否禁止小数点后的零打印。
• nanstr：NaN 值的字符串表示形式。
• infstr：无穷大值的字符串表示形式。
• sign：是否打印有关正号的信息。

#打印精度为2
arr = np.array([0.123456789, 0.987654321])
np.set_printoptions(precision=2)	
print(arr)	# 输出:[0.12 0.99]

#阈值设置为10
arr = np.arange(100)
np.set_printoptions(threshold=10)	#10<100则触发数组摘
print(arr)	# 输出:[ 0  1  2 ... 97 98 99]
1
2
3
4
5
6
7
8
9

.vectorize()：向量化

将普通 Python 函数转换为适用于 NumPy 数组的通用函数

def my_func(x):
    # 自定义的函数
    # 对单个输入 x 进行操作
    return x**2 + 1

# 创建一个向量化函数
vec_func = np.vectorize(my_func)

arr = np.array([1, 2, 3])
result = vec_func(arr)

print(result)
# 输出: [ 2  5 10]
1
2
3
4
5
6
7
8
9
10
11
12
13

**.**median()：中位数

.median() ：计算数组的中位数

arr = np.array([1, 3, 2, 4, 5])
median = np.median(arr)
print(median)
# 输出: 3.0

arr = np.array([[1, 4, 2], [3, 6, 5]])
median_axis0 = np.median(arr, axis=0)
print(median_axis0)
# 输出: [2. 5. 3.]

1
2
3
4
5
6
7
8
9
10

.bincount()、.argmax()：众数

.bincount() ：计算非负整数数组中每个值的出现次数

.argmax() ：返回数组中最大元素的索引

#求众数
arr = np.array([1, 3, 2, 4, 2])
bin_counts = np.bincount(arr)
print(bin_counts)	# 输出: [0 1 2 1 1]
max_index = np.argmax(bin_counts)
print(max_index)	# 输出: 2


#可选的 weights 参数，用于指定每个元素的权重
arr = np.array([1, 3, 2, 4, 2])
weights = np.array([0.5, 1.0, 0.5, 1.5, 1.0])
bin_counts = np.bincount(arr, weights=weights)
print(bin_counts)
# 输出: [0. 1.5 2. 1.5 1.]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

.percentile()：分位数

arr = np.array([1, 2, 3, 4, 5])
p75 = np.percentile(arr, 75)
print(p75)
# 输出: 4.0

arr = np.array([1, 2, 3, 4, 5])
p25, p50, p75 = np.percentile(arr, [25, 50, 75])
print(p25, p50, p75)
# 输出: 2.0 3.0 4.0
1
2
3
4
5
6
7
8
9

.corrcoef()：相关系数

相关系数衡量了两个变量之间的线性相关程度。它的值介于 -1 和 1 之间，其中 -1 表示完全负相关，1 表示完全正相关，0 表示无相关性。

arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([2, 4, 6, 8, 10])
correlation_matrix = np.corrcoef(arr1, arr2)
print(correlation_matrix)
# 输出:
# [[1.  1. ]
#  [1.  1. ]]

arr = np.array([[1, 2, 3], [4, 5, 6], [4, 8, 2]])
correlation_matrix = np.corrcoef(arr[:,0], arr[:,2])
print(correlation_matrix)
# 输出:
# [[1.        0.2773501]
#  [0.2773501 1.       ]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

.isnan()、.where()：定位NaN元素

判断NaN元素位置

arr = np.array([1, np.nan, 3, np.nan, 5])

is_nan = np.isnan(arr)
print(is_nan)
# 输出: [False  True False  True False]

is_nan_where = np.where(is_nan)
print(is_nan_where)
# 输出：(array([1, 3], dtype=int64),)
1
2
3
4
5
6
7
8
9

缺失值填充为0

arr = np.array([1, np.nan, 3, np.nan, 5])
arr[np.isnan(arr)] = 0
print(arr)	#[1. 0. 3. 0. 5.]
1
2
3

无缺失值置为1

arr = np.array([1, np.nan, 3, np.nan, 5])
arr[~np.isnan(arr)] = 1.0
print(arr)	#[ 1. nan  1. nan  1.]
1
2
3