前四节内容点击链接跳转
【python包】NumPy-快速处理数据1_Zincy星辰的博客-CSDN博客
https://blog.csdn.net/qq_52057693/article/details/121201077
目录
目录
五、Numpy随机数
- numpy自带大量的函数，可以基本覆盖常见线性代数运算和随机数生成。配合更庞大的scipy，基本能够满足常见科学计算的需求。
- numpy和scipy配合，基本和matlab旗鼓相当。matlab速度上略胜一筹，但仍然不是很快。python胜在生态，包罗万象，语言本身的速度短板靠生态来补。
- python目前也有挑战者，比如开源的julia、Go、R，各有优势，但软件生态都不如python丰富。python永远开源的政策可以保证它的软件生态的发展。
import numpy as np
import matplotlib.pyplot as plt # 画图用matplotlib
# 0到1之间的随机数
a = np.random.rand(10000)
plt.hist(a,100)
#plt.show()
# 指定范围随机整数
a = np.random.randint(1,10,1000)
plt.hist(a,100)
# 均匀分布随机浮点数
a = np.random.uniform(1,10,10000)
plt.hist(a,100)
# 随机排列
a = np.random.permutation(10);print(a)
# 随机抽取
a = np.random.choice([1,2,3,4,'2233','张三','韩梅'])
print(a)
# 标准正态分布随机数
a = 2.5 * np.random.randn(2, 4) + 3;print(a)
# 正态分布随机数
mu = 2.5; sigma = 3.5
a = np.random.normal(mu, sigma, 10000)
plt.hist(a,100)
# 泊松分布随机数
a = np.random.poisson(5,10000);plt.hist(a,100)
# 随机乱序洗牌
# 只接受一个参数，必须是numpy数组
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print('original array: \n', a)
np.random.shuffle(a)
print('shuffled array: \n', a)
# 设置随机数种子
for i in range(10):
np.random.seed(0)
a = np.random.rand()
print(a)
Poisson分布
- Poisson分布是一种统计与概率学里常见到的离散概率分布，由法国数学家西莫恩·德尼·泊松（Siméon-Denis Poisson）在1838年时发表。
- 泊松分布的期望和方差均为 λ。
- 泊松分布的参数λ是单位时间(或单位面积)内随机事件的平均发生次数。 泊松分布适合于描述单位时间内随机事件发生的次数。
六、求和求积、均值方差
求和：sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
求积：prod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
加权平均：average(a, axis=None, weights=None, returned=False)
方差：var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>)
标准差：std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>)
# 求和求积、均值方差
import numpy as np
a = np.arange(100)
b = a.reshape((5,20))
print(a);print(b)
# 求和 python标准库
print(sum(a))
print(sum(b))
# 求和 numpy
print(np.sum(a))
print(np.sum(b))
print(np.sum(b,axis=0)) # 沿第0轴下标求和（变化第0轴下标，其它轴不变，放在一起求和）
print(np.sum(b,axis=1)) # 沿第1轴下标求和（变化第1轴下标，其它轴不变，放在一起求和）
for i in range(5):
s = 0.0
for j in range(20):
s += b[i,j]
print(s)
c = a.reshape(2,5,10)
print(c)
print(c.shape)
print(np.sum(c,axis=0)) # 沿第0轴下标求和（变化第0轴下标，其它轴不变，放在一起求和）
print(np.sum(c,axis=1)) # 沿第1轴下标求和（变化第1轴下标，其它轴不变，放在一起求和）
print(np.sum(c,axis=2)) # 沿第2轴下标求和（变化第2轴下标，其它轴不变，放在一起求和）
# 连乘
print(np.product(c,axis=0)) # 沿第0轴下标连乘（变化第0轴下标，其它轴不变，放在一起连乘）
print(np.product(c,axis=1)) # 沿第1轴下标连乘（变化第1轴下标，其它轴不变，放在一起连乘）
print(np.product(c,axis=2)) # 沿第2轴下标连乘（变化第2轴下标，其它轴不变，放在一起连乘）
# 求和求积、均值方差
import numpy as np
# 加权平均
d = np.array([1,2,3,4,5])
w = np.array([0.1, 0.2, 0.5, 0.1, 0.3])
print(np.average(d, weights=w))
# 算术平均
print(np.mean(c,axis=0)) # 沿第0轴下标平均（变化第0轴下标，其它轴不变，放在一起平均）
print(np.mean(c,axis=1)) # 沿第1轴下标平均（变化第1轴下标，其它轴不变，放在一起平均）
print(np.mean(c,axis=2)) # 沿第2轴下标平均（变化第2轴下标，其它轴不变，放在一起平均）
# 方差
print(np.var(a))
# 标准差
print(np.std(a))七、大小与排序
最小：amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
最大：amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
当输入是不一定是numpy.array 时，用np.amin, 如果输入是np.array, 可以直接用input.min(axis=n) 来求最小值矩阵
最大值的下标: argmax(a, axis=None, out=None)
# 大小与排序
import numpy as np
a = np.arange(100);b = a.reshape((5,20));c = a.reshape(2,5,10)
# 最小值
print(np.min(a,axis=0)) # 沿第0轴下标取最小值（变化第0轴下标，其它轴不变，放在一起取最小值）
print(np.min(b,axis=0)) # 沿第1轴下标取最小值（变化第1轴下标，其它轴不变，放在一起取最小值）
print(np.min(b,axis=1)) # 沿第1轴下标取最小值（变化第2轴下标，其它轴不变，放在一起取最小值）
print(np.min(c,axis=0)) # 沿第0轴下标取最小值（变化第0轴下标，其它轴不变，放在一起取最小值）
print(np.min(c,axis=1)) # 沿第1轴下标取最小值（变化第1轴下标，其它轴不变，放在一起取最小值）
print(np.min(c,axis=2)) # 沿第2轴下标取最小值（变化第2轴下标，其它轴不变，放在一起取最小值）
# 最大值
print(np.max(a))
# 二元最小值
print(np.minimum(25,4))
# 二元最大值
print(np.maximum(25,4))
# 最大值的下标
print(np.argmax(a))
# 大小与排序
import numpy as np
a = np.arange(100);b = a.reshape((5,20))
c = a.reshape(2,5,10)
# 最小值的下标
print(np.argmin(a))
# 最大值与最小值之差
print(np.ptp(a))
# 转换一维数组和多维数组的下标
# numpy数组（array）中，所有的元素其实都是一维化后连续存储在内存里，所以numpy速度很快
# numpy的多维数组实际上是一种读取数组的方式，所有numpy数组实际上都被视作一维数组来操作，只不过这个过程被numpy隐藏了
# numpy提供的unravel_index函数可以将高维数组的坐标转化为一维数组的坐标，给用户提供numpy内部的数组访问方式
# 例如，在一个维度是(2,5,10)的三维数组中，第38号元素是哪一个呢？
print(np.unravel_index(38,(2,5,10)))
print(a[38])
print(c[0,3,8])
# c语言和fortran语言中，高维数组的排序方式不一样
# c语言中，第0轴在最外侧；fortran语言中，第0轴在最内侧
# python模仿c风格的排序，但你也可以指定为fortran风格，看看算出来的坐标是什么
print(np.unravel_index(38,(2,5,10),order='C'))
print(np.unravel_index(38,(2,5,10),order='F'))
排序：sort(a, axis=-1, kind=None, order=None)
排序算法: QuickSort快速排序、MergeSort归并排序、HeapSort堆排序
stable: 保证相等元素的原本相对次序在排序后保持不变。
返回排序下标：argsort(a, axis=-1, kind=None, order=None)
多列扩展排序: lexsort(keys, axis=-1)
快速排序前k位: partition(a, kth, axis=-1, kind='introselect', order=None)
前k位的下标:argpartition(a, kth, axis=-1, kind='introselect', order=None)
中位数median，百分位数percentile,二分查找searchsorted
# 大小与排序
import numpy as np
# 排序
a = np.array([3,2,5,1,4,7,8,2])
print(np.sort(a))
# 返回排序下标
a = np.array([3,2,5,1,4,7,8,2])
idx = np.argsort(a)
print(idx);print(a[idx])
# 多列扩展排序
# 先按数组a排序，如果a的元素一样，那就按b排序
a = np.array([1,5,1,4,3,4,4]) # First column
b = np.array([9,4,0,4,0,2,1]) # Second column
ind = np.lexsort((b,a)) # Sort by a, then by b
print(ind);print(a[ind])
print(b[ind])
# 快速排序前k位
a = np.array([2,5,1,7,9,3,1,8,10])
print(np.partition(a,2)) # 只挑出前2名，放在开头，后面维持不变
# 返回快速排序前k位的下标
ind = np.argpartition(a,2)
print(ind)
print(a[ind])
# 中位数
print(np.median(a))
# 百分位数
a = np.random.randn(10000)
print(np.percentile(a,5))
print(np.percentile(a,50))
print(np.percentile(a,95))
# 二分查找
# 从数组中找某一个元素在哪两个元素之间，返回下标
print(np.searchsorted([1,2,3,4,5,6], 2.5))
print(np.searchsorted([1,2,3,4,5,6], 2.5, side='right'))
八、多维数组操作
- 连接多个数组concatenate
- 数组分段split
- 沿第1轴连接数组（横向拼接）hstack
- 沿第0轴连接数组（纵向拼接）vstack
- 按列拼接多个一维数组column_stack
- 交换两个轴的顺序swapaxes
- 转置a.T; a.transpose()
- 删除多余的维度squeeze
- 删除指定的的维度
import numpy as np
a = np.arange(3 * 4 * 5).reshape(3, 4, 5)
lidx = [[0], [1]]
aidx = np.array(lidx)
print(a[lidx])
print(a[aidx])
print(a[[0,1,2]])
print(a[0,1,2])
print(a[0,1])
print(a[[0,1]])
print(a[0])
print(a[[0]])
# 多维数组操作
import numpy as np
# 连接多个数组
a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8,9],[10,11,12]])
c = np.concatenate((a,b));print(c)
# 数组分段
x = np.arange(9.0);np.split(x, 3)
np.split(x, [3, 5, 6, 10])
# 沿第1轴连接数组（横向拼接）
a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8,9],[10,11,12]])
c = np.hstack((a,b))
print(c)
# 沿第0轴连接数组（纵向拼接）
c = np.vstack((a,b));print(c)
# 按列拼接多个一维数组
a = np.array([1,2,3]);b = np.array([4,5,6])
c = np.array([7,8,9]);d = np.column_stack((a,b,c))
print(d)
#交换两个轴的顺序
a = np.array([[1,2,3],[4,5,6]])
print(np.swapaxes(a,0,1))
#转置
print(a.T);print(a.transpose())
# 删除多余的维度
a = np.random.random([1,1,3])
print(a);print(a.shape)
b = a.squeeze();print(b);print(b.shape)
# 删除指定的的维度
a = np.random.random([2,1,3])
print(a);print(a.shape)
b = a.squeeze(axis = 1);print(b)
print(b.shape)
# numpy只有删除维度的函数squeeze，没有扩增维度的函数unsqueeze。但pytorch里有，还很常用。
九、基本线性代数
引用：
外积：一个列向量乘以一个行向量称作向量的外积，外积是一种特殊的克罗内克积，结果是一个矩阵。
内积：一个行向量乘以一个列向量称作向量的内积，又叫作点积，结果是一个数；
张量乘积
np.tensordot
tensordot(a, b, axes=2)
# 基本线性代数
import numpy as np
a = np.array(range(1, 9))
a.shape = (2, 2, 2)
A = np.array(('a', 'b', 'c', 'd'), dtype=object)
A.shape = (2, 2)
np.tensordot(a, A) # third argument default is 2 for double-contraction
np.tensordot(a, A, 1)
np.tensordot(a, A, 0)
np.tensordot(a, A, (0, 1))
np.tensordot(a, A, (2, 1))
np.tensordot(a, A, ((0, 1), (0, 1)))
np.tensordot(a, A, ((2, 1), (1, 0)))
解方程Ax=b
R(A)：矩阵的秩。
求最小二乘解
最小化误差的平方和寻找数据的最佳函数匹配
求行列式
求特征值和特征向量
求条件数
求条件数：条件数定义为：矩阵的范数，乘以矩阵的逆矩阵的范数
矩阵的条件数总是大于1.正交矩阵的条件数等于1，奇异矩阵的条件数为无穷大，而病态矩阵的条件数则为比较大的数据。
# 基本线性代数
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8,9],[10,11,12]])
# 矩阵相加
print(a+b)
# 矩阵相乘
print(np.dot(a,b.T))
# 外积
print(np.outer(a,b.T))
# 内积
print(np.inner(a,b))
# 张量乘积
print(np.tensordot(a,b))
# 解方程Ax=b
A = np.array([[3,1],[1,2]]).
b = np.array([9,8])
x = np.linalg.solve(A,b)
print(x)
# 求最小二乘解
x = np.array([0, 1, 2, 3])
y = np.array([-1, 0.2, 0.9, 2.1])
A = np.vstack([x, np.ones(len(x))]).T
m, c = np.linalg.lstsq(A, y, rcond=None)[0]
print(m, c)
import matplotlib.pyplot as plt
plt.plot(x, y, 'o', label='Original data', markersize=10)
plt.plot(x, m*x + c, 'r', label='Fitted line')
plt.legend()
help(np.linalg.lstsq)
# 求行列式
A = np.array([[1,2],[3,4]])
print(np.linalg.det(A))
# 求特征值和特征向量
print(np.linalg.eig(A))
# 求条件数
print(np.linalg.cond(A))
范数
范数是具有“长度”概念的函数。在线性代数、泛函分析及相关的数学领域，范数是一个函数，是矢量空间内的所有矢量赋予非零的正长度或大小。
求迹
求迹：一个n×n矩阵A的主对角线（从左上方至右下方的对角线）上各个元素的总和被称为矩阵A的迹（或迹数），一般记作tr(A)。
Cholesky分解
cholesky分解：把一个对称正定的矩阵表示成一个下三角矩阵L和其转置的乘积的分解。它要求矩阵的所有特征值必须大于零，故分解的下三角的对角元也是大于零。Cholesky分解法又称平方根法，是当A为实对称正定矩阵时，LU三角分解法的变形。
QR分解
QR分解：如果非奇异矩阵A能够化成正交矩阵Q与非奇异上三角矩阵R的乘积，即A=QR，则称其为A的QR分解。
Q正交矩阵
R非奇异上三角矩阵
SVD分解
其中U和V均为单位正交阵，即有UUT=I和VVT=I，U称为左奇异矩阵，V称为右奇异矩阵，Σ仅在主对角线上有值，称它为奇异值，其它元素均为0。上面矩阵的维度分别为U∈Rm×m, Σ∈Rm×n, V∈Rn×n 。
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
img_eg = mpimg.imread("ye.jpg")
print(img_eg.shape)
img_temp = img_eg.reshape(600, 400 * 3)
U,Sigma,VT = np.linalg.svd(img_temp)
# 取前60个奇异值
sval_nums = 60
img_restruct1 = (U[:,0:sval_nums]).dot(np.diag(Sigma[0:sval_nums])).dot(VT[0:sval_nums,:])
img_restruct1 = img_restruct1.reshape(600,400,3)
# 取前120个奇异值
sval_nums = 120
img_restruct2 = (U[:,0:sval_nums]).dot(np.diag(Sigma[0:sval_nums])).dot(VT[0:sval_nums,:])
img_restruct2 = img_restruct2.reshape(600,400,3)
fig, ax = plt.subplots(1,3,figsize = (24,32))
ax[0].imshow(img_eg)
ax[0].set(title = "src")
ax[1].imshow(img_restruct1.astype(np.uint8))
ax[1].set(title = "nums of sigma = 60")
ax[2].imshow(img_restruct2.astype(np.uint8))
ax[2].set(title = "nums of sigma = 120")
求逆
求伪逆
# 基本线性代数
import numpy as np
A = np.array([[1,2],[3,4]])
# 求范数
print(np.linalg.norm(A))
# 求迹
print(np.trace(A))
# cholesky分解
print(np.linalg.cholesky(np.dot(A,A.T)))
# QR分解
print(np.linalg.qr(A))
# SVD分解
print(np.linalg.svd(np.dot(A,A.T)))
# 求逆
print(np.linalg.inv(A))
# 求伪逆
print(np.linalg.pinv(A))
6166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
