• 利用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:UsersadminDesktoparray_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()
  • 相关阅读:
    android 基础项目及开发出现:error opening trace file: No such file or directory错误解决
    Android开发遇到的问题
    Don‘t talk.Just do it.
    LeetCode——Word Break
    晋IT分享成长沙龙集锦
    logback 简单配置总述
    HDU 2119 Matrix 简单二分匹配
    华为招聘机试整理5:简单四则运算
    JSP简单练习-猜字母游戏
    Codechef July Challenge 2014部分题解
  • 原文地址:https://www.cnblogs.com/xiyouzhi/p/9600730.html
Copyright © 2020-2023  润新知