数据分析-Python数据分析实操01
numpy简介、Ndarray对象、数组、数组索引、数组复制、转置、翻转、拼接、分裂、运算、函数
·
NumPy库简介
NumPy概述
NumPy安装
# 安装命令
pip install numpy==1.26.4
# # 导入numpy库，简写为np
import numpy as np
print(np.__version__) #查看版本
NumPy优势
高效的数值计算能力
它的核心有C和Fortran编写，计算速度比纯Python快很多。比如数组相加，NumPy利用底层优化算法直接操作数组，避免了纯Python循环相加的解释器开销。
以两个长度为1000的数组相加为例，在纯Python中可能需要以下代码：
# 定义数组a/b，长度均为1000
a = [i for i in range(1000)]
b = [i for i in range(1000)]
c = []
# 循环数组a，使得a和b元素相加
for i in range(len(a)):
c.append(a[i] + b[i])使用NumPy
import numpy as np
a = np.arange(1000)
b = np.arange(1000)
c = a + b运行时间上，后者会比前者快很多，尤其是当数组规模更大时，这种速度优势会更加明显。
强大的多维数组支持
在数据科学和数值计算中常处理多维数据，NumPy的ndarray对象能很好地表示这些数据。如彩色图像可用三维数组表示，且能方便地访问和操作数组元素。可以使用以下方式创建一个简单的二维数组（类似矩阵）：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])并且可以方便地反问和操作数组中的元素，如a[0,1]可以访问第一行第二列的元素。
# 生成长度为9(从0到8)数组
a = np.arange(9)
# 将数组转为3*3的二维数组
b = a.reshape(3, 3)
print(b)
print(b[1:3,1:3])
与其他库的良好集成
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(10)
y = np.sin(x)
plt.plot(x, y)
plt.show()
Ndarray对象
数组基础概述
数据类型
数组常用的数据类型
import numpy as np
# 整数型数组
arr1 = np.array([1, 2, 3])
arr1[0] = 100.9
print(arr1)
# 浮点型数组
arr2 = np.array([1.0, 2.0, 3.0])
arr2[0] = 100
print(arr2)
# [100 2 3]
# [100. 2. 3.]数组维度
import numpy as np
# 一维数组
arr1 = np.zeros(3)
print(arr1)
# 二维数组(2×3)
arr2 = np.zeros((2, 3))
print(arr2)
# 三维数组(2×2×3)
arr3 = np.zeros((2, 2, 3))
print(arr3)
数组的创建
创建指定数组
语法格式
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
参数说明
创建一维数组，代码如下：
import numpy as np
# 由列表创建一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
print(arr1.dtype) # int64（默认根据输入类型推断）
# [1 2 3 4 5]
# int64
# 由numpy.array()函数生成的数组，元素之间没有逗号分割创建一维数组，指定数据类型为float32，代码如下：
import numpy as np
arr2 = np.array([1, 2, 3, 4], dtype=np.float32)
print(arr2)
print(arr2.dtype) # float32
# [1. 2. 3. 4.]
# float32
# 由numpy.array()函数生成的数组，如果数据类型为浮点数，则小数点后的0可以省略创建一维数组。数据类型指定为int32，代码如下：
import numpy as np
arr3 = np.array([1.5, 2.6, 3.3, 4.2], dtype=np.int)
print(arr3)
print(arr3.dtype) # int32
# [1 2 3 4]
# int32
# 指定类型为int类型，则小数部分舍弃（不会四舍五入）创建一个2行3列的多维数组，代码如下：
import numpy as np
arr4 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr4)
print(arr4.shape) # (2, 3)
'''
[[1 2 3]
[4 5 6]]
(2, 3)
'''创建一个数组，指定最小维度，代码如下：
import numpy as np
arr4 = np.array([1, 2, 3], ndmin=3)
print(arr4)
print(arr4.shape) # (1, 1, 3)
# [[[1 2 3]]]
# (1, 1, 3)
创建全0数组
语法格式
# 创建全0数组
numpy.zeros(shape, dtype = float, order = 'C')
# 创建全1数组
numpy.ones(shape, dtype = float, order = 'C')
参数说明
创建一个2D的全0数组（矩阵），代码如下：
import numpy as np
# 创建一个 3x4 的矩阵
arr2 = np.zeros((3, 4))
print(arr2)
'''
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
'''指定全1数据的数据类型，代码如下：
import numpy as np
# 创建一个 2x3 的整数矩阵
arr2 = np.ones((2, 3), dtype=int)
print(arr2)
'''
[[1 1 1]
[1 1 1]]
'''
创建递增数组
语法格式
numpy.arange([start,] stop[, step,], dtype=None)
参数说明
创建从0到4的一维数组，代码如下：
import numpy as np
arr1 = np.arange(1, 10)
print(arr1)
# [0 1 2 3 4]
指定start和step，创建一个数组，从1到9，代码如下：
import numpy as np
arr1 = np.arange(1, 10)
print(arr1)
# [1 2 3 4 5 6 7 8 9]
指定step，创建一个步长为2的一维数组，代码如下：
import numpy as np
arr3 = np.arange(1, 10, 2)
print(arr3)
# [1 3 5 7 9]
创建其他数组
empty()方法
语法格式
numpy.empty(shape, dtype=float, order='C')
参数说明
创建一个2D数组（矩阵），代码如下：
import numpy as np
# 创建一个 3x3 的矩阵
arr = np.empty((3, 3))
print(arr)
'''
[[ 2.60605835e-31 -5.21211670e-31 1.30302917e-31]
[-5.21211670e-31 1.13363538e-30 -3.51817877e-31]
[ 1.30302917e-31 -3.51817877e-31 2.01969522e-31]]
'''创建数组，指定数据类型，代码如下：
import numpy as np
# 创建一个 3x3 的整数矩阵
arr2 = np.empty((3, 3), dtype=int)
print(arr2)
'''
[[ 4149262842402738775 -5069605594824666534 4144759242775368293]
[-5069605594824666534 4158790770364394488 -5072026279624378161]
[ 4144759242775368290 -5072026279624378163 4147923825727815223]]
'''
随机数组
有时需要创建随机数组，那么可以使用np.random系列函数，代码如下：
import numpy as np
# 0-1 均匀分布的浮点型随机数组
# 形状为 5 的向量
arr1 = np.random.random(5)
print(arr1)
# [0.59372751 0.60180654 0.03689425 0.54579112 0.04378903]
可以发现，数组的取值范围在[0,1]之间。如果要创建一个取值范围在[1,100]之间的随机数组，可以通过randint()函数来实现，代码如下：
import numpy as np
# 取值范围为1~100的数组
arr2 = np.random.randint(1, 100, 5)
print(arr2)
# [51 17 29 60 94]
数组索引
基本索引
创建一维和二维数据，并访问数组的元素，代码如下：
import numpy as np
# 创建一个一维数组
arr_1d = np.array([10, 20, 30, 40, 50])
print(arr_1d[2])
# 创建一个二维数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr_2d[1, 2])
# 30
# 6切片索引
向量切片
向量与列表切片的操作完全一致。
创建一维数组并切片，代码如下：
import numpy as np
# 创建一个一维数组
arr_1 = np.array([0, 1, 2, 3, 4, 5])
print(arr_1[1:4])
# [1 2 3]
创建一维数组并切片，并每隔2个步长切片，代码如下：
import numpy as np
# 创建一个一维数组
arr_1 = np.array([0, 1, 2, 3, 4, 5])
print(arr_1[1:5:2])
# [1 3]
矩阵切片
二维矩阵的切片
import numpy as np
# 创建一个 3x4 的二维矩阵
matrix = np.array([[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
# 提取第1行
row_1 = matrix[1, :]
print("Row 1:", row_1)
# 提取第2列
col_2 = matrix[:, 2]
print("Column 2:", col_2)
# 提取子矩阵：第 1~2 行，第 1~3 列
sub_matrix = matrix[1:3, 1:4]
print("Sub-matrix:\n", sub_matrix)
'''
Row 1: [ 6 7 8 9 10]
Column 2: [ 3 8 13]
Sub-matrix:
[[ 7 8 9]
[12 13 14]]
''' 
其他索引
布尔索引
布尔索引是通过布尔数组来选择数组中的元素。布尔数组的形状必须与原数组的形状一致。
import numpy as np
# 创建一个一维数组
arr_1d = np.array([10, 20, 30, 40, 50])
# 创建一个布尔数组(条件成立返回True, 否则返回False)
condition = arr_1d > 20
print("condition:", condition)
# 输出：[False False True True True]
# 使用布尔索引(索引满足条件的数组)
print("arr_1d[condition]:", arr_1d[condition])
# 输出：[30 40 50]指定索引
一维数组的整数数组索引
假设我们有一个一维数组，我们想通过整数数组索引来选择特定的元素。
import numpy as np
# 创建一个一维数组
arr = np.array([10, 20, 30, 40, 50])
print("原始数组:", arr)
# 创建一个整数数组，表示需要选择的索引
indices = np.array([1, 3, 4])
# 使用整数数组索引
selected_elements = arr[indices]
print("通过整数数组索引选择的元素:", selected_elements)
# 原始数组: [10 20 30 40 50]
# 通过整数数组索引选择的元素: [20 40 50]
二维数组的整数数组索引
整数数组索引不仅适用于一维数组，还可以用于多维数组。对于二维数组，可以通过两个整数数组分别指定行和列的索引。
# 创建一个二维数组
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print("原始矩阵:\n", matrix)
# 创建整数数组，分别指定行和列的索引
row_indices = np.array([0, 2]) # 选择第 0 行和第 2 行
col_indices = np.array([1, 2]) # 选择第 1 列和第 2 列
# 使用整数数组索引
selected_elements = matrix[row_indices, col_indices]
print("通过整数数组索引选择的元素:", selected_elements)
'''
原始矩阵:
[[1 2 3]
[4 5 6]
[7 8 9]]
通过整数数组索引选择的元素: [2 9]
'''
# 取出第0行第1列的元素，第2行第2列的元素
更复杂的整数数组索引
整数数组索引可以用于更复杂的场景，比如选择不规则的元素组合。
# 创建一个二维数组
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print("原始矩阵:\n", matrix)
# 创建整数数组，分别指定行和列的索引
row_indices = np.array([0, 1, 2]) # 选择第 0 行、第 1 行和第 2 行
col_indices = np.array([2, 0, 1]) # 选择第 2 列、第 0 列和第 1 列
# 使用整数数组索引
selected_elements = matrix[row_indices, col_indices]
print("通过整数数组索引选择的元素:", selected_elements)
'''
原始矩阵:
[[1 2 3]
[4 5 6]
[7 8 9]]
通过整数数组索引选择的元素: [3 4 8]
'''
数组的复制
切片复制
与Python列表和Matlab不同，NumPy数组的切片仅仅是原数组的一个视图。换言之，NumPy切片并不会创建新的变量，示例如下。
import numpy as np
# 创建原数组 arr
arr = np.arange(10)
# 创建切片数组 cut
cut = arr[ :3 ]
# 改变切片数组元素值
cut[0] = 12
print(arr)
print(cut)
# [12 1 2 3 4 5 6 7 8 9]
# [12 1 2]由此我们可以发现，切片数组的改变，对应的原数组也会改变。因此，切片数组是原数组的视图。如果真的需求切片创建新变量（虽然现实情况极其稀少），可以使用.copy()方法。
import numpy as np
# 创建原数组 arr
arr = np.arange(10)
# 以copy方式创建切片数组 cut
cut = arr[ :3 ].copy()
# 改变切片数组元素值
cut[0] = 12
print(arr)
print(cut)
# [0 1 2 3 4 5 6 7 8 9]
# [12 1 2]数组复制
与NumPy数组的切片一样，NumPy数组完整的赋值给另一个数组，也只是绑定。换言之，NumPy数组之间的赋值并不会创建新的变量，示例如下。
import numpy as np
# 创建原数组 arr
arr = np.arange(10)
# 创建新数组 arr_new, 赋值为原数组 arr
arr_new = arr
# 改变切片数组元素值
arr_new[0] = 12
print(arr)
print(arr_new)
# [12 1 2 3 4 5 6 7 8 9]
# [12 1 2 3 4 5 6 7 8 9]此特性的出现是为了节约空间，如果真的需要赋给一个新数组，使用.copy()方法。
import numpy as np
# 创建原数组 arr
arr = np.arange(10)
# 创建新数组 arr_new, 赋值为原数组 arr
arr_new = arr.copy()
# 改变切片数组元素值
arr_new[0] = 12
print(arr)
print(arr_new)
# [0 1 2 3 4 5 6 7 8 9]
# [12 1 2 3 4 5 6 7 8 9]数组的变形
数组重塑
基础语法：arr.reshape(newshape, order='C')
参数说明
向量重塑
import numpy as np
# 创建原始数组
arr1 = np.arange(1, 10)
# 对原始数组变形为 3×3 形状
arr2 = arr1.reshape((3, 3))
print(arr1)
print(arr2)
'''
[1 2 3 4 5 6 7 8 9]
[[1 2 3]
[4 5 6]
[7 8 9]]
'''
# 重塑后的元素个数一定和原来的相同矩阵重塑
import numpy as np
# 创建原始数组 3×3 形状
arr1 = np.arange(1, 10).reshape((3, 3))
# 将数组变形为 1×9 形状
arr2 = arr1.reshape((1, 9))
print(arr1)
print(arr2)
'''
[[1 2 3]
[4 5 6]
[7 8 9]]
[[1 2 3 4 5 6 7 8 9]]
'''
arr1 = np.arange(12)
arr2 = arr1.reshape((4,-1))
print(arr1)
print(arr2)
'''
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
'''数组转置
向量转置
向量转置，需要将其先升级为数组，再进行转置操作。
import numpy as np
# 创建原始数组（向量），并将向量升级为矩阵
arr1 = np.arange(5).reshape((1, -1))
# 对矩阵arr2进行转置
arr2 = arr1.T
print(arr1)
print(arr2)
'''
[[0 1 2 3 4]]
[[0]
[1]
[2]
[3]
[4]]
'''矩阵转置
import numpy as np
# 创建原始矩阵 2×2 形状
arr1 = np.arange(4).reshape((2, 2))
# 对矩阵arr2进行转置
arr2 = arr1.T
print(arr1)
print(arr2)
'''
[[0 1]
[2 3]]
[[0 2]
[1 3]]
'''数组翻转
向量翻转
import numpy as np
# 创建原始向量
arr1 = np.arange(4)
# 对矩阵arr2进行翻转
arr2 = np.flipud(arr1)
print(arr1)
print(arr2)
# [0 1 2 3]
# [3 2 1 0]矩阵翻转
对矩阵进行上下翻转，代码如下：
import numpy as np
# 创建原始矩阵
arr1 = np.arange(4).reshape(2, 2)
# 对矩阵arr2进行上下翻转
arr2 = np.flipud(arr1)
print(arr1)
print(arr2)
'''
[[0 1]
[2 3]]
[[2 3]
[0 1]]
'''对矩阵左右翻转，代码如下：
import numpy as np
# 创建原始矩阵
arr1 = np.arange(4).reshape(2, 2)
# 对矩阵arr2进行左右翻转
arr2 = np.fliplr(arr1)
print(arr1)
print(arr2)
'''
[[0 1]
[2 3]]
[[1 0]
[3 2]]
'''数组拼接
向量拼接
两个向量拼接，将得到一个新的加长版向量。
import numpy as np
# 创建向量 1
arr1 = np.array([1,2,3])
# 创建向量 2
arr2 = np.array([4,5,6])
# 拼接
arr3 = np.concatenate([arr1,arr2])
print(arr1)
print(arr2)
print(arr3)
'''
[1 2 3]
[4 5 6]
[1 2 3 4 5 6]
'''矩阵拼接
两个矩阵可以按不同的维度进行拼接，但拼接时必须注意维度的吻合。
# 创建两个二维数组
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
# 沿着行拼接（axis=0）
concatenated_row = np.concatenate((arr1, arr2), axis=0)
print("沿着行拼接：\n", concatenated_row)
# 沿着列拼接（axis=1）
concatenated_col = np.concatenate((arr1, arr2), axis=1)
print("沿着列拼接：\n", concatenated_col)
'''
沿着行拼接：
[[1 2]
[3 4]
[5 6]
[7 8]]
沿着列拼接：
[[1 2 5 6]
[3 4 7 8]]
'''
数组分裂
向量分裂
向量均匀分裂，将得到若干个更短的向量
import numpy as np
# 创建原始向量
arr1 = np.arange(1, 11)
# 对向量分裂为两个短向量
sub1, sub2 = np.split(arr1, 2)
print(arr1)
print(sub1)
print(sub2)
'''
[ 1 2 3 4 5 6 7 8 9 10]
[1 2 3 4 5]
[ 6 7 8 9 10]
'''向量指定位置分裂，将得到指定的短向量。
import numpy as np
# 创建原始向量
arr1 = np.arange(1, 11)
# 对向量分裂为两个短向量
sub1, sub2, sub3 = np.split(arr1, [2, 8])
print(arr1)
print(sub1)
print(sub2)
print(sub3)
'''
[ 1 2 3 4 5 6 7 8 9 10]
[1 2]
[3 4 5 6 7 8]
[ 9 10]
'''
# 在索引2和索引8的位置截断，返回三个短向量矩阵分裂
矩阵的分裂同样可以按不同的维度进行，分裂出来的均为矩阵。
矩阵按照行分裂，实例如下。
import numpy as np
# 创建原始矩阵
arr1 = np.arange(1,9).reshape(2,4)
# 按第一个维度（行）分裂
# 默认参数 axis=0
sub1,sub2 = np.split(arr1,[1]) # 按第一行分裂
print(arr1)
print(sub1)
print(sub2)
'''
[[1 2 3 4]
[5 6 7 8]]
[[1 2 3 4]]
[[5 6 7 8]]
'''矩阵按照列分裂，均分，示例如下。
import numpy as np
# 创建原始矩阵
arr1 = np.arange(1,9).reshape(2,4)
# 按第二个维度（列）分裂，均分为2列
sub1,sub2 = np.split(arr1, [2], axis=1) # 按第二列分裂
print(arr1)
print(sub1)
print(sub2)
'''
[[1 2 3 4]
[5 6 7 8]]
[[1 2]
[5 6]]
[[3 4]
[7 8]]
'''矩阵按照列分裂，指定位置分裂，示例如下。
import numpy as np
# 创建原始矩阵
arr1 = np.arange(1,9).reshape(2,4)
# 按第二个维度（列）分裂，在索引1和3处分裂
sub1,sub2,sub3 = np.split(arr1, [1,3], axis=1)
print(arr1)
print(sub1)
print(sub2)
print(sub3)
'''
[[1 2 3 4]
[5 6 7 8]]
[[1]
[5]]
[[2 3]
[6 7]]
[[4]
[8]]
'''数组的运算
数组与系数的运算
import numpy as np
# 创建 2×4 形状矩阵
arr = np.arange(1,9).reshape(2,4)
print(arr)
print(arr+10)
print(arr-5)
'''
[[1 2 3 4]
[5 6 7 8]]
[[11 12 13 14]
[15 16 17 18]]
[[-4 -3 -2 -1]
[ 0 1 2 3]]
'''数组与数组的运算
import numpy as np
# 创建 2×2 形状矩阵
arr1 = np.arange(0, 4).reshape(2,2)
# 创建 2×2 形状矩阵
arr2 = np.arange(4, 8).reshape(2,2)
print(arr1 + arr2)
'''
[[ 4 6]
[ 8 10]]
'''数组的广播
import numpy as np
# 创建 1×3 行矩阵(即向量)
arr1 = np.arange(3)
# 创建 3×1 列矩阵
arr2 = np.arange(3).reshape(3,1)
print(arr1 + arr2)
'''
[[0 1 2]
[1 2 3]
[2 3 4]]
'''
数组的函数
点积函数
import numpy as np
# 创建 2×3 形状矩阵
arr1 = np.arange(1,7).reshape(2,3)
# 创建 3×2 形状矩阵
arr2 = np.arange(1,7).reshape(2,3).T
np.dot(arr1, arr2)
'''
array([[14, 32],
[32, 77]])
'''数学函数
绝对值函数
import numpy as np
arr = np.array([-1, -2, 3, -4, 5])
abs_arr = np.abs(arr)
print(abs_arr) # 输出：[1 2 3 4 5]平方根函数
import numpy as np
arr = np.array([0, 1, 4, 9, 16])
sqrt_arr = np.sqrt(arr)
print(sqrt_arr) # 输出：[0. 1. 2. 3. 4.]取整函数
import numpy as np
arr = np.array([1.2, 2.5, -3.7, 4.9])
ceil_arr = np.ceil(arr) # 向上取整，返回大于或等于每个元素的最小整数
floor_arr = np.floor(arr) # 向下取整，返回小于或等于每个元素的最大整数
rint_arr = np.rint(arr) # 四舍五入到最近的整数
print(ceil_arr) # 输出：[ 2. 3. -3. 5.]
print(floor_arr) # 输出：[ 1. 2. -4. 4.]
print(rint_arr) # 输出：[ 1. 2. -4. 5.]符号函数
import numpy as np
arr = np.array([-1, 0, 1, -2, 2])
sign_arr = np.sign(arr)
print(sign_arr) # 输出：[-1 0 1 -1 1]三角函数
import numpy as np
# 正弦
arr = np.array([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi])
sin_arr = np.sin(arr)
print(sin_arr)
# 输出：[ 0.0000000e+00 1.0000000e+00 1.2246468e-16 -1.0000000e+00 -2.4492936e-16]
# 余弦
arr = np.array([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi])
cos_arr = np.cos(arr)
print(cos_arr)
# 输出：[ 1.0000000e+00 6.1232340e-17 -1.0000000e+00 -1.8369702e-16 1.0000000e+00]
# tan
arr = np.array([0, np.pi / 4, np.pi / 2, 3 * np.pi / 4, np.pi])
tan_arr = np.tan(arr)
print(tan_arr)
# 输出：[ 0.00000000e+00 1.00000000e+00 1.63312394e+16 -1.00000000e+00 -1.22464680e-16]
指数函数
import numpy as np
#底数是e，e的x次方
arr = np.array([0, 1, 2, 3])
exp_arr = np.exp(arr)
print(exp_arr)
# 输出：[ 1. 2.71828183 7.3890561 20.08553692]
#底数是2,2的x次方
arr = np.array([1, 2, 3])
exp2_arr = np.exp2(arr)
print(exp2_arr) # 输出：[ 2. 4. 8.]
# 计算任意幂，x的y次方
power_arr = np.power(arr, 3)
print(power_arr) # 输出：[ 1 8 27]对数函数
import numpy as np
arr = np.array([1, np.e, np.e**2, np.e**3])
log_arr = np.log(arr)
print(log_arr) # 输出：[0. 1. 2. 3.]
arr = np.array([1, 10, 100, 1000])
log10_arr = np.log10(arr)
print(log10_arr) # 输出：[0. 1. 2. 3.]
arr = np.array([1, 2, 4, 8])
log2_arr = np.log2(arr)
print(log2_arr) # 输出：[0. 1. 2. 3.]聚合函数
最值函数
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 计算整个数组的最大值和最小值
max_val = np.max(arr)
min_val = np.min(arr)
print("最大值:", max_val) # 输出：6
print("最小值:", min_val) # 输出：1
# 按列计算最大值和最小值，取出每列的最小值和最大值
col_max = np.max(arr, axis=0)
col_min = np.min(arr, axis=0)
print("每列的最大值:", col_max) # 输出：[4 5 6]
print("每列的最小值:", col_min) # 输出：[1 2 3]
# 按行计算最大值和最小值，取出每行的最小值和最大值
row_max = np.max(arr, axis=1)
row_min = np.min(arr, axis=1)
print("每行的最大值:", row_max) # 输出：[3 6]
print("每行的最小值:", row_min) # 输出：[1 4]均值函数
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 计算整个数组的平均值
mean_val = np.mean(arr)
print("平均值:", mean_val) # 输出：3.5
# 按列计算平均值
col_mean = np.mean(arr, axis=0)
print("每列的平均值:", col_mean) # 输出：[2.5 3.5 4.5]
# 按行计算平均值
row_mean = np.mean(arr, axis=1)
print("每行的平均值:", row_mean) # 输出：[2. 5.]求和函数
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 计算整个数组的总和
total_sum = np.sum(arr)
print("总和:", total_sum) # 输出：21
# 按列计算总和
col_sum = np.sum(arr, axis=0)
print("每列的总和:", col_sum) # 输出：[5 7 9]
# 按行计算总和
row_sum = np.sum(arr, axis=1)
print("每行的总和:", row_sum) # 输出：[6 15]中位数函数
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 计算整个数组的中位数
median_val = np.median(arr)
print("中位数:", median_val) # 输出：3.5
# 按列计算中位数
col_median = np.median(arr, axis=0)
print("每列的中位数:", col_median) # 输出：[2.5 3.5 4.5]
# 按行计算中位数
row_median = np.median(arr, axis=1)
print("每行的中位数:", row_median) # 输出：[2. 5.]唯一值函数
arr = np.array([1, 2, 2, 3, 4, 4, 4])
# 获取唯一值
unique_vals = np.unique(arr)
print("唯一值:", unique_vals) # 输出：[1 2 3 4]方差函数
arr = np.array([2,4,4,4,5,5,7,9])
# 计算整个数组的方差
var_val = np.var(arr)
print("方差:", var_val) # 输出：4.0标准差
arr = np.array([2,4,4,4,5,5,7,9])
# 计算整个数组的标准差
std_val = np.std(arr)
print("方差:", std_val) # 输出：2.0
魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。
更多推荐
18
0- 0
已为社区贡献5条内容
所有评论(0)