Python 学习-Day8-Numpy相关操作

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

一、Numpy 介绍与配置

1. Numpy 介绍

Numpy 是 Python 中科学计算的基础库，主要用于高效处理数组和矩阵运算。其底层采用 C 语言编写，因此在进行数值计算、大规模数据操作时具有极高的执行效率。同时，它集成了大量数学函数，便于进行线性代数、傅里叶变换等复杂运算。

2. 安装 Numpy

使用 Python 的包管理工具 pip 可以轻松安装 NumPy：

pip install numpy

二、Numpy 相关操作

1. 创建 array

1.1. 使用 array() 将列表转换为数组

创建一维数组：

import numpy as np
list1 = [1, 2, 3, 4, 5]  # 普通 Python 列表
a = np.array(list1)
print(a)

创建二维数组（模拟矩阵）：

b = np.array([list1, list1, list1])
print(b)

创建三维及更高维数组：

三维数组可视为多个二维数组的堆叠。

# 方法一：通过嵌套列表直接构建
c = np.array([[list1, list1, list1],
              [list1, list1, list1],
              [list1, list1, list1]])
print(c)

# 方法二：基于已有的二维数组构造
c1 = np.array([b, b, b])
print(c1)

1.2. 数组的基本属性

创建数组后，可通过以下属性获取其结构信息：

• shape：表示数组各维度的大小
• ndim：数组的维度数量
• size：元素总个数
• dtype：数据类型

d = np.array([1, 2, 3, 4, 5])
print(type(d))
print("形状:", d.shape)
print("维度:", d.ndim)
print("元素总数:", d.size)
print("数据类型:", d.dtype)
print("-------------")

# 二维数组示例
e = np.array([[1, 2, 3], [4, 5, 6]])
print("形状:", e.shape)
print("维度:", e.ndim)
print("元素总数:", e.size)
print("数据类型:", e.dtype)

2. 数组的升维与降维

2.1. 升维操作

2.1.1. reshape() 方法

该方法用于重新组织数组的形状，不改变原始数据内容，返回一个新的视图（若可能），原数组保持不变。

将一维数组转为二维：

list1 = [1, 2, 3, 4, 5, 6, 7, 8]
v = np.array(list1)
print("原始一维数组:", v)

r1 = v.reshape(2, 4)
print("重塑为 2×4 形状:\n", r1)
print("维度:", r1.ndim)

r2 = v.reshape(2, -1)  # 使用 -1 让系统自动推断对应维度
print("自动计算列数:\n", r2)

说明：当使用 -1 时，NumPy 会根据总元素数和其他维度自动计算缺失维度的大小。

将一维数组升维至三维：

r3 = v.reshape(1, -1, 2)  # 转换为 1×4×2 的三维数组

2.1.2. resize() 方法

与 reshape 不同，resize() 可以修改原数组的形状，支持扩展或截断数据。

2.2. 数组的降维操作

2.2.1. 使用 reshape() 实现降维

例如将二维或三维数组压平为一维：

f = np.array([[1, 2], [3, 4], [5, 6]])
flattened = f.reshape(-1)

2.2.2. 使用 ravel() 方法

ravel() 返回展平后的一维数组，且尽可能返回原数组的视图（节省内存）。

2.2.3. 使用 flatten() 方法

flatten() 同样返回一维数组，但总是返回副本，不会影响原始数据。

3. 创建特殊结构的数组

3.1. 全零数组

使用 np.zeros() 创建所有元素为 0 的数组。

3.2. 全一数组

使用 np.ones() 生成所有值为 1 的数组。

3.3. 填充指定值的数组

利用 np.full() 或 np.ones() * value 构造固定值填充的数组。

4. 常用生成函数

4.1. arange() 函数

4.1.1. 使用方式

类似于 Python 内置的 range，但返回的是 NumPy 数组。

4.1.2. 示例

arr = np.arange(0, 10, 2)  # 起始=0, 结束=10(不含), 步长=2

4.2. linspace() 函数

4.2.1. 使用方式

在指定区间内生成等间距的数值序列，常用于绘图采样。

4.2.2. 示例

linspace_arr = np.linspace(0, 1, 5)  # 从 0 到 1，生成 5 个点

5. 数组元素的选取与修改

5.1. 一维数组的操作

支持索引访问和切片修改，如 a[0], a[1:4] 等。

5.2. 二维数组的操作

通过行、列索引选取数据，如 b[0, 1] 表示第1行第2列元素。

5.3. 三维数组的操作

需提供三个维度的索引，如 c[0, 1, 2]。

6. 数组的组合操作

6.1. 水平组合

使用 np.hstack() 或 np.column_stack() 将数组沿列方向拼接。

6.2. 垂直组合

使用 np.vstack() 沿行方向合并数组。

7. 数组的切割操作

7.1. 水平切割

使用 np.hsplit() 按列分割数组。

7.2. 垂直切割

使用 np.vsplit() 按行进行切分。

8. 数组的算术运算

支持加减乘除、幂运算等逐元素操作，也支持广播机制实现不同形状间的计算。

9. 浅拷贝与深拷贝

浅拷贝：使用 view() 创建新对象，共享数据，修改会影响原数组。
深拷贝：使用 copy() 完全独立复制数据，互不影响。

10. 随机模块（random）

10.1. 随机整数生成

使用 np.random.randint(low, high, size) 生成随机整数。

10.2. 均匀分布随机数

使用 np.random.rand() 或 np.random.uniform() 生成 [0,1) 区间内的随机浮点数。

10.3. 正态分布随机数

使用 np.random.randn() 或 np.random.normal() 生成服从标准正态分布的数据。

10.4. 生成随机数矩阵

可结合 shape 参数批量生成多维随机数组。

11. NumPy 中部分常用函数的使用

包括但不限于 sum(), mean(), max(), min(), clip(), where() 等，广泛应用于数据分析和条件筛选场景。

2.1.2 resize() 方法

resize() 方法与 reshape() 类似，但其作用是直接修改原始数组的形状，而不是返回一个新的数组。

示例代码如下：

r4 = np.array([1, 2, 3, 4, 5, 6, 7, 8])

print("原始数组:", r4)

r4.resize(4, 4)

print("resize后数组:\n", r4)

需要注意的是，当新形状所需的元素总数与原数组不一致时，resize() 会通过重复原有数据或截断多余部分的方式来调整数组大小。

二维数组升为三维数组

可以通过 reshape() 方法将低维数组转换为高维数组。例如，将一个二维数组重塑为三维结构：

r3 = r1.reshape(1, 2, 4)

print("三维数组 (1×2×4):\n", r3)

print("形状:", r3.shape)

该操作不会改变数据内容，仅重新组织其维度布局。

三维数组示例

展示一个三维数组的创建及其基本信息输出：

print("三维数组 (1×4×2):\n", r3)

print("形状:", r3.shape)

print("维度:", r3.ndim)

此部分可用于理解高维数组在内存中的表示形式和维度属性。

2.2 数组的降维操作

降维是指将高维数组转化为低维（如一维）数组的过程，常用方法包括 reshape()、ravel() 和 flatten()。

2.2.1 使用 reshape() 进行降维

首先创建一个三维数组：

list1 = [1, 2, 3, 4, 5, 6, 7, 8]

v = np.array(list1).reshape(2, 2, 2)

print("三维数组:\n", v)

print("维度:", v.ndim)

接着使用 reshape() 将其降为二维：

r1 = v.reshape(1, 8)

print("降为二维:\n", r1)

print("维度:", r1.ndim)

此外，也可以直接修改数组的 shape 属性实现类似效果（需确保元素总数不变）：

r2 = v.copy()

r2.shape = (2, 4)

print("修改shape属性:\n", r2)

2.2.2 使用 ravel() 展开数组

ravel() 方法用于将多维数组展平为一维数组，并返回原数组的视图（即共享内存）。

list1 = [1, 2, 3, 4, 5, 6, 7, 8]

v = np.array(list1)

r1 = v.reshape(2, 4)

print("原数组:\n", r1)

r2 = r1.ravel()

print("ravel()结果:", r2)

print("维度:", r2.ndim)

由于返回的是视图，因此对 r2 的修改可能会影响原始数据（取决于是否可连续访问）。

2.2.3 使用 flatten() 展平数组

flatten() 方法同样将多维数组转换为一维数组，但始终返回副本，不会影响原始数据。

list1 = [1, 2, 3, 4, 5, 6, 7, 8]

v = np.array(list1)

r1 = v.reshape(2, 4)

r3 = r1.flatten()

print("flatten()结果:", r3)

print("维度:", r3.ndim)

验证独立性：

r3[0] = 999

print("修改后新数组:\n", r3)

print("修改后原始数组:\n", r1)

可见原始数组未被更改，说明两者内存独立。

3. 特殊数组的创建
NumPy 提供了多种便捷函数用于生成具有特定初始值的数组。

3.1 全零数组

使用 zeros() 可创建所有元素均为 0 的数组，支持任意维度：

# 一维

a = np.zeros(4)

# 二维

b = np.zeros((2,3))

# 三维

c = np.zeros((3,2,2))

print(a,'\n',b,'\n',c)

适用于初始化权重、占位等场景。

3.2 全一数组

ones() 函数用于生成所有元素为 1 的数组：

# 一维

a = np.ones(4)

# 二维

b = np.ones((2,3))

# 三维

c = np.ones((3,2,2))

print(a,'\n',b,'\n',c)

常用于需要统一初值的数学运算中。

3.3 填充指定值的数组

full() 函数允许用户创建指定形状且每个元素都为给定值的数组：

v = np.full((3,2,2), 5)

print(v)

该方法灵活性更高，适用于设定固定偏置或标记值。

4. 常用数值序列生成函数

arange() 与 linspace() 是 NumPy 中最常用的两个用于生成规律数值序列的函数，分别适用于不同场景。

4.1 arange() 函数

arange() 用于生成一个左闭右开区间内的等差数列，语法结构如下：

np.arange(start, stop, step)  # 类似于 Python 内置的 range()

参数说明：

- start：起始值（包含），默认为 0

- stop：终止值（不包含）

- step：步长（可为负），默认为 1

示例：

r1 = np.arange(0,12,2)

print(r1)

输出结果为从 0 到 10 的偶数序列。

4.2 linspace() 函数

linspace() 用于在指定区间内生成固定数量的均匀分布数值，适合需要精确控制点数的情形。

使用方式：

np.linspace(start, stop, num=50, endpoint=True)

其中：

- start：起始值

- stop：结束值

- num：要生成的样本数量，默认为 50

- endpoint：是否包含终点，默认为 True

该函数特别适用于绘图时生成横坐标轴数据。

4.2.2 np.linspace 函数说明

该函数用于在指定区间内生成等间距的数值序列，其基本语法为：
np.linspace(start, stop, num)

参数含义如下：
- start：起始值（包含在序列中）
- stop：终止值（同样包含在序列中）
- num：需要生成的数据点总数

此方法创建的是左右闭合的区间，即起始和结束值均会被包含。

示例代码：
r2 = np.linspace(0, 1, 21)
print(r2)



5. 数组元素的操作：选取与修改

5.1 一维数组中的元素操作

选取方式

首先构建一个基础的一维数组：
array1 = np.arange(1, 9, 1)
print("原始数组:", array1)

1. 提取单个元素  
通过索引获取特定位置的值：
a = array1[1]
print("array1[1]:", a)

2. 获取多个非连续位置的元素  
使用列表形式传入索引：
b = array1[[1, 3, 5]]
print("array1[[1,3,5]]:", b)

3. 利用切片提取连续子集（左闭右开原则）  
c = array1[0:6]
print("array1[0:6]:", c)

4. 带步长的切片操作  
可跳跃式地选择元素：
d = array1[0:8:2]
print("array1[0:8:2]:", d)



修改操作实现

1. 更改单一元素值  
print("修改前:", array1)
array1[0] = 10
print("修改array1[0]=10后:", array1)

2. 批量更新若干不相邻元素  
array1[[1, 3, 5]] = 20
print("修改array1[[1,3,5]]=20后:", array1)

3. 对一段连续区域赋新值  
array1[0:6] = 100
print("修改array1[0:6]=100后:", array1)

4. 使用带步长的方式进行修改  
array1[0:8:2] = 0
print("修改array1[0:8:2]=0后:", array1)



5.2 二维数组中的元素操作

数据准备

构造一个形状为 4×6 的二维数组：
array2 = np.arange(24).reshape(4, 6)
print("二维数组 (4×6):")
print(array2)

元素选取方法

1. 获取某个具体位置的元素（行、列索引）  
a = array2[1, 4]
print("\narray2[1, 4]:", a)

2. 提取整行数据  
b = array2[3, :]
print("array2[3, :]:", b)

3. 截取连续多行  
c = array2[0:2, :]
print("\narray2[0:2, :]:")
print(c)

4. 抽取指定的非连续行  
d = array2[[0, 2], :]
print("array2[[0,2], :]:")
print(d)

5. 获取某一整列  
e = array2[:, 3]
print("\narray2[:, 3]:", e)

6. 选取连续的若干列  
f = array2[:, 0:3]
print("array2[:, 0:3]:")
print(f)

7. 提取多个非连续列  
g = array2[:, [0, 3]]
print("\narray2[:, [0,3]]:")
print(g)

8. 获取子矩阵（按行列范围）  
h = array2[1:3, 2:5]
print("\narray2[1:3, 2:5]:")
print(h)



修改操作演示

1. 修改某一个单独元素  
print("原始数组:")
print(array2)
array2[1, 4] = 100
print("\n修改array2[1,4]=100后:")
print(array2)

2. 替换整行为相同值  
array2[3, :] = 100
print("\n修改array2[3,:]=100后:")
print(array2)

3. 同时修改多个指定行  
array2[[0, 2], :] = 50
print("\n修改array2[[0,2],:]=50后:")
print(array2)

4. 更新某一整列的值  
array2[:, 2] = 0
print("\n修改array2[:,2]=0后:")
print(array2)



5.3 三维数组中的元素操作

初始化数组

创建一个维度为 2×4×6 的三维数组：
array3 = np.arange(48).reshape(2, 4, 6)
print("三维数组 (2×4×6):")
print(array3)

元素选取方式

1. 取出单个元素（需提供深度、行、列三个索引）  
a = array3[1, 0, 0]
print(f"\narray3[1, 0, 0]: {a}")

2. 获取某一平面中的完整行  
b = array3[0, 1, :]

# 3. 提取连续行数据 [深度索引, 起始行:结束行, :]
c = array3[0, 1:3, :]
print("\narray3[0, 1:3, :]:")
print(c)

# 4. 获取不连续的行 [深度索引, [行索引列表], :]
d = array3[0, [1, 3], :]
print("\narray3[0, [1,3], :]:")
print(d)

# 5. 选取特定列 [深度索引, :, 列索引]
e = array3[1, :, 1]
print(f"\narray3[1, :, 1]: {e}")

# 6. 提取连续列 [深度索引, :, 起始列:结束列]
f = array3[1, :, 1:4]
print("\narray3[1, :, 1:4]:")
print(f)

# 7. 选择非连续列 [深度索引, :, [列索引列表]]
g = array3[1, :, [1, 4]]
print("\narray3[1, :, [1,4]]:")
print(g)

# 8. 获取完整的二维切片 [深度索引, :, :]
h = array3[0, :, :]
print("\narray3[0, :, :] :\n", h)


# 1. 基础索引访问 [深度, 行, 列]
b = array3[0, 1, :]
print(f"array3[0, 1, :]: {b}")


# 修改指定位置元素值
print("修改前:", array3[1, 0, 0])
array3[1, 0, 0] = 100
print("修改后:", array3[1, 0, 0])


6. 数组的组合操作

NumPy 支持将多个数组沿不同方向（如水平或垂直）进行拼接，从而生成新的数组结构。

6.1 水平方向组合

该方式在列方向上连接数组，要求参与拼接的数组具有相同的行数。

# 构造原始数组
array1 = np.arange(9).reshape(3,3)
array2 = 2*array1
print("array1:\n", array1)
print("array2:\n", array2)

# 使用 hstack 进行水平拼接
a3 = np.hstack((array1, array2))
print("水平组合 np.hstack((array1,array2)):")
print(a3)

a4 = np.hstack((array2, array1))
print("水平组合 np.hstack((array2,array1)):")
print(a4)

a5 = np.hstack((array1, array2, array1))
print("水平组合 np.hstack((array1,array2,array1)):")
print(a5)

# 利用 concatenate 实现相同效果（axis=1 表示列方向）
a6 = np.concatenate((array1, array2), axis=1)
print("水平组合 np.concatenate((array1,array2),axis=1):")
print(a6)

注：concatenate 函数中，当 axis=1 时表示水平拼接，axis=0 时表示垂直拼接。


6.2 垂直方向组合

此方法沿行方向堆叠数组，要求各数组的列数一致。

# 执行垂直拼接
a7 = np.vstack((array2, array1))
print("垂直组合 np.vstack((array2,array1)):\n")
print(a7)

# 使用 concatenate (axis=0 表示行方向)
a8 = np.concatenate((array1, array2), axis=0)
print("垂直组合 np.concatenate((array1,array2),axis=0):\n")
print(a8)


7. NumPy 中的数组分割功能

NumPy 提供了多种手段，可将一个数组按指定维度拆分为若干子数组。

7.1 水平分割

将数组沿列方向切分。

# 创建测试数组
array1 = np.arange(16).reshape(4,4)
print(array1)

# 使用 hsplit 分成两部分
a = np.hsplit(array1, 2)
print(a[0])
print(a[1])

# 等效于使用 split 并设置 axis=1
b = np.split(array1, 2, axis=1)
print(b[0])
print(b[1])


7.2 垂直分割

沿行方向对数组进行切分。

# 使用 vsplit 分割
c = np.vsplit(array1, 2)
print(c[0])
print(c[1])

# 使用 split 并指定 axis=0 实现相同效果
d = np.split(array1, 2, axis=0)
print(d[0])
print(d[1])


8. 数组间的算术运算

NumPy 支持对数组执行基本的数学运算操作，前提是参与运算的数组形状需兼容。

# 初始化两个形状相同的数组

# 数组的基本运算示例
array1 = np.arange(1, 5, 1).reshape(2, 2)
array2 = 2 * array1

print("原始数组 array1:")
print(array1)
print("\n倍增后的数组 array2:")
print(array2)

# 执行对应位置元素的加法操作（需保证形状一致）
print("\n执行数组加法运算 array1 + array2:")
print(array1 + array2)

# 对应位置元素相减
print("\n执行数组减法运算 array1 - array2:")
print(array1 - array2)

# 元素级乘法（非矩阵乘法）
print("\n执行数组乘法运算 array1 * array2:")
print(array1 * array2)

# 元素级除法
print("\n执行数组除法运算 array1 / array2:")
print(array1 / array2)

# 取余运算，对应位置进行模运算
print("\n数组取余操作 array2 % array1:")
print(array2 % array1)

# 地板除法（舍去小数部分的整除）
print("\n数组取整运算 array1 // array2:")
print(array1 // array2)

9. NumPy 中数组的浅拷贝与深拷贝机制

在 NumPy 中，拷贝方式分为浅拷贝和深拷贝两种：

• 浅拷贝：采用引用传递的方式。新变量与原数组共享内存空间，修改其中一个会影响另一个。
• 深拷贝：采用值传递方式。副本独立存储数据，修改副本不会影响原始数组。

代码演示如下：

array1 = np.array([1, 2, 3])

# 创建浅拷贝
array2 = array1
array2[0] = 100  # 修改副本

print("修改后的 array2:")
print(array2)
print("查看原数组 array1 是否被影响:")
print(array1)  # 输出结果会显示 array1 也被修改

# 创建深拷贝
array3 = array1.copy()
array3[0] = 10  # 修改深拷贝的副本

print("修改后的 array3:")
print(array3)
print("再次检查原数组 array1 是否保持不变:")
print(array1)  # 此时 array1 不受影响

10. NumPy 随机模块功能详解

10.1 生成随机整数

使用 np.random.randint() 函数可生成指定范围内的随机整数。区间为左闭右开 [start, end)。

通过设置随机种子可以确保每次运行程序时生成相同的随机序列，便于调试和复现结果。

import random
import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子（仅对后续一次随机调用有效，且仅作用于 NumPy 的随机函数）
np.random.seed(1000)

r1 = np.random.randint(0, 10)
print("单个随机整数 r1:", r1)

# 生成 100 个随机整数并统计分布
a = [np.random.randint(0, 10) for _ in range(100)]
print("\n共生成 100 个随机整数:", a)

# 绘制直方图展示频数分布
plt.hist(a, color='r')
plt.title("随机整数分布直方图")
plt.xlabel("随机数值")
plt.ylabel("频数")
plt.show()

10.2 均匀分布随机数生成

函数 np.random.rand() 返回 (0, 1) 区间内服从均匀分布的浮点数。

# np.random.seed(10)  # 可选：设定种子以控制输出
r1 = np.random.rand()
print("均匀分布随机浮点数 r1:", r1)

10.3 正态分布随机数生成

利用 np.random.normal() 可生成符合正态分布的数据，默认均值为 0，标准差为 1（即标准正态分布 N~(0,1)）。

参数说明：

• loc：分布的均值（中心位置），默认为 0.0；
• scale：标准差（离散程度），默认为 1.0；
• size：输出数据的形状，如整数或元组形式，若为 None 则返回单一数值。

r2 = np.random.normal()
print("标准正态分布随机数 r2:", r2)

10.4 构造随机数矩阵

可直接生成各种分布类型的二维或多维随机数组：

• 随机整数矩阵：使用 randint 指定维度；
• 均匀分布矩阵：使用 rand 生成 (0,1) 浮点矩阵；
• 正态分布矩阵：自定义均值与标准差生成高斯分布矩阵。

# 生成 5×5 的随机整数矩阵
r3 = np.random.randint(0, 10, size=(5, 5))
print("\n5×5 随机整数矩阵:")
print(r3)

# 生成 5×5 均匀分布浮点矩阵
r4 = np.random.rand(5, 5)
print("\n5×5 均匀分布随机矩阵:")
print(r4)

# 生成 5×5 正态分布矩阵（均值=5，标准差=10）
r5 = np.random.normal(5, 10, size=(5, 5))
print("\n5×5 正态分布矩阵（均值=5，标准差=10）:")
print(r5)

11. NumPy 内置常用函数的应用

以下示例将创建一个 3×3 的数组，其元素来自标准正态分布：

# 创建一个 3×3 的正态分布随机数组
data = np.random.normal(size=(3, 3))
print("3×3 正态分布随机数组:")
print(data)

# 生成一个3x3的随机数组，服从标准正态分布
array1 = np.random.normal(size=(3, 3))
print("原始数组:")
print(array1)

# 计算数组的总和
c = array1.sum()
print("总和 array1.sum():", c)

# 计算均值
b = array1.mean()
print("均值 array1.mean():", b)

# 计算方差
variance = array1.var()
print("\n方差 array1.var():", variance)

# 计算标准差
a = array1.std()
print("标准差 array1.std():", a)

# 计算中位数（注意：数组本身无median方法，需使用numpy函数）
d = np.median(array1)
print("中位数 np.median(array1):", d)

# 求和操作按不同轴进行
# 对每一行进行求和（即每行的列元素相加）
e = array1.sum(axis=1)
print("\n按行求和 array1.sum(axis=1):")
print(e)

# 对每一列进行求和（即每列的行元素相加）
f = array1.sum(axis=0)
print("\n按列求和 array1.sum(axis=0):")
print(f)

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：python Numpy Day NUM concatenate