Python数据分析（1）Numpy库使用方法

刺骨的言语ヽ痛彻心扉 2022-05-22 19:58 294阅读 0赞

Numpy是一个开源的Python科学计算库，它是python科学计算库的基础库，许多其他著名的科学计算库如Pandas，Scikit-learn等都要用到Numpy库的一些功能。

Numpy数组通常是由相同种类的元素组成的，即数组中的数据项的类型一致。这样有一个好处，由于知道数组元素的类型相同，所以能快速确定存储数据所需空间的大小。Numpy数组能够运用向量化运算来处理整个数组，速度较快；而Python的列表则通常需要借助循环语句遍历列表，运行效率相对来说要差。Numpy使用了优化过的C API，运算速度较快

#coding=gbk
    #numpy数组的大小是固定的
    import numpy as np  #导入包
    from matplotlib.pyplot import axis
    a=np.array([1,2,3])
    print(a)    #输出：[1 2 3]
    print('分割线------')
    #array（）参数可以是单层或多层列表
    b=np.array([[1.2,3.4],[2.6,4.5]])
    print(b)    #shuhcu :[[1.2 3.4]
                 #           [2.6 4.5]]
    print(b.ndim)   #2,表示数组的维度
    print(b.size)   # 4，表示数据的个数
    print(b.shape)  # (2, 2)
    #array（）参数可以是单层或多层元组，结果与参数是列表是一样的
    c=np.array(((1,2,3),(4,5,6)))
    print(c)    
    # #输出：
    # [[1 2 3]
    #  [4 5 6]]

numpy数据类型：

![20180607163005285][]

#numpy数据类型
    #使用dtype定义数据类型
    f=np.array([[1,2],[3,4]],dtype=complex)
    print(f)
    # [[1.+0.j 2.+0.j]    输出类型为复数形式
    #  [3.+0.j 4.+0.j]]

#创建数组的函数
    g=np.zeros((3,3))   #创建3行3列的数组
    print(np.ones((3,3)))
    print(np.arange(0,12).reshape(3,4))
    # [[ 0  1  2  3]
    #  [ 4  5  6  7]
    #  [ 8  9 10 11]]
    print(np.linspace(1,15,5))
    #[ 1.   4.5  8.  11.5 15. ]    将其分成5份
    print(np.random.random((3,3)))
    # [[0.68333882 0.64261184 0.31273476]    生成3行3列的随机数
    #  [0.34138222 0.62380152 0.24387784]
    #  [0.70731665 0.5085779  0.26858421]]

### 数组创建函数： ###

import numpy as np
    print('---')
    print(np.empty((2,4)).ndim)
    print(np.zeros((2,4)).dtype)
    d = [1,2,3,4]
    d1 = np.asarray(d)  #将其转换成 ndarray 对象
    print(d1.dtype)
    print(d1)   # [1 2 3 4]
    print(np.ones_like(d1)) # [1 1 1 1]
    #创建对角线为1 ， 其余数为0的方阵
    print(np.eye(3,3))
    # [[1. 0. 0.]
    #  [0. 1. 0.]
    #  [0. 0. 1.]]
    print(np.identity(3,dtype='float64'))
    # [[1. 0. 0.]
    #  [0. 1. 0.]
    #  [0. 0. 1.]]

![70][]

#基本运算
    A=np.arange(0,9).reshape((3,3))
    B=np.arange(10,19).reshape((3,3))
    print(A+B)
    # [[10 12 14]    numpy中的数组运算都是元素级，即将一个数组看做一个整体
    #  [16 18 20]
    #  [22 24 26]]
    print(A*B)
    # [[  0  11  24]
    #  [ 39  56  75]
    #  [ 96 119 144]]
    #矩阵乘积
    print(np.dot(A,B))
    # [[ 45  48  51]
    #  [162 174 186]
    #  [279 300 321]]    表示A矩阵和B矩阵相乘
    #自减自加
    A+=1
    B-=1
    print(A)
    # [[1 2 3]        A全部元素自加 1
    #  [4 5 6]
    #  [7 8 9]]
    print(B)
    #聚合函数：对一个数组计算，返回一个单一值得函数
    print(np.mean(B))   #得到一个平均值
    print(np.median(B))
    print(np.var(B))    #得到方差  6.666666666666667
    print(np.sqrt(np.var(B)))
    print(np.std(B)) #得到标准方差 2.581988897471611
    #索引
    print(A[1,2]) #形式如： A[ ] ,查找第2行第3列的数据
    #切片
    print(A[0,:])   #抽取第一行    [1 2 3]
    print(A[:,0])
    print(A[0:2,0:2])#抽取 前2行前2列
    #数组迭代
    for items in A.flat:
        print(items)    #遍历A数组中每个元素
    a1=np.apply_along_axis(np.mean, axis=1, arr=A)
    print(a1)   #[2. 5. 8.] ,    axis=1 求得每行的平均数 ，axis=0时，求得每列的平均数
    
    def add(x):
        return x+12
    a2=np.apply_along_axis(add, axis=1, arr=A)
    print(a2)
    #布尔操作
    print(A>5)
    # [[False False False]        获得bool形式的数组
    #  [False False  True]
    #  [ True  True  True]]
    print(A[A>5])   #获得大于5的新的数组    [6 7 8 9]
    
    A1=np.array(np.random.random((3,4)))
    print(A1)
    print(A1.ravel())   #使数组转换成一维数组
    print(A1.transpose())   #交换行列的顺序

### 花式索引(Fancy Indexing)： ###

花式索引与切片不同，它总是将数据复制到新数组中。

arr = np.empty((8,4))
    for i in range(8):
        arr[i] = i 
    print(arr)
    # [[0. 0. 0. 0.]
    #  [1. 1. 1. 1.]
    #  [2. 2. 2. 2.]
    #  [3. 3. 3. 3.]
    #  [4. 4. 4. 4.]
    #  [5. 5. 5. 5.]
    #  [6. 6. 6. 6.]
    #  [7. 7. 7. 7.]]
    print(arr[[6,2,3,1]])
    # [[6. 6. 6. 6.]
    #  [2. 2. 2. 2.]
    #  [3. 3. 3. 3.]
    #  [1. 1. 1. 1.]]
    arr1 = np.arange(32).reshape((8,4))
    print(arr1)
    # [[ 0  1  2  3]
    #  [ 4  5  6  7]
    #  [ 8  9 10 11]
    #  [12 13 14 15]
    #  [16 17 18 19]
    #  [20 21 22 23]
    #  [24 25 26 27]
    #  [28 29 30 31]]
    print(arr1[[1,5,7,2],[0,3,1,2]]) # 选取的数是(1,0),(5,3)..4个
    # [ 4 23 29 10]
    print(arr1[[1,5,7,2]][:,[0,3,1,2]]) # 第一个中括号和第三个中括号是隔离的，先花式索引，在进行索引
    # [[ 4  7  5  6]
    #  [20 23 21 22]
    #  [28 31 29 30]
    #  [ 8 11  9 10]]
    print(arr1[np.ix_([1,5,7,2],[0,3,1,2])])    #使用np.ix_ 函数
    # [[ 4  7  5  6]
    #  [20 23 21 22]
    #  [28 31 29 30]
    #  [ 8 11  9 10]]

#数组操作
    #1数组连接
    c=np.ones((3,3))
    b=np.zeros((3,3))
    print(np.vstack((c,b))) #垂直入栈操作，即在c的下面增加
    # [[1. 1. 1.]
    #  [1. 1. 1.]
    #  [1. 1. 1.]
    #  [0. 0. 0.]
    #  [0. 0. 0.]
    #  [0. 0. 0.]]
    print(np.hstack((c,b))) #水平入栈，在右边入栈
    # [[1. 1. 1. 0. 0. 0.]
    #  [1. 1. 1. 0. 0. 0.]
    #  [1. 1. 1. 0. 0. 0.]]
    #2数组切分
    b1=np.arange(16).reshape(4,4)
    print(b1)
    # [[ 0  1  2  3]
    #  [ 4  5  6  7]
    #  [ 8  9 10 11]
    #  [12 13 14 15]]
    [b2,b3]=np.hsplit(b1,2)     #水平切分，按照数组的宽度切分
    print(b2)
    # [[ 0  1]
    #  [ 4  5]
    #  [ 8  9]
    #  [12 13]]
    [b7,b8]=np.vsplit(b1,2)     #垂直切分，按照数组的高度切分
    print(b7)
    # [[0 1 2 3]
    #  [4 5 6 7]]
    [b4,b5,b6]=np.split(b1,[1,3],axis=1)   #将b1数组分为3组 
    print(b4)
    # [[ 0]    输出最后一列
    #  [ 4]
    #  [ 8]
    #  [12]]

### 线性代数： ###

> 需要导入需要的包： from numpy.linalg import inv, qr, svd 等等

from numpy.linalg import inv, qr
    np.random.seed(666)
    X = np.random.randn(5,5)
    mat = X.T.dot(X)
    print(mat)
    # [[ 4.35987122 -1.15558512  1.44432912 -0.49270722 -1.01438036]
    #  [-1.15558512  2.99638693  0.4955742   3.68729962 -0.09641802]
    #  [ 1.44432912  0.4955742   3.63299369  0.94672747 -0.29892057]
    #  [-0.49270722  3.68729962  0.94672747  5.33934661 -1.02307693]
    #  [-1.01438036 -0.09641802 -0.29892057 -1.02307693  1.12499434]]
    print(inv(mat)) # 求 mat 的逆
    # [[  0.42242116   0.48534444  -0.15895398  -0.23633069   0.16532758]
    #  [  0.48534444  21.66659836   0.31320917 -17.58148752 -13.61092649]
    #  [ -0.15895398   0.31320917   0.3612934   -0.36203949  -0.34972354]
    #  [ -0.23633069 -17.58148752  -0.36203949  14.56048181  11.42527577]
    #  [  0.16532758 -13.61092649  -0.34972354  11.42527577  10.16872937]]
    print(mat.dot(inv(mat)).astype(np.uint16))
    # [[1 0 0 0 0]
    #  [0 1 0 0 0]
    #  [0 0 1 0 0]
    #  [0 0 0 1 0]
    #  [0 0 0 0 1]]
    q, r = qr(mat)  #计算QR 分解
    print(r)
    # [[-4.86843595  1.95215977 -2.22009885  1.36279661  1.1050742 ]
    #  [ 0.         -4.51152441 -2.09906469 -6.47522425  1.1754303 ]
    #  [ 0.          0.         -2.67974971  0.24274374 -0.37949861]
    #  [ 0.          0.          0.         -0.66773665  0.83107575]
    #  [ 0.          0.          0.          0.          0.04883298]]

![70 1][]

#广播机制
    f1=np.arange(4)
    f2=np.arange(16).reshape(4,4)
    print(f1+f2)
    # [[ 0  2  4  6]    
    #  [ 4  6  8 10]
    #  [ 8 10 12 14]
    #  [12 14 16 18]]

numpy库中随机函数中的permutation() ,和 shuffle() 函数的对比：

np.random.permutation(), 可以设置测试集和验证集

import numpy as np
    arr=np.arange(16).reshape(4,4)
    print(arr)
    # [[ 0  1  2  3]
    #  [ 4  5  6  7]
    #  [ 8  9 10 11]
    #  [12 13 14 15]]
    arr1=np.random.permutation(arr) #将行的索引值打乱

#permutation不直接在原来的数组上进行作，   
    #而是返回一个新的打乱顺序的数组，并不改变原来的数组。
    print(arr1)
    # [[12 13 14 15]
    # [ 0 1 2 3]
    # [ 8 9 10 11]
    # [ 4 5 6 7]]
    
    np.random.shuffle(arr) 
    #将行的索引值打乱 #shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值
    print(arr)
    # [[ 8 9 10 11]
    # [ 4 5 6 7]
    # [ 0 1 2 3]
    # [12 13 14 15]]

![70 2][]

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

![1240][]

[20180607163005285]: /images/20220523/5547e2510a81426293cc40425f4a82d9.png
[70]: /images/20220523/623ba2b9db8b4cdeb4c5205c40bd82cc.png
[70 1]: /images/20220523/2e125b54f6104e7bab57b95327681b38.png
[70 2]: /images/20220523/380e406c700d4597a6996e9ee5e2793c.png
[1240]: /images/20220523/c43da38b3d454d9a9c85a4064ff90589.png