科学计算工具-Numpy初探

叁歲伎倆 2022-05-30 03:57 160阅读 0赞

## Numpy基础数据结构 ##

Numpy数组是一个多维数组，称为ndarray。其由两部分组成：

*  实际的数据
 *  描述这些数据的原数据

导入该库：

import numpy as np

### 多维数组ndarray ###

数组的基本属性

*  数组的维数称为秩（rank），一维数组的秩为1，二维数组的秩为2，以此类推
 *  在NumPy中，每一个线性的数组称为是一个轴（axes），秩其实是描述轴的数量

ar = np.array([1,2,3,4,5,6,7])
    print(ar)          # 输出数组，注意数组的格式：中括号，元素之间没有逗号（和列表区分）
    print(ar.ndim)     # 输出数组维度的个数（轴数），或者说“秩”，维度的数量也称rank
    print(ar.shape)    # 数组的维度，对于n行m列的数组，shape为（n，m）
    print(ar.size)     # 数组的元素总数，对于n行m列的数组，元素总数为n*m
    print(ar.dtype)    # 数组中元素的类型，类似type()（注意了，type()是函数，.dtype是方法）
    print(ar.itemsize) # 数组中每个元素的字节大小，int32l类型字节为4，float64的字节为8
    print(ar.data)     # 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

Out:

[1 2 3 4 5 6 7]
    1
    (7,)
    7
    int64
    8
    <memory at 0x106549d08>

### 创建数组 ###

*  array()函数括号内是列表，元组，数组和生成器等

ar1 = np.array(range(10))   # 整型
    ar2 = np.array([1,2,3.14,4,5])   # 浮点型
    ar3 = np.array([[1,2,3],('a','b','c')])   # 二维数组：嵌套序列（列表，元组均可）
    ar4 = np.array([[1,2,3],('a','b','c','d')])  
    print(ar1,type(ar1),ar1.dtype)
    print(ar2,type(ar2),ar2.dtype)
    print(ar3,ar3.shape,ar3.ndim,ar3.size)     # 二维数组，共6个元素
    print(ar4,ar4.shape,ar4.ndim,ar4.size)     # 一维数组，共2个元素

Out:

[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'> int64
    [1.   2.   3.14 4.   5.  ] <class 'numpy.ndarray'> float64
    [['1' '2' '3']
    ['a' 'b' 'c']] (2, 3) 2 6
    [list([1, 2, 3]) ('a', 'b', 'c', 'd')] (2,) 1 2

*  arange(),与python的range()类似，在给定间隔内返回均匀间隔的值

print(np.arange(10))    # 返回0-9，整型
    print(np.arange(10.0))  # 返回0.0-9.0，浮点型
    print(np.arange(5,12))  # 返回5-11
    print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
    print(np.arange(10000))  # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角

Out:

[0 1 2 3 4 5 6 7 8 9]
    [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
    [ 5  6  7  8  9 10 11]
    [ 5.  7.  9. 11.]
    [0    1    2 ... 9997 9998 9999]

*  linspace():返回在间隔\[开始，停止\]上计算的num个均匀间隔的样本

umpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

1.  *start*：| 起始值，stop：结束值
2.  *num*：生成样本数，默认为50
3.  *endpoint*：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。
4.  *retstep*：如果为真，返回（样本，步骤），其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值

ar1 = np.linspace(2.0, 3.0, num=5)
    ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
    ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
    print(ar1,type(ar1))
    print(ar2)
    print(ar3,type(ar3))

Out:

[2.   2.25 2.5  2.75 3.  ] <class 'numpy.ndarray'>
    [2.  2.2 2.4 2.6 2.8]
    (array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25) <class 'tuple'>

*  zeros()/zeros\_like()/ones()/ones\_like()

numpy.zeros(shape, dtype=float, order='C')

返回给定形状和类型的新数组，用零填充。  
\- shape：数组纬度，二维以上需要用()，且输入参数为整数  
\- dtype：数据类型，默认numpy.float64  
\- order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据

ar1 = np.zeros(5)  
    ar2 = np.zeros((2,2), dtype = np.int)
    print(ar1,ar1.dtype)
    print(ar2,ar2.dtype)
    print('------')
    
    # 返回具有与给定数组相同的形状和类型的零数组，这里ar4根据ar3的形状和dtype创建一个全0的数组
    ar3 = np.array([list(range(5)),list(range(5,10))])
    ar4 = np.zeros_like(ar3)
    print(ar3)
    print(ar4)
    
    ar5 = np.ones(9)
    ar6 = np.ones((2,3,4))
    ar7 = np.ones_like(ar3)

Out:

[ 0.  0.  0.  0.  0.] float64
    [[0 0]
    [0 0]] int32
    ------
    [[0 1 2 3 4]
    [5 6 7 8 9]]
    [[0 0 0 0 0]
    [0 0 0 0 0]]

*  eye() 创建一个正方的N\*N的单位矩阵，对角线值为1，其余为0

print(np.eye(5))

Out:

[[ 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.]]

### Numpy通用函数 ###

#### 数组形状 .T/.reshape()/.resize() ####

*  .T方法：转置，如原shape为(3,4)，转置结果为(4,3) 。一维数组转置后结果不变

ar1 = np.ones((5,2))
    print(ar1,'\n',ar1.T)

Out:

[[1. 1.]
     [1. 1.]
     [1. 1.]
     [1. 1.]
     [1. 1.]] 
     [[1. 1. 1. 1. 1.]
     [1. 1. 1. 1. 1.]]

*  numpy.reshape(a, newshape, order=’C’)：为数组提供新形状，不更改其数据，元素数量一致

ar2 = np.arange(10).reshape(2,5)     # 用法1：直接将已有数组改变形状             
    ar3 = np.zeros((4,6)).reshape(3,8)   # 用法2：生成数组后直接改变形状
    ar4 = np.reshape(np.arange(12),(3,4))   # 用法3：参数内添加数组，目标形状
    print(ar2)
    print(ar3)
    print(ar4)

Out:

[0 1 2 3 4]
    [5 6 7 8 9]]
    [[0. 0. 0. 0. 0. 0. 0. 0.]
     [0. 0. 0. 0. 0. 0. 0. 0.]
     [0. 0. 0. 0. 0. 0. 0. 0.]]
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]

*  numpy.resize(a, new\_shape)：返回具有指定形状的新数组，如有必要可重复填充所需数量的元素

ar6 = np.resize(np.arange(5),(3,4))
    print(ar6)

Out:

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

**注意：**.T/.reshape()/.resize()都是生成新的数组

#### 数组的复制 ####

复制后，ar1和ar2指向内存中的同一个值（python中赋值逻辑）

ar1 = np.arange(10)
    ar2 = ar1
    print(ar2 is ar1)
    ar1[2] = 9
    print(ar1,ar2)

Out:

True
    [0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]

copy()方法生成数组及其数据的完整拷贝

ar3 = ar1.copy()
    print(ar3 is ar1)
    ar1[0] = 9
    print(ar1,ar3)

Out:

False
    [9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]

#### 数组类型转换 ####

a.astype()：转换数组类型,数组类型用np.int32，而不是直接int32

ar1 = np.arange(10,dtype=float)# 可以在参数位置设置数组类型
    ar2 = ar1.astype(np.int32)
    print(ar2,ar2.dtype)
    print(ar1,ar1.dtype)

Out:

[0 1 2 3 4 5 6 7 8 9] int32
    [ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.] float64

#### 数组拆分 ####

*  numpy.hsplit(ary, indices\_or\_sections)：将数组水平（逐列）拆分为多个子数组(按列拆分)
 *  numpy.vsplit(ary, indices\_or\_sections)：:将数组垂直（行方向）拆分为多个子数组 (按行拆分)

ar = np.arange(16).reshape(4,4)
    ar1 = np.hsplit(ar,2)
    print(ar)
    print(ar1,type(ar1)) # 输出结果为列表，列表中元素为数组
    
    ar2 = np.vsplit(ar,4)
    print(ar2,type(ar2))

Out:

[[ 0  1  2  3]
    [ 4  5  6  7]
    [ 8  9 10 11]
    [12 13 14 15]]
    [array([[ 0,  1],
           [ 4,  5],
           [ 8,  9],
           [12, 13]]), array([[ 2,  3],
           [ 6,  7],
           [10, 11],
           [14, 15]])] <class 'list'>
    [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])] <class 'list'>

#### 数组简单运算 ####

ar = np.arange(6).reshape(2,3)
    print(ar + 10)   # 加法
    print(ar * 2)   # 乘法
    print(1 / (ar+1))  # 除法
    print(ar ** 0.5)  # 幂
    # 与标量的运算
    
    print(ar.mean())  # 求平均值
    print(ar.max())  # 求最大值
    print(ar.min())  # 求最小值
    print(ar.std())  # 求标准差
    print(ar.var())  # 求方差
    print(ar.sum(), np.sum(ar,axis = 0))  # 求和，np.sum() axis为0，按列求和；axis为1，按行求和
    print(np.sort(np.array([1,4,3,2,5,6])))  # 排序

Out:

[[10 11 12]
     [13 14 15]]
    [[ 0  2  4]
     [ 6  8 10]]
    [[1.         0.5        0.33333333]
     [0.25       0.2        0.16666667]]
    [[0.         1.         1.41421356]
     [1.73205081 2.         2.23606798]]
    2.5
    5
    0
    1.707825127659933
    2.9166666666666665
    15 [3 5 7]
    [1 2 3 4 5 6]

### Numpy索引及切片 ###

#### 基本索引及切片 ####

*  一维数组索引及切片

ar = np.arange(10)
    print(ar)
    print(ar[4])
    print(ar[3:6])

Out:

[0 1 2 3 4 5 6 7 8 9]
    4
    [3 4 5]

*  二维数组索引及切片

ar = np.arange(16).reshape(4,4)
    print(ar, '轴数%i' %ar.ndim)   # 4*4的数组
    print(ar[2], '轴数%i' %ar[2].ndim)  # 切片为下一维度的一个元素，所以是一维数组
    print(ar[2][1]) # 二次索引，得到一维数组中的一个值
    print(ar[1:3],  '轴数为%i' %ar[1:3].ndim)  # 切片为两个一维数组组成的二维数组
    print(ar[2,2])  # 切片数组中的第三行第三列 
    print(ar[:2,1:])  # 切片数组中的1,2行、2,3,4列

Out:

[[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]] 轴数2
    [ 8  9 10 11] 轴数1
    9
    [[ 4  5  6  7]
    [ 8  9 10 11]] 轴数为2
    10
    [[1 2 3]
    [5 6 7]]

#### 布尔型索引及切片 ####

布尔型索引：以布尔型的矩阵去做筛选

ar = np.arange(12).reshape(3,4)
    i = np.array([True,False,True])
    j = np.array([True,True,False,False])
    print(ar)
    print(i)
    print(j)
    print(ar[i,:])  # 在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:]=ar[i]
    print(ar[:,j])  # 在第二维度做判断
    
    m = ar > 5
    print(m)  # 这里m是一个判断矩阵
    print(ar[m])  # 用m判断矩阵去筛选ar数组中>5的元素

Out:

[[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    [ True False  True]
    [ True  True False False]
    [[ 0  1  2  3]
     [ 8  9 10 11]]
    [[0 1]
     [4 5]
    [8 9]]
    [[False False False False]
     [False False  True  True]
     [ True  True  True  True]]
    [ 6  7  8  9 10 11]

#### 数组索引及切片的值更改、复制 ####

一个标量赋值给一个索引/切片时，会自动改变/传播原始数组

ar = np.arange(10)
    print(ar)
    ar[5] = 100
    ar[7:9] = 200
    print(ar)
    
    ar = np.arange(10)
    b = ar.copy()
    b[7:9] = 200
    print(ar)
    print(b)

Out:

[0 1 2 3 4 5 6 7 8 9]
    [  0   1   2   3   4 100   6 200 200   9]
    [0 1 2 3 4 5 6 7 8 9]
    [  0   1   2   3   4   5   6 200 200   9]

### Numpy随机数 ###

numpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一

#### 随机数生成 ####

*  生成一个标准正太分布的4\*4样本值

samples = np.random.normal(size=(4,4))
    print(samples)

Out:

[[ 1.45889345  0.02346933 -0.37334637 -0.10410853]
     [-0.32613981 -0.45842463 -0.34698901 -1.88793082]
     [ 1.30471253  0.86085788 -0.11643461  0.12422668]
     [ 0.61681041 -0.44217887 -0.4622161  -0.64353789]]

*  numpy.random.rand(d0, d1, …, dn)：生成一个\[0,1)之间的随机浮点数或N维浮点数组
 *  numpy.random.randn(d0, d1, …, dn)：生成一个浮点数或N维浮点数组,正态分布
 *  numpy.random.randint(low, high=None, size=None, dtype=’l’)：生成一个整数或N维整数数组,若high不为None时，取\[low,high)之间随机整数，否则取值\[0,low)之间随机整数，且high必须大于low , dtype参数：只能是int类型

a = np.random.rand(2,3)
    print(a,type(a))  # 生成形状为2*3的二维数组
    
    print(np.random.randint(2)) # low=2：生成1个[0,2)之间随机整数
    print(np.random.randint(2,size=5)) # low=2,size=5 ：生成5个[0,2)之间随机整数
    print(np.random.randint(2,6,size=5)) # low=2,high=6,size=5：生成5个[2,6)之间随机整数 
    print(np.random.randint(2,size=(2,3))) # low=2,size=(2,3)：生成一个2x3整数数组,取数范围：[0,2)随机整数

Out:

[[0.23028839 0.42272169 0.71694801]
     [0.74268556 0.29011389 0.63466075]] <class 'numpy.ndarray'>
    
     1
    [1 0 1 1 0]
    [2 2 2 2 3]
    [[1 1 0]
     [0 0 0]]

### Numpy数据的输入输出 ###

#### 存储数组数据 .npy文件 ####

ar = np.random.rand(5,5)
    print(ar)
    np.save('arraydata.npy', ar)

Out:

[[ 0.57358458  0.71126411  0.22317828  0.69640773  0.97406015]
     [ 0.83007851  0.63460575  0.37424462  0.49711017  0.42822812]
     [ 0.51354459  0.96671598  0.21427951  0.91429226  0.00393325]
     [ 0.680534    0.31516091  0.79848663  0.35308657  0.21576843]
     [ 0.38634472  0.47153005  0.6457086   0.94983697  0.97670458]]

#### 读取数组数据 .npy文件 ####

ar_load =np.load('arraydata.npy')
    print(ar_load)

Out:

如上输出

#### 存储/读取文本文件 ####

np.savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\\n’, header=”, footer=”, comments=’\# ‘)：存储为文本txt文件

ar = np.random.rand(5,5)
    np.savetxt('array.txt',ar, delimiter=',')
    ar_loadtxt = np.loadtxt('array.txt', delimiter=',')
    print(ar_loadtxt)

Out:

[[ 0.28280684  0.66188985  0.00372083  0.54051044  0.68553963]
     [ 0.9138449   0.37056825  0.62813711  0.83032184  0.70196173]
     [ 0.63438739  0.86552157  0.68294764  0.2959724   0.62337767]
     [ 0.67411154  0.87678919  0.53732168  0.90366896  0.70480366]
     [ 0.00936579  0.32914898  0.30001813  0.66198967  0.04336824]]