python基础之Numpy库中array用法总结_Python

前言

Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。

NumPy数组是一个多维数组对象，称为ndarray。数组的下标从0开始,同一个NumPy数组中所有元素的类型必须是相同的。

				?

									>>> import numpy as np

为什么要用numpy

Python中提供了list容器，可以当作数组使用。但列表中的元素可以是任何对象，因此列表中保存的是对象的指针，这样一来，为了保存一个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说，这种结构显然不够高效。

Python虽然也提供了array模块，但其只支持一维数组，不支持多维数组(在TensorFlow里面偏向于矩阵理解)，也没有各种运算函数。因而不适合数值运算。

NumPy的出现弥补了这些不足。

数组的创建

使用numpy.array方法将tuple和list, array, 或者其他的序列模式的数据转创建为 ndarray, 默认创建一个新的 ndarray.

				?

									>>> 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(开始值, 终值, 元素个数): 创建等比数列

				?

									>>> 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 的方阵.

				?

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

获取数组的属性

				?

									>>> 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中表示该维所有元素

				?

									>>> 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)    #

									>>> b

									array([[ 0,  1,  2,  3],

									       [10, 11, 12, 13],

									       [20, 21, 22, 23],

									       [30, 31, 32, 33],

									       [40, 41, 42, 43]])

数组操作

				?

									>>> a = np.ones((2,2))

									>>> b = np.eye(2)

									>>> print a

									[[ 1.  1.]

									 [ 1.  1.]]

									>>> print b

									[[ 1.  0.]

									 [ 0.  1.]]

				?

									>>> 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 a

									True

									>>> c = a.copy()       #深拷贝

									>>> c is a

									False

内置函数（min,max,sum)，同时可以使用axis指定对哪一维进行操作：

				?

									>>> a.sum()

									4.0

									>>> a.sum(axis=0)    #计算每一列（二维数组中类似于矩阵的列）的和

									array([ 2.,  2.])

									>>> a.min()          #数组最小值

									1.0

									>>> a.max()          #数组最大值

									1.0

使用numpy下的方法：

				?

									>>> 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^x

									array([[ 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模块中有很多关于矩阵运算的方法：

				?

									>>> 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自动省略中间部分而只打印两端的数据：

				?

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