Python数据分析--numpy总结

傷城~ 2022-10-23 14:27 287阅读 0赞

# Python数据分析–numpy总结 #

> NumPy常用方法总结  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTc2NTQ4_size_16_color_FFFFFF_t_70]

### 文章目录 ###

*  Python数据分析--numpy总结
 *  生成ndarray的几种方式
 *   *  从已有数据中创建
     *  利用random模块生成ndarray
     *  创建特定形状的多维数组
     *  利用arange函数
 *  存取元素
 *  矩阵操作
 *  数据合并与展平
 *   *  合并一维数组
     *  多维数组的合并
     *  矩阵展平
 *  通用函数
 *   *  使用math与numpy函数性能比较：
     *  使用循环与向量运算比较：
 *  广播机制

# 生成ndarray的几种方式 #

## 从已有数据中创建 ##

import numpy as np
    list1 = [3.14,2.17,0,1,2]
    nd1 = np.array(list1)
    print(nd1)
    print(type(nd1))

[3.14 2.17 0.   1.   2.  ]
    <class 'numpy.ndarray'>

list2 = [[3.14,2.17,0,1,2],[1,2,3,4,5]]
    nd2 = np.array(list2)
    print(nd2)
    print(type(nd2))

[[3.14 2.17 0.   1.   2.  ]
     [1.   2.   3.   4.   5.  ]]
    <class 'numpy.ndarray'>

## 利用random模块生成ndarray ##

import numpy as np
    
    nd5 = np.random.random([3,3])
    print(nd5)
    print(type(nd5))

[[0.31192569 0.3022696  0.48253531]
     [0.38008201 0.59103878 0.98225759]
     [0.54242215 0.14208123 0.59577163]]
    <class 'numpy.ndarray'>

import numpy as np
    
    np.random.seed(123)
    nd5_1 = np.random.randn(2,3)
    print(nd5_1)
    np.random.shuffle(nd5_1)
    print("随机打乱后数据")
    print(nd5_1)
    print(type(nd5_1))

[[-1.0856306   0.99734545  0.2829785 ]
     [-1.50629471 -0.57860025  1.65143654]]
    随机打乱后数据
    [[-1.50629471 -0.57860025  1.65143654]
     [-1.0856306   0.99734545  0.2829785 ]]
    <class 'numpy.ndarray'>

## 创建特定形状的多维数组 ##

import numpy as np
    
    #生成全是0的3x3矩阵
    nd6 = np.zeros([3,3])
    #生成全是1的3x3矩阵
    nd7 = np.ones([3,3])
    #生成3阶的单位矩阵
    nd8= np.eye(3)
    #生成3阶对角矩阵
    print (np.diag([1, 2, 3]))

[[1 0 0]
     [0 2 0]
     [0 0 3]]

import numpy as np
    nd9 = np.random.random([5,5])
    np.savetxt(X=nd9,fname='./test2.txt')
    nd10 = np.loadtxt('./test2.txt')

## 利用arange函数 ##

import numpy as np
    
    print(np.arange(10))
    print(np.arange(0,10))
    print(np.arange(1, 4,0.5))
    print(np.arange(9, -1, -1))

[0 1 2 3 4 5 6 7 8 9]
    [0 1 2 3 4 5 6 7 8 9]
    [1.  1.5 2.  2.5 3.  3.5]
    [9 8 7 6 5 4 3 2 1 0]

# 存取元素 #

import numpy as np
    np.random.seed(2018)
    nd11 = np.random.random([10])
    #获取指定位置的数据，获取第4个元素
    nd11[3]
    #截取一段数据
    nd11[3:6]
    #截取固定间隔数据
    nd11[1:6:2]
    #倒序取数
    nd11[::-2]
    #截取一个多维数组的一个区域内数据
    nd12=np.arange(25).reshape([5,5])
    nd12[1:3,1:3]
    #截取一个多维数组中，数值在一个值域之内的数据
    nd12[(nd12>3)&(nd12<10)]
    #截取多维数组中，指定的行,如读取第2,3行
    nd12[[1,2]]  #或nd12[1:3,:]
    ##截取多维数组中，指定的列,如读取第2,3列
    nd12[:,1:3]

array([[ 1,  2],
           [ 6,  7],
           [11, 12],
           [16, 17],
           [21, 22]])

> 获取数组中的部分元素除通过指定索引标签外，还可以使用一些函数来实现，如通过random.choice函数可以从指定的样本中进行随机抽取数据。

import numpy as np
    from numpy import random as nr
    
    a=np.arange(1,25,dtype=float)
    c1=nr.choice(a,size=(3,4))  #size指定输出数组形状
    c2=nr.choice(a,size=(3,4),replace=False)  #replace缺省为True，即可重复抽取。
    #下式中参数p指定每个元素对应的抽取概率，缺省为每个元素被抽取的概率相同。
    c3=nr.choice(a,size=(3,4),p=a / np.sum(a))
    print("随机可重复抽取")
    print(c1)
    print("随机但不重复抽取")
    print(c2)
    print("随机但按制度概率抽取")
    print(c3)

随机可重复抽取
    [[18.  1.  7. 14.]
     [22. 23. 24.  1.]
     [24.  9.  8. 10.]]
    随机但不重复抽取
    [[ 3. 20.  4. 10.]
     [13. 22.  5. 17.]
     [ 8. 15. 24.  2.]]
    随机但按制度概率抽取
    [[20.  5. 12. 18.]
     [18. 15.  7. 14.]
     [23. 21. 24. 18.]]

# 矩阵操作 #

import numpy as np
    
    nd14=np.arange(9).reshape([3,3])
    
    #矩阵转置
    np.transpose(nd14)
    
    #矩阵乘法运算
    a=np.arange(12).reshape([3,4])
    b=np.arange(8).reshape([4,2])
    a.dot(b)
    
    #求矩阵的迹
    a.trace()
    #计算矩阵行列式
    np.linalg.det(nd14)
    
    #计算逆矩阵
    c=np.random.random([3,3])
    np.linalg.solve(c,np.eye(3))

array([[ 0.38142768, -5.29433928,  6.34332256],
           [ 1.76114014,  1.09115706, -4.37965093],
           [-0.61650199,  4.92267848, -3.55057072]])

# 数据合并与展平 #

## 合并一维数组 ##

import numpy as np
    a=np.array([1,2,3])
    b=np.array([4,5,6])
    c=np.append(a,b)
    print(c)
    #或利用concatenate
    d=np.concatenate([a,b])
    print(d)

[1 2 3 4 5 6]
    [1 2 3 4 5 6]

## 多维数组的合并 ##

import numpy as np
    a=np.arange(4).reshape(2,2)
    b=np.arange(4).reshape(2,2)
    #按行合并
    c=np.append(a,b,axis=0)
    print(c)
    print("合并后数据维度",c.shape)
    #按列合并
    d=np.append(a,b,axis=1)
    print("按列合并结果:")
    print(d)
    print("合并后数据维度",d.shape)

[[0 1]
     [2 3]
     [0 1]
     [2 3]]
    合并后数据维度 (4, 2)
    按列合并结果:
    [[0 1 0 1]
     [2 3 2 3]]
    合并后数据维度 (2, 4)

## 矩阵展平 ##

import numpy as np
    nd15=np.arange(6).reshape(2,-1)
    print(nd15)
    #按照列优先，展平。
    print("按列优先,展平")
    print(nd15.ravel('F'))
    #按照行优先，展平。
    print("按行优先,展平")
    print(nd15.ravel())

[[0 1 2]
     [3 4 5]]
    按列优先,展平
    [0 3 1 4 2 5]
    按行优先,展平
    [0 1 2 3 4 5]

# 通用函数 #

## 使用math与numpy函数性能比较： ##

import time
    import math
    import numpy as np
    
    x = [i * 0.001 for i in np.arange(1000000)]
    start = time.clock()
    for i, t in enumerate(x):
        x[i] = math.sin(t)
    print ("math.sin:", time.clock() - start )
    
    x = [i * 0.001 for i in np.arange(1000000)]
    x = np.array(x)
    start = time.clock()
    np.sin(x)
    print ("numpy.sin:", time.clock() - start )

## 使用循环与向量运算比较： ##

import time
    import numpy as np
    
    x1 = np.random.rand(1000000)
    x2 = np.random.rand(1000000)
    ##使用循环计算向量点积
    tic = time.process_time()
    dot = 0
    for i in range(len(x1)):
        dot+= x1[i]*x2[i]
    toc = time.process_time()
    print ("dot = " + str(dot) + "\n for loop----- Computation time = " + str(1000*(toc - tic)) + "ms")
    ##使用numpy函数求点积
    tic = time.process_time()
    dot = 0
    dot = np.dot(x1,x2)
    toc = time.process_time()
    print ("dot = " + str(dot) + "\n verctor version---- Computation time = " + str(1000*(toc - tic)) + "ms")

# 广播机制 #

import numpy as np
    a=np.arange(10)
    b=np.arange(10)
    #两个shape相同的数组相加
    print(a+b)
    #一个数组与标量相加
    print(a+3)
    #两个向量相乘
    print(a*b)
    
    #多维数组之间的运算
    c=np.arange(10).reshape([5,2])
    d=np.arange(2).reshape([1,2])
    #首先将d数组进行复制扩充为[5,2],如何复制请参考图1-2，然后相加。
    print(c+d)

[ 0  2  4  6  8 10 12 14 16 18]
    [ 3  4  5  6  7  8  9 10 11 12]
    [ 0  1  4  9 16 25 36 49 64 81]
    [[ 0  2]
     [ 2  4]
     [ 4  6]
     [ 6  8]
     [ 8 10]]

--------------------

> 到这里就结束了，如果对你有帮助，欢迎点赞关注，你的点赞对我很重要

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTc2NTQ4_size_16_color_FFFFFF_t_70]: /images/20221023/73603d26d9694c8d950546a4d0139505.png