Python 数组计算模块 NumPy快速入门 这篇就够了
目录
1.NumPy概述
2.安装NumPy
3.NumPy 创建数组
4. 从已有的数组中创建数组
5.数组的运算
5.1算术运算：
5.2统计运算：
5.3逻辑运算：
5.4比较运算：
5.5线性代数运算：
5.6形状操作：
5.7索引和切片：
5.8广播（Broadcasting）：
5.9随机模块：
5.10其他常用函数：
1.NumPy概述
NumPy（Numerical Python的简称）是Python的一种开源的数值计算扩展库，它提供了大量的维度数组与矩阵运算的功能，此外也针对数组运算提供大量的数学函数库。NumPy的核心是ndarray对象，这是一个强大的N维数组对象，封装了Python原生的同数据类型的n维数组，以提供更高的性能。
NumPy提供了各种派生对象，如掩码数组和矩阵，以及用于数组快速操作的各种API，包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、基本线性代数，基本统计运算和随机模拟等功能。
2.安装NumPy
pip install numpy3.NumPy 创建数组
下面是常用的创建数组函数
示例：
import numpy as np
# 创建一个一维数组
one_dimensional_array = np.array([1, 2, 3, 4, 5])
print("一维数组:", one_dimensional_array)
# 创建一个二维数组
two_dimensional_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("二维数组:\n", two_dimensional_array)
# 创建一个全零数组，形状为 (3, 3)
zeros_array = np.zeros((3, 3))
print("全零数组:\n", zeros_array)
# 创建一个全一数组，形状为 (2, 2)
ones_array = np.ones((2, 2))
print("全一数组:\n", ones_array)
# 创建一个空数组，形状为 (2, 2)
empty_array = np.empty((2, 2))
print("空数组:\n", empty_array)
# 创建一个从0到9的一维数组
arange_array = np.arange(10)
print("arange数组:", arange_array)
# 创建一个包含10个等间距元素，从0到1（不包括1）的一维数组
linspace_array = np.linspace(0, 1, 10)
print("linspace数组:", linspace_array)
# 创建一个形状为 (3, 3) 的随机浮点数数组，范围在 [0, 1) 之间
random_float_array = np.random.rand(3, 3)
print("随机浮点数数组:\n", random_float_array)
# 创建一个形状为 (4,) 的随机整数数组，范围在 0 到 10 之间
random_int_array = np.random.randint(0, 10, 4)
print("随机整数数组:", random_int_array)运行结果：
一维数组: [1 2 3 4 5]
二维数组:
[[1 2 3]
[4 5 6]
[7 8 9]]
全零数组:
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
全一数组:
[[1. 1.]
[1. 1.]]
空数组:
[[1. 1.]
[1. 1.]]
arange数组: [0 1 2 3 4 5 6 7 8 9]
linspace数组: [0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
0.66666667 0.77777778 0.88888889 1. ]
随机浮点数数组:
[[0.59046604 0.18775417 0.5771293 ]
[0.31822654 0.05677973 0.65466802]
[0.8189839 0.80190297 0.99657669]]
随机整数数组: [1 1 3 9]
还可以使用logspace函数创建等比数列
4. 从已有的数组中创建数组
示例：
import numpy as np
# 使用asarray创建数组，它将尝试将输入转换为NumPy数组
list_data = [1, 2, 3, 4, 5]
array_from_list = np.asarray(list_data, dtype=np.int64)
print("使用asarray从列表创建的数组:", array_from_list)
# 创建一个原始数组
original_array = np.array([[1, 2], [3, 4]])
# 使用empty_like创建一个与原始数组形状相同但内容未初始化的数组
empty_array = np.empty_like(original_array, dtype=original_array.dtype)
print("使用empty_like创建的数组:", empty_array)
# 使用zeros_like创建一个与原始数组形状相同且全为0的数组
zeros_array = np.zeros_like(original_array)
print("使用zeros_like创建的数组:", zeros_array)
# 使用ones_like创建一个与原始数组形状相同且全为1的数组
ones_array = np.ones_like(original_array)
print("使用ones_like创建的数组:", ones_array)
# 使用full_like创建一个与原始数组形状相同且全为指定值的数组
full_array = np.full_like(original_array, fill_value=5)
print("使用full_like创建的数组:", full_array)运行结果：
使用asarray从列表创建的数组: [1 2 3 4 5]
使用empty_like创建的数组: [[ 452028457 1691728998]
[1589277032 -837084891]]
使用zeros_like创建的数组: [[0 0]
[0 0]]
使用ones_like创建的数组: [[1 1]
[1 1]]
使用full_like创建的数组: [[5 5]
[5 5]]
5.数组的运算
NumPy（Numerical Python的简称）是一个强大的Python库，用于处理大型多维数组和矩阵的数学运算。它提供了许多高级数学函数来操作这些数组。以下是一些常见的NumPy数组运算：
5.1算术运算：
- 加法：
numpy.add()或+ - 减法：
numpy.subtract()或- - 乘法：
numpy.multiply()或*（对于逐元素乘法）或@（对于矩阵乘法） - 除法：
numpy.divide()或/ - 取模：
numpy.mod()或% - 幂运算：
numpy.power()或**
示例：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 加法
add_result = np.add(a, b)
print("加法结果:", add_result) # 输出: [5 7 9]
# 减法
sub_result = np.subtract(b, a)
print("减法结果:", sub_result) # 输出: [3 3 3]
# 乘法
mul_result = np.multiply(a, b)
print("乘法结果:", mul_result) # 输出: [ 4 10 18]
# 除法
div_result = np.divide(b, a)
print("除法结果:", div_result) # 输出: [4. 2.5 2.]
# 幂运算
power_result = np.power(a, 2)
print("幂运算结果:", power_result) # 输出: [1 4 9]运行结果：
加法结果: [5 7 9]
减法结果: [3 3 3]
乘法结果: [ 4 10 18]
除法结果: [4. 2.5 2. ]
幂运算结果: [1 4 9]
5.2统计运算：
- 求和：
numpy.sum() - 平均值：
numpy.mean() - 中位数：
numpy.median() - 标准差：
numpy.std() - 方差：
numpy.var() - 最小值：
numpy.min() - 最大值：
numpy.max()
示例：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
# 求和
sum_result = np.sum(a)
print("求和结果:", sum_result) # 输出: 15
# 平均值
mean_result = np.mean(a)
print("平均值结果:", mean_result) # 输出: 3.0
# 中位数
median_result = np.median(a)
print("中位数结果:", median_result) # 输出: 3.0
# 标准差
std_result = np.std(a)
print("标准差结果:", std_result) # 输出: 1.4142135623730951
# 方差
var_result = np.var(a)
print("方差结果:", var_result) # 输出: 2.0
# 最小值
min_result = np.min(a)
print("最小值结果:", min_result) # 输出: 1
# 最大值
max_result = np.max(a)
print("最大值结果:", max_result) # 输出: 5运行结果：
求和结果: 15
平均值结果: 3.0
中位数结果: 3.0
标准差结果: 1.4142135623730951
方差结果: 2.0
最小值结果: 1
最大值结果: 5
5.3逻辑运算：
- 逻辑与：
numpy.logical_and()或& - 逻辑或：
numpy.logical_or()或| - 逻辑非：
numpy.logical_not()或~
示例：
import numpy as np
a = np.array([1, 0, 2, 0, 3])
b = np.array([0, 1, 2, 0, 1])
# 逻辑与
and_result = np.logical_and(a > 0, b > 0)
print("逻辑与结果:", and_result) # 输出: [False False True False True]
# 逻辑或
or_result = np.logical_or(a > 1, b > 1)
print("逻辑或结果:", or_result) # 输出: [False False True False True]
# 逻辑非
not_result = np.logical_not(a == b)
print("逻辑非结果:", not_result) # 输出: [ True True False False True]运行结果：
逻辑与结果: [False False True False True]
逻辑或结果: [False False True False True]
逻辑非结果: [ True True False False True]
5.4比较运算：
- 等于：
numpy.equal()或== - 不等于：
numpy.not_equal()或!= - 小于：
numpy.less()或< - 大于：
numpy.greater()或> - 小于等于：
numpy.less_equal()或<= - 大于等于：
numpy.greater_equal()或>=
示例：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
# 等于
equal_result = np.equal(a, 3)
print("等于结果:", equal_result) # 输出: [False False True False False]
# 不等于
not_equal_result = np.not_equal(a, 3)
print("不等于结果:", not_equal_result) # 输出: [ True True False True True]
# 小于
less_result = np.less(a, 3)
print("小于结果:", less_result) # 输出: [ True True False False False]
# 大于等于
greater_equal_result = np.greater_equal(a, 3)
print("大于等于结果:", greater_equal_result) # 输出: [False False True True True]运行结果：
等于结果: [False False True False False]
不等于结果: [ True True False True True]
小于结果: [ True True False False False]
大于等于结果: [False False True True True]
5.5线性代数运算：
- 矩阵乘法：
numpy.dot()或@ - 矩阵转置：
numpy.transpose()或.T属性 - 矩阵的逆：
numpy.linalg.inv() - 行列式：
numpy.linalg.det() - 特征值和特征向量：
numpy.linalg.eig()
示例：
import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
# 矩阵乘法
dot_product = np.dot(A, B)
print("矩阵乘法结果:", dot_product)
# 矩阵转置
A_transpose = A.T
print("矩阵转置结果:", A_transpose)
# 矩阵的逆（如果矩阵可逆）
A_inv = np.linalg.inv(A)
print("矩阵的逆结果:", A_inv)
# 行列式
det_A = np.linalg.det(A)
print("行列式结果:", det_A)
# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
print("特征值:", eigenvalues)
print("特征向量:", eigenvectors)运行结果：
矩阵乘法结果: [[19 22]
[43 50]]
矩阵转置结果: [[1 3]
[2 4]]
矩阵的逆结果: [[-2. 1. ]
[ 1.5 -0.5]]
行列式结果: -2.0000000000000004
特征值: [-0.37228132 5.37228132]
特征向量: [[-0.82456484 -0.41597356]
[ 0.56576746 -0.90937671]]
5.6形状操作：
- 改变形状：
numpy.reshape() - 扁平化：
numpy.ravel()或numpy.flatten() - 连接数组：
numpy.concatenate() - 拆分数组：
numpy.split()
示例：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
# 改变形状
reshaped_a = np.reshape(a, (3, 2))
print("改变形状结果:", reshaped_a)
# 扁平化
flattened_a = a.flatten()
print("扁平化结果:", flattened_a)
# 连接数组
b = np.array([[7, 8, 9], [10, 11, 12]])
concatenated_ab = np.concatenate((a, b), axis=0)
print("连接数组结果:", concatenated_ab)
# 拆分数组
split_a = np.split(a, 3, axis=1)
print("分割后的数组:", split_a)运行结果：
改变形状结果: [[1 2]
[3 4]
[5 6]]
扁平化结果: [1 2 3 4 5 6]
连接数组结果: [[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
分割后的数组: [array([[1],
[4]]), array([[2],
[5]]), array([[3],
[6]])]
5.7索引和切片：
- 一维数组索引和切片类似于Python列表
- 多维数组支持复杂的索引和切片方式，包括整数数组索引和布尔索引
示例：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 索引
print("索引结果:", a[1, 2]) # 输出: 6
# 切片
slice_result = a[0:2, 1:3]
print("切片结果:", slice_result) # 输出: [[2 3] [5 6]]运行结果：
索引结果: 6
切片结果: [[2 3]
[5 6]]
5.8广播（Broadcasting）：
- 当两个数组的维度不兼容时，NumPy会自动触发广播机制，使得它们可以进行数学运算
示例：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([1, 2, 3])
# 广播后相加
added_result = a + b
print("广播相加结果:", added_result)运行结果：
广播相加结果: [[2 4 6]
[5 7 9]]
5.9随机模块：
- 生成随机数：
numpy.random.rand() - 从正态分布中生成随机数：
numpy.random.randn() - 设置随机种子：
numpy.random.seed()
示例：
import numpy as np
# 设置随机种子以确保结果可复现
np.random.seed(0)
# 生成随机数
random_numbers = np.random.rand(3, 2)
print("随机数结果:", random_numbers)
# 从正态分布中生成随机数
normal_distribution = np.random.randn(3, 2)
print("正态分布随机数结果:", normal_distribution)运行结果：
随机数结果: [[0.5488135 0.71518937]
[0.60276338 0.54488318]
[0.4236548 0.64589411]]
正态分布随机数结果: [[ 0.95008842 -0.15135721]
[-0.10321885 0.4105985 ]
[ 0.14404357 1.45427351]]
5.10其他常用函数：
- 排序：
numpy.sort() - 唯一值：
numpy.unique() - 查找：
numpy.where() - 条件计数：
numpy.count_nonzero() - 剪裁值：
numpy.clip()
示例：
import numpy as np
a = np.array([5, 2, 6, 1, 9, 4, 7, 3, 8])
# 排序
sorted_a = np.sort(a)
print("排序结果:", sorted_a)
# 唯一值
unique_a = np.unique(a)
print("唯一值结果:", unique_a)
# 查找：返回满足条件的索引
indices = np.where(a > 5)
print("查找结果:", indices)
# 条件计数：计算数组中大于5的元素个数
count = np.count_nonzero(a > 5)
print("条件计数结果:", count)
# 剪裁值：将数组中的值限制在2到7之间
clipped_a = np.clip(a, 2, 7)
print("剪裁值结果:", clipped_a)运行结果：
排序结果: [1 2 3 4 5 6 7 8 9]
唯一值结果: [1 2 3 4 5 6 7 8 9]
查找结果: (array([2, 4, 6, 8], dtype=int64),)
条件计数结果: 4
剪裁值结果: [5 2 6 2 7 4 7 3 7]