利用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',''],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()