前言
Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。
NumPy数组是一个多维数组对象，称为ndarray。数组的下标从0开始,同一个NumPy数组中所有元素的类型必须是相同的。
|
1
|
>>> import numpy as np |
为什么要用numpy
Python中提供了list容器，可以当作数组使用。但列表中的元素可以是任何对象，因此列表中保存的是对象的指针，这样一来，为了保存一个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说，这种结构显然不够高效。
Python虽然也提供了array模块，但其只支持一维数组，不支持多维数组(在TensorFlow里面偏向于矩阵理解)，也没有各种运算函数。因而不适合数值运算。
NumPy的出现弥补了这些不足。
数组的创建
使用numpy.array方法将tuple和list, array, 或者其他的序列模式的数据转创建为 ndarray, 默认创建一个新的 ndarray.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> np.array([1,2,3,4]) [1 2 3 4]>>> b = array( [ (1.5,2,3), (4,5,6) ] ) array([[ 1.5, 2. , 3. ], [ 4. , 5. , 6. ]]) >>> c = array( [ [1,2], [3,4] ], dtype=complex) #指定数组中元素的类型>>> c array([[ 1.+0.j, 2.+0.j], [ 3.+0.j, 4.+0.j]]) |
生成均匀分布的array：
arange（最小值，最大值，步长）（左闭右开） : 创建等差数列
linspace（最小值，最大值，元素数量）
logspace(开始值, 终值, 元素个数): 创建等比数列
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> np.arange(15)[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]>>> np.arange(15).reshape(3,5)[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]]>>> np.arange( 0, 2, 0.3 ) array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])>>> np.linspace(1,3,9)[ 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. ] |
生成特殊数组
np.ones: 创建一个数组, 其中的元素全为 1
np.zeros: 创建元素全为 0 的数组, 类似 np.ones
np.empty创建一个内容随机并且依赖与内存状态的数组。
np.eye: 创建一个对角线为 1 其他为 0 的矩阵.
np.identity: 创建一个主对角线为 1 其他为 0 的方阵.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> np.zeros((3,4))[[ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.]]>>> np.ones((3,4))[[ 1. 1. 1. 1.] [ 1. 1. 1. 1.] [ 1. 1. 1. 1.]]>>> np.eye(3)[[ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]] |
获取数组的属性
|
1
2
3
4
5
6
7
8
9
10
11
|
>>> a = np.zeros((2,2,2))>>> a.ndim #数组的维数3>>> a.shape #数组每一维的大小(2, 2, 2)>>> a.size #数组全部元素的数量 8>>> a.dtype #数组中元素的类型float64>>> print a.itemsize #每个元素所占的字节数8 |
数组索引，切片，赋值
‘…'符号表示将所有未指定索引的维度均赋为 ‘：'
‘：'在python中表示该维所有元素
|
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
|
>>> a = np.array( [[2,3,4],[5,6,7]] )>>> a[[2 3 4] [5 6 7]]>>> a[1,2]7>>> a[1,:][5 6 7]>>> print a[1,1:2][6]>>> a[1,:] = [8,9,10]>>> a[[ 2 3 4] [ 8 9 10]]>>> c[1,...] # same as c[1,:,:] or c[1]array([[100, 101, 102], [110, 112, 113]])>>> c[...,2] # same as c[:,:,2]array([[ 2, 13], [102, 113]])>>> def f(x,y):... return 10*x+y...>>> b = np.fromfunction(f,(5,4),dtype=int) #>>> barray([[ 0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33], [40, 41, 42, 43]]) |
数组操作
|
1
2
3
4
5
6
7
8
|
>>> a = np.ones((2,2))>>> b = np.eye(2)>>> print a[[ 1. 1.] [ 1. 1.]]>>> print b[[ 1. 0.] [ 0. 1.]] |
|
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 a > 2[[False False] [False False]]>>> print a+b #数组加，对应位置相加[[ 2. 1.] [ 1. 2.]]>>> print a-b #数组减，对应位置相减[[ 0. 1.] [ 1. 0.]]>>> print b*2 #数组与数值相乘，对应位置乘[[ 2. 0.] [ 0. 2.]]>>> print (a*2)*(b*2) #数组与数组相乘，按位置一对一相乘[[ 4. 0.] [ 0. 4.]]>>> print b/(a*2) #数组与数组相除，按位置一对一相除[[ 0.5 0. ] [ 0. 0.5]]>>> print a.dot(b) # matrix product，矩阵乘>>> np.dot(a,a) #矩阵乘法array([[ 2., 2.], [ 2., 2.]])>>> print (a*2)**4[[ 16. 16.] [ 16. 16.]]>>> b = a #浅拷贝>>> b is aTrue>>> c = a.copy() #深拷贝>>> c is aFalse |
内置函数（min,max,sum)，同时可以使用axis指定对哪一维进行操作：
|
1
2
3
4
5
6
7
8
|
>>> a.sum()4.0>>> a.sum(axis=0) #计算每一列（二维数组中类似于矩阵的列）的和array([ 2., 2.])>>> a.min() #数组最小值1.0>>> a.max() #数组最大值1.0 |
使用numpy下的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
>>> np.sin(a)array([[ 0.84147098, 0.84147098], [ 0.84147098, 0.84147098]])>>> np.max(a)1.0>>> np.floor(a) array([[ 1., 1.], [ 1., 1.]])>>> np.exp(a) #e^xarray([[ 2.71828183, 2.71828183], [ 2.71828183, 2.71828183]])>>> print np.vstack((a,b)) #合并数组[[ 1. 1.] [ 1. 1.] [ 1. 0.] [ 0. 1.]]>>> print np.hstack((a,b)) #合并数组[[ 1. 1. 1. 0.] [ 1. 1. 0. 1.]]>>> print a.transpose() #转置 |
numpy.linalg模块中有很多关于矩阵运算的方法：
|
1
|
>>> import numpy.linalg as nplg |
NumPy中的基本数据类型
| 名称 | 描述 |
|---|---|
| bool | 用一个字节存储的布尔类型（True或False） |
| inti | 由所在平台决定其大小的整数（一般为int32或int64） |
| int8/16/32/64 | 整数，1/2/4/8个字节大小 |
| uint8/16/32/64 | 无符号整数 |
| float16/32/64 | 半/单/双精度浮点数，16/32/64位，指数、精度也不同 |
| complex64/128 | 复数，分别用两个32/64位浮点数表示实部和虚部 |
输出数组
当输出一个数组时，NumPy以特定的布局用类似嵌套列表的形式显示：
- 第一行从左到右输出
- 每个切片通过一个空行与下一个隔开
- 一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表。
- 如果一个数组太长，则NumPy自动省略中间部分而只打印两端的数据：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
>>> a = arange(6) # 1d array >>> print a [0 1 2 3 4 5] >>> b = arange(12).reshape(4,3) # 2d array >>> print b [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] >>> c = arange(24).reshape(2,3,4) # 3d array >>> print c [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]] |
总结
到此这篇关于python基础之Numpy库中array用法的文章就介绍到这了,更多相关python Numpy中array用法内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/github_36669230/article/details/78038756
