要知道的数学名词
线性代数 行列式 行列式的计算 矩阵的乘法
矩阵的转置 矩阵的逆 矩阵*矩阵的逆=单位阵 矩阵QR分解
随机漫步
随机生成1或者-1，每次生成进行叠加，存入数组，查看关系
# -*- coding: utf-8 -*-
import numpy as np
'''
将数组以二进制方式存入磁盘
'''
arr=np.arange(10)
print(arr)#[0 1 2 3 4 5 6 7 8 9]
#npy结尾的文件
np.save('some_array',arr)
#读取文件
read_arr=np.load('some_array.npy')
print(read_arr)#[0 1 2 3 4 5 6 7 8 9]
#保存到压缩格式,npz结尾的文件
np.savez('zip_arr',a=arr,b=arr)
#加载npz的文件
arch=np.load('zip_arr.npz')
print(arch['b'])#[0 1 2 3 4 5 6 7 8 9]
#加载cvs格式的txt文件
arr=np.loadtxt('a.txt',delimiter=',')
print(arr)
# [[ 1. 23. 4. 532. 52. 23.]
# [ 1. 123. 321. 3. 1. 3.]
# [123. 32. 32. 1. 23. 1.]]
#存入文件
np.savetxt('b.txt',arr)
'''
线性代数
行列式
行列式的计算
矩阵的乘法
矩阵的转置
矩阵的逆
矩阵*矩阵的逆=单位阵
矩阵QR分解
随机漫步
'''
x=np.array([[1,2,3,],[4,5,6]])
y=np.array([[6,23],[-1,7],[8,9]])
print(x)
print(y)
# [[1 2 3]
# [4 5 6]]
# [[ 6 23]
# [-1 7]
# [ 8 9]]
# xy
#矩阵的乘法，y的行数要等x的列数
print(x.dot(y))
#[[ 28 64]
# [ 67 181]]
#如果yx，
# 就是x的行数要等与y的列数
print(y.dot(x))
# [[ 98 127 156]
# [ 27 33 39]
# [ 44 61 78]]
z=np.array([[1,2],[3,4]])
print(z)
# [[1 2]
# [3 4]]
#print(z.dot(y))#ValueError: shapes (2,2) and (3,2) not aligned: 2 (dim 1) != 3 (dim 0)
print(y.dot(z))#y的列数=z的行数 生成的类型y的行数z的列数的矩阵
# [[ 75 104]
# [ 20 26]
# [ 35 52]]
w=np.ones(3)
print(w)
# w
# [1. 1. 1.]
#x
# [[1 2 3]
# [4 5 6]]
print(x.dot(w))#[ 6. 15.]
from numpy.linalg import inv,qr,det
X=np.random.randn(5,5)
print(X)
#X的转置 * X矩阵的本身
mat=X.T.dot(X)
print(mat)
#再去矩阵的逆
mat_=inv(mat)
#在将矩阵 * 矩阵的逆=单位阵
print(mat.dot(inv(mat)))
# [[ 1.00000000e+00 -1.38777878e-17 9.71445147e-17 1.11022302e-16
# -4.16333634e-17]
# [-1.11022302e-16 1.00000000e+00 -4.44089210e-16 0.00000000e+00
# 0.00000000e+00]
# [ 0.00000000e+00 1.11022302e-16 1.00000000e+00 0.00000000e+00
# -3.33066907e-16]
# [-2.42861287e-17 8.15320034e-17 -1.40512602e-16 1.00000000e+00
# 6.59194921e-17]
# [ 5.55111512e-17 0.00000000e+00 0.00000000e+00 -1.66533454e-16
# 1.00000000e+00]]
x_=inv(X)
a=X.dot(x_)
print(a)
'''
qr分解
'''
print(mat)
# [[ 5.94700575 1.67794721 5.05492158 -2.95012009 -6.74457499]
# [ 1.67794721 5.98947553 2.05150894 -0.09196568 -1.65633165]
# [ 5.05492158 2.05150894 7.10432233 -3.14996849 -5.51766286]
# [-2.95012009 -0.09196568 -3.14996849 2.06381474 2.80042822]
# [-6.74457499 -1.65633165 -5.51766286 2.80042822 11.17434671]]
q,r=qr(mat)
print(q)
# [[-0.54763541 0.07785414 0.29677708 0.43010504 0.64881987]
# [-0.15451529 -0.97188837 0.0945459 0.09265504 -0.1184658 ]
# [-0.46548703 -0.04648143 -0.8442281 -0.2185828 0.14374207]
# [ 0.27166448 -0.17202467 0.14554887 -0.68493222 0.63740827]
# [ 0.62108029 -0.13273556 -0.41119203 0.53806515 0.37154751]]
print(r)
# [[-10.85942525 -3.85301838 -10.67485961 5.39602571 14.21884047]
# [ 0. -5.55014905 -0.65624782 -0.72062709 -0.62383063]
# [ 0. 0. -2.49317729 0.92394106 -1.68727171]
# [ 0. 0. 0. -0.49561403 2.24614612]
# [ 0. 0. 0. 0. 0.96390096]]
#以矩阵的形式，返回对角线矩阵
import matlab as mb
a=np.array([[1,0,0],[0,1,0],[0,0,1]])
print(a)
a=mb.diag(a)
print(a)
# [1 1 1]
'''
计算矩阵的行列式
'''
a=det(mat)
print(a)#1.2810727850030796
'''
随机数的生成
'''
#生成有一个标准的正态分布的4*4的样本
sample=np.random.normal(size=(4,4))
print(sample)
# [[-0.46801467 1.14814752 -0.06250482 -0.81041506]
# [ 0.7279229 -0.73639369 0.252881 -0.25403524]
# [ 0.80712111 1.51751028 -1.02781585 -1.75518633]
# [-0.45332071 0.0496177 -0.86698178 0.64285792]]
from random import normalvariate
samples=[normalvariate(0,1) for _ in range(100)]
#print(samples)
'''
随机漫步
模拟随机漫步，说明如何运用数组运算
'''
import random
position=0
walk=[position]
steps=1000
for i in range(steps):
step=1 if random.randint(0,1) else -1#随机生成0是step=1，生成1时step=-1
position+=step
walk.append(position)
#print(walk)
#另一种方式
nsteps=1000
draws=np.random.randint(0,2,size=nsteps)#随机产生0或者1，生成数组
steps=np.where(draws>0,1,-1)#遍历draws大于0的为1，等于零的为-1
walk=steps.cumsum()#数组累加
print(walk)
#计算最大值
print(walk.max())
#计算最小值
print(walk.min())
'''
首次穿越时间--随机漫步，过程中第一次到达某一特定值得时间
'''
#到达10或者时所用的时间
#返回一个布尔类型的数组
bulr=np.abs(walk)>10
#print(bulr)
#找到第一个出现True的索引
index=(np.abs(walk)>=10).argmax()
print(index)
arr=np.array([[1,2,3,4,5],[1,2,3,4,5]])
arr=arr.cumsum(1)
print(arr)
# [[ 1 3 6 10 15]
# [ 1 3 6 10 15]]
'''
模拟多个随机漫步
'''
nwalks=5000
nsteps=1000
draws=np.random.randint(0,2,size=(nwalks,nsteps))#生成二维数组，大数组内包含五千小数组，每个小数组中有一千个数
steps=np.where(draws>0,1,-1)
walks=steps.cumsum(1)#二维数组的叠加
print(walks)
#计算五千个数组中，随机漫步的最大值
print(walks.max())
#最小值
print(walks.min())
'''
难点，五千个过程中计算到30或者-30的最小时间
'''
#先判断这五千个过程中那些数组穿越的30 这里用到了any(),上一篇讲过
boo_list=(np.abs(walks)>30).any(1)#生成了由五千个元素组成的一维数组boolean类型
print(boo_list.sum())#为True的数量总和(大于30的)#3228
#然后我们从五千个过程中选出大于30的过程
boo_test=np.array([True,False])
boo_test2=np.array([[1,2,3],[4,5,6]])
a=boo_test2[boo_test]#选出为True对应的数组
print(a)#[[1 2 3]]
#获取存在三十的过程
one=walks[boo_list]
#获取大于三十的过程
two=np.abs(one)>30
#我们获取大于30的过程的第一个出现30或者-30的索引,集合
three=two.argmax(1)
print(three)#[634 406 450 ... 782 476 584]
#求算数平均数mean
fore=three.mean()
print(fore)#507.4455626715462
从随机漫步中可以看出python真的是一个强大的语言
矩阵乘法上图
每天进步一点点~