NumPy高效科学计算全解析
NumPy（Numerical Python），专门用来做「数值计算」的 Python 核心库，弥补Python高性能科学计算的缺失，是数据分析、机器学习、深度学习等基础库。
安装
pip install numpy导入
import numpy as np # 查看numpy版本 print(np.__version__)np是numpy约定俗成的别名。
numpy存储特性
python的列表：
lst = [10, 20, 30, 40]lst 是一个指针数组： 索引： 0 1 2 3 ┌────┬────┬────┬────┐ │ ptr│ptr │ptr │ptr │ <-- 存的是地址 └──┼─┴──┼─┴──┼─┴──┼─┘ ▼ ▼ ▼ ▼ 10 20 30 40 <-- 数据分散在内存各处- 每个位置存指针（地址）
- 数据类型可以随便混
- 内存不连续、散乱、速度慢
numpy数组：
import numpy as np arr = np.array([10, 20, 30, 40])arr 是一整块连续内存： 内存地址： 0x100 0x104 0x108 0x10C ┌────┬────┬────┬────┐ │ 10 │ 20 │ 30 │ 40 │ <-- 真正数据连续排列 └────┴────┴────┴────┘- 数据直接紧挨着存，没有指针
- 必须同一类型（全 int / 全 float）
- 内存连续 → 速度极快
数组概念
NumPy 数组（ndarray）就是一块连续、整齐、同类型的数字块，可以是 1 条线、1 张表、1 个立方体。它是 Python 里做数值计算、数据分析、画图的基础容器。
0维->点->标量
1维->线->向量
2维->面->矩阵
3维->立方体->张量
低维度复制多次就成为高纬度。如从上图也可以看到一个立方体复制2次就成了超立方体（四次元立方体）。
数组创建
从python创建数组
创建一维数组
arr1 = np.array([1, 2, 3, 4, 5]) print(arr1) arr2 = np.array((1, 2, 3, 4, 5)) print(arr2)创建二维数组
arr3 = np.array([[1, 2, 3], [4, 5, 6]]) print(arr3)创建三维数组
arr4=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]) print(arr4)指定数据类型创建数组
arr_float = np.array([1, 2, 3], dtype=float) print(arr_float) # [1. 2. 3.]arr_int = np.array([1.2, 5.8, 9.9], dtype=int) print(arr_int) # [1 5 9] 截断小数部分使用内置函数创建数组
全零数组 zeros
arr1 = np.zeros(5) # 创建一个1维数组，元素全为0 print(arr1) # [0. 0. 0. 0. 0.] print(arr1.shape) # (5,) arr2 = np.zeros((2, 3)) # 创建一个2维数组，元素全为0 print(arr2) # [[0. 0. 0.] # [0. 0. 0.]] print(arr2.shape) # (2, 3) arr3 = np.zeros((2, 3, 4)) # 创建一个3维数组，元素全为0 print(arr3) # [[[[0. 0. 0. 0.] # [0. 0. 0. 0.]] # [[0. 0. 0. 0.] # [0. 0. 0. 0.]]] print(arr3.shape) # (2, 3, 4)全1数组 ones
arr1 = np.ones(5) # 创建一个1维数组，元素全为0 print(arr1) # [1. 1. 1. 1. 1.] print(arr1.shape) # (5,) arr2 = np.ones((2, 3)) # 创建一个2维数组，元素全为0 print(arr2) # [[1. 1. 1.] # [1. 1. 1.]] print(arr2.shape) # (2, 3) arr3 = np.ones((2, 3, 4)) # 创建一个3维数组，元素全为0 print(arr3) # [[[[1. 1. 1. 1.] # [1. 1. 1. 1.]] # [[1. 1. 1. 1.] # [1. 1. 1. 1.]]] print(arr3.shape) # (2, 3, 4)全值数组 full
arr = np.full((2, 3), 100) print(arr) # [[100 100 100] # [100 100 100]] print(arr.shape) # (2, 3)空数组 empty
记住empty只是向系统申请内存空间，不赋值。值仍然是原来的值，看起来是随机的效果。使用的empty的有什么用？快！
arr = np.empty((2, 3))单位矩阵 eye identity
主对角线是1的矩阵是单位矩阵。
eye可以创建任意形状的单位矩阵，identity只能创建正方形的单位矩阵。
arr = np.eye(3) print(arr) # [[1. 0. 0. 0.] # [0. 1. 0. 0.] # [0. 0. 1. 0.]] print(arr.shape) # (3, 3) arr = np.eye(3, 4) print(arr) # [[1. 0. 0.] # [0. 1. 0.] # [0. 0. 1.]] print(arr.shape) # (3, 4) arr2 = np.identity(3) print(arr2) # [[1. 0. 0.] # [0. 1. 0.] # [0. 0. 1.]] print(np.identity(3).shape) # (3, 3)使用范围函数创建数组
arange创建一维数组
arr1 = np.arange(10) print(arr1) # [0 1 2 3 4 5 6 7 8 9] arr2 = np.arange(1, 10) print(arr2) # [1 2 3 4 5 6 7 8] arr3 = np.arange(1, 10, 2) print(arr3) # [1 3 5 7] arr4 = np.arange(1, 10, 0.5) print(arr4) # [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9.]linspace创建一维等间距数组
arr1 = np.linspace(0, 1, 5) # 生成5个等间距的点，包括0和1 print(arr1) # [0. 0.25 0.5 0.75 1. ]logspace生成一维10的等比数列
arr1 = np.logspace(0, 1, 5) # 10的0次方到10的1次方，指数从0 0.25 0.5 0.75 1递增 print(arr1) # [ 1. 1.77827941 3.16227766 5.62341325 10.]数组属性
就像图片的属性有什么分辨率、宽度、高度等。ndarray对象=元数据+数据。这里的元数据就是ndarray对象的属性。
ndarray 对象 ├─ 数据缓冲区：[1,2,3,4,5,6] （真正的数字） └─ 描述头（元数据） ├─ ndim 维度数 ├─ shape 每个维度长度 ├─ dtype 元素数据类型 ├─ itemsize 单个元素占据字节数 ├─ strides 每个维度跨多少字节 ├─ size 元素总个数 ├─ nbytes 数组元素总字节数 └─ data 内存起始指针strides：往某一维走 1 格，内存里要跳过多少字节
假设有一个float64（8字节）的2x3数组
跨越一行：跳过 3×8=24 字节
跨越一列：跳过 8 字节
strides = （24，8）
arr = np.array([[1, 2, 3], [4, 5, 6]]) # 数组维度 print(arr.ndim) # 2数组的维度 # 数组形状 print(arr.shape) # (2, 3) 2行2列 # 数组元素类型 print(arr.dtype) # int64 # 单个元素占据字节数 print(arr.itemsize) # 8 # 数组步长 print(arr.strides) # (24, 8) 每个元素的字节数，每个维度的步长 # 数组元素个数 print(arr.size) # 6 # 数组元素总字节数 print(arr.nbytes) # 48 # 数组数据 print(arr.data) # <memory at 0x0000022491840FB0>数组取值
一维数组取值
arr = np.array([1, 2, 3]) # 创建一个1维数组 print(arr) # [1 2 3] print(arr[0]) # 1 print(arr[0:2]) # [1 2] 左闭右开 print(arr[-1]) # 3 print(arr[arr>=2]) # [2 3] 布尔索引从结果可以看到，一维数组的取值方式和python 列表一致。
另外注意，索引和切片操作是视图，非副本。（副本是独立内存，修改互不影响，视图是共享内存，改了一个，另外一个也变）
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) # 切片是视图，不是副本 # 原数组基本属性 print("原数组的形状:", arr.shape) print("原数组的维度:", arr.ndim) print("原数组的元素个数:", arr.size) print("原数组的元素类型:", arr.dtype) print("原数组的每个元素的字节数:", arr.itemsize) print("原数组的每个维度的步长（字节数）:", arr.strides) print("原数组的总字节数:", arr.nbytes) print("原数组的起始内存地址:", arr.data) # 起始内存地址一样 print("arr的真实内存起始地址:", arr.ctypes.data) # 真实数据和元数组相比偏移量不一样 arr2 = arr[2:7] # arr2基本属性 print("arr2的形状:", arr2.shape) print("arr2的维度:", arr2.ndim) print("arr2的元素个数:", arr2.size) print("arr2的元素类型:", arr2.dtype) print("arr2的每个元素的字节数:", arr2.itemsize) print("arr2的每个维度的步长（字节数）:", arr2.strides) print("arr2的总字节数:", arr2.nbytes) print("arr2的起始内存地址:", arr2.data) # 起始内存地址一样 print("arr2的真实内存起始地址:", arr2.ctypes.data) # 真实数据和元数组相比偏移量不一样二维数组取值
二维取值格式为[行，列]
二维数组有行和列的概念，通过行列在一维连续存储。
数组多维的概念只是逻辑结构，实际底层仍然是一维连续空间。
arr = np.array([[1, 2, 3], [4, 5, 6]]) # 创建一个2维数组 print(arr) # [[1 2 3] [4 5 6]] # 取行 print(arr[0]) # [1 2 3] 取第一行 print(arr[0:2]) # [[1 2 3] [4 5 6]] 左闭右开 取第一行和第二行 # 取列 print(arr[:, 0]) # [1 4] 取第一列 print(arr[:, 0:2]) # [[1 2] [4 5]] 取第一列和第二列 # 取行列 print(arr[0, 1]) # 2 取第一行第二列 print(arr[0:2, 0:2]) # [[1 2] [4 5]] 取第一行和第二行，第一列和第二列 # 列表取多值 print(arr[:, [0, 1]]) # [[1 2] [4 5]] 取第一列和第二列 # 花式索引：用「列表 / 数组」去当索引，一次性挑出多行、多列、多个点。 # 布尔索引 print(arr[arr > 3]) # [4 5 6]取大于大于3的元素 # 用...代替所有维度 print(arr[..., 1]) # [2 5] 取第二列 # 链式取值,一般不推荐，速度慢 print(arr[0][1]) # 2 取第一行第二列 # 步长取值、取反 print(arr[:, ::2]) # [[1 3] [4 6]] 第一列、第三列 print(arr[::-1, :]) # [[4 5 6] [1 2 3]] 反转行一维数组取值和二维数组取值小结：
1.没有逗号，取行；有逗号，逗号左边取行，逗号右边取列，arr[0]，arr[0, 1]
2.一个冒号切片，二个冒号步长，arr[0:2]，arr[:, ::2]
3.只有冒号没有数字，取全部，arr[:, 0]
4.[]取多值，arr[:, [0, 1]]
5.布尔按条件取值，arr[arr > 3]
6.链式速度慢，不建议使用，arr[0][1]
7. 点点点所有维度，arr[..., 1]
三维数组取值
三维取值格式为[层，行，列]
arr = np.array( [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18]]] ) # 创建一个3维数组 print(arr) print(arr.shape) # (3, 2, 3) 3个层，每个层有2行3列 print(arr[0]) # [[1 2 3] [4 5 6]] 取第一层 print(arr[0, 0]) # [1 2 3] 取第一层第一行 print(arr[0, 0, 0]) # 1 取第一层第一行第一列其它的取值方式类同二维数组取值。
数组运算
基本算数运算
加减乘除
a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) # 加减乘除 print(a + b) # [5 7 9] print(a - b) # [-3 -3 -3] print(a * b) # [4 10 18] print(a / b) # [0.25 0.4 0.5]幂运算
# 幂运算 print(a**b) # [ 1 32 729]取模
# 取模 print(a%b) # [1 2 3]与标量运算
标量会被广播到每个元素上
# 与标量运算 print(a+2) # [3 4 5] print(a-2) # [-1 0 1] print(a*2) # [2 4 6] print(a/2) # [0.5 1. 1.5]比较运算
比较运算得到的是布尔值的数组。
arr = np.array([1, 2, 3, 4, 5]) # 比较运算 print(arr > 2) # [False False True True True] print(arr < 2) # [ True True False False False] print(arr == 2) # [False True False False False] print(arr != 2) # [ True True True True True]数组间比较
a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) print(a > b) # [False False False] print(a < b) # [ True True True] print(a == b) # [False False False] print(a != b) # [ True True True]广播机制
数组的广播机制允许不同形状的数组进行运算。
以一个例子讲解，现在有一个(2,3)的矩阵和一个(3,)向量做加法运算
1、变维，低维度补1
(3,)变维成(1,3)
2、兼容，每个维度上，要么相等，要么一个是1
(2,3) 行维度是2，(1,3)行维度是1，符合其中一个是1
(2,3) 列维度是3，(1,3)列维度是3，符合相等
3、拉伸，维度为1的拉伸以匹配另一个数组，拉伸行复制上一行，拉伸列复制前一列
(1,3)变为 (2,3)
最后结果为：
数组变形
变形 reshape
数组变形要元素个数一致。
arr1 = np.arange(1, 13) # 生成1维数组，元素从1到12 # reshape变形 arr2 = arr1.reshape(3, 4) # 将1维数组转换为3行4列的2维数组 print(arr2) # [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]] arr3 = arr1.reshape(2, 3, 2) print(arr3) # [[[ 1 2] # [ 3 4] # [ 5 6]] # [[ 7 8] # [ 9 10] # [11 12]]] # 使用-1自动计算维度 arr4 = arr1.reshape(2, -1) print(arr4) # [[ 1 2 3 4 5 6] # [ 7 8 9 10 11 12]] # 列优先,F代表fortran，Fortran是一列一列存储的 arr5 = arr1.reshape(3, 4, order="F") print(arr5) # [[ 1 4 7 10] # [ 2 5 8 11] # [ 3 6 9 12]] # 行优先，C代表C语言 arr6 = arr1.reshape(3, 4, order="C") # 默认 print(arr6) # [[ 1 2 3 4] # [ 5 6 7 8] # [ 9 10 11 12]]展平 flatten
flatten把多维数组压成一维数组（展平），返回副本。
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) arr2 = arr1.flatten() # 将2维数组转换为1维数组 print(arr2) # [1 2 3 4 5 6] arr2[0] = 100 print(arr2) print(arr1)展平 ravel
ravel把多维数组压成一维数组（展平），返回视图。
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) arr2 = arr1.ravel() # 将2维数组转换为1维数组 print(arr2) # [1 2 3 4 5 6] arr2[0] = 100 print(arr2) print(arr1)转置 transpost / T
arr1 = np.array([[1, 2, 3], [4, 5, 6]]) print(arr1) # 2行3列 # [[1 2 3] # [4 5 6]] print(arr1.T) # 3行2列 # [[1 4] # [2 5] # [3 6]] print(arr1.transpose()) # [[1 4] # [2 5] # [3 6]] arr2 = np.array( [ [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]], ] ) print(arr2.shape) # (2, 3, 4) print(arr2.transpose(2, 1, 0)) #默认维度是(0,1,2),现在列维度变层维度，层维度变列维度 print(arr2.transpose(2, 1, 0).shape) # (4, 3, 2)交换轴 swapaxes
arr = np.array([[1, 2, 3], [4, 5, 6]]) arr.swapaxes(1, 0) print(arr) # [[1 2 3] # [4 5 6]]扩展维度 expand_dims
arr = np.array([[1, 2, 3], [4, 5, 6]]) # (2,3) print(np.expand_dims(arr, axis=0)) # [[[1 2 3] # [4 5 6]]] print(np.expand_dims(arr, axis=0).shape) # (1, 2, 3) print(np.expand_dims(arr, axis=2)) # [[[1] # [2] # [3]] # [[4] # [5] # [6]]] print(np.expand_dims(arr, axis=2).shape) # (2, 3, 1)移除1维度 squeeze
arr = np.array([[1, 2, 3], [4, 5, 6]]).reshape(2, 3, 1) print(arr.shape) # (2, 3, 1) print(arr.squeeze()) # [[1 2 3] # [4 5 6]] print(arr.squeeze().shape) # (2, 3)数组拼接分割
vstack 垂直拼接
a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) # 垂直拼接 print(np.vstack((a, b))) # [[1 2] # [3 4] # [5 6] # [7 8]]hstack 水平拼接
a = np.array([[1, 2], [3, 4]]) b = np.array([[5, 6], [7, 8]]) # 水平拼接 print(np.hstack((a, b))) # [[1 2 5 6] # [3 4 7 8]]concatenate拼接
# concatenate拼接 print( np.concatenate((a, b), axis=0) ) # axis=0 轴0是行，以行的方式拼接，垂直拼接，等同于vstack # [[1 2] # [3 4] # [5 6] # [7 8]] print( np.concatenate((a, b), axis=1) ) # axis=1 轴1是列，以列的方式拼接，水平拼接，等同于hstack # [[1 2 5 6] # [3 4 7 8]]split分割数组
# 分割数组 arr = np.arange(12).reshape(4, 3) print(arr) # [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]] print(np.split(arr, 2, axis=0)) # 按行分割2部分 # [array([[0, 1, 2], # [3, 4, 5]]), array([[ 6, 7, 8], # [ 9, 10, 11]])]数学运算
通用函数
arr = np.array([1, 4, 9, 16, 25]) # 求平方根 print(np.sqrt(arr)) # [1. 2. 3. 4. 5. ] # 求e的指数 e^arr = x e是欧拉数，约等于2.7182818 print(np.exp(arr)) # [2.71828183e+00 5.45981500e+01 8.10308393e+03 8.88611052e+06 # 7.20048993e+10] # 求自然对数 log e?arr=x e^x=arr print(np.log(arr)) # [0. 1.38629436 2.19722458 2.77258872 3.21887582] # 求常用对数 log10(arr) = x 10^x=arr print(np.log10(arr)) # [0. 0.60205999 0.95424251 1.20411998 1.39794001] # 求绝对值 print(np.abs([-1, -2, -3])) # [1 2 3] # 取整 arr2 = np.array([1.4, 2.7, 3.5]) # 四舍五入 print(np.round(arr2)) # [1. 3. 4.] # 向上取整 print(np.ceil(arr2)) # [2. 3. 4.] # 向下取整 print(np.floor(arr2)) # [1. 2. 3.]三角函数
π和角度关系：
π是圆周率， π=圆的周长/直径。任何大小的圆，π都是固定的。
弧度=弧长/半径，圆周长=2πr（r是半径）。一圈圆的弧度=2πr/r，即一圈弧度是2π（弧度）。而一圈是360°（角度），即2π=360°，π=180°（也就是弧度和角度的换算关系）。
sin、cos、tan都是以弧度参与运算的。
### 三角函数 radians = np.array( [0, np.pi / 6, np.pi / 4, np.pi / 3, np.pi / 2] ) # 0° 30° 45° 60° 90° print("正弦:", np.sin(radians)) # [0. 0.5 0.8660254 0.5 1. ] print("余弦:", np.cos(radians)) # [1. 0.8660254 0.5 0. 1. ] print("正切:", np.tan(radians)) # [0. 1.7320508 1. 1.7320508 1. ] # 角度和弧度抓换 degrees = np.array([0, 30, 45, 60, 90]) # 0° 30° 45° 60° 90° print( "弧度:", np.deg2rad(degrees) ) # [0. 0.52359877 0.87266462 1.04719755 1.57079633]聚合函数
arr = np.array([[1, 2, 3], [4, 5, 6]]) # [[1 2 3] # [4 5 6]] # 求和 print(np.sum(arr)) # 21 # 列求和 print(np.sum(arr, axis=0)) # [5 7 9] # 行求和 print(np.sum(arr, axis=1)) # [6 15] # 求平均值 print(np.mean(arr)) # 3.5 # 求最大值 print(np.max(arr)) # 6 print(np.argmax(arr)) # 5 # 最大值的索引(一维数组) # 求最小值 print(np.min(arr)) # 1 print(np.argmin(arr)) # 0 # 最小值的索引(一维数组) # 累积和 print(np.cumsum(arr)) # [1 3 6 4 9 15] 3是前两项的和，6是前三项的和，以此类推 # 乘积 print(np.prod(arr)) # 720线性代数
矩阵点积
矩阵A第一行和矩阵B第一列相乘，(1,2,3) x (7,9,11)=1x7+2x9+3x11=58，新矩阵第一行第一列为58
矩阵A第一行和矩阵B第二列相乘，(1,2,3) x (9,10,12)=1x9+2x10+3x12=64，新矩阵第一行第二列为64
最终得到结果。
a = np.array([[1, 2, 3], [4, 5, 6]]) b = np.array([[7, 8], [9, 10], [11, 12]]) print(a.dot(b)) # [[58 64] # [139 154]]行列式
矩阵的行列式是一个可以从方形矩阵（方阵）计算出来的特别的数。
注意，是正方形矩阵。
如果2x2的矩阵，行列式计算公式为：
|A| 表示求A的行列式。
如果是3x3矩阵，行列式计算公式为：
如果是4x4矩阵，
这种展开方式为拉普拉斯展开
a = np.array([[1, 2], [3, 4]]) print(np.linalg.det(a)) # -2.0逆矩阵
8 × (1/8) = 1，1/8是倒数
那类似的，矩阵x逆矩阵=1，如
A × A⁻¹ = I (单位矩阵）
a = np.array([[1, 2], [3, 4]]) a_inv = np.linalg.inv(a) print(a_inv) # [[-2. 1. ] # [ 1.5 -0.5]] # 验证逆矩阵 print(a_inv.dot(a)) # [[ 1. 0. ] # [ 0. 1. ]]特征值和特征向量
如图，x2向量在矩阵A的变换下，方向不变，仅仅做了拉伸。而x1向量在矩阵A的变换下，方向已经改变。我们把x2称为特征向量，λ是特征值。
其实，我们探究的是，什么向量能在矩阵A的变换下，只做拉伸和压缩的变换，而不设计旋转等其他类型的转换。
如图，2就是特征值，(1,1)就是特征向量。
a = np.array([[1, 2], [3, 4]]) # 特征值和特征向量 eigvals, eigvecs = np.linalg.eig(a) # 特征值: # [-0.37228132 5.37228132] print("特征值:\n", eigvals) print("特征向量:\n", eigvecs) # 特征向量: # [[-0.82456484 -0.41597356] # [ 0.56576746 -0.90937671]]线性方程组
线性方程组的特点是没有平方、没有根号、没有相乘项（xy 这种）。
# 解线性方程组 A*x=b A = np.array([[2, 1], [1, 2]]) b = np.array([5, 7]) x = np.linalg.solve(A, b) print("解线性方程组 A*x=b:\n", x) # 解线性方程组 A*x=b: # [1. 3.] # 验证 c = np.array([1, 3]) print(np.dot(A, c)) # [5 7]统计函数
基本统计
方差的计算公式：
标准差计算公式：
方差和标准差观察数据的离散程度。
均值+-标准差：包含68%的数据
均值+-2x标准差：包含95%的数据
均值+-3x标准差：包含99.7%的数据
### 基本统计 data = np.array([23, 45, 67, 89, 12, 34, 56, 78, 90, 11]) # 平均值 print("平均值:", np.mean(data)) # 平均值: 50.5 # 中位数 print( "中位数:", np.median(data), # 中位数: 50.5 ) # 从小到大排序后的中间值，如果是偶数个，中间2个数求平均 # 最大值 print("最大值:", np.max(data)) # 最大值: 90 # 最小值 print("最小值:", np.min(data)) # 最小值: 11 # 极差=最大值-最小值 print("极差:", np.ptp(data)) # 极差: 79 # 百分位数 print("25百分位数:", np.percentile(data, 25)) # 25百分位数: 25.75 print("75百分位数:", np.percentile(data, 75)) # 75百分位数: 75.25 # 标准差 data2 = np.array([2, 4, 6, 8, 10]) print("标准差:", np.std(data2)) # 标准差: 2.8284271247461903 # 方差 print("方差:", np.var(data2)) # 方差: 8.0相关性统计
相关系数：就是用来衡量两组数据之间线性关系有多强的一个数。
取值永远在-1 ≤ r ≤ 1。
- r = 1：完全正相关（你涨我也涨，一模一样）
- r = -1：完全负相关（你涨我就跌，完全相反）
- r = 0：完全没关系，各走各的
假设有2个变量，身高和体重
协方差矩阵长这样：
相关系数矩阵长这样：
协方差计算公式：
相关系数计算公式：
###相关性统计 x = np.array([1, 2, 3, 4, 5]) y = np.array([2, 4, 5, 4, 5]) # 相关系数矩阵 print("相关系数矩阵:\n", np.corrcoef(x, y)) # 相关系数矩阵: # [[1. 0.77459667] # [0.77459667 1. ]] # 协方差矩阵 print("协方差矩阵:\n", np.cov(x, y)) # 默认样本协方差矩阵 # 协方差矩阵: # [[2.5 1.5] # [1.5 1.5]]随机数生成
基本用法
### 基本用法 # 设置随机种子（种子一样，随机数一样） np.random.seed(42) # 0-1之间的随机数 print("0-1之间的随机数:\n",np.random.rand()) # 0-1之间的随机数: # 0.3745401188473625 #生成随机数矩阵 arr=np.random.rand(3,3) print("随机矩阵:\n",arr) # 随机矩阵: # [[0.95071431 0.73199394 0.59865848] # [0.15601864 0.15599452 0.05808361] # [0.86617615 0.60111501 0.70807258]] #指定范围的随机整数 print("指定范围的随机整数:\n",np.random.randint(1,10)) # 指定范围的随机整数: # 6 print("生成3x3矩阵:\n",np.random.randint(1,10,size=(3,3))) # 生成3x3矩阵: # [[5 2 8] # [6 2 5] # [1 6 9]] #标准正态分布（均值为0，标准差为1的正态分布随机数） print("标准正态分布:\n",np.random.randn(3,3)) # 标准正态分布: # [[ 0.81644508 -1.523876 -0.42804606] # [-0.74240684 -0.7033438 -2.13962066] # [-0.62947496 0.59772047 2.55948803]] #指定均值和标准差的正态分布随机数 print("指定均值和标准差的正态分布随机数:\n",np.random.normal(loc=50,scale=10,size=100)) #从数组中随机选择 arr=np.array([1,2,3,4,5]) print("从数组中随机选择:\n",np.random.choice(arr,size=3,replace=False)) # 随机选择3个数，返回新数组，不替换新数组 # 从数组中随机选择: # [1 3 2]常用分布
均匀分布：啥概率都一样平，如掷骰子
正态分布：中间多，两头少，如身高
二项分布：做N次独立试验，成功几次，如抛硬币
泊松分布：一段时间内，发生几次，如1分钟内，路过几辆车
指数分布：两次事件之间隔多久，如电话两次响铃间隔
###常用分布 # 均匀分布 uniform = np.random.uniform(low=0, high=10, size=1000) # 正态分布 normal = np.random.normal(loc=0, scale=1, size=1000) # 二项分布 binomial = np.random.binomial(n=10, p=0.5, size=1000) # 泊松分布 poisson = np.random.poisson(lam=5, size=1000) # 指数分布 exponential = np.random.exponential(scale=1, size=1000)随机打乱
使用shuffle或permutation打算数组。shuffle返回视图，permutation返回副本。
###随机打乱 # 随机打乱数组 arr = np.array([1, 2, 3, 4, 5]) np.random.shuffle(arr) # shuffle洗牌打乱,视图 print("随机打乱:", arr) # 返回打乱后的副本 arr2 = np.array([1, 2, 3, 4, 5]) shuffled = np.random.permutation(arr) # 副本 print("返回打乱后的副本:", shuffled) print("原数组:", arr2)