利用python进行数据分析--numpy基础

随书练习，第四章 NumPy基础：数组和矢量运算
# coding: utf-8

# In[1]:


# 加注释的三个方法1.用一对"""括起来要注释的代码块。
# 2.用一对\'\'\'括起来要注释的代码块。
# 3.选中要注释的代码，按下ctrl+/注释。
# from numpy import *
import numpy as np


# In[2]:


data=[[0.9526,-0.246,-0.8856],
     [0.5639,0.2379,0.9104]]


# In[3]:


data


# In[4]:


data=np.array(data)  #构造数组，输出结果中加了小括号


# In[5]:


data


# In[6]:


data*10  #利用数组对整块数据进行数学运算


# In[7]:


data+data


# In[8]:


data.shape #数组是一个同构数据多维容器，所有元素必须是相同类型的，shape表示维度大小


# In[9]:


data.dtype  #dtype说明数组数据类型


# In[10]:


# ------array函数：接受一切序列型对象（包括其他数组），产生一个新的数组


# In[11]:


data1 = [6,7.5,8,0,1]


# In[12]:


arr1 = np.array(data1)


# In[13]:


arr1


# In[14]:


data11 = np.array([1,2,3])


# In[15]:


data11


# In[16]:


arr11= np.array(data11)  #接受对象为其他数组


# In[17]:


arr11


# In[18]:


data2 = [[1,2,3,4],[5,6,7,8]]


# In[19]:


arr2 = np.array(data2)


# In[20]:


arr2


# In[21]:


arr2.ndim  #dim是dimension维度的缩写


# In[22]:


arr2.shape


# In[23]:


data22 = [[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]


# In[24]:


arr22 = np.array(data22)


# In[25]:


arr22  #维度为3的数组


# In[26]:


arr22.ndim


# In[27]:


arr22.shape


# In[28]:


arr1.dtype  #np.array自行推断出一个合适的数据类型


# In[29]:


arr2.dtype


# In[30]:


np.zeros(10)


# In[31]:


np.zeros((3,6))


# In[32]:


np.empty((2,3,2))  #返回一些未初始化的垃圾值


# In[33]:


np.arange(15) #arange是python内置函数range的数组版


# In[34]:


np.arange(0,100,10) #创建一个[0,100)范围内步长为10的数组


# In[35]:


#数组常见函数：array,asarray(同上，若输入本身为ndarray,则不复制),arange,ones,ones_like,zeros,zeros_like,empty,empty_like,eye,identity


# In[36]:


np.ones_like(arr2)


# In[37]:


np.ones((2,2,6)) #两层括号，一层表示函数，一层表示形状的list


# In[38]:


np.identity(5) #对角线为1的方形矩阵


# In[39]:


np.eye(5)


# In[40]:


np.eye(5,k=1)


# In[41]:


np.eye(5,4,k=-1)  #可以创建矩形矩阵，k表示偏离对角线的位置


# In[42]:


arr1 = np.array([1,2,3],dtype=np.float64)


# In[43]:


arr2 = np.array([1,2,3],dtype=np.int32)


# In[44]:


arr1.dtype


# In[45]:


arr2.dtype


# In[46]:


#两个特殊的数据类型：string_字符串类型  unicode_固定长度的unicode类型，这两个数据类型表示中有一个小的下划线


# In[47]:


arr3 = np.array([\'a\',\'b\',\'c\'],dtype=np.string_)


# In[48]:


arr3.dtype


# In[49]:


arr = np.array([1,2,3,4,5])


# In[50]:


arr.dtype


# In[51]:


float_arr = arr.astype(np.float64)  #astype的用法


# In[52]:


float_arr.dtype


# In[53]:


arr = np.array([3.7,-1.2,-2.6,0.5,12.9,10.1])


# In[54]:


arr


# In[55]:


arr.astype(np.int32)  #结果中小数部分被截断


# In[56]:


arr #但是并未改变原始数据，只是外在表现形式变了


# In[57]:


arr.astype(np.float64)


# In[58]:


numberic_strings = np.array([\'1.25\',\'-9.6\',\'42\'],dtype=np.string_)


# In[59]:


numberic_strings.astype(np.float64) #可以把本身是数字的字符串类型转换为浮点型数字格式的


# In[60]:


int_array = np.arange(10)


# In[61]:


calibers = np.array([.22,.270,.357,.380,.44,.50],dtype=np.float64)


# In[62]:


int_array.astype(calibers.dtype)


# In[63]:


empty_unit32 = np.empty(8,dtype=\'u4\') #可以用简洁的类型代码表示


# In[64]:


empty_unit32


# In[65]:


arr = np.array([[1.,2.,3.],[4.,5.,6.]])


# In[66]:


arr


# In[67]:


arr*arr #大小相等的数组之间应用到元素级


# In[68]:


arr-arr


# In[69]:


1/arr #标量与数组同样传播至元素级


# In[70]:


arr**0.5 #指数运算


# In[71]:


arr = np.arange(10)


# In[72]:


arr


# In[73]:


arr[5]


# In[74]:


arr[5:8]


# In[75]:


arr[5:8]=12  #对切片赋值改变原始数据


# In[76]:


arr


# In[77]:


arr_slice = arr[5:8] #前包含后不包含


# In[78]:


arr_slice[1] = 12345


# In[79]:


arr


# In[80]:


arr_slice[:] = 64


# In[81]:


arr


# In[82]:


arr_slice1 = arr[1:8:2] #起点，终点，步长


# In[83]:


arr_slice1[:] = 3


# In[84]:


arr


# In[85]:


arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])


# In[86]:


arr2d[2]


# In[87]:


arr2d[0][2]


# In[88]:


arr2d[0,2]


# In[89]:


arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])


# In[90]:


arr3d


# In[91]:


arr3d[0]


# In[92]:


old_values = arr3d[0].copy()


# In[93]:


arr3d[0] = 42


# In[94]:


arr3d


# In[95]:


arr3d[0] = old_values


# In[96]:


arr3d


# In[97]:


arr3d[1,0]


# In[98]:


arr[1:6]


# In[99]:


arr2d


# In[100]:


arr2d[:2]


# In[101]:


arr2d[:2,1:]


# In[102]:


arr2d[1,:2]


# In[103]:


arr2d[2,:1]


# In[104]:


arr2d[:,:1]


# In[105]:


arr2d[:2,1:] = 0


# In[106]:


arr2d


# In[107]:


names = np.array([\'Bob\',\'Joe\',\'Will\',\'Bob\',\'Will\',\'Joe\',\'Joe\'])


# In[108]:


data = np.random.randn(7,4)


# In[109]:


names


# In[110]:


data


# In[111]:


names == \'Bob\'


# In[112]:


data[names == \'Bob\']


# In[113]:


data[names == \'Bob\',2:]


# In[114]:


data[names == \'Bob\',3]


# In[115]:


names != \'Bob\'


# In[116]:


data[names != \'Bob\']


# In[117]:


mask = (names == \'Bob\')|(names == \'Will\') #python关键字and和or在布尔型数组中无效


# In[118]:


mask


# In[119]:


data[mask]


# In[120]:


data[data<0] = 0


# In[121]:


data


# In[122]:


data[names != \'Joe\'] = 7


# In[123]:


data


# In[124]:


arr = np.empty((8,4))


# In[125]:


for i in range(8):
    arr[i] = i


# In[126]:


arr


# In[127]:


arr[[4,3,0,6]]


# In[128]:


arr[[-3,-5,-7]]


# In[129]:


arr = np.arange(32).reshape((8,4))


# In[130]:


arr


# In[131]:


arr[[1,5,7,2],[0,3,1,2]] #结果竟然不是矩阵！！！！！


# In[132]:


arr[[1,5,7,2]][:,[0,3,1,2]] #结果为矩阵


# In[133]:


arr[np.ix_([1,5,7,2],[0,3,1,2])]  #使用函数np.ix_函数


# In[134]:


arr = np.arange(15).reshape((3,5))


# In[135]:


arr


# In[136]:


arr.T #转置


# In[137]:


arr = np.random.randn(6,3)


# In[138]:


np.dot(arr.T,arr)


# In[139]:


arr = np.arange(16).reshape((2,2,4))


# In[140]:


arr


# In[141]:


arr.transpose((1,0,2))  #转置，索引（0,1,2）按照（1,0,2）的顺序重新设置


# In[142]:


arr


# In[143]:


arr.swapaxes(1,2)  #y轴和z轴互换


# In[144]:


arr = np.arange(10)


# In[145]:


np.sqrt(arr)  #元素级函数，开方


# In[146]:


np.exp(arr) #指数e的arr次方


# In[147]:


x = np.random.randn(8)


# In[148]:


y = np.random.randn(8)


# In[149]:


x


# In[150]:


y


# In[151]:


np.maximum(x,y) #元素级最大值，相对位置一一比较取较大值


# In[152]:


arr= np.random.randn(7)*5


# In[153]:


arr


# In[154]:


np.modf(arr)  #小数部分和整数部分分离  ,符号均保留


# In[155]:


#一元函数


# In[156]:


np.abs(arr) #取绝对值


# In[157]:


np.fabs(arr) #取绝对值，对于非复数运算速度更快


# In[158]:


np.square(arr) #平方


# In[159]:


np.log(arr)


# In[160]:


np.log10(arr)


# In[161]:


np.log2(arr) 


# In[162]:


np.log1p(arr) #log(1+arr)


# In[163]:


np.sign(arr) #计算各元素的正负号


# In[164]:


np.ceil(arr) #计算各元素的大于等于该值的最小整数


# In[165]:


np.floor(arr) #计算各元素的小于等于该值的最大整数


# In[166]:


np.rint(arr) #将各元素四舍五入到最接近的整数


# In[167]:


np.isnan(arr) #返回一个哪些值是NAN的布尔型数组


# In[168]:


np.isfinite(arr) #返回一个哪些值是有穷的布尔型数组


# In[169]:


np.isinf(arr) #返回一个哪些值是无穷的布尔型数组


# In[170]:


np.cos(arr) #三角函数，其他还有cosh,sin,sinh,tan,tanh；；；；反三角函数：arccos,arccosh,arcsin,arcsinh,arctan,arctanh


# In[171]:


np.logical_not(arr) #计算各元素not x 的真值，非0即为真


# In[172]:


arr


# In[173]:


#二元函数--元素级


# In[174]:


arr1 = np.random.randn(5)


# In[175]:


arr2 = np.random.randn(5)


# In[176]:


arr1


# In[177]:


arr2


# In[178]:


np.add(arr1,arr2)


# In[179]:


np.subtract(arr1,arr2) # 从第一个数组中减去第二个数组中的元素


# In[180]:


np.multiply(arr1,arr2) #数组元素相乘


# In[181]:


np.divide(arr1,arr2) # 除法


# In[182]:


np.floor_divide(arr1,arr2) #除法，丢弃余数


# In[183]:


np.power(arr1,arr2) #arr1的arr2次方


# In[184]:


np.maximum(arr1,arr2)


# In[185]:


np.fmax(arr1,arr2) #同上，元素级最大值，忽略NaN


# In[186]:


np.minimum(arr1,arr2)


# In[187]:


np.fmin(arr1,arr2)


# In[188]:


np.mod(arr1,arr2) #除法的余数


# In[189]:


np.copysign(arr1,arr2) #将第二组的值的符号赋给第一组的值


# In[190]:


np.greater(arr1,arr2) #其他类似还有：greater_equal,less,less_equal,equal,not_equal


# In[191]:


np.logical_and(arr1,arr2) #其他类似还有：logical_or,logical_xor


# In[192]:


points = np.arange(-5,5,0.01) #1000个间隔相等的点


# In[193]:


xs,ys = np.meshgrid(points,points)


# In[194]:


ys


# In[195]:


xs


# In[196]:


import matplotlib.pyplot as plt  #引入绘图模块


# In[197]:


z = np.sqrt(xs**2+ys**2)


# In[198]:


z


# In[199]:


plt.imshow(z,cmap=plt.cm.gray)
plt.colorbar()


# In[200]:


plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")


# In[201]:


xarr = np.array([1.1,1.2,1.3,1.4,1.5])


# In[202]:


yarr = np.array([2.1,2.2,2.3,2.4,2.5])


# In[203]:


cond = np.array([True, False, True, True, False])


# In[204]:


result = [(x if c else y)
             for x,y,c in zip(xarr,yarr,cond)]


# In[205]:


result #处理速度慢，无法用于多维数组


# In[206]:


result = np.where(cond,xarr,yarr)


# In[207]:


result


# In[208]:


arr = np.random.randn(4,4)


# In[209]:


arr


# In[210]:


np.where(arr>0,2,-2) #将正值设置为2，负值设置为-2


# In[211]:


np.where(arr>0,2,arr) #只将正值设置为2


# In[212]:


arr = np.random.randn(5,4)


# In[213]:


arr


# In[214]:


arr.mean()  #数学和统计函数


# In[215]:


np.mean(arr)


# In[216]:


arr.sum()


# In[217]:


arr.mean(axis=1)


# In[218]:


arr.sum(0)


# In[219]:


arr = np.array([[0,1,2],[3,4,5],[6,7,8]])


# In[220]:


arr.cumsum(0)  #求累计和


# In[221]:


arr.cumprod(1) #求累计积


# In[222]:


arr.cumsum()


# In[223]:


arr.min(1)


# In[224]:


arr.max()


# In[225]:


arr.argmax() #最大值的索引


# In[226]:


arr.argmax(0)


# In[227]:


arr.std() #标准差


# In[228]:


arr.var() #方差


# In[229]:


arr = np.random.randn(100)


# In[230]:


(arr>0).sum() #正值的数量


# In[231]:


bools = np.array([False,False,True,False])


# In[232]:


bools.any() #测试数组中是否有一个或多个True


# In[233]:


bools.all() #检查数组中是否都是True


# In[234]:


arr = np.random.randn(8)


# In[235]:


arr


# In[236]:


arr.sort()  #改变原数组


# In[237]:


arr


# In[238]:


arr = np.random.randn(5,3)


# In[239]:


arr


# In[240]:


arr.sort(1) #在某轴向排序，改变原数组


# In[241]:


arr


# In[242]:


arr = np.random.randn(5,3)


# In[243]:


arr


# In[244]:


np.sort(arr,1)  #在某轴向排序，不改变原数组


# In[245]:


arr


# In[246]:


large_arr = np.random.randn(1000)


# In[247]:


large_arr.sort()


# In[248]:


large_arr[int(0.05*len(large_arr))] #5%分位数


# In[249]:


names = np.array([\'Bob\',\'Joe\',\'Will\',\'Bob\',\'Will\',\'Joe\',\'Joe\'])


# In[250]:


np.unique(names) #找出唯一值并排序


# In[251]:


ints = np.array([3,3,3,2,2,1,1,4,4])


# In[252]:


np.unique(ints)


# In[253]:


set(ints)


# In[254]:


values = np.array([6,0,0,3,2,5,6])


# In[255]:


np.in1d(values,[2,3,6]) #测试一个数组中的值在另一个数组中是否存在


# In[256]:


np.intersect1d(values,[2,3,4]) #求交集


# In[257]:


np.union1d(values,[2,3,4]) # 求并集


# In[258]:


np.setdiff1d(values,[2,3,4]) #在前面数组不在后面数组


# In[259]:


np.setxor1d(values,[2,3,4])#存在于一个数组但不同时存在于两个数组


# In[260]:


arr = np.arange(10)


# In[261]:


np.save(\'some_array\',arr)


# In[262]:


arr = arr+1


# In[263]:


arr


# In[264]:


np.load(\'some_array.npy\')


# In[265]:


np.savez(\'array_archive.npz\',a=arr,b=arr)


# In[266]:


arch = np.load(\'array_archive.npz\')


# In[267]:


arch[\'b\']


# In[268]:


get_ipython().system(\'type "C:\\Users\\admin\\Desktop\\array_ex.txt"\')


# In[269]:


#arrs = np.loadtxt(\'C:\Users\admin\Desktop\array_ex.txt\',delimiter=\',\') 出错了


# In[270]:


x = np.array([[1,2,3],[4,5,6]])


# In[271]:


y = np.array([[6,23],[-1,7],[8,9]])


# In[272]:


x


# In[273]:


y


# In[274]:


x.dot(y)#相当于np.dot(x,y)


# In[275]:


np.dot(x,np.ones(3))


# In[276]:


from numpy.linalg import inv,qr


# In[277]:


X = np.random.randn(5,5)


# In[278]:


mat = X.T.dot(X)


# In[279]:


inv(mat) #求逆


# In[280]:


mat.dot(inv(mat))


# In[281]:


q,r = qr(mat) #计算QR分解


# In[282]:


r


# In[283]:


#常用的numpy.linalg函数：det:计算矩阵行列式；eig：计算方阵的本征值和本征向量；solve：解线性方程组;lstsq:最小二乘解


# In[284]:


x = np.arange(9).reshape(3,3)


# In[285]:


x


# In[286]:


y = np.diag(x) #diag函数：返回方阵的对角线元素，或将一维数组转换为方阵


# In[287]:


y


# In[288]:


y = np.diag(y)


# In[289]:


y


# In[290]:


y = np.trace(x) #trace函数：计算对角线元素的和


# In[291]:


y


# In[292]:


#随机数生成


# In[296]:


a = np.random.permutation(np.arange(5)) #permutation返回一个序列的随机排列


# In[297]:


a


# In[299]:


np.random.randint(0,10) #在给定上下限内随机选取整数


# In[300]:


#模拟随机漫步


# In[301]:


nsteps = 1000


# In[308]:


draws = np.random.randint(0,2,size=nsteps)


# In[309]:


steps = np.where(draws > 0,1,-1)


# In[310]:


walk = steps.cumsum()


# In[311]:


walk.min()


# In[312]:


walk.max()


# In[314]:


(np.abs(walk) >= 10).argmax() #argmax第一个最大值的索引，由于整个布尔型数组中只有0,1两个数，1即为最大值


# In[315]:


#一次模拟多个随机漫步：5000个


# In[316]:


nwalks = 5000


# In[317]:


nsteps = 1000


# In[318]:


draws = np.random.randint(0,2,size=(nwalks,nsteps))


# In[319]:


steps = np.where(draws > 0,1,-1)


# In[322]:


walks = steps.cumsum(1)


# In[323]:


walks


# In[324]:


walks.max()


# In[325]:


walks.min()


# In[326]:


hits30 = (np.abs(walks) >= 30).any(1)


# In[327]:


hits30


# In[328]:


hits30.sum()


# In[329]:


crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)


# In[331]:


crossing_times.mean()