NumPy库
安装：
Linux系统（Ubuntu和Debian）：
sudo apt-get install python-numpy
导入：
import numpy as np
1.ndarry---N维数组：NumPy库的心脏
数组的维数和元素数量由数组的型（shape）来确定，数组的型由N个正整数组成的元组来确定，元组的每个元素对应每一维的大小。数组的维统称为轴（axes），轴的数量成为秩（rank）
创建时其大小就固定，而列表（list）大小可以改变的
- 定义
>>> import numpy as np
>>> a = np.array([1,2,3])
>>> a
array([1, 2, 3])
- 检测a是否是ndarray
>>> type(a)
<class 'numpy.ndarray'>
- 获取ndarray的数据类型
>>> a.dtype
dtype('int64')
- 获取轴
>>> a.ndim
1
- 获取数组长度
>>> a.size
3
- 获取型，（3,1）
>>> a.shape
(3,)
接下来，创建一个二维数组：
>>> b = np.array([[1.3,2.4],[0.3,4.1]])
>>> b
array([[ 1.3, 2.4],
[ 0.3, 4.1]])
>>> b.dtype
dtype('float64')
- 两条轴，所以秩为2，每条轴长度为2
>>> b.ndim
2
>>> b.size
4
>>> b.shape
(2, 2)
- ndarray还有一个叫itemsize的重要属性---其定义了数组中每个元素的长度为几个字节
>>> b.itemsize
8
- data属性表示包含数组实际元素的缓冲区
>>> b.data
<memory at 0x7ff93fc778b8>
1）- 创建数组
除了使用array（）函数以外，还可以嵌套元组或元组列表作为参数：
>>> d = np.array(((1,2,3),(4,5,6)))
>>> d
array([[1, 2, 3],
[4, 5, 6]])
参数还可以是由元组或列表组成的列表：
>>> e = np.array([(1,2,3),[4,5,6],(7,8,9)])
>>> e
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
2）- 数据类型：
>>> g = np.array([['a','b'],['c','d']])
>>> g
array([['a', 'b'],
['c', 'd']],
dtype='<U1')
>>> g.dtype
dtype('<U1')
>>> g.dtype.name
'str32'
3）-dtype选项
array（）函数可以接受多个参数，其默认根据列表或元素序列中各元素的数据类型，为ndarray（）对象指定最合适的数据类型
- 指定一个复数类型
>>> f = np.array([[1,2,3],[4,5,6]],dtype=complex)
>>> f
array([[ 1.+0.j, 2.+0.j, 3.+0.j],
[ 4.+0.j, 5.+0.j, 6.+0.j]])
4） -自带的数组创建方法
>>> np.zeros((3,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> np.ones((3,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])
>>> np.arange(0,10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(4,10)
array([4, 5, 6, 7, 8, 9])
- 为arange（）指定第三个参数，表示序列相邻两元素的步长
>>> np.arange(0,12,3)
array([0, 3, 6, 9])
- 步长也可以为浮点类型
>>> np.arange(0,6,0.6)
array([ 0. , 0.6, 1.2, 1.8, 2.4, 3. , 3.6, 4.2, 4.8, 5.4])
- 自动生成数组并结合reshape（）函数来指定形状
>>> np.arange(0,12).reshape(3,4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
- 与arange（）函数相似的一个函数是linspace（），而linspace（）的第三个参数表示的是把前两个数字区间内分成几个部分
>>> np.linspace(0,10,5)
array([ 0. , 2.5, 5. , 7.5, 10. ])
- 使用随机数填充数组（使用np.random模块的random()函数）
>>> np.random.random(3)
array([ 0.82435572, 0.53784738, 0.89049281])
>>> np.random.random((3,3))
array([[ 0.07570078, 0.24920832, 0.88829288],
[ 0.83053228, 0.92501309, 0.07700749],
[ 0.41759238, 0.42657463, 0.64897918]])
2 -基本操作
1）算术运算符
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> a+4
array([4, 5, 6, 7])
>>> a*2
array([0, 2, 4, 6])
在NumPy中，这些运算符为元素级，只用于将位置相同的元素之间，所得到的运算结果组成一个新的数组
>>> b = np.arange(4,8)
>>> b
array([4, 5, 6, 7])
>>> a + b
array([ 4, 6, 8, 10])
>>> a - b
array([-4, -4, -4, -4])
>>> a * b
array([ 0, 5, 12, 21])
- 正弦值
>>> a * np.sin(b)
array([-0. , -0.95892427, -0.558831 , 1.9709598 ])
- 平方根
>>> a * np.sqrt(b)
array([ 0. , 2.23606798, 4.89897949, 7.93725393])
- 对于多维数组，下列的运算符也是元素级别的：
>>> A = np.arange(0,9).reshape(3,3)
>>> A
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> B = np.ones((3,3))
>>> B
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])
>>> A * B
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.]])
2）- 矩阵积
NumPy用dot（）函数表示这类乘法，注意，它不是元素级的：
>>> np.dot(A,B)
array([[ 3., 3., 3.],
[ 12., 12., 12.],
[ 21., 21., 21.]])
第一个矩阵中与该元素行号相同的元素与第二个矩阵中与该元素列号相同的元素，两两相乘后再求和
另外一种写法：
>>> A.dot(B)
array([[ 3., 3., 3.],
[ 12., 12., 12.],
[ 21., 21., 21.]])
- 注意矩阵积运算不遵循交换律：
>>> np.dot(B,A)
array([[ 9., 12., 15.],
[ 9., 12., 15.],
[ 9., 12., 15.]])
3）- 自增和自减运算符
>>> a
array([0, 1, 2, 3])
>>> a +=1
>>> a
array([1, 2, 3, 4])
>>> a -+1
array([0, 1, 2, 3])
>>> a +=4
>>> a
array([5, 6, 7, 8])
>>> a *=2
>>> a
array([10, 12, 14, 16])
4）- 通用函数（ufunc）
它对数组中的每个元素逐一进行操作
>>> a = np.arange(1,5)
>>> a
array([1, 2, 3, 4])
>>> np.sqrt(a)
array([ 1. , 1.41421356, 1.73205081, 2. ])
>>> np.log(a)
array([ 0. , 0.69314718, 1.09861229, 1.38629436])
>>> np.sin(a)
array([ 0.84147098, 0.90929743, 0.14112001, -0.7568025 ])
5）- 聚合函数
其是指对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。比如：求数组所有元素之和的函数
>>> a = np.array([3.3,4.5,1.2,5.7,0.3])
>>> a.sum()
15.0
>>> a.min()
0.29999999999999999
>>> a.max()
5.7000000000000002
- 平均值
>>> a.mean()
3.0
- 标准差
>>> a.std()
2.0079840636817816
5- 索引机制，切片和迭代方法
通过索引和切片方法选择元素，以获取数组中某几个元素的视图或者用赋值操作改变元素
1）- 索引机制
>>> a = np.arange(10,16)
>>> a
array([10, 11, 12, 13, 14, 15])
>>> a[4]
14
>>> a[-1]
15
>>> a[[1,3,4]]
array([11, 13, 14])
- 二维数组的索引，轴0是行，轴1是列，所以需要一组值
>>> A = np.arange(10,19).reshape(3,3)
>>> A
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
>>> A[1,2]
15
2）切片操作
切片操作是指抽取数组的一部分元素生成新数组。
>>> a = np.arange(10,16)
>>> a
array([10, 11, 12, 13, 14, 15])
>>> a[1:5]
array([11, 12, 13, 14])
- 抽取元素间隔为2，每隔一个元素抽取一个
>>> a[1:5:2]
array([11, 13])
- 若省略第一个元素，则从0开始；省略第二个元素，则就是数组最大索引值；省去最后一个数字，则就是1
>>> a[::2]
array([10, 12, 14])
>>> a[:5:]
array([10, 11, 12, 13, 14])
- 对于二维数组仍然适用：
>>> A
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
- 只抽取第一行，第2个数字适用冒号，选择的是所有列
>>> A[0,:]
array([10, 11, 12])
- 只抽取第一列
>>> A[:,0]
array([10, 13, 16])
- 抽取的行或列索引不连续，就把索引放到数组中：
>>> A[[0,2],0:2]
array([[10, 11],
[16, 17]])
3）- 数组迭代
>>> a
array([10, 11, 12, 13, 14, 15])
>>> for i in a:
... print(i)
...
10
11
12
13
14
15
- 二维数组也可以遍历
>>> A
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
- 遍历二维数组的每一个元素：
>>> for item in A.flat:
... print(item)
...
10
11
12
13
14
15
16
17
18
>>> for row in A:
... print(row)
...
[10 11 12]
[13 14 15]
[16 17 18]
- 除了for循环之外，NumPy提供了一种更为优雅的遍历方式------apply_along_axis()
接受三个参数：
聚合函数，对哪条轴应用迭代操作和数组，axis=0，对列操作；=1，对行操作
比如：求行列的平均数：
>>> A
array([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
>>> np.apply_along_axis(np.mean,axis=0,arr=A)
array([ 13., 14., 15.])
>>> np.apply_along_axis(np.mean,axis=1,arr=A)
array([ 11., 14., 17.])
- 上述采用的是NumPy库定义的函数，你也可以自己定义这个函数：
>>> def foo(x):
... return x/2
...
>>> np.apply_along_axis(foo,axis=1,arr=A)
array([[ 5. , 5.5, 6. ],
[ 6.5, 7. , 7.5],
[ 8. , 8.5, 9. ]])
>>> np.apply_along_axis(foo,axis=0,arr=A)
array([[ 5. , 5.5, 6. ],
[ 6.5, 7. , 7.5],
[ 8. , 8.5, 9. ]])
6. 条件和布尔数组
除了用索引和切片的方法从数组抽取一部分元素之外，还可以采用条件表达式和布尔运算符
比如：从0-1之间的随机数组成的4*4矩阵中选取所有小于0.5的元素：
>>> A = np.random.random((4,4))
>>> A
array([[ 0.08800794, 0.90730209, 0.60728979, 0.4505796 ],
[ 0.73299702, 0.45857674, 0.42037101, 0.74451569],
[ 0.04556848, 0.2941476 , 0.00976259, 0.35953475],
[ 0.51925217, 0.77491286, 0.22829107, 0.11662305]])
>>> A < 0.5
array([[ True, False, False, True],
[False, True, True, False],
[ True, True, True, True],
[False, False, True, True]], dtype=bool)
>>> A[A < 0.5]
array([ 0.08800794, 0.4505796 , 0.45857674, 0.42037101, 0.04556848,
0.2941476 , 0.00976259, 0.35953475, 0.22829107, 0.11662305])
7. 形状变换
之前以及了解了reshape（）函数，改变数组形状的操作是可逆的，ravel（）函数可以把二维数组再变回一维数组
>>> a
array([10, 11, 12, 13, 14, 15])
>>> a.reshape(2,3)
array([[10, 11, 12],
[13, 14, 15]])
>>> a = a.ravel()
>>> a
array([10, 11, 12, 13, 14, 15])
8. 数组操作
1）- 连接数组
将多个数组整合在一起形成一个包含这些数组的新数组。
NumPy使用了栈，运用了几个栈概念的函数，例如：
vstack()函数执行垂直入栈操作，把第二个数组作为行添加到第一个数组
hstack()函数执行水平入栈操作，作为列添加到第一个数组
>>> A = np.ones((3,3))
>>> B = np.zeros((3,3))
>>> np.vstack((A,B))
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.],
[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> np.hstack((A,B))
array([[ 1., 1., 1., 0., 0., 0.],
[ 1., 1., 1., 0., 0., 0.],
[ 1., 1., 1., 0., 0., 0.]])
另外两个用于多个数组之间栈操作函数是：
column_stack()和row_stack()
将一维数组作为行或列压入栈结构，形成新的二维数组
>>> a = np.array([0,1,2])
>>> b = np.array([3,4,5])
>>> c = np.array([6,7,8])
>>> np.column_stack((a,b,c))
array([[0, 3, 6],
[1, 4, 7],
[2, 5, 8]])
>>> np.row_stack((a,b,c))
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
2）- 数组切分
上面是多个数组的组装，下面是它的逆操作：切分
水平切分---hsplit()
竖直切分---vsplit()
>>> A = np.arange(16).reshape(4,4)
>>> A
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> [B,C] = np.hsplit(A,2)
>>> B
array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]])
>>> C
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])
>>> [B,C] = np.vsplit(A,2)
>>> B
array([[0, 1, 2, 3],
[4, 5, 6, 7]])
>>> C
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])
split()函数，除了传入数组作为参数外，还得指定部分索引：
axis=1---列索引；axis=0---行索引
例如：把矩阵分为三部分，第一部分第一列，第二部分第二，三列，第三部分最后一列：
>>> [A1,A2,A3] = np.split(A,[1,3],axis=1)
>>> A1
array([[ 0],
[ 4],
[ 8],
[12]])
>>> A2
array([[ 1, 2],
[ 5, 6],
[ 9, 10],
[13, 14]])
>>> A3
array([[ 3],
[ 7],
[11],
[15]])
9. 常用概念
1）- 对象的副本或视图
NumPy中，所有赋值运算不会为数组和数组中的任何元素创建副本。
>>> a
array([0, 1, 2])
>>> b = a
>>> b
array([0, 1, 2])
>>> a[0]=3
>>> b
array([3, 1, 2])
如果想为原数组生成一份完整的副本，则需要copy()函数
>>> a = np.array([1,2,3,4])
>>> c = a.copy()
>>> c
array([1, 2, 3, 4])
2）- 向量化
向量化和广播是NumPy内部实现的基础。有了向量化无需使用for循环
例如：NumPy中两个数组相乘可以表示为：
a * b
两个矩阵相乘也是: A * B
而其他语言的上述操作，需要for循环来进行
而使用NumPy，代码的可读性更强，其表达式更像是数学表达式
3）- 广播机制
广播机制---实现了对两个或以上数组进行运算或函数处理，即使形状不完全相同：
但是必须遵守，两个数组各维度兼容，也就是两个数组的每一维等长，或其中一个数组为一维---适用
否则，抛出异常
两条规则：
>>> A
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> b = np.arange(4)
>>> b
array([0, 1, 2, 3])
4*4
4
1---为缺失的维度补上1
4*4
4*1
2---假定缺失元素（一维）都用已有值填充
b= 0 1 2 3
0 1 2 3
0 1 2 3
0 1 2 3
接下来，里面的值就可以相加了：
>>> A + b
array([[ 0, 2, 4, 6],
[ 4, 6, 8, 10],
[ 8, 10, 12, 14],
[12, 14, 16, 18]])
再比如更甚者情况：两个数组形状不同，维度不同，互有长短
3*1 扩展成 3*1*2
3*2 3*2*1
11. 数组数据文件的读写
1）- 二进制文件的读写
NumPy的save()方法以二进制格式保存数据，load()是读取数据
save()函数有两个参数：（要保存的文件名，要保存的数组）
其中，文件名的.npy扩展名系统自动添加
>>> data
array([[ 0.26935728, 0.15859244, 0.71116824, 0.33111241],
[ 0.05092776, 0.26280112, 0.852181 , 0.41840037],
[ 0.83938955, 0.77790115, 0.37949835, 0.14586993],
[ 0.01925793, 0.91346943, 0.82411824, 0.48712098]])
>>> np.save('saved_data',data)
>>> loaded_data = np.load('saved_data.npy')
>>> loaded_data
array([[ 0.26935728, 0.15859244, 0.71116824, 0.33111241],
[ 0.05092776, 0.26280112, 0.852181 , 0.41840037],
[ 0.83938955, 0.77790115, 0.37949835, 0.14586993],
[ 0.01925793, 0.91346943, 0.82411824, 0.48712098]])
2）- 读取文件中列表形式数据
date.csv
id,value1,value2,value3
1,123,1.4,23
2,110,1.4,23
3,164,2.1,19
NumPy的genfromtxt（）函数可以从文本文件中读取数据并将其插入数组中。接受三个参数：
存放数据文件名，用于分割值字符，是否含有列标题
>>> data = np.genfromtxt('data.csv',delimiter=',',names=True)
>>> data
array([( 1., 123., 1.4, 23.), ( 2., 110., 1.4, 23.),
( 3., 164., 2.1, 19.)],
dtype=[('id', '<f8'), ('value1', '<f8'), ('value2', '<f8'), ('value3', '<f8')])
各列的标题变为各字段的名称
当某行列具体位置缺少值时，将会自动添加上NaN
读取到的数据，数值索引是按行抽取数据
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
