数据分析-numpy
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import numpy as np ls2 = np.arange(10) list(ls2) type(ls2) #numpy.ndarray
简单的方法:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
np.ones([3,4]) #返回元素全为1的3×4二维数组 np.zeros([2,3])#返回元素全为0的2×3二维数组
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]])
np.empty(3) #返回一维空数组
有关数组的属性和函数
属性:
arr3 = np.array(((1,1,2,3),(5,8,13,21),(34,55,89,144)))
arr3.shape #shape方法返回数组的行数和列数 (3, 4)
arr3.dtype #dtype方法返回数组的数据类型 dtype('int32')
a = arr3.ravel() #通过ravel的方法将数组拉直(多维数组降为一维数组) array([ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144])
b = arr3.flatten() #通过flatten的方法将数组拉直 array([ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144])
两者的区别在于ravel方法生成的是原数组的视图,无需占有内存空间,但视图的改变会影响到原数组的变化。而flatten方法返回的是真实值,其值的改变并不会影响原数组的更改。
arr4.ndim #返回数组的维数
arr4.size #返回数组元素的个数
arr4.T #返回数组的转置结果
如果数组的数据类型为复数的话,real方法可以返回复数的实部,imag方法返回复数的虚部。
函数:
len(arr4) #返回数组有多少行
np.hstack((arr3,arr4))两个行数相同的数组横向拼接。np.column_stack((arr3,arr4)) #与hstack函数具有一样的效果
np.vstack((arr3,arr4)) 两个行数相同的数组纵向拼接。np.row_stack((arr3,arr4)) #与vstack函数具有一样的效果
reshape()函数和resize()函数可以重新设置数组的行数和列数:
arr5 = np.array(np.arange(24))
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,17, 18, 19, 20, 21, 22, 23])
a = arr5.reshape(4,6) 通过reshape函数将一维数组设置为二维数组,且为4行6列的数组。
a.resize(6,4) 通过resize函数会直接改变原数组的形状。
数组转换:tolist将数组转换为列表,astype()强制转换数组的数据类型,下面是两个函数的例子:
b = a.tolist() c = a.astype(float)
数组元素的获取
通过索引和切片的方式获取数组元素,一维数组元素的获取与列表、元组的获取方式一样:
arr7=np.arange(10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr7[3] #获取index=3元素 3
arr7[:3] #获取index=3前面的元素 array([0, 1, 2])
arr7[3:] #获取index=3元素以及之后的所有元素 array([3, 4, 5, 6, 7, 8, 9])
arr7[-2:] #获取末尾的2个元素 array([8, 9])
arr7[::2] #从index=0开始,获取步长为2的所有元素 array([0, 2, 4, 6, 8])
二维数组元素的获取
arr8 = np.array(np.arange(12)).reshape(3,4)
arr8[1] #返回数组的index=1的行 array([4, 5, 6, 7])
arr8[:2] #返回数组的index=2以前的行 array([[0, 1, 2, 3],[4, 5, 6, 7]])
arr8[[0,2]] #返回指定的index=0和index=2行
arr8[[0,2]] #返回指定的index=0行和index=2行
arr8[:,0] #返回数组的index=0列
arr8[:,-2:] #返回数组的后2列
arr8[:,[0,2]] #返回数组的index=0列和index=2列
arr8[1,2] #返回数组中index=1行index=2列对应的元素
布尔索引,即索引值为True和False,需要注意的是布尔索引必须输数组对象。
log = np.array([True,False,False,True,True,False])
arr9 = np.array(np.arange(24)).reshape(6,4)
arr9[log] #返回所有为True的对应行 #0,3,4行
array([[ 0, 1, 2, 3],[12, 13, 14, 15],[16, 17, 18, 19]])
arr9[-log] #通过负号筛选出所有为False的对应行
举一个场景,一维数组表示区域,二维数组表示观测值,如何选取目标区域的观测?
area = np.array(['A','B','A','C','A','B','D'])
observes = np.array(np.arange(21)).reshape(7,3)
observes[area == 'A'] 返回所有A区域的观测。 array([[ 0, 1, 2],[ 6, 7, 8],[12, 13, 14]])
observes[(area == 'A') | (area == 'D')] #条件值需要在&(and),|(or)两端用圆括号括起来 返回所有A区域和D区域的观测。
当然,布尔索引也可以与普通索引或切片混合使用:
observes[area == 'A'][:,[0,2]] 返回A区域的所有行,且只获取index=0列与index=2列数据。
花式索引:实际上就是将数组作为索引将原数组的元素提取出来
arr10 = np.arange(1,29).reshape(7,4)
arr10[[4,1,3,5]] #按照指定顺序返回指定行
arr10[[4,1,5]][:,[0,2,3]] #返回指定的行与列 如果想使用比较简单的方式返回指定行以列的二维数组的话,可以使用ix_()函数
arr10[np.ix_([4,1,5],[0,2,3])]
arr10[[4,1,5],[0,2,3]] array([17, 7, 24])
请注意!这与上面的返回结果是截然不同的,上面返回的是二维数组,而这条命令返回的是一维数组。
统计函数与线性代数运算
统计运算中常见的聚合函数有:最小值、最大值、中位数、均值、方差、标准差等。首先来看看数组元素级别的计算:
arr11 = 5-np.arange(1,13).reshape(4,3)
arr12 = np.random.randint(1,10,size = 12).reshape(4,3)
arr11 ** 2 #计算每个元素的平方
np.sqrt(arr11) #计算每个元素的平方根 由于负值的平方根没有意义,故返回nan。
np.exp(arr11) #计算每个元素的指数值
np.log(arr12) #计算每个元素的自然对数值
np.abs(arr11) #计算每个元素的绝对值
相同形状数组间元素的操作:
arr11 + arr12 #加 arr11 - arr12 #减 arr11 * arr12 #乘 arr11 / arr12 #除 arr11 // arr12 #整除 arr11 % arr12 #取余
统计运算函数:
np.sum(arr11) #计算所有元素的和
np.sum(arr11,axis = 0) #对每一列求和
np.sum(arr11, axis = 1) #对每一行求和
np.cumsum(arr11) #对每一个元素求累积和,返回一维数组(从上到下,从左到右的元素顺序)#array([ 4, 7, 9, 10, 10, 9, 7, 4, 0, -5, -11, -18], dtype=int32)
np.cumsum(arr11, axis = 0) #计算每一列的累积和,并返回二维数组 #array([[ 4, 3, 2],[ 5, 3, 1],[ 3, 0, -3],[ -2, -6, -10]], dtype=int32)
np.cumprod(arr11, axis = 1) #计算每一行的累计积,并返回二维数组
np.min(arr11) #计算所有元素的最小值 np.max(arr11, axis = 0) #计算每一列的最大值 np.mean(arr11) #计算所有元素的均值
np.mean(arr11, axis = 1) #计算每一行的均值 np.median(arr11) #计算所有元素的中位数 np.median(arr11, axis = 0) #计算每一列的中位数
np.var(arr12) #计算所有元素的方差 np.std(arr12, axis = 1) #计算每一行的标准差
numpy中的统计函数运算是非常灵活的,既可以计算所有元素的统计值,也可以计算指定行或列的统计指标。还有其他常用的函数,如符号函数sign,ceil(>=x的最小整数),floor(<=x的最大整数),modf(将浮点数的整数部分与小数部分分别存入两个独立的数组),cos,arccos,sin,arcsin,tan,arctan等。
让我很兴奋的一个函数是where(),它类似于Excel中的if函数,可以进行灵活的变换:
np.where(arr11 < 0, 'negtive','positive')
当然,np.where还可以嵌套使用,完成复杂的运算。
其它函数
unique(x):计算x的唯一元素,并返回有序结果
intersect(x,y):计算x和y的公共元素,即交集
union1d(x,y):计算x和y的并集
setdiff1d(x,y):计算x和y的差集,即元素在x中,不在y中
setxor1d(x,y):计算集合的对称差,即存在于一个数组中,但不同时存在于两个数组中
in1d(x,y):判断x的元素是否包含于y中
线性代数运算
同样numpu也跟R语言一样,可以非常方便的进行线性代数方面的计算,如行列式、逆、迹、特征根、特征向量等。但需要注意的是,有关线性代数的函数并不在numpy中,而是numpy的子例linalg中。
arr13 = np.array([[1,2,3,5],[2,4,1,6],[1,1,4,3],[2,5,4,1]])
np.linalg.det(arr13) #返回方阵的行列式 51.000000000000021
np.linalg.inv(arr13) #返回方阵的逆
np.trace(arr13) #返回方阵的迹(对角线元素之和),注意迹的求解不在linalg子例程中 10
np.linalg.eig(arr13) #返回由特征根和特征向量组成的元组
np.linalg.qr(arr13) #返回方阵的QR分解
np.linalg.svd(arr13) #返回方阵的奇异值分解
np.dot(arr13,arr13) #方阵的正真乘积运算
随机数生成
统计学中经常会讲到数据的分布特征,如正态分布、指数分布、卡方分布、二项分布、泊松分布等,下面就讲讲有关分布的随机数生成。
正态分布直方图
In [137]: import matplotlib #用于绘图的模块
In [138]: np.random.seed(1234) #设置随机种子
In [139]: N = 10000 #随机产生的样本量
In [140]: randnorm = np.random.normal(size = N) #生成正态随机数
In [141]: counts, bins, path = matplotlib.pylab.hist(randnorm, bins = np.sqrt(N), normed = True, color = 'blue') #绘制直方图
以上将直方图的频数和组距存放在counts和bins内。
In [142]: sigma = 1; mu = 0
In [143]: norm_dist = (1/np.sqrt(2*sigma*np.pi))*np.exp(-((bins-mu)**2)/2) #正态分布密度函数
In [144]: matplotlib.pylab.plot(bins,norm_dist,color = 'red') #绘制正态分布密度函数图
使用二项分布进行赌博
同时抛弃9枚硬币,如果正面朝上少于5枚,则输掉8元,否则就赢8元。如果手中有1000元作为赌资,请问赌博10000次后可能会是什么情况呢?
In [146]: np.random.seed(1234)
In [147]: binomial = np.random.binomial(9,0.5,10000) #生成二项分布随机数
In [148]: money = np.zeros(10000) #生成10000次赌资的列表
In [149]: money[0] = 1000 #首次赌资为1000元
In [150]: for i in range(1,10000):
...: if binomial[i] < 5:
...: money[i] = money[i-1] - 8
#如果少于5枚正面,则在上一次赌资的基础上输掉8元
...: else:
...: money[i] = money[i-1] + 8
#如果至少5枚正面,则在上一次赌资的基础上赢取8元
In [151]: matplotlib.pylab.plot(np.arange(10000), money)
一个醉汉在原始位置上行走10000步后将会在什么地方呢?如果他每走一步是随机的,即下一步可能是1也可能是-1。
In [152]: np.random.seed(1234) #设定随机种子
In [153]: position = 0 #设置初始位置
In [154]: walk = [] #创建空列表
In [155]: steps = 10000 #假设接下来行走10000步
In [156]: for i in np.arange(steps):
...: step = 1 if np.random.randint(0,2) else -1 #每一步都是随机的
...: position = position + step #对每一步进行累计求和
...: walk.append(position) #确定每一步所在的位置
In [157]: matplotlib.pylab.plot(np.arange(10000), walk) #绘制随机游走图
上面的代码还可以写成(结合前面所讲的where函数,cumsum函数):
In [158]: np.random.seed(1234)
In [159]: step = np.where(np.random.randint(0,2,10000)>0,1,-1)
In [160]: position = np.cumsum(step)
In [161]: matplotlib.pylab.plot(np.arange(10000), position)