一、数组的创建与操作
1.获取数组的元素
import numpy as np
arr1 = np.array([3,10,12,5,6,8,9,111])
print(arr1.shape)
arr2 = np.reshape(arr1,(2,4))
print(arr2)
print(arr1)
#取出10,12
print(arr1[1:3])
#取出第一行第三个 12
print(arr2[0,2])
#3 10 12
#6 8 9
#print(arr2[0:2,0:3])
#取出10 8 第二列的所有数据
print(arr2[:,1])
#取出12 5 第一行的 第3列和第4列
print(arr2[:1,2:4])
print("\n")
#取出的是第二行
print(arr2[1,:])
#取出的是第一行第二列，第二行第4列
print(arr2[[0,-1],[1,3]])
print("------------------------------------")
#使用了ix_后就会打破上面按照row col取值，下面就可以获取 0 -> -1行 2行的数据并且是第2和第4列
#也就是 10 5
# 8 111
print(arr2[np.ix_([0,-1],[1,3])])
print("------------------------------------")
print(arr2[0:,1:4])
print("------------------------------------")
#获取的结果和上面的一样，通过ix_就可以将某一行的某几列全部输出,前面的是行号，后面的是列号
arr3 = np.array([12,5,69,88,99,77,8,5,5,1212,55,66,997,5,82,12])
arr4 = np.resize(arr3,(4,4))
print(arr4)
print(arr4[np.ix_([0,1,3],[1,2,3])])
2.读文件和重新定义数组形状
import numpy as np
stu_score = np.genfromtxt(fname=r'stu_socre.txt', delimiter='\t', skip_header=1)
print(type(stu_score))
print(stu_score)
# c查看维度，维度是2
print(stu_score.ndim)
# 查看行列数
print(stu_score.shape)
# 查看数组的数据类型
print(stu_score.dtype)
# 查看数组元素的个数
print(stu_score.size)
# 改变数组形状
stu_score1 = stu_score.reshape((69, 100))
print("---------------------------reshape---------------------------------")
# 不会变化
print(stu_score.shape)
# 新的数组变成 69 100
print(stu_score1.shape)
print("----------------------------resize-------------------------")
stu_score2 = stu_score.resize(10, 690)
#resize不会返回预览所以一直返回的是None，stu_score会直接被改变
print(stu_score.shape)
print("-------------------------正常以行的顺序进行降维------------------------")
print(stu_score.ravel())
print(stu_score.flatten())
print(stu_score.reshape(-1))
print("-------------------------以列的顺序进行降维-----------------")
print(stu_score.ravel(order='F'))
print(stu_score.flatten(order='F'))
print(stu_score.reshape(-1,order='F'))
print("-------------------------三种降维方式是否克隆的区别--------------")
stu_score.flatten()[2]=2000
print('flatten \n',stu_score)
stu_score.ravel()[0]=2000
print('ravel \n',stu_score)
stu_score.reshape(-1)[1]=2000
print('reshape \n',stu_score)
#上述的结果表名，flatten没有改变原数组所以他是一个克隆的方式，ravel和reshape都改变了原数组所以他返回的只是一个视图
print("------------------------- vstack and row_stack-------------------")
arr4 = np.array([[1,10,100],[2,20,200],[3,30,300]])
arr5 = np.array([1,2,3])
#需要保证列的个数是相同的,然后添加行数
print('vstack纵向堆叠数组:\n',np.vstack((arr4,arr5)))
print('row_stack纵向堆叠数组\n',np.row_stack([arr5,arr4]))
print("--------------------------hstack and column_stack--------------")
#需要保证行的个数是相同的，然后添加列数
arr6 = np.array([[12,14],[13,16],[15,18]])
print('hstack横向堆叠数组:\n',np.hstack((arr6,arr4)))
print('column_stack横向堆叠数组:\n',np.column_stack((arr6,arr4)))
二、数组的基本运算符
import numpy as np
math = np.array([98, 83, 86, 92, 67, 82])
english = np.array([68, 74, 66, 82, 75, 89])
chinese = np.array([92, 83, 76, 85, 87, 77])
total_symbol = math + english + chinese
total_fun = np.add(chinese, np.add(math, english))
print("---------------加法运算--------------")
print("符号加法\n", total_symbol)
print("函数加法\n", total_fun)
print("---------------除法运算--------------")
height = np.array([165, 177, 158, 169, 173])
weight = np.array([62, 73, 59, 72, 80])
BMI_symbol = weight / (height / 100) ** 2
BMI_fun = np.divide(weight, np.divide(height, 100) ** 2)
print("符号除法\n", BMI_symbol)
print("函数除法\n", BMI_fun)
print("---------------余数运算--------------")
arr7 = np.array([[1, 2, 10], [10, 8, 3], [7, 6, 5]])
arr8 = np.array([[2, 2, 2], [3, 3, 3], [4, 4, 4]])
print("数组arr7 \n", arr7)
print("数组arr8 \n", arr8)
print('计算余数:\n', arr7 % arr8)
print("计算整除:\n", arr7 // arr8)
print("计算指数:\n", arr7 ** arr8)
print("---------------比较运算-------------")
print("---------------取子集---------------")
print(arr7)
print("满足arr7的元素>arr8的元素\n", arr7[arr7 > arr8])
arr9 = np.array([3, 10, 23, 7, 16, 9, 17, 22, 4, 8, 15])
print("满足条件>10所有arr9的元素\n", arr9[arr9 > 10])
print("---------------判断操作-------------")
print("二维数组arr7中元素大于7的变成5,其余不变\n", np.where(arr7 > 7, 5, arr7))
print("一维数组arr9中元素大于7的变成5,其余不变\n", np.where(arr9 > 7, 5, arr9))
print("---------------广播运算-------------")
print("广播运算指的是，当数组形状不同时，也能进行数学运算的功能，但广播运算也有规则")
# 1.各输入数组的维度可以不相同，但必须确保从右到左的对应维度值相等
# 2.如果对应维度值不相等，就必须保证其中一个为1
# 3.各输入数组都应向其shape最长的数组看齐,shape中不足的部分都通过在前面加1补齐
# arr10,arr11输入的数组维度一致
arr10 = np.arange(12).reshape(3, 4)
arr11 = np.arange(101, 113).reshape(3, 4)
print("3*4的二维矩阵运算", arr10 + arr11)
# 各输入组维度不一致，对应维度值相等
arr12 = np.arange(60).reshape(5, 4, 3)
arr10 = np.reshape(arr10, (4, 3))
print("维数不一致，但是末尾的维度值相等\n", arr12 + arr10)
# 由于是变成(4,1),第一行加0，第二行加1，第三行加2，第四行加3
arr13 = np.arange(4).reshape(4, 1)
# 各输入组维度不一致，末尾维度值也不相同，但是其中有一个为1
print("维数不一致，末尾的维度值不全相等，但其中有个维度的值为1\n", arr13 + arr10)
arr14 = np.array([5, 15, 25])
# 此时arr10变成(4,3)
# 每一行按按顺序将arr10+arr14，也就是第一列+5，第二列+15，第三列+25
print('arr14的维度自动补1也就是变成(1,3)\n', arr10 + arr14)
# 按照行的顺序处理，第一行+5，第二行+15，第三行+25，第四行+35
arr15 = np.array([5, 15, 25, 35])
arr15 = np.reshape(arr15, (4, 1))
print(arr10 + arr15)
三、常用的数学和统计函数
| 分类 |
函数 |
函数说明 |
| 数学函数 |
np.pi |
常数π |
| np.e |
常数e |
| np.fabs(arr) |
计算各元素的浮点型绝对值 |
| np.ceil(arr) |
对各元素向上取整 |
| np.floor(arr) |
对各元素向下取整 |
| np.round(arr) |
对各元素四舍五入 |
| np.fmod(arr1,arr2) |
计算arr1/arr2的余数 |
| np.modf(arr) |
返回数组元素的小数部分和整数部分 |
| np.sqrt(arr) |
计算各元素的算术平方根 |
| np.square(arr) |
计算各元素的平方值 |
| np.exp(arr) |
计算以e为底的指数 |
| np.power(arr,α) |
计算各元素的指数 |
| np.log2(arr) |
计算以2为底数各元素的对数 |
| np.log10(arr) |
计算以10为底数各元素的对数 |
| np.log(arr) |
计算以e为底数各元素的对数 |
| 分类 |
函数 |
函数说明 |
| 统计函数 |
np.min(arr,axis) |
按照轴的方向计算最小值 |
| np.max(arr,axis) |
按照轴的方向计算最大值 |
| np.mean(arr,axis) |
按照轴的方向计算均值 |
| np.median(arr,axis) |
按照轴的方向计算中位数 |
| np.sum(arr,axis) |
按照轴的方向计算和 |
| np.std(arr,axis) |
按照轴的方向计算标准差 |
| np.var(arr,axis) |
按照轴的方向计算方差 |
| np.cumsum(arr,axis) |
按照轴的方向计算累加和 |
| np.cumprod(arr,axis) |
按照轴的方向计算累计乘积 |
| np.argmin(arr,axis) |
按照轴的方向返回最小值所在位置 |
| np.argmax(arr,axis) |
按照轴的方向返回最大值所在位置 |
| np.corrcoef() |
计算皮尔逊相关系数 |
| np.cov(arr) |
计算协方差矩阵 |
四、线性代数的相关计算
| 函数 |
说明 |
函数 |
说明 |
| np.zeros |
生成零矩阵 |
np.ones |
生成所有元素为1的矩阵 |
| np.eye |
生成单位矩阵 |
np.transpose |
矩阵转置 |
| np.dot |
计算两个数组的点积 |
np.inner |
计算两个数组的内积 |
| np.diag |
矩阵主对角线与一维数组间的转换 |
np.trace |
矩阵主对角元素的和 |
| np.linalog.det |
计算矩阵行列式 |
np.linalg.eig |
计算矩阵特征根和特征向量 |
| np.linalog.eigvals |
计算方阵特征根 |
np.linalg.inv |
计算方阵的逆 |
| np.linalog.pinv |
计算方阵的Moore-Penrose伪逆 |
np.linalg.solve |
计算Ax=b的线性方程组的解 |
| np.linalog.lstsq |
计算Ax=b的最小二乘解 |
np.linalg.qr |
计算QR分解 |
| np.linalg.svd |
计算奇异值分解 |
np.linalg.norm |
计算向量或矩阵的范数 |
import numpy as np
print("--------------矩阵乘法dot的使用----------------")
# 一维数组的点积
vector_dot = np.dot(np.array([1, 2, 3]), np.array([4, 5, 6]))
print("一维数组的点积\n", vector_dot)
# 二维数组的乘法
arr10 = np.arange(12).reshape(4, 3)
arr11 = np.arange(101, 113).reshape(3, 4)
print('两个二维数组:')
print(arr10)
print(arr11)
arr2d = np.dot(arr10, arr11)
print("二维数组的乘法\n", arr2d)
print("--------------diag函数的使用------------------")
# 变成4*4的矩阵
arr15 = np.arange(16).reshape(4, -1)
print('4*4矩阵\n', arr15)
print('取出矩阵的主对角元素\n', np.diag(arr15))
print('由一维数组构造的方阵\n', np.diag(np.array([5, 15, 25])))
print("---------------特征根和特征向量--------------")
arr16 = np.array([[1, 2, 5], [3, 6, 8], [4, 7, 9]])
print("3*3数组\n", arr16)
print("计算3*3方阵的特征根", np.linalg.eigvals(arr16))
print('计算3*3方阵的特征根和特征向量', np.linalg.eig(arr16))
print("---------------多元线性回归模型的解----------")
X = np.array(
[[1, 1, 4, 3], [1, 2, 7, 6], [1, 2, 6, 6], [1, 3, 8, 7], [1, 2, 5, 8], [1, 3, 7, 5], [1, 6, 10, 12], [1, 5, 7, 7],
[1, 6, 3, 4], [1, 5, 7, 8]])
Y = np.array([3.2, 3.8, 3.7, 4.3, 4.4, 5.2, 6.7, 4.8, 4.2, 5.1])
# 计算方阵的逆
# np.transpose矩阵转置
# np.inv矩阵的逆
X_inverse = np.linalg.inv(np.dot(np.transpose(X), X))
# np.dot计算两个数的点积
beta = np.dot(np.dot(X_inverse, np.transpose(X)), Y)
print('偏回归系数为\n', beta)
# 所以得到式子是Y = 1.7.81+0.247X1+0.158X2+0.1333X3
print("------------多元一次方程组的求解-------------")
A = np.array([[3, 2, 1], [2, 3, 1], [1, 2, 3]])
B = np.array([39, 34, 26])
x = np.linalg.solve(A, B)
print("多元一次方程组的求解结果 \n", x)
print("-----------范数的计算---------------------")
arr17 = np.array([1, 3, 5, 7, 9, 10, -12])
# 一范数
res1 = np.linalg.norm(arr17, ord=1)
print("向量的一范数\n", res1)
# 二范数
res2 = np.linalg.norm(arr17, ord=2)
print("向量的二范数\n", res2)
# 无穷范数
resn = np.linalg.norm(arr17, ord=np.inf)
print("向量的无穷范数\n",resn)
#一范数就是将每个值的绝对值求和
#二范数是将每个值的平方和再开方
#三范数是将每个值的立方和再开三次方
#范数指的是最大的向量的长度，无穷范数就是将向量变成n*1，1维的向量中，n个向量中最大的值
五、伪随机数，各类分布
| 函数 |
说明 |
| seed(n) |
设置随机种子 |
| beta(a,b,size=None) |
生成贝塔分布随机数 |
| chisquare(df,size=None) |
生成卡方分布随机数 |
| choice(a,siez=None,replace=True,p=None) |
从a中有放回地随机挑选指定数量的样本 |
| exponential(scale=1.0,size=None) |
生成指数分布随机数 |
| f(dfnum,dfden,size=None) |
生成F分布随机数 |
| gamma(shape,scale=1.0,size=None) |
生成伽马分布随机数 |
| geometric(p,size=None) |
生成几何分布随机数 |
| hypergeometric |
生成超几何分布随机数 |
| laplace(loc=0.0,scale=1.0,size=None) |
生成拉普拉斯分布随机数 |
| logistic(loc=0.0,scale=1.0,size=None) |
生成Logistic分布随机数 |
| lognormal(mean=0.0,sigma=1.0,size=None) |
生成对数正态分布随机数 |
| negative_binominal(n,p,size=None) |
生成负二项分布随机数 |
| multinomial(n,pvals,size=None) |
生成多项分布随机数 |
| multivariate_normal(mean,cov[,size]) |
生成多元正态分布随机数 |
| normal(loc,0.0,scale=1.0,size=None) |
生成正态分布随机数 |
| pareto(a,size=None) |
生成帕累托分布随机数 |
| poisson(lam=1.0,size=None) |
生成泊松分布随机数 |
| rand(d0,d1,..,dn) |
生成n维的均匀分布随机数 |
| randn(d0,d1,....dn) |
生成n维的标准正态分布随机数 |
| randint(low,high=None,size=None,dtype='1') |
生成指定范围的随机整数 |
| random_sample(size=None) |
生成[0,1)随机数 |
| standard_t(df,size=None) |
生成标准的t分布随机数 |
| uniform(low=0.0,high=1.0,size=None) |
生成指定范围的均匀分布随机数 |
| wald(mean,scale,size=None) |
生成Wald分布随机数 |
| weibull(a,size=None) |
生成Weibull分布随机数 |
1.正态分布
import seaborn as sns
import matplotlib.pyplot as plt
from scipy import stats
import numpy as np
# 生成各种正态分布随机数
np.random.seed(1234)
rn1 = np.random.normal(loc=0, scale=1, size=1000)
rn2 = np.random.normal(loc=0, scale=2, size=1000)
rn3 = np.random.normal(loc=2, scale=3, size=1000)
rn4 = np.random.normal(loc=5, scale=3, size=1000)
# 绘图
plt.style.use('ggplot')
sns.distplot(rn1, hist=False, kde=False, fit=stats.norm,
fit_kws={'color': 'black', 'label': 'u=0,s=1', 'linestyle': '-'})
sns.distplot(rn2, hist=False, kde=False, fit=stats.norm,
fit_kws={'color': 'red', 'label': 'u=0,s=2', 'linestyle': '--'})
sns.distplot(rn3, hist=False, kde=False, fit=stats.norm,
fit_kws={'color': 'blue', 'label': 'u=2,s=3', 'linestyle': ':'})
sns.distplot(rn4, hist=False, kde=False, fit=stats.norm,
fit_kws={'color': 'purple', 'label': 'u=5,s=3', 'linestyle': '-.'})
#生成各种指数分布随机数
#呈现图例
plt.legend()
#呈现图形
plt.show()
2.指数分布
import seaborn as sns
import matplotlib.pyplot as plt
from scipy import stats
import numpy as np
np.random.seed(1234)
re1 = np.random.exponential(scale=0.5,size=1000)
re2 = np.random.exponential(scale=1,size=1000)
re3 = np.random.exponential(scale=1.5,size=1000)
sns.distplot(re1, hist=False, kde=False, fit=stats.expon,
fit_kws={'color': 'yellow', 'label': 'lambda=0.5', 'linestyle': '-'})
sns.distplot(re2, hist=False, kde=False, fit=stats.expon,
fit_kws={'color': 'green', 'label': 'lambda=1.0', 'linestyle': '--'})
sns.distplot(re3, hist=False, kde=False, fit=stats.expon,
fit_kws={'color': 'pink', 'label': 'lambda=1.5', 'linestyle': ':'})
plt.legend()
#呈现图形
plt.show()
