代码收藏家 Python中NumPy库的使用详解
目录
1.概念
1.1.基础概念
1.2核心概念
1.3Numpy的主要优点
1.4Numpy的典型应用场景
2.ndarray
2.1array创建对象
2.2 zeros()
2.3 ones()
2.4 full()
2.5 arange()
2.6 linspace
2.7主要属性
2.8切片及索引
3.广播
3.1广播的基本规则
3.2广播的流程
3.3广播实例
4.遍历数组
4.1for循环
4.2nditer()
5.数组操作
5.1改变形状
5.2调整维度
5.3数组转置
5.4分割数组
5.5连接数组
6.数组元素的增删改查
6.1数组元素查询
6.2数组元素修改
6.3数组元素增加
1. 使用 append 添加元素
2. 使用 insert 插入元素
6.4数组元素删除
2. 使用布尔掩码删除元素
7.统计函数
7.1基础统计量
7.1.1 集中趋势度量
7.1.2 离散程度度量
7.2顺序统计量
7.3多维数组统计
7.3.1 沿轴计算
7.3.2 整体统计
7.4高级统计函数
7.4.1. 相关性计算
7.4.2 直方图统计
7.4.3 累积统计
7.5特殊统计方法
7.5.1忽略无效值
7.5.2 其他实用函数
8 练习
9.练习
1.概念
1.1.基础概念
NumPy（Numerical Python）是 Python 中用于科学计算的核心库，提供了高性能的多维数组对象（ndarray）以及大量操作这些数组的函数。NumPy 还提供了多种数据结构，这些数据结构能够非常契合的应用在数组和矩阵的运算上
1.2核心概念
-
ndarray（N-dimensional Array）
NumPy 的核心数据结构，用于存储同类型数据（如整数、浮点数）。支持多维数组（1D 向量、2D 矩阵、3D 张量等）。比 Python 原生列表（List）更高效，因为底层用 C 实现，且数据连续存储。
-
广播（Broadcasting）
允许不同形状的数组进行算术运算，而无需显式复制数据。
-
矢量化（Vectorization）
用数组运算代替循环，提高计算效率（底层用 C 优化）。
-
通用函数（ufunc）
提供快速的逐元素运算（如
np.sin(),np.exp()）。
1.3Numpy的主要优点
| 优点 | 说明 |
|---|---|
| 高性能计算 | 底层用 C 实现，比 Python 原生列表快 10-100 倍 |
| 内存高效 | 数据连续存储，减少内存占用 |
| 丰富的数学函数 | 提供线性代数、傅里叶变换、随机数生成等 |
| 广播机制 | 支持不同形状数组运算，避免显式循环 |
| 矢量化操作 | 避免 Python 循环，提高计算速度 |
| 与其他库集成 | Pandas、SciPy、Matplotlib 等都依赖 NumPy |
| 跨平台 | 支持 Windows、Linux、macOS |
| 开源免费 | 可自由使用和修改 |
1.4Numpy的典型应用场景
-
数值计算（矩阵运算、微积分）
-
数据科学（Pandas 底层依赖 NumPy）
-
机器学习（Scikit-learn、TensorFlow/PyTorch 使用 NumPy 数组）
-
图像处理（OpenCV 图像数据用 NumPy 存储）
-
信号处理（傅里叶变换、滤波）
-
物理模拟（计算物理、量子力学）
2.ndarray
ndarray（N-dimensional array，N维数组）是NumPy库中最核心的数据结构，用于存储和处理大型多维数组和矩阵。
2.1array创建对象
通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：
numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)
参数说明：
| 序号 | 参数 | 描述说明 |
|---|---|---|
| 1 | object | 表示一个数组序列 |
| 2 | dtype | 可选参数，通过它可以更改数组的数据类型 |
| 3 | copy | 可选参数，表示数组能否被复制，默认是 True |
| 4 | order | 以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认) |
| 5 | ndmin | 用于指定数组的维度 |
import numpy as np
# 从列表创建
arr1 = np.array([1, 2, 3, 4])
# 创建全零数组
zeros = np.zeros((3, 4))
# 创建全1数组
ones = np.ones((2, 2, 2))
# 创建单位矩阵
eye = np.eye(3)
# 创建等差数列数组
lin = np.linspace(0, 10, 5) # [0, 2.5, 5, 7.5, 10]
# 创建随机数组
rand = np.random.rand(2, 3)
2.2 zeros()
创建指定大小的数组，数组元素以 0 来填充
格式：
numpy.zeros(shape, dtype = float, order = 'C')
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组 |
2.3 ones()
创建指定形状的数组，数组元素以 1 来填充
格式：
numpy.ones(shape, dtype = None, order = 'C')
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组 |
2.4 full()
full()用于创建一个填充指定值的数组。
格式：
numpy.full(shape, fill_value, dtype=None, order='C')
| 参数 | 描述 |
|---|---|
| shape | 数组的形状（如 (2, 3) 表示 2 行 3 列的数组） |
| fill_value | 填充的值 |
| dtype | 数组的数据类型（如 np.float32） |
| order | 数组的内存布局（如 'C' 表示 C 风格，'F' 表示 Fortran 风格） |
2.5 arange()
arange() 函数用于创建一个等差数列的数组。它类似于 Python 内置的 range() 函数，但返回的是一个 NumPy 数组而不是一个列表。
格式：
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为 0 |
| stop | 终止值（不包含） |
| step | 步长，默认为 1 |
| dtype | 返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型 |
注意：
arange() 函数生成的数组不包含 stop 值。
如果 step 为负数，则 start 必须大于 stop，否则生成的数组为空。
arange() 函数在处理浮点数时可能会出现精度问题，因为浮点数的表示和计算存在精度误差。
2.6 linspace
在指定的数值区间内，返回均匀间隔的一维等差数组，默认均分 50 份
格式：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为 0 |
| stop | 终止值（默认包含） |
| num | 表示数值区间内要生成多少个均匀的样本，默认值为 50 |
| endpoint | 默认为 True，表示数列包含 stop 终止值，反之不包含 |
| retstep | 表示是否返回步长。如果为 True，则返回一个包含数组和步长的元组；如果为 False，则只返回数组。默认为 False。 |
| dtype | 返回 ndarray 的数据类型，默认为 None，表示根据输入参数自动推断数据类型。 |
2.7主要属性
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.ndim) # 维度数: 2
print(arr.shape) # 形状: (2, 3)
print(arr.size) # 元素总数: 6
print(arr.dtype) # 数据类型: int64
print(arr.itemsize) # 每个元素字节大小: 8flags属性功能：返回 ndarray 数组的内存信息
def flags_test():
array_one = np.array([[1,2,3],[4,5,6]])
print('array_one 数数组的内存信息：\n',array_one.flags)
'''
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
'''| C_CONTIGUOUS |
表示数组在内存中是 C 风格连续的（行优先）。 如果为 True，则数组是 C 风格连续的。 |
| F_CONTIGUOUS |
表示数组在内存中是 Fortran 风格连续的（列优先）。 如果为 True，则数组是 Fortran 风格连续的。 |
| OWNDATA | 表示数组是否拥有自己的数据（即是否是视图）。 如果为 True，则数组拥有自己的数据；如果为 False，则数组可能是从另一个数组或对象借用数据的。 |
| WRITEABLE | 表示数组是否可写。 如果为 True，则数组是可写的；如果为 False，则数组是只读的。 |
| ALIGNED | 表示数组是否对齐。 如果为 True，则数组的数据在内存中是对齐的。 |
| WRITEBACKIFCOPY | 表示数组是否是通过 np.copy 创建的副本，并且需要将更改写回原始数组。 如果为 True，则数组是通过 np.copy 创建的副本，并且需要将更改写回原始数组。 |
| UPDATEIFCOPY | 表示数组是否是通过 np.copy 创建的副本，并且需要将更改写回原始数组。 如果为 True，则数组是通过 np.copy 创建的副本，并且需要将更改写回原始数组。 |
2.8切片及索引
切片操作可通过 [start:stop:step] 的形式来实现
参数：
start 是切片开始的位置（包含该位置）。
stop 是切片结束的位置（不包含该位置）。
step 是切片的步长，即选取元素的间隔。
整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 索引
print(arr[0, 1]) # 第0行第1列 → 2
# 切片
print(arr[1:3, :2]) # 第1~2行，前2列 → [[4, 5], [7, 8]]
# 布尔索引
mask = arr > 5
print(arr[mask]) # 所有大于5的元素 → [6, 7, 8, 9]3.广播
广播(Broadcasting)是NumPy中一项强大的功能，它允许不同形状的数组进行算术运算，而无需显式复制数据。
3.1广播的基本规则
广播遵循以下规则来比较两个数组的形状：
维度匹配：如果两个数组的维度数不同，维度数较少的数组会在前面补上长度为 1 的维度。
形状匹配：如果两个数组在某个维度上的长度不同，但其中一个数组在该维度上的长度为 1，则该数组会沿着该维度进行广播。
不匹配：如果两个数组在某个维度上的长度既不相同也不为 1，则广播失败，抛出 ValueError。
3.2广播的流程
-
扩展维度：在较小数组的形状前面添加长度为1的维度
-
扩展大小：将大小为1的维度扩展到与较大数组对应维度相同的大小
-
执行运算：在扩展后的数组上执行元素级运算
3.3广播实例
标量与数组的运算：
import numpy as np
a = np.array([1, 2, 3])
b = 2
print(a + b) # [3 4 5] - 标量b被广播为[2, 2, 2]不同形状数组运算：
a = np.array([[1, 2, 3],
[4, 5, 6]]) # 形状(2, 3)
b = np.array([10, 20, 30]) # 形状(3,)
print(a + b)
# [[11 22 33]
# [14 25 36]] - b被广播为[[10,20,30], [10,20,30]]维度扩展：
a = np.ones((4, 3)) # 形状(4, 3)
b = np.array([1, 2, 3]) # 形状(3,)
print(a + b) # b被广播为(4,3)广播失败：
a = np.ones((3, 4))
b = np.ones((2, 3))
try:
a + b
except ValueError as e:
print(e) # "operands could not be broadcast together with shapes (3,4) (2,3)"4.遍历数组
4.1for循环
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 遍历一维数组
for element in arr.flat: # 使用flat属性展开为一维
print(element)
# 遍历多维数组
for row in arr: # 按第一维度遍历
for element in row: # 遍历每一行中的元素
print(element)4.2nditer()
nditer 是 NumPy 中的一个强大的迭代器对象，用于高效地遍历多维数组。nditer 提供了多种选项和控制参数，使得数组的迭代更加灵活和高效。
# 基本用法
with np.nditer(arr, flags=['multi_index']) as it:
while not it.finished:
print(f"值: {it[0]}, 索引: {it.multi_index}")
it.iternext()
# 修改元素值（需要指定op_flags=['readwrite']）
with np.nditer(arr, flags=['multi_index'], op_flags=['readwrite']) as it:
while not it.finished:
it[0] *= 2 # 将每个元素乘以2
it.iternext()5.数组操作
5.1改变形状
arr = np.arange(6)
# 重塑形状
reshaped = arr.reshape(2, 3)
# 展平数组
flattened = arr.flatten()
# 转置
transposed = reshaped.T5.2调整维度
# 增加维度
expanded = np.expand_dims(arr, axis=0)
# 压缩维度
squeezed = np.squeeze(expanded)
# 拼接数组
a = np.array([1, 2])
b = np.array([3, 4])
concatenated = np.concatenate([a, b]) # [1, 2, 3, 4]5.3数组转置
import numpy as np
def transpose_test():
array_one = np.arange(12).reshape(3, 4)
print("原数组：")
print(array_one)
print("使用transpose()函数后的数组：")
print(np.transpose(array_one))
def T_test():
array_one = np.arange(12).reshape(3, 4)
print("原数组：")
print(array_one)
print("数组转置：")
print(array_one.T)5.4分割数组
| 函数名称 | 参数 | 说明 |
|---|---|---|
| hsplit(ary, indices_or_sections) | ary：原数组 indices_or_sections：按列分割的索引位置 | 将一个数组水平分割为多个子数组（按列） |
| vsplit(ary, indices_or_sections) | ary：原数组 indices_or_sections：按行分割的索引位置 | 将一个数组垂直分割为多个子数组（按行） |
5.5连接数组
| 函数名称 | 参数 | 说明 |
|---|---|---|
| hstack(tup) | tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组 | 按水平顺序堆叠序列中数组（列方向） |
| vstack(tup) | tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组 | 按垂直方向堆叠序列中数组（行方向） |
hstack函数要求堆叠的数组在垂直方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。
vstack() 要求堆叠的数组在水平方向（列）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。
vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。
6.数组元素的增删改查
6.1数组元素查询
1. 基本索引查询
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
# 查询单个元素
print(arr[0]) # 输出: 1
# 查询切片
print(arr[1:4]) # 输出: [2 3 4]2. 布尔索引查询
# 查询大于3的元素
print(arr[arr > 3]) # 输出: [4 5]
# 多条件查询
print(arr[(arr > 2) & (arr < 5)]) # 输出: [3 4]3. 花式索引查询
# 使用整数数组索引
indices = np.array([0, 2, 4])
print(arr[indices]) # 输出: [1 3 5]6.2数组元素修改
1.直接赋值修改
arr[0] = 10 # 修改单个元素
print(arr) # 输出: [10 2 3 4 5]
arr[1:3] = [20, 30] # 修改切片
print(arr) # 输出: [10 20 30 4 5]2.条件修改
# 将所有大于3的元素改为0
arr[arr > 3] = 0
print(arr) # 输出: [10 20 30 0 0]3.使用where函数修改
arr = np.where(arr > 10, 1, arr) # 大于10的改为1，其余不变
print(arr) # 输出: [10 1 1 0 0]6.3数组元素增加
1. 使用 append 添加元素
# 在末尾添加元素（创建新数组）
new_arr = np.append(arr, [6, 7])
print(new_arr) # 输出: [10 1 1 0 0 6 7]2. 使用 insert 插入元素
# 在指定位置插入元素
new_arr = np.insert(arr, 2, [8, 9]) # 在索引2处插入
print(new_arr) # 输出: [10 1 8 9 1 0 0]3. 使用 concatenate 连接数组
# 连接两个数组
arr2 = np.array([11, 12])
combined = np.concatenate((arr, arr2))
print(combined) # 输出: [10 1 1 0 0 11 12]6.4数组元素删除
1.使用 delete 删除元素
# 删除指定位置的元素
new_arr = np.delete(arr, [0, 4]) # 删除索引0和4的元素
print(new_arr) # 输出: [1 1 0]2. 使用布尔掩码删除元素
# 删除满足条件的元素
mask = arr != 0 # 保留不等于0的元素
new_arr = arr[mask]
print(new_arr) # 输出: [10 1 1]7.统计函数
7.1基础统计量
7.1.1 集中趋势度量
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
# 平均值
print(np.mean(arr)) # 3.0
# 中位数
print(np.median(arr)) # 3.0
# 加权平均值
weights = np.array([0.1, 0.2, 0.3, 0.2, 0.2])
print(np.average(arr, weights=weights)) # 3.2
# 众数（需配合scipy）
from scipy import stats
print(stats.mode(arr)) # ModeResult(mode=1, count=1)7.1.2 离散程度度量
# 方差
print(np.var(arr)) # 2.0
# 标准差
print(np.std(arr)) # 1.4142135623730951
# 极差（最大值-最小值）
print(np.ptp(arr)) # 47.2顺序统计量
# 最小值
print(np.min(arr)) # 1
# 最大值
print(np.max(arr)) # 5
# 分位数
print(np.percentile(arr, 25)) # 第25百分位数: 2.0
print(np.quantile(arr, 0.75)) # 第75百分位数: 4.0
# 排序
print(np.sort(arr)) # [1 2 3 4 5]7.3多维数组统计
7.3.1 沿轴计算
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
# 每列的平均值
print(np.mean(arr_2d, axis=0)) # [2.5 3.5 4.5]
# 每行的最大值
print(np.max(arr_2d, axis=1)) # [3 6]7.3.2 整体统计
# 整个数组的和
print(np.sum(arr_2d)) # 21
# 整个数组的最小值位置
print(np.argmin(arr_2d)) # 0 (扁平化后的索引)7.4高级统计函数
7.4.1. 相关性计算
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 4, 3, 2, 1])
# 协方差矩阵
print(np.cov(x, y))
"""
[[ 2.5 -2.5]
[-2.5 2.5]]
"""
# 相关系数
print(np.corrcoef(x, y))
"""
[[ 1. -1.]
[-1. 1.]]
"""7.4.2 直方图统计
data = np.random.normal(0, 1, 1000)
# 直方图计数
counts, bins = np.histogram(data, bins=10)
print(counts) # 各区间计数
# 二维直方图
x = np.random.rand(100)
y = np.random.rand(100)
hist_2d = np.histogram2d(x, y, bins=5)7.4.3 累积统计
# 累积和
print(np.cumsum(arr)) # [ 1 3 6 10 15]
# 累积乘积
print(np.cumprod(arr)) # [ 1 2 6 24 120]7.5特殊统计方法
7.5.1忽略无效值
arr_with_nan = np.array([1, 2, np.nan, 4])
# 忽略NaN计算均值
print(np.nanmean(arr_with_nan)) # 2.333...
# 忽略NaN计算标准差
print(np.nanstd(arr_with_nan)) # 1.247...7.5.2 其他实用函数
# 非零元素计数
print(np.count_nonzero(arr)) # 5
# 满足条件的元素计数
print(np.sum(arr > 3)) # 2
# 元素出现频率
values, counts = np.unique(arr, return_counts=True)
print(values, counts) # [1 2 3 4 5] [1 1 1 1 1]8 练习
1.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]])，提取第 2 行的所有元素，并将其值加 10。
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
second_row = arr[1] + 10
print(second_row) # 输出: [14 15 16]2.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])，提取出所有大于3且小于8的元素，并将这些元素替换为-1。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
mask = (arr > 3) & (arr < 8)
arr[mask] = -1
print(arr)
"""
输出:
[[ 1 2 3]
[-1 -1 6]
[ 7 8 9]]
"""3.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])，提取出主对角线上的元素，并将这些元素替换为它们的平方。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
diag_indices = np.diag_indices_from(arr)
arr[diag_indices] = arr[diag_indices] ** 2
print(arr)
"""
输出:
[[ 1 2 3]
[ 4 25 6]
[ 7 8 81]]
"""4.给定一个 NumPy 数组，编写一个函数，使用广播机制将数组的每个元素加上一个给定的标量值，并返回结果数组。
def add_scalar(arr, scalar):
return arr + scalar
# 示例用法
arr = np.array([1, 2, 3])
result = add_scalar(arr, 5)
print(result) # 输出: [6 7 8]5.使用Python的NumPy库，创建一个形状为(4,4)的二维数组，并且初始化所有元素为-1。
arr = np.full((4, 4), -1)
print(arr)
"""
输出:
[[-1 -1 -1 -1]
[-1 -1 -1 -1]
[-1 -1 -1 -1]
[-1 -1 -1 -1]]
"""6.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])，将其按行分割为两个子数组：第一个子数组包含前两行，第二个子数组包含最后一行。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
sub1, sub2 = np.split(arr, [2])
print("第一个子数组:\n", sub1)
print("第二个子数组:\n", sub2)
"""
输出:
第一个子数组:
[[1 2 3]
[4 5 6]]
第二个子数组:
[[7 8 9]]
"""7.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])，在第二列插入一个全为零的列。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
new_arr = np.insert(arr, 1, 0, axis=1)
print(new_arr)
"""
输出:
[[1 0 2 3]
[4 0 5 6]
[7 0 8 9]]
"""8.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])，找出所有大于5的元素的索引，并将这些元素替换为它们的平方根。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
indices = np.where(arr > 5)
arr[indices] = np.sqrt(arr[indices])
print(arr)
"""
输出:
[[1. 2. 3. ]
[4. 5. 2.44948974]
[2.64575131 2.82842712 3. ]]
"""9.给定一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])，删除最后一行和最后一列。
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
new_arr = arr[:-1, :-1]
print(new_arr)
"""
输出:
[[1 2]
[4 5]]
"""9.练习
1.创建一个二维 NumPy 数组，其中包含从 1 到 100 的整数，然后使用高级索引提取所有偶数，并计算这些偶数的总和。
import numpy as np
# 创建1到100的二维数组(10x10)
arr = np.arange(1, 101).reshape(10, 10)
# 提取所有偶数
even_numbers = arr[arr % 2 == 0]
# 计算偶数和
even_sum = np.sum(even_numbers)
print("偶数数组:", even_numbers)
print("偶数和:", even_sum)2.编写一个函数，返回数组沿指定轴的方差。
def axis_variance(arr, axis=None):
"""
计算数组沿指定轴的方差
参数:
arr: NumPy数组
axis: 计算轴(0=列,1=行,None=整个数组)
返回:
方差值或沿轴的方差数组
"""
return np.var(arr, axis=axis)
# 示例使用
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("列方差:", axis_variance(arr_2d, axis=0)) # [2.25 2.25 2.25]
print("行方差:", axis_variance(arr_2d, axis=1)) # [0.66666667 0.66666667]
print("总体方差:", axis_variance(arr_2d)) # 2.91666666666666653.实现一个函数，它接受一个 NumPy 数组，并返回该数组中所有唯一元素的列表。
def unique_elements(arr):
"""
返回数组中的唯一元素列表
参数:
arr: NumPy数组
返回:
唯一元素列表(排序后)
"""
return np.unique(arr).tolist()
# 示例使用
arr = np.array([1, 2, 3, 4, 3, 5, 3])
print("唯一元素:", unique_elements(arr)) # [1, 2, 3, 4, 5]4.假设数组：[1, 2, 3, 4, 3, 5, 3]，删除数组中所有值为3的元素。
def remove_value(arr, value):
"""
删除数组中所有指定值的元素
参数:
arr: NumPy数组
value: 要删除的值
返回:
删除指定值后的新数组
"""
return arr[arr != value]
# 示例使用
arr = np.array([1, 2, 3, 4, 3, 5, 3])
print("原数组:", arr)
print("删除3后:", remove_value(arr, 3)) # [1 2 4 5]作者：linn125
