数据分析小白训练营：基于python编程语言的Numpy库介绍（第三方库）（上篇）
（一）Numpy库的安装
安装指定版本的Numpy库，打开命令提示符，输入下图内容，只需要将1.25.5的版本修改成个人需要的版本，然后按下回车键，numpy库就安装在python中：
指定版本numpy库安装可能出现与当前python解释器不适配的报错情况，numpy库版本不同，函数功能也有变化，想知道当前电脑的python解释器适配什么版本的numpy库，有一下两种方法：
- 在命令提示符，输入python，按下回车键，查看当前python解释器版本，然后去浏览器搜索当前版本的python解释器适配哪些numpy库
- 在命令提示符里，任意输入一个版本的版本，如果出现报错，命令提示符也会在报错的同时，给你适配版本的python解释器
（二）认识numpy和配置环境
对大量数据进行分析，python中的列表和字典可以存储大量数据，但是无法对数据进行计算，而numpy库可以将数据存储为矩阵的格式，
numpy库将数据存储为矩阵的格式的优势：
- 把数据当作矩阵来处理，可以大大提高运行速度（numpy库的底层用c封装，python只是调用代码，方便用户操作）
- 极大方便了计算（numpy库依赖math数学库）
- 金融行业将大量数据存储在excel中，但是excel执行的速度没有numpy库执行的速度快
数组与矩阵的关系和区别：
- 二维数组可以直接视为矩阵，因为其形状和索引方式与数学矩阵完全一致
| 特性 | 矩阵（Mathematics） | 数组（Programming） |
|---|---|---|
| 维度限制 | 仅限二维 | 可有一维、二维、三维及以上 |
示例代码：
#numpy第三方库，可以将数据存储为矩阵的形式
import numpy as np#import numpy：导入numpy库，as np：取别名为np（可不写）
#numpy(底层用C，Python)：数字，矩阵)处理数据的速度比较忙，：
#科学计算 库，包含了很多和数学相关的公式#计算一下sin()，cos，tan()
print(np.sin(1))#这里参数为弧度，角度（D）和弧度（R）之间的关系：D = (180/π) × R
#计算一下绝对值
print(np.abs(-1))#abs()：求绝对值
# np.还有很多函数，进入源代码浏览一下。
#numpy 还可以进行矩阵运算
#numpy库依赖math数学库（三）创建array
- 矩阵的数据类型叫做ndarray
np.array(...)是 NumPy 的构造函数，不是任何实例方法- array：将矩阵数据可视化展示
示例代码和解释：
#array(数组) ->模拟了矩阵import numpy as np#导入numpy as np#一维数组
list1 = [1,2,3,4,5] #python自带的列表数据类型
v = np.array(list1)
print(v)#二维数组[多个一维数组构成]
m = np.array([list1,list1,list1])
print(m)#三维数组[多个二维数组构成]
z = np.array([[list1,list1,list1],[list1,list1,list1],[list1,list1,list1]])
print(z)z = np.array([m,m,m])
#更高维的y = np.array([z,z,z])"""
数组的基本属性
"""
#一维数组
a = v.shape #查询数组的形状
b = v.ndim #查询数组的维度
c = v.size #查询数组中数据个数
print(type(v))
d = v.dtype #查询数组中的元素类型，int8, int16, int32, int64: 表示不同长度的有符号整数。
# uint8, uint16, uint32, uint64: 表示不同长度的无符号整数。
# float16, float32, float64 (float 是 float64 的简写): 表示不同精度的浮点数。
# complex64, complex128 (complex 是 complex128 的简写): 表示复数，其中64和128表示复数的实部和虚部的位数。
# bool: 布尔类型，可以存储True或False。
# str_: 表示定长字符串，可以通过添加数字来指定字符串的长度，如 'S10' 表示长度为10的字符串。
# object: 表示Python对象类型，可以用来存储任意Python对象。
#二维数组
a = m.shape
b = m.ndim
c = m.size
print(type(m))
d = m.dtype
#三维数组
z.shape
z.ndim
z.size
type(z)
z.dtype
（四）数组的升维
核心功能：
1.np.array()
将列表转为NumPy数组
2.reshape()
改变数组形状，返回新数组
-1：自动计算该维度大小例：
v.reshape(4,-1)→ 4行，列数自动推算
3.ndim
查看数组维度数（如二维数组返回
2）
4.resize()
直接修改原数组，无返回值
例：
v.resize(4,4)→ 强制将原数组变为4×4
示例代码和解释：
import numpy as nplist1 = [1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8]# list1:[1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8]
v = np.array(list1)# v:[1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8]
print(v)#一维变二维[-1表示自己计算]【返回一个改变后的矩阵】
# a.reshape(newshape, order='C')
# a：要重新形状的数组。
# newshape：一个整数或者元组，用于定义新的形状。
# order：可选参数，指定元素在数组中的读取顺序。'C'意味着按行，'F'意味着按列，'A'意味着原顺序，'K'意味着元素在内存中的出现顺序。
r1 = v.reshape(4,4)r1 = v.reshape(4,-1)
print(r1)
r1.ndim#一维变三维
r2 = v.reshape(1,-1,2)#16/1=16表示一个维度里有16个数据，16/2=8表示每个维度里有8行数据，2表示2列数据
print(r2)#二维变三维
r3 = r1.reshape(2,2,4)
print(r3)#resize()【不返回计算结果】【直接修改原始数组】
#r4 = v.resize(2,4)
#print(r4)
r4 = v.resize(4,4)#直接会修改原始数据到相应的维度
print(v)
（五）数组的降维
核心功能：
1. 创建 & 升维
np.array(list1)→ 将列表转为NumPy数组（默认一维）v.reshape(2,2,2)→ 将数组升维为 2×2×2 的三维数组
2. 查看维度
v.ndim→ 返回数组的维度数（此处为3）
3. 降维为二维
v.reshape(1,8)→ 将三维数组降维为 1行8列的二维数组
4. 降维为一维
ravel()：展平为一维（可能共享内存，修改可能影响原数组）flatten()：展平为一维（独立副本，修改不影响原数组）
5. 直接修改形状
v.shape = (2,4)→ 就地修改原数组为 2×4 的二维数组矩阵在内存条里是以链式结构的形式存储的，通过矩阵的形式去表达
可以通过shape修改属性的方式，实现对数据的降维
示例代码：
import numpy as nplist1 = [1,2,3,4,5,6,7,8]
v = np.array(list1)
v = v.reshape(2,2,2)
print(v)
v.ndim#将三维降到二维
r1 = v.reshape(1,8)
print(r1)
r1.ndim#将高维数据转化为一维
#ravel()
r2 = v.ravel()
print(r2)
r2.ndim#flatten()
r3 = v.flatten()#非常重要，
print(r3)
# flatten方法返回的是原数组的副本，这意味着对返回的一维数组所做的任何修改都不会影响原始的多维数组。
# ravel方法（如果可能）返回的是原始数组的视图，因此对返回的一维数组所做的修改可能会影响原始的多维数组。这是因为ravel只是改变了数组的形状和步长，而没有复制数据。#小补充shape也可以实现降维
v.shape = (2,4)#通过直接对array数据的属性进行修改。
print(v)
（六）创建特殊的数组
核心功能：
1. 创建全零数组 np.zeros()
功能：生成指定形状的数组，所有元素初始化为0
示例：
a = np.zeros(5)→ 一维数组[0., 0., 0., 0., 0.]（浮点型）b = np.zeros((2,2))→ 二维数组[[0., 0.], [0., 0.]]c = np.zeros((3,2,2))→ 三维数组（3×2×2），全为0
特点：默认生成浮点数（
float64），适用于数学计算
2. 创建全一数组 np.ones()
功能：生成指定形状的数组，所有元素初始化为1
示例：
d = np.ones(5)→ 一维数组[1., 1., 1., 1., 1.]e = np.ones((2,2))→ 二维数组[[1., 1.], [1., 1.]]f = np.ones((2,2,2))→ 三维数组（2×2×2），全为1
3. 创建自定义填充值的数组 np.full()
功能：生成指定形状的数组，所有元素填充为给定值
示例：
g = np.full((2,2,2), 5)→ 三维数组（2×2×2），所有元素为5语法：
np.full(shape, fill_value)
4. 生成单位矩阵 np.eye()
功能：生成对角线为1、其余为0的矩阵（可指定行列数）
示例：
h = np.eye(5,7)→ 5行7列的矩阵，主对角线为1，其余为0特点：用于稀疏矩阵初始化或线性代数运算
关键注意事项
数据类型：所有数组默认以浮点数（
float64）创建，适合数学计算形状参数：通过元组指定多维形状（如
(2,2)表示二维数组）应用场景：常用于初始化权重矩阵、占位符数组或数值模拟中的初始条件
示例代码：
import numpy as np#创建全为0的数组
a = np.zeros(5)#a:[0. 0. 0. 0.]
#a表示为带小数的浮点数类型（float64），所有矩阵表达是带.的
b = np.zeros((2,2))#(2,2)np.zeros((2,2))
#zeros只能接受一个参数，（2，2）为元组形式
c = np.zeros((3,2,2))#创建全为1的数组
d = np.ones(5)
e = np.ones((2,2))
f = np.ones((2,2,2))#创建全为2的数组 矩阵中全部填充指定的数据
g = np.full((2,2,2), 5)#小补充
h = np.eye(5,7)#生成单位矩阵
print('hello')
#默认创建矩阵时，都是以浮点数的形式创建的，方便数学计算
（七）numpy中常用的两个函数
核心功能：
1. np.arange() —— 按步长生成形如 range() 的数组
功能：类似 Python 内置的
range()，但返回 NumPy 数组语法：
np.arange(start, end, step)特点：
左闭右开区间：包含
start，不包含end步长控制：通过
step指定元素间的增量
- 示例：
r1 = np.arange(0, 9, 3) # 输出: [0, 3, 6]解释：从 0 开始，每次增加 3，直到小于 9（不包含 9）
2. np.linspace() —— 生成指定数量的等间距数值
功能：在指定区间内生成 固定数量 的等间距数值
语法：
np.linspace(start, end, num)特点：
闭区间：同时包含
start和end均匀分布：自动计算步长以匹配指定数量
num
- 示例：
r2 = np.linspace(0, 1, 21) # 输出: [0.0, 0.05, 0.1, ..., 1.0]解释：从 0 到 1，生成 21 个等间距数值（含端点）
关键区别：
| 特征 | np.arange() | np.linspace() |
|---|---|---|
| 区间性质 | 左闭右开 | 闭区间（包含两端） |
| 控制方式 | 通过 step 控制步长 | 通过 num 控制总点数 |
| 适用场景 | 整数序列、已知步长的场景 | 精确控制点数、浮点数场景 |
| 典型用途 | 迭代循环、离散采样 | 科学计算、绘图坐标轴 |
示例代码：
import numpy as np#1.arange(start, end, step) -> range(start, end, step)
# [左闭右开的区间]一次性产生规律的数据。
r1 = np.arange(0,9,3)
print(r1)#2.linspace(start, end, nums)
# [左右都是闭区间]
r2 = np.linspace(0,1,21)
print(r2)
（八）一维数组元素的选取与修改
[ ]的功能：
- 创建一个列表
- 索引/切片
核心功能：
1. 创建数组 np.arange()
功能：生成指定范围内的等差数列（类似 Python 的
range()）示例：
array1 = np.arange(1,9,1)→ 创建数组[1,2,3,4,5,6,7,8]参数说明：起始值=1，终止值=9（不含），步长=1
2. 单个元素选取
语法：
array[index]示例：
a = array1[1]→ 选取第二个元素（索引从0开始），结果为2特点：通过整数索引直接访问特定位置的元素
3. 多个元素选取
语法：
array[[indices]]示例：
b = array1[[1,3,5]]→ 选取索引为1、3、5的元素，结果为[2,4,6]特点：通过列表传递多个索引，返回对应位置的元素集合
4. 切片操作（左闭右开）
语法：
array[start:end]示例：
c = array1[0:6]→ 选取索引0到5的元素（含0，不含6），结果为[1,2,3,4,5,6]规则：遵循“左闭右开”原则，即包含起始索引，不包含结束索引
5. 修改单个元素
语法：
array[index] = new_value示例：
array1[0] = 10→ 将第一个元素修改为10效果：原数组被直接修改，后续打印会反映新值
6. 批量修改元素
语法：
array[[indices]] = new_value示例：
array1[[1,3,5]] = 20→ 将索引1、3、5的元素修改为20效果：一次性修改多个指定位置的元素值
7. 切片批量修改
语法：
array[start:end] = new_value示例：
array1[0:6] = 100→ 将索引0到5的所有元素修改为100效果：对切片范围内的所有元素统一赋值
示例代码：
import numpy as nparray1 = np.arange(1,9,1)
print(array1)#选取某个元素
a = array1[1]#选取某些元素
b = array1[[1,3,5]]#切片(左闭右开)
c = array1[0:6]#修改某个元素
print(array1)
array1[0] = 10#批量修改某些元素
array1[[1,3,5]] =20
print(array1)array1[0:6] = 100
print(array1)
（九）二维数组元素的选取与修改
核心功能：
一、创建二维数组
np.arange().reshape()
功能：生成连续数值并重塑为指定形状的二维数组
示例：
array1 = np.arange(24).reshape(4,6)np.arange(24)→ 生成0~23的一维数组.reshape(4,6)→ 重塑为4行6列的二维数组
输出示例：
[[ 0 1 2 3 4 5][ 6 7 8 9 10 11][12 13 14 15 16 17][18 19 20 21 22 23]]
二、元素选取与切片
1. 单个元素选取
语法：
array[row, col]示例：
a = array1[1,4]→ 选取第2行（索引1）、第5列（索引4）的元素（值为10）
2. 选取整行
语法：
array[row, :]示例：
b = array1[3,:]→ 选取第4行（索引3）的所有列（结果为[18,19,20,21,22,23]）
3. 选取连续多行
语法：
array[start_row:end_row, :]示例：
c = array1[0:2,:]→ 选取前2行（索引0和1）的所有列
4. 选取非连续多行
语法：
array[[rows], :]示例：
d = array1[[0,2],:]→ 选取第1行（索引0）和第3行（索引2）的所有列
5. 选取单列
语法：
array[:, col]示例：
e = array1[:,3]→ 选取第4列（索引3）的所有行（结果为[3,9,15,21]）
6. 选取多列
方式1：连续列 →
array[:, start_col:end_col]示例：
f = array1[:,0:3]→ 选取前3列（索引0、1、2）
方式2：非连续列 →
array[:, [cols]]示例：
g = array1[:,[0,3]]→ 选取第1列（索引0）和第4列（索引3）
三、修改元素
1. 修改单个元素
语法：
array[row, col] = new_value示例：
array1[1,4] = 100→ 将第2行第5列的元素改为100
2. 修改整行
语法：
array[row, :] = new_values示例：
array1[3,:] = 100→ 将第4行的所有元素改为100
3. 修改多行
语法：
array[[rows], :] = new_values示例：
array1[[0,2],:] = 50→ 将第1行和第3行的所有元素改为50
关键规则总结：
| 操作类型 | 语法示例 | 说明 |
|---|---|---|
| 单个元素 | array[i,j] | 精确定位到某单元格 |
| 整行 | array[i,:] | 冒号表示该维度的全部 |
| 连续多行 | array[i:j,:] | 左闭右开区间 |
| 非连续多行 | array[[i,k],:] | 用列表传递非连续索引 |
| 单列 | array[:,j] | 所有行的某一列 |
| 多列（连续） | array[:,i:j] | 左闭右开区间 |
| 多列（非连续） | array[:,[i,k]] | 用列表传递非连续索引 |
| 修改操作 | array[...] = value | 直接赋值，原数组被永久修改 |
示例代码：
import numpy as nparray1 = np.arange(24).reshape(4,6)#array数据 .reshape()
print(array1)#选取某个元素
a = array1[1,4]#第2行第5列#选取某行元素
b = array1[3,:] #逗号是用分隔 行和列。#选取某些行
c = array1[0:2,:]
d = array1[[0,2],:]#如果不是获取连续的行，[]#选取某列
e = array1[:,3]#选取某些列
f = array1[:,0:3]
g = array1[:,[0,3]]#修改元素
#修改某个元素
array1[1,4] = 100
print(array1)#修改某行元素
array1[3,:] = 100
print(array1)
array1[[0,2],:] = 50
print(array1)
（十）三维数组元素的选取与修改
核心功能：
一、创建三维数组
np.arange().reshape()
- 功能：生成连续数值并重塑为指定形状的三维数组
- 示例：
array1 = np.arange(48).reshape(2,4,6)np.arange(48)→ 生成0~47的一维数组.reshape(2,4,6)→ 重塑为 2层 × 4行 × 6列 的三维数组
- 结构说明：
- 第一维（深度）：2个二维数组（称为“块”）
- 第二维（行）：每个块有4行
- 第三维（列）：每行有6列
二、元素选取与切片
1. 单个元素选取
语法：
array[depth, row, col]示例：
a = array1[1,0,0]→ 选取第2层（索引1）、第1行（索引0）、第1列（索引0）的元素（值为24）
2. 选取某行元素
语法：
array[depth, row, :]示例：
b = array1[0,1,:]→ 选取第1层（索引0）、第2行（索引1）的所有列（结果为[6,7,8,9,10,11]）
3. 选取连续多行
语法：
array[depth, start_row:end_row, :]示例：
c = array1[0,1:3,:]→ 选取第1层中第2~4行（索引1到2，左闭右开）的所有列
4. 选取非连续多行
语法：
array[depth, [rows], :]示例：
d = array1[0,[1,3],:]→ 选取第1层中第2行（索引1）和第4行（索引3）的所有列
5. 选取某列
语法：
array[depth, :, col]示例：
e = array1[1,:,1]→ 选取第2层中所有行的第2列（索引1）（结果为[24,25,26,27]）
6. 选取多列
方式1：连续列 →
array[depth, :, start_col:end_col]示例：
f = array1[1,:,1:4]→ 选取第2层中所有行的第2~5列（索引1到3，左闭右开）
方式2：非连续列 →
array[depth, :, [cols]]示例：
g = array1[1,:,[1,4]]→ 选取第2层中所有行的第2列（索引1）和第5列（索引4）
三、修改元素
语法：array[depth, row, col] = new_value
- 示例：
array1[1,0,0] = 100→ 将第2层、第1行、第1列的元素修改为100 - 特点：就地修改原数组，无返回值
关键规则总结：
| 操作类型 | 语法示例 | 说明 |
|---|---|---|
| 单个元素 | array[d,r,c] | 精确定位到某单元格 |
| 整行 | array[d,r,:] | 冒号表示该维度的全部 |
| 连续多行 | array[d,r_start:r_end,:] | 左闭右开区间 |
| 非连续多行 | array[d,[r1,r2],:] | 用列表传递非连续索引 |
| 单列 | array[d,:,c] | 所有行的某一列 |
| 多列（连续） | array[d,:,c_start:c_end] | 左闭右开区间 |
| 多列（非连续） | array[d,:,[c1,c2]] | 用列表传递非连续索引 |
| 修改操作 | array[...] = value | 直接赋值，原数组被永久修改 |
代码示例：
import numpy as nparray1 = np.arange(48).reshape(2,4,6)
print(array1)#选取某个元素
#首先确定选取哪一个二维数组
a = array1[1,0,0]#选取某行元素
b = array1[0,1,:]#选取某些行元素
c = array1[0,1:3,:]
d = array1[0,[1,3],:]#选取某列
e = array1[1,:,1]#选取某些列
f = array1[1,:,1:4]
g = array1[1,:,[1,4]]#修改
array1[1,0,0]=100
print(array1)