我的Python分析成长之路8

Numpy数值计算基础

　　Numpy:是Numerical Python的简称，它是目前Python数值计算中最为基础的工具包，Numpy是用于数值科学计算的基础模块，不但能够完成科学计算的任而且能够用作高效的多维数据容器,可用于存储和处理大型矩阵。Numpy的数据容器能够保存任意类型的数据，这使得Numpy可以无缝并快速地整合各种数据。Numpy本身并没有提供很多高效的数据分析功能。理解Numpy数组即数组计算有利于更加高效地使用其他如pandas等数据分析工具。

　　Numpy提供了两种基本的对象：ndarray（多维数组对象）和ufunc（通用函数）

1.数组属性：

　　　　　　ndim:返回int 。数组的维度

　　　　　　shape:返回tuple。表示数组的尺寸，对于n行m列的矩阵，形状为(m,n)

　　　　　　size:返回int。表示数组的元素整数,等于数组形状的乘积

　　　　　　dtype:返回data-typle。描述数组中元素的类型

　　　　　　itemsize:返回int。表示数组中每个元素的大小（以字节为单位）

　　　　　　　　

 import numpy as np
 arr1 = np.arange(9).reshape(3,3)
 print("创建数组:",arr1)
 print("数组的维度:",arr1.ndim)
 print("数组的尺寸(形状）：",arr1.shape)
 print("数组的数据类型：",arr1.dtype)
 print("数据元素个数：",arr1.size)
 print("数据每个元素大小:",arr1.itemsize)

2.数组创建

　　　　一、生成多维数组最简单的方式就是使用array函数,array函数接受任意的序列型对象（当然也包括其他的数组）。

　　　　基本语法法：numpy.array(object,dtype=None,copy=True,order='K',subok=False,ndmin=0)

　　　　　　　　　　1.object 接受array。表示想要创建的数组.无默认

　　　　　　　　　　2.dtype 接受data-type.表示数组所需的数据类型。默认为None

　　　　　　　　　　3.ndmin 接受int。指定数组的最小维度。默认为None

import numpy as np
data1 = [1,2,3,4,5]
data2 = [[1,2,3,4],[5,6,7,8]]
print("生成一维数组:",np.array(data1))   #生成一维数组
print("生成二维数组:",np.array(data2))   #生成二维数组

　　　　二、使用其他函数创建数组

　　　　　　

 import numpy as np
 print("使用arange函数生成数组:",np.arange(0,10,1))  #左闭右开
 print("使用linspace函数生成数组:",np.linspace(0,9,10))  #闭区间
 print("使用logspace函数生成数组:",np.logspace(0,2,10)) #[1,100]生成10个数
 print("使用zeros函数生成数组:",np.zeros((2,3)))  #生成二行三列全为0的数组
 print("使用ones函数生成数组:",np.ones((2,3))) #生成二行三列全为一的数组
 print("使用eye函数生成数组:",np.ones(3))  #生成对角线上为一的数组
 print("使用diag函数生成数组:",np.diag([1,2,3,4]))

3.数组的数据类型

　　　　在Numpy中，所欲数组的数据类型是同质的,即数组中的所有元素必须是一致的。这样做的好处，更容易确定数组所需要的存储空间。

　　　　bool :用一位存储的布尔类型（True or False）

　　　　inti:由所在平台决定其精度的整数

　　　　int8:整数 范围为：-128~127

　　　　int16:整数 范围为：-32768~32767

　　　　int32:整数 范围为：-2^31~2^32-1

　　　　int64:整数 范围为:-2^63~2^63-1

　　　　unit8:无符号整数 范围为:0~255

　　　　unit16:无符号整数 范围为:0~65535

　　　　unit32:无符号整数 范围为0~2^32-1

　　　　unit64 无符号整数 范围为0~2^64-1

　　　　float16:半精度浮点数

　　　　float32:单精度浮点数

　　　　float64: 双精度浮点数

　　　　complex64 复数 分别用32为浮点数代表实部和虚部

　　　　complex128/comple 复数分别用64位浮点数表示实部和虚部

　　　　np.dtype（） 查看数据类型

print(np.float(32))   #整形转化为浮点型
print(np.int(42.0))  #浮点型转化为整形
print(np.bool(42))  #整形转化为bool型
print(np.float(True))  #bool型转化为浮点型

4.生成随机数

　　　　Numpy提供了强大的生成随机数的功能，但使用的都是伪随机数.random 是最常见的生成随机数的方法.

 print("生成随机数：",np.random.random())
 print("生成均匀分布的随机数",np.random.rand(10,5))
 print("生成正态分布的随机数",np.random.randn(10,5))
 print("生成给定上下限的随机数：",np.random.randint(0,10,size=[5,2]))
 print("生成二项分布随机数：",np.random.binomial(10,0,(2,3)))
 print("生成beta分布随机数：",np.random.beta(0.2,0.3,(2,3)))
 print("生成卡方分布随机数：",np.random.chisquare(10,[5,2]))
 print("生成gamma分布随机数:",np.random.gamma(10,1,(5,2)))
 print("生成任意期间均匀分布随机数：",np.random.uniform(0,10,(5,2)))

5.通过索引访问数组

　　　　1.一维数组的索引

　　　　一维数组的索引比较简单，与Python中list的索引方法类似：如果你传递一个数值给数组的切片，数值会被传递给整个切片。区别于Python的内建列表，数组的切片是原数组的视图。这意味着数据并不是被复制，任何对于视图的修改都会反映到原数组上。

　　　　

 arr1 = np.arange(10)
 print(arr1[1])  #获得索引为1的值
 print(arr1[1:3])  #获得索引为1,2的值
 arr1[2:4] = 12
 print(arr1)   #[ 0  1 12 12  4  5  6  7  8  9] 获得
 x = arr1[1:3].copy()   #如果不想要获得是一份视图的话，就用显示的复制这个数组 .copy（）
 print(arr1)

　　　　2.多维数组的索引

　　　　　多维数组的每一个维度都有一个索引，各个维度的索引之间用逗号隔开，或分两个括号

 arr= np.arange(9).reshape(3,3)
 print(arr[0][2])    #
 print(arr[0,2])     #2 这两种方式访问等价
 print(arr[1:,1:]) #第二、三行，第二、三列
 print(arr[:2,2])  #前两行，第三列
 arr2 = np.array([[[1,2,3],[4,5,6]],[7,8,9],[10,11,12]])
 print(arr2[0])   #[[1, 2, 3], [4, 5, 6]]
 print(arr2[0][0]) #[1, 2, 3]

　　　　3.布尔索引

 names = np.array(["A","B","C","D","E","F"])
 data = np.random.randn(6,4)
 print(names=="B")   #[False  True False False False False]
 print(data[names=='B'])   #在索引数组中引入布尔数组  选择names=="B"的行
 print(data[names=='B',2:])     #names ="B" 的后两列

6.改变数组的形态

　　在对数组进行操作时，经常需要改变数组的维度。在Numpy中，常用reshape函数改变数组的“形状”，也就是改变数组的维度。参数为一个正整数元组，分别指定数组在每个维度上的大小，reshape函数在改变原始数据形状的同时不改变原始数据。如果指定的数据和数组的元素不吻合，则函数将抛出异常。

　　使用ravel（）、flatten()完成展开工作，使用hstack()、vstack() 、concatenate完成组合操作,使用hsplit、vsplit、dsplit、split完成分割操作,可以将数组分割成相同大小的子数组，也可以指定原数组中需要分割的位置。

　　

 arr = np.arange(12)
 print("创建一维数组:",arr)
 print("新的数组:",arr.reshape(3,4))   #返回（3,4）的数组
 print("数组的维度:",arr.ndim)   #查看数组的维度 2
 arr2 = np.arange(12).reshape(3,4)
 print("创建的二维数组:",arr2)
 print("使用ravel展平:",arr2.ravel())  #获得一维数组[ 0  1  2  3  4  5  6  7  8  9 10 11]
 print("使用flatten横向展开:",arr2.flatten())   #横向展开 [ 0  1  2  3  4  5  6  7  8  9 10 11]
 print("使用flatten纵向展开:",arr2.flatten("F"))  #纵向展开，[ 0  4  8  1  5  9  2  6 10  3  7 11]
 arr3 = arr2 *3
 print("使用hstack完成横向组合:",np.hstack((arr2,arr3)))  #横向组合
 print("使用vstack完成纵向组合:",np.vstack((arr2,arr3)))  #纵向组合
 print("使用concatenate完成纵向组合操作",np.concatenate((arr2,arr3),axis=0))   #沿着纵向组合
 print("使用concatenate完成横向组合操作",np.concatenate((arr2,arr3),axis=1))  #沿着横向组合
 print("横向分割:",np.hsplit(arr2,2))   #使用hsplit完成横向分割
 arr4 = np.arange(16).reshape(4,4)
 print("纵向分割:",np.vsplit(arr4,2))  #使用vstack完成纵向分割  必须保证分割后相同大小
 print("横向分割：",np.split(arr4,axis=1))  #完成横向分割
 print("纵向分割:",np.split(arr4,axis=0))  #完成纵向分割

7.创建numpy矩阵

　　　　在Numpy中，矩阵是ndarray的子类，在Numpy中，数组和矩阵有着重要的区别.Numpy中提供了两个基本的对象：一个N维数组对象和一个通用函数对象。其他对象在它们之上构建的。矩阵是继承自Numpy数组对象的二维数组对象。矩阵也是二维的

　　　　使用mat、matrix、bmat函数构建矩阵和矩阵的操作

 mat1 = np.mat("1 2 3;2 3 4;3 4 5")
print("使用mat创建的矩阵:",mat1)
mat2 = np.matrix([[1,2,3],[2,3,4],[3,4,5]])
print("使用matrix创建的矩阵:",mat2)
mat3 = np.bmat("mat1;mat2")
print("使用bmat创建的矩阵:",mat3)
mat4 = mat1*3
print("矩阵与数相乘:",mat4)
mat5 = mat1+mat2
print("矩阵相加结果:",mat5)
mat6 = mat2 - mat1
print("矩阵相减结果:",mat6)
mat7 = mat1 * mat2    #等价于mat1@mat2
print("矩阵与矩阵相乘:",mat7)  #相当于求内积
mat8 = np.multiply(mat1,mat2)
print("矩阵对应元素相乘:",mat8)
print("矩阵的转置：",mat1.T)  #相当于mat1.T
print("矩阵的共轭转置:",mat1.H)
print("矩阵的逆矩阵:",mat1.I)
print("矩阵的一个视图:",mat1.A)

8.ufunc函数

　　　　ufunc函数全称为通用函数,是一种能够对数组中的所有元素（逐元素）进行操作的函数。ufunc是针对数组进行操作的，并且都以Numpy数组作为输出,因为不需要对数组中的每个元素进行操作。

　　　　一元通用函数:

　　　　　　　　　　add、fabs 逐元素计算整数、浮点数或复数的绝对值

　　　　　　　　　　sqrt：计算每个元素的平方根

　　　　　　　　　　square:计算每个元素的平方

　　　　　　　　　　exp:计算每个元素的自然指数值

　　　　　　　　　　log :计算对数

　　　　　　　　　　ceil：计算每个元素的最高整数值  （大于等于这个数的最小整数）

　　　　　　　　　　floor ：计算每个元素的最小整数值（小于等于这个数的最大整数）

　　　　　　　　　　sign:计算每个值的符号值：1（正数） 0（0）-1（负数）

　　　　　二元通用函数：

　　　　　　　　　　add（+）:将对应元素相加

　　　　　　　　　　subtract（-）:在第二个数组中，将第一个数组中包含的元素去掉 　　　　　

　　　　　　　　　　multiply（*） :将属组中对应的元素相乘     *

　　　　　　　　　　divide（/），floor_diveide 除或整除

　　　　　　　　　　power(**）：将第二个数组的元素作为第一个数组对应元素的幂次方

　　　　　　　　　　maximum,fmax 逐个元素计算最大值，fmax忽略NAN

　　　　　　　　　　minimun,fmax:逐个元素计算最小值，fmin忽略NAN

　　　　　　　　　　mod:按元素的求模计算(求除法的余数）

 x = np.array([1,2,3])
 y = np.array([4,5,6])
 print("数组相加的结果:",np.add(x,y))   #相当于+   [5 7 9]
 print("数组相减的结果:",np.subtract(x,y))  #相当于- [-3,-3,-3]
 print("数组相乘的结果:",np.multiply(x,y))  #相当于* [ 4 10 18]
 print("数组相除的结果:",np.divide(x,y)) #相当于/ [0.25 0.4  0.5 ]
 print("数组幂运算结果：",np.power(x,y))  #相当于** [  1  32 729]
 print("数组求最大值:",np.maximum(x,y))   #求x,y中数组元素的最大值
 print("数组求模:",np.mod(x,y))  #相当于%

9.ufunc函数的广播机制

　　　　广播是指不同形状的数组之间执行算术运算的方式、当使用ufunc函数进行数组计算时，ufunc会对两个元素对应元素进行计算。进行这种操作的前提是两个数组的shape一样。当两个数组shape不一样时，Numpy就会执行广播机制。需要遵循四个原则:（1）让所有的输入数组向其中shape最大的数组看齐，shape中不足的地方通过在前面补1.

（2）输出数组的shape是输入数组shape的各个轴上的最大值.(3)如果输入数组的某个轴和输出数组的对应轴的长度相同或者长度为一,则这个数组能够用来计算，否则出错.

(4)当输入数组的某个轴长度为1时，沿着此轴运算时使用此轴上的第一组值。

 arr1 = np.array([[0,0,0],[1,1,1],[2,2,2]])
 arr2 = np.array([1,2,3])
 print(arr1+arr2)
 arr3 = np.array([[0,0,0],[1,1,1],[2,2,2]])
 arr4= np.array([1,2,3]).reshape(3,1)
 print(arr3+arr4)

10、利用Numpy进行统计分析

　　　　1.读、写文件：

　　　　Numpy文件的读/写主要有二进制的文件读/写和文件列表形式的数据读/写两种形式.save函数主要以二进制的格式保存数据，load函数从二进制的文件中读取数据

　　　　基本语法:np.save(file,arr,allow_pickle=True,fix_imports=Trues) file为文件名称，arr表示需要保存的数据，如果需要保存多个数组至一个文件中，可以使用savez函数

　　　　　　　　data = np.load(file)   从二进制文件中获取数据

　　　　　　　　np.savetxt(file,X,delimeter=' ,')需要保存数据至文本中，file表示文件名,X表示保存的数据,delimeter表示分隔符。

　　　　　　　　np.loadtxt(file)  从文本中获取数据

　　　　2.简单的统计分析

　　　　

 import numpy as np
 arr1 = np.array([1,3,4,8,6])
 np.sort(arr1)  #对arr1进行排序
 arr2= np.random.randint(1,9,(3,3))
 arr2.sort(axis=1)   #对arr2列向排列
 print(arr2)
 arr2.sort(axis=0)  #对arr2进行横向排列
 arr3 = np.array([1,1,2,5,3,6,4,6,6,8])
 print(np.unique(arr3))   #相当于 np.sort(set(arr3)) ,对arr3进行去重并排序
 print(np.tile(arr1,3))   #对整个arr1数组进行复制，3 代表3次
 print(np.repeat(arr1,2,axis=0))   #对arr1中的元素进行横向复制2次
 print(np.repeat(arr1,2,axis=1))  #对arr1中元素进行列向复制2次
 print("arr1数组的和:",np.sum(arr1))   #计算数组的和
 print("arr2数组列向的和",np.sum(arr2,axis=0))  #计算arr2列向的和
 print("arr2数组横向的和",np.sum(arr2,axis=1))  #计算arr1横向的和
 print("arr1数组的平均值:",np.mean(arr1))  #计算数组的平均值
 print("arr2数组的纵向的平均值",np.mean(arr2,axis=0))  #计算列向的平均值
 print("arr2数组的横向平均值:",np.mean(arr2,axis=1))  #计算横向的平均值
 print("方差:",np.var(arr1))  #计算arr1的方差
 print("标准差:",np.std(arr1))  #计算arr1的标准差
 print("数组的最大值",np.max(arr1))  #计算arr1的最大值
 print("数组的最小值:",np.min(arr1))  #计算arr1的最小值
 print("最大值的索引:",arr1)  #返回最大值的索引
 print("最小值的索引:",arr1)  #返回最小值的索引
 print("累计求和:",np.cumsum(arr1))  #累计求和
 print('累积：',np.cumprod(arr1))  #累乘

11线性代数

　　　　

 import numpy as np
 arr1 = np.array([[1,2,3],[2,3,4]])
 arr2 = np.array([[1,2],[2,3],[3,4]])
 print(arr1@arr2)  #点乘积
 print(np.dot(arr1,arr2))  #点乘积
 print(arr1*arr1)#逐元素乘积
 arr3 = np.array([[1,2,3],[2,3,4],[5,6,7]])
 print(np.linalg.inv(arr3))  #inv  求逆矩阵
 print(np.diag(arr3))     #将方阵的对角线元素以一元数组的形式返回
 print(np.trace(arr3))  #计算对角线元素的和
 print(np.linalg.det(arr3))  #计算矩阵的行列式
 x,y = np.linalg.eig(arr3) #计算方针的特征值和特征矩阵
 print(x) #x 特征值，y特征向量
 print(np.linalg.qr(arr3))  #计算qr分解
 print(np.linalg.svd(arr3))  #计算svd分解
 #np.linalg.solve(a,b)  #求解方程
 # np.linalg.lstsq(a,b)  #计算最小二乘