数据分析--Numpy

数据分析–Numpy

一、numpy基础

1、什么是numpy?
numpy是帮助我们处理数值型数据的，十分方便快捷，是科学计算的基础库。
定义：一个在python中做科学计算的基础库，重在数值计算，也是大部分python科学计算库的基础库，多用于大型、多维数组上执行数值运算。
2、numpy创建数组
在python内建对象中，数组有3种形式：列表list [1,2,3]、元组 tuple （1，2，3）、字典 dict {a:1,b:2}；在numpy中使用numpy.array将列表或者元组转换为ndarray数组。
np.array(object,dtype=None,copy=True,order:None,subok=False,ndmin=0)
object:输入对象列表、元组等；
dtype:数据类型；
copy:布尔类型，默认True 表示复制
order:顺序
subok:布尔类型，表示子类是否被传递
ndmi:秩

import  numpy as np
#使用numpy生成数组，得到ndarray的类型
t1=np.array([1,2,3,4])
t2=np.array(range(1,5))
t3=np.arange(10)#numpy自带方法 可快速生成数组 和range(10)一样的
t4=np.array(range(10))
t5=np.arange(1,10,2)
print(t1,t2,t3,t4,t5)
#数组的类名
print(type(t1),type(t2),type(t3),type(t4))
#数组里所存放的数据的类型
print(t3.dtype)
print(t5.dtype)

（1）numpy中常见的数据类型

在numpy中，大部分数据类型名是以数字结尾的，这个数字表示其在内存中占用的位数。
（2）数据类型的操作
①指定创建的数组的数据类型a=np.array([1,0,1,0],dpyte=np.bool)#dtype=’?’
②修改数组的数据类型a.astype(“i1”)#a.astype(np.int8)
③numpy中的小数
t7=np.array([random.random() for i in range(10)])
t8=np.round(t7,2)
④同样，每种数据类型均有对应的类型转换函数，如float（32）可转换为浮点型

import random
import  numpy as np
#指定numpy中的数据类型
t4=np.array(range(1,4),dtype=np.int8)
print(t4)
print(t4.dtype)
t5=np.array([1,0,1,1,0],dtype=bool)
print(t5,t5.dtype)
#修改数据类型
t6=t5.astype("i1")
print(t5,t6,t5.dtype,t6.dtype)
t6=t5.astype(np.float)
print(t6)
t5=t5.astype("i1")
print(t5,t6,t5.dtype,t6.dtype)
#numpy中的小数
t7=np.array([random.random() for i in range(10)])
print(t7)
print(t7.dtype)
t8=np.round(t7,2)#取小数,保留两位小数
print(t8)
print(round(random.random(),3))#python里保留三位小数

(3）数组的形状
形状：几行几列的数组，几维数组有几个值。（t1.reshape t1.shape）

import random
import  numpy as np
#(3)数组的形状shape,修改形状reshape
t1=np.arange(24)
print(t1.shape)
t2=t1.reshape((2,3,4))
print("t2",t2)
t3=t1.reshape((4,6))
print("t3",t3)
t4=t2.reshape((4,6))
print("t4",t4)
num=t4.shape[0]*t4.shape[1]#t4的行数*列数
print("t4元素个数",num)
t5=t4.reshape((24,))#一维 4*6 统计数组里数据个数
t6=t4.reshape((24,1))#二维24行1列
t7=t4.reshape((1,24))#二维1行24列
print("t5",t5)
print("t6",t6)
print("t7",t7)
t8=t7.flatten()#修改形状为一维数组
print("t8",t8)

运行结果如下
(24,)
t2 [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
t3 [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
t4 [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
t4元素个数 24
t5 [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
t6 [[ 0]
 [ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]
 [13]
 [14]
 [15]
 [16]
 [17]
 [18]
 [19]
 [20]
 [21]
 [22]
 [23]]
t7 [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]]
t8 [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

（4）数组的计算
①数组和数值的运算（广播机制，数组里每一个元素都做相应的运算）
②数组和数组的运算：以二维数组为例。形状完全相同对应位置数字做相应运算；有一个维度一致时，可以在行上或者列上做运算；维度都不一致时报错。
注：广播原则：如果两个数组的后缘维度（即从末尾开始算起的维度）的轴长度相等或其中一方的长度为1，则认为他们是广播兼容的，广播会在缺失和（或）长度为1的维度上进行。例如，shape为（3，3，3）的数组不可以和（3，2）的数组进行计算；但形状为（3，3，2）的数组可以和（3，2）的进行计算；（3，3，2）的数组不可以和（3，3）的数组进行计算。（3，3，3）可以理解为有3块3行3列的数据。

③轴：在numpy中可以理解为方向，使用0，1，2表示。对于一个一维数组，只有一个0轴；对于2维数组，有0轴和1轴，0轴表示沿行向下的轴，1轴表示沿列横穿的轴；对于三维数组shape(2,3,4)，有0，1，2轴，0轴指的是2，也就是块，1轴指3，也就是沿行，2轴指4，也就是沿列。

import  numpy as np
t1=np.arange(24).reshape(4,6)
t2=np.arange(100,124).reshape(4,6)
t3=t1+2
t4=t3+t2
print("t3",t3)#数组和数字相加
# print("t2",t2)
print("t4",t4)#数组和数组相加 形状相同 对应位置元素相加
t5=np.arange(0,6)
print("t5",t5)
#有一个维度一致时 可以在行上或者列上做运算
t6=t5+t3
print("t6",t6)
t7=np.arange(4).reshape(4,1)
print("t7",t7)
t8=t3-t7
print("t8",t8)
#广播原则
t9=np.arange(18).reshape(3,3,2)
t10=np.arange(9).reshape(3,3)
print("t9")
print(t9)
print("t10")
print(t10)

结果
t3 [[ 2  3  4  5  6  7]
 [ 8  9 10 11 12 13]
 [14 15 16 17 18 19]
 [20 21 22 23 24 25]]
t4 [[102 104 106 108 110 112]
 [114 116 118 120 122 124]
 [126 128 130 132 134 136]
 [138 140 142 144 146 148]]
t5 [0 1 2 3 4 5]
t6 [[ 2  4  6  8 10 12]
 [ 8 10 12 14 16 18]
 [14 16 18 20 22 24]
 [20 22 24 26 28 30]]
t7 [[0]
 [1]
 [2]
 [3]]
t8 [[ 2  3  4  5  6  7]
 [ 7  8  9 10 11 12]
 [12 13 14 15 16 17]
 [17 18 19 20 21 22]]
t9
[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]

 [[12 13]
  [14 15]
  [16 17]]]
t10
[[0 1 2]
 [3 4 5]
 [6 7 8]]

import random
import  numpy as np

#补充 矩阵和矩阵相乘 以及 点乘
#注：相乘要注意数组的形状 只有当第一个矩阵（左矩阵）的列数等于第二个矩阵（右矩阵）的行数时才能相乘
A=np.array([[2,4],[1,2]])
B=np.array([[3,1],[6,4]])
C=np.matmul(A,B)
print(C)
#点乘  矩阵对应元素相乘
D=A*B
print(D)

结果
[[30 18]
 [15  9]]
[[6 4]
 [6 8]]

import  numpy as np
#轴
a=np.arange(16).reshape(2,4,2)
print(a)
print("0",a.sum(axis=0))
print("1",a.sum(axis=1))
print("2",a.sum(axis=2))

[[[ 0  1]
  [ 2  3]
  [ 4  5]
  [ 6  7]]

 [[ 8  9]
  [10 11]
  [12 13]
  [14 15]]]
0 [[ 8 10]
 [12 14]
 [16 18]
 [20 22]]
1 [[12 16]
 [44 48]]
2 [[ 1  5  9 13]
 [17 21 25 29]]

（5）ndarray对象的其他属性
①size:数组中元素个数，等于shape元素的乘积；
②itemsize:数组中元素的数据类型的大小，例如一个类型为float64的元素的数组的itemsize为8（64/8），complex64的itemsize为8（64/8）；
③ndim:数组的轴（维度）的数量，也叫做秩（rank);
④Flat：返回数组的一维迭代器；
⑤imag:返回数组的虚部；
⑥real:返回数组的实部；
⑦nbytes:数组中所有元素的字节长度。
（6）python中range和numpy中arange的区别和联系
①range函数：range(start,stop[,step]),根据start和stop指定的范围以及step设定的步长，生成一个序列，函数返回的是一个range object。
start：计数从start开始，默认是0
stop：计数到stop结束,但不包括stop
step：步长，每次跳跃的间距，默认是1，且不支持步长为小数
②arange函数：arange(start,stop,step，dtype),根据start和stop指定的范围以及step设定的步长，生成一个数组，函数返回的是一个ndarray。
start：计数从start开始，默认是0
stop：计数到stop结束,但不包括stop
step：步长，用于设置值之间的间隔，默认是1，且支持步长为小数
dtype:可选参数，可以设置返回ndarray的值类型
（7）其他特殊的数组

import random
import  numpy as np

#（7）其他特殊数组
#linspace生成等差数组，用于在指定区间内返回间隔均匀的值
#np.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)
#序列的开始值，结束值，生成的样本数默认值为50，endpoint布尔值如果为True表示最后一个样本值包含在序列内；retstep布尔值如果为True返回间距；数组的类型
t1=np.linspace(1,10,num=10,endpoint=True,retstep=True)
print(t1)
t2=np.linspace(1,10,num=9,endpoint=False,retstep=False)
print(t2)

#logspace生成等比数组，用于在指定区间内返回间隔均匀的值
#np.logspace(start,stop,num=50,endpoint=True,base=10.0,dtype=None)
#序列的开始值，基底base的start次幂作为左边界；
# 结束值，基底base的stop次幂作为右边界，
# 生成的样本数默认值为50，
# endpoint布尔值如果为True表示最后一个样本值包含在序列内；
# base基底，取对数时log的下标；
# 数组的类型
t1=np.logspace(1,10,num=10,endpoint=True)
print(t1)
t1=np.logspace(1,10,num=10,endpoint=True,dtype="int64")
print(t1)
t2=np.logspace(1,10,num=9,endpoint=False,base=2)
print(t2)

#ones 和zeros系列函数
#函数ones创建一个全1的数组，函数zeros创建一个全部为0的数组，函数empty创建一个内容随机的数组
#默认这些函数的数据类型是float64
#这三个函数还有三个从已知的数组中创建shape相同的多维数组的扩展函数，分别是ones_likes,zeros_like,empty_likes
a=np.ones(5)
b=np.zeros((2,1))
c=np.zeros_like(a)
temp=np.array(range(7))
d=np.empty_like(temp)
#eye(N,M=None,k=0,dtype=float) 依据给定的参数，生成第k个对角线的元素为1、其他元素为0的正方形数组（方阵）
#N：整数，返回数组的行数；M整数 可选返回数组的列数；k 可选整数 对角线的序列号 0对应主对角线 正数对应 upper diagonal 上三角，负数对应lower diagonal下三角
e=np.eye(3,k=1)
#identity(n,dtype)依据给定的参数，一个n维单位阵,n 整数返回方阵的行列数为int
#单位阵 主对角线元素是1 其余都是0
f=np.identity(3)
print("a={}\nb={}\nc={}\nd={}\ne={}\nf={}\n".format(a,b,c,d,e,f))
#补充：获取最大值最小值的位置
#np.argmax(t,axis=0)   np.argmin(t,axis=1)

(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
[1. 2. 3. 4. 5. 6. 7. 8. 9.]
[1.e+01 1.e+02 1.e+03 1.e+04 1.e+05 1.e+06 1.e+07 1.e+08 1.e+09 1.e+10]
[         10         100        1000       10000      100000     1000000
    10000000   100000000  1000000000 10000000000]
[  2.   4.   8.  16.  32.  64. 128. 256. 512.]
a=[1. 1. 1. 1. 1.]
b=[[0.]
 [0.]]
c=[0. 0. 0. 0. 0.]
d=[2128575739 1309500030 1661424176 1988385690 1324770695      12290
          0]
e=[[0. 1. 0.]
 [0. 0. 1.]
 [0. 0. 0.]]
f=[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

二、numpy常用方法

1、numpy读取本地数据
由于csv文件便于展示、读取和写入，所以很多地方也是用csv的格式存储和传输中小型的数据。
①csv:comma-separated value逗号分隔值文件。显示：表格状态。源文件：换行和逗号分隔行列的格式化文本，每一行的数据表示一条记录。
方法：np.loadtxt(frame,dtype=np.float,delimiter=none,skiprows=0,usecols=none,unpack=False)
frame:文件路径、字符串、产生器，可以是.gz或bz2压缩文件；
dtype：数据类型，可选，csv的字符串以什么数据类型读入数组中，默认np.float；
delimiter：分隔字符串，默认是任何空格，改为逗号；CSV用的逗号；
skiprows：跳过前x行，一般跳过第一行表头；
usecols：读取指定的列，索引，元组类型（使用哪几列）；
unpack：如果为True，读入属性将分别写入不同数组变量，False读入数据只写入一个数组变量，默认为False；表示转置。
例子：YouTube视频数据读取
数据来源：https://www.kaggle.com/datasnaek/youtube/data

file_path="./youtube_video_data/shuju.csv"
t1=np.loadtxt(file_path,delimiter=",")#科学计数法显示,所以可以自己指定数据类型
t2=np.loadtxt(file_path,delimiter=",",dtype="int")#这样显示的就是整型的数据了
t3=np.loadtxt(file_path,delimiter=",",dtype="int",unpack=True)#转置

注：numpy中转置的三种方法

#数组的转置(如果维度小于2返回他自己)
t2=np.arange(24).reshape((4,6))
print(t2)
t3=t2.transpose()#转置
print("*"*100)
print(t3)
t4=t2.T     #数学符号转置，他是ndarray类型对象的一个属性
print("*"*100)
print(t4)
t5=t2.swapaxes(1,0)#交换轴 0，1轴交换
print("*"*100)
print(t5)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
****************************************************************************************************
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
****************************************************************************************************
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
****************************************************************************************************
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]

2、numpy索引和切片
（1）取行、取连续多行、取不连续多行: t2[2] t2[2:] t2[[2,4,6]] 他们等同于t2[2,:] t2[2:,:] t2[[2,4,6],:] 分别取得是第三行的值、第三行及以后行的所有值、第三五七行的值，逗号之前表示取行，逗号之后表示取列
（2）取列、取连续的多列、取不连续的多列：t2[:,0] 取第一列，t2[:,2:]取第三列及以后，t2[:,[0,2]]取第一列和第三列数据
（3）取多行和多列（取得是行和列交叉点的位置）
① 取第三行第四列的值 t2[2,3] numpy.int64类型
②取第三行到第五行，第二列到第四列的结果 t2[2:5,1:4]， 因为最后的下标5取不到 左闭右开
③取多个不相邻的点 t2[[0,2,2],[0,1,3]] 取得是坐标为（0,0)、（2，1）和（2，3）的值
（4）索引 t2[2,3]
（5）numpy中数值的修改:取到之后重新赋值
t2[:,2:4]=0 第三列和第四列重新赋值了
如果我要修改 t2 中数值小于10的改为3，则t2[t2<10]=3 其中t2<10是把t2换成了布尔类型 所以可以取到所有小于10的数据 然后可以对应位置的数据修改为数值3。(numpy中的布尔索引)

t2=np.arange(24).reshape(4,6)
print(t2)
print(t2<10)
t2[t2<10]=3
print(t2)
print(t2[t2>20])

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ True  True  True  True  True  True]
 [ True  True  True  True False False]
 [False False False False False False]
 [False False False False False False]]
[[ 3  3  3  3  3  3]
 [ 3  3  3  3 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[21 22 23]

3、numpy中的三元运算符
np.where(t<10,0,10) t如果小于10等于0，否则为10（把t中小于10的替换为0，其他的替换为10）；python中三元运算符 a= 3 if 3<2 else 4 返回结果是4 。

t3=np.where(t2<=3,100,300)
print(t3)

[[100 100 100 100 100 100]
 [100 100 100 100 300 300]
 [300 300 300 300 300 300]
 [300 300 300 300 300 300]]

4、numpy中的clip(裁剪）
clip裁剪，裁剪为三个部分。 用法 t2.clip(10,18)可以把t2中小于或小于等于10的数据赋值为10，大于或大于等于18的数据赋值为18。

t2=np.arange(24).reshape(4,6)
# print(t2)
# # print(t2<10)
t2[t2<10]=3
print(t2)

t2=t2.astype(float)
t2[3,3]=np.nan
print(t2)
t3=t2.clip(10,18)
print(t3)

[[ 3  3  3  3  3  3]
 [ 3  3  3  3 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 3.  3.  3.  3.  3.  3.]
 [ 3.  3.  3.  3. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. nan 22. 23.]]
[[10. 10. 10. 10. 10. 10.]
 [10. 10. 10. 10. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 18. 18. nan 18. 18.]]

报错
    t2[2,4]=np.nan
ValueError: cannot convert float NaN to integer
因为nan是浮点型数据 不能转化为整型

5、数组的拼接
①竖直拼接 np.vstack((t1,t2)) 横着划线在竖直方向上操作 多加了行；
②水平拼接 np.hstack((t1,t2)) 竖着划线在水平方向上操作 多加了列。
（拼接时应该注意每一列代表的意义要相同）分割同理
③数组的行列交换：如果拼接时每一列的意义不同，这个时候应该交换某一组的数的列，让其和另外一个类相同。
行交换：t[[1,2],:]=t[[2,1],:]
列交换：t[:,[0,2]]=t[:,[2,0]]

t2=np.arange(24).reshape(4,6)
t2[[1,2],:]=t2[[2,1],:]
print(t2)
t2[:,[0,2]]=t2[:,[2,0]]
print(t2)

[[ 0  1  2  3  4  5]
 [12 13 14 15 16 17]
 [ 6  7  8  9 10 11]
 [18 19 20 21 22 23]]
[[ 2  1  0  3  4  5]
 [14 13 12 15 16 17]
 [ 8  7  6  9 10 11]
 [20 19 18 21 22 23]]

6、numpy生成随机数
np.random.randint(10,20,(4,5)) #取不到20

参数	解释
.rand(d0,d1,…,dn)	创建d0-dn维度的均匀分布的随机数数组，浮点数，范围从0-1
.randn(d0,d1,…,dn)	创建d0-dn维度的标准正态分布随机数，浮点数，平均数为0，标准差为1
.randint(low,high,(shape))	从给定上下限范围选取随机数整数，范围是low-high，形状是shape
.uniform(low,high,(shape))	产生具有均匀分布的数组（小数)，low起始值、high结束值、size形状
.normal(loc,scale,(size))	从指定正态分布中随机抽取样本，分布中心是loc（概率分布的均值）标准差是scale，size形状
.seed(s)	随机数种子，s是给定的种子值，因为计算机生成的是伪随机数，所以通过设定相同的随机数种子，可以每次生成相同的随机数（在上五个方法之前添加 np.random.seed(10) 就可以保证每次生成的随机数是一样的，但如果不同电脑运行哪怕seed参数值一样生成的随机数也未必一样）

7、numpy的copy和view
①a=b 完全不复制，a b相互影响
②a=b[:] 视图的操作，切片赋值，会创建新的对象a，但是a的数据完全由b保管，他们俩的数据变化是一致的
③a=b.copy（）复制 互不影响

三、numpy常用统计方法

1、numpy中nan和inf
nan:表示不是一个数字 not a number
当我们读取本地的文件为float时，如果有缺失，就会出现nan；当做了一个不合适的计算的时候也会出现nan（比如零除以零，无穷大(inf)减去无穷大）。
inf（-inf,inf）正无穷 -inf表示负无穷；一个数字除以0的时候会出现inf 在python中会报错，但在numpy中是一个inf或者-inf。
注：numpy中nan的注意点
①两个nan是不相等的 np.nan==np.nan 结果是False
②np.nan !=np.nan 结果是True
③利用以上的特性，可以判断数组中nan的个数
np.count_nonzero(t2)#统计t2中不为零的个数
np.count_nonzero(t2!=t2)#只有是nan的值才会出现自己不等于自己的情况，这时是True 为1 统计非零个数即可
④np.isnan(t2) 判断t2中哪些是nan ，作用效果同t2!=t2 （np.nan !=np.nan ），np.count_nonzero(np.isnan(t2)) 同样可以统计nan的个数
⑤nan和任何值进行计算结果都为nan np.sum(t2) 求和
⑥在一组数据中单纯的把nan替换为0其实是不合适的，比如全部替换为0后，如果替换之前的平均值大于0 ，替换之后的均值会变小，，所以一般会把nan（缺失的数值）替换为均值（中值）或者直接删掉有缺失值的一行。
2、numpy中常用的统计方法
求和：t2.sum(axis=None)
均值：t2.mean(axis=None)受离群点的影响较大
中值：np.median(t2,axis=None)
最大值：t2.max(axis=None)
最小值：t2.min(axis=None)
极值：np.ptp(t2,axis=None) 最大值和最小值的差
标准差：t.std(axis=None) 标准差是一组数据平均值分散程度的一种度量。方差开根号，一个较大的标准差代表大部分数值和其平均值之间差异较大；一个较小的标准差代表这些数值较接近平均值反映出数据的波动稳定情况。数值越大表示波动越大，越不稳定。（反映数据的离散程度）标准差公式（μ是均值）
这些默认都是返回多维数组的全部统计结果，如果指定axis则返回一个当前轴上的结果。

import random
import  numpy as np

#用列的均值或者中值替换nan
def fill_ndarray(t1):
    # 按列遍历
    for i in range(t1.shape[1]):
        tem_col = t1[:, i]  # 当前的一列
        nan_num = np.count_nonzero(tem_col != tem_col)  # 统计nan的个数
        if nan_num != 0:  # 不为0说明当前这一列中存在nan
            tem_not_nan_col = tem_col[tem_col == tem_col]  # 当前一列不为nan的array
            tem_col[np.isnan(tem_col)] = tem_not_nan_col.mean()  # 选中当前为nan的位置，把值赋值为不为nan的均值
            # tem_col[tem_col != tem_col]=tem_not_nan_col.mean()
    return t1

if __name__=='__main__':
    t1 = np.arange(24).reshape((4, 6)).astype("float")
    t1[1, 2:] = np.nan
    print(t1)
    t1=fill_ndarray(t1)
    print(t1)

[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7. nan nan nan nan]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7. 12. 13. 14. 15.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]

3、矩阵运算和线性代数

函数	说明
np.linalg.norm	表示范数、范数是对向量或者矩阵的度量，是一个标量
np.linalg.inv	矩阵的逆 如果矩阵A是奇异阵或非方阵，则会抛出异常（LinAlgError）。（方阵：行数列数相等的矩阵；奇异阵:首先，看这个矩阵是不是方阵（即行数和列数相等的矩阵，若行数和列数不相等，那就谈不上奇异矩阵和非奇异矩阵）。然后，再看此矩阵的行列式是否等于0，若等于0，称矩阵A为奇异矩阵；若不等于0，称矩阵A为非奇异矩阵。可逆矩阵就是非奇异矩阵，非奇异矩阵也是可逆矩阵） 计算矩阵A的广义逆矩阵用pinv
np.linalg.solve	求解线性方程组
np.linalg.det	求矩阵的行列式
np.linalg.lstsq	最小二乘法求解线性函数
np.linalg.eig	特征值和特征向量
np.linalg.eigval	特征值
np.linalg.SVD	奇异值分解
np.linalg.qr	矩阵的QR分解

import  numpy as np

x=np.array([[0,3,4],[1,6,4]])
#np.linalg.norm(x,ord=None,axis=None,keepdims=False)
#ord 表示范数的种类  默认取2 表示二范数（平方和再开根号）; 1 一范数 绝对值求和 ;  ord=np.inf无穷范数 max(|xi|)
#keepdims:是否保持矩阵的二维特性
#axis 1 按行向量处理 求多个行向量的范数 0 按列处理 求多个列向量的范数
print("默认参数 矩阵二范数 不保留矩阵的二维特性:",np.linalg.norm(x))
print(" 矩阵二范数 保留矩阵的二维特性:",np.linalg.norm(x,keepdims=True))
print(" 矩阵行向量二范数 保留矩阵的二维特性:",np.linalg.norm(x,axis=1,keepdims=True))
print(" 矩阵列向量二范数 保留矩阵的二维特性:",np.linalg.norm(x,axis=0,keepdims=True))
print(" 矩阵一范数 保留矩阵的二维特性:",np.linalg.norm(x,ord=1,keepdims=True))
print(" 矩阵二范数 保留矩阵的二维特性 :",np.linalg.norm(x,ord=2,keepdims=True))
print(" 矩阵∞范数 保留矩阵的二维特性:",np.linalg.norm(x,ord=np.inf,keepdims=True))
print("矩阵行向量一范数 保留矩阵的二维特性:",np.linalg.norm(x,ord=1,axis=1,keepdims=True))

#矩阵的逆
a=np.mat("0 1 2;1 0 3;4 -3 8")
a_inv=np.linalg.inv(a)
print(a)
print(a_inv)
print(a*a_inv)#检查原矩阵与逆矩阵相乘的结果是否为单位阵

#求方程组的解
b=np.array([[3,1],[1,2]])
c=np.array([9,8])
x1=np.linalg.solve(b,c)
print(x1)
print(np.dot(b,x1))#使用dot函数检查求得的解是否正确

#计算矩阵的行列式
d=np.array([[1,2],[3,4]])
print(np.linalg.det(d).astype(int))

#最小二乘法求解线性函数
x_d=[18,23,25,35,65,54,34,56,72,19,23,42,18,39,37]#个人年龄
y_d=[202,186,187,180,156,169,174,172,153,199,193,174,198,183,178]
n=len(x_d)
B=np.array(y_d)
A=np.array(([[x_d[i],1] for i in range(n)]))
# print(A)
X=np.linalg.lstsq(A,B)[0]
k=X[0];
d=X[1];
print("line is :y=",k,"x+",d)

#求特征值和特征向量
C=np.mat("3 -2;1 0")
c0=np.linalg.eigvals(C)#求解特征值
print(c0)
c1,c2=np.linalg.eig(C)#返回一个元组 第一列为特征值 第二列维特征向量
print(c1)
print(c2)
for i in range(len(c1)):
    print(np.dot(C,c2[:,i]))
    print(c1[i]*c2[:,i])

#奇异值分解 一种因子分解算法 将一个矩阵分解为3个矩阵的乘积
D=np.mat("4 11 14;8 7 -2")
#svd返回三个矩阵 U V是正交阵  Sigma包含输入矩阵的奇异值
U,Sigma,V=np.linalg.svd(D,full_matrices=False)
print("U:{}\nSigma:{}\nV:{}".format(U,Sigma,V))
#验证
print(U*np.diag(Sigma)*V)
print(np.diag(Sigma))#生成对角阵

默认参数 矩阵二范数 不保留矩阵的二维特性: 8.831760866327848
 矩阵二范数 保留矩阵的二维特性: [[8.83176087]]
 矩阵行向量二范数 保留矩阵的二维特性: [[5.        ]
 [7.28010989]]
 矩阵列向量二范数 保留矩阵的二维特性: [[1.         6.70820393 5.65685425]]
 矩阵一范数 保留矩阵的二维特性: [[9.]]
 矩阵二范数 保留矩阵的二维特性 : [[8.70457079]]
 矩阵∞范数 保留矩阵的二维特性: [[11.]]
矩阵行向量一范数 保留矩阵的二维特性: [[ 7.]
 [11.]]
[[ 0  1  2]
 [ 1  0  3]
 [ 4 -3  8]]
[[-4.5  7.  -1.5]
 [-2.   4.  -1. ]
 [ 1.5 -2.   0.5]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[2. 3.]
[9. 8.]
-2
line is :y= -0.7977265649330422 x+ 210.0484584241669
[2. 1.]
[2. 1.]
[[0.89442719 0.70710678]
 [0.4472136  0.70710678]]
[[1.78885438]
 [0.89442719]]
[[1.78885438]
 [0.89442719]]
[[0.70710678]
 [0.70710678]]
[[0.70710678]
 [0.70710678]]
U:[[-0.9486833  -0.31622777]
 [-0.31622777  0.9486833 ]]
Sigma:[18.97366596  9.48683298]
V:[[-0.33333333 -0.66666667 -0.66666667]
 [ 0.66666667  0.33333333 -0.66666667]]
[[ 4. 11. 14.]
 [ 8.  7. -2.]]
[[18.97366596  0.        ]
 [ 0.          9.48683298]]

4、numpy中的排序和搜索

函数	说明
sort(a[,axis,kind,order)	axis默认参数是1 即沿着数组的最后一个轴进行排序 不改变原始数组
argsort(a[,axis,kind,order)	对数组a进行排序 返回一个排序后的索引 a 不变
lexsort(key[,axis)	间接排序 支持对数组按指定行或列的顺序排序 不修改原数组 返回索引
argmax(a[,axis,out)	找到数组a 中最大值的下标，有多个最值时得到第一个最值得下标
anargmax(a[,axis)	找到数组a 中最大值的下标，有多个最值时得到第一个最值得下标(不含nan)
argmin(a[,axis,out)	找到数组a 中最小值的下标，有多个最值时得到第一个最值得下标
anargmin(a[,axis)	找到数组a 中最小值的下标，有多个最值时得到第一个最值得下标(不含nan)

5、numpy中数据的保存
np.loadtxt和np.savetxt可以读写一维和二维数组，如果想将多个数组保存到一个文件中，可以用np.savez函数； np.load和np.save是读写磁盘数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为.npy的文件中。