基础
NumPy的主要对象是齐次多维数组。表由相同类型的元素组成（通常为数字），由一个正整数元组索引。在NumPy中维数被称为轴，轴数称为秩。例如，一个三维空间中点的坐标[1,2,1]是一个秩为1的数组，因为其轴数为1，轴的长度为3。在下图中，数组的秩为2（2维），第二维的长度为3。
[[ 1., 0., 0.],
[ 0., 1., 2.]]
NumPy的数组类是ndarray，也称array。需要注意numpy.array和标准Python库类array.array不同，后者只能处理一维数组，提供的功能较少。ndarray对象的主要属性如下所示：ndarray.ndim
数组的轴的数量（维度的数量）。也称为秩。ndarray.shape
数组的维度。这是用一个整数元组表示每个维度的数组的大小。比如一个n行m列的矩阵，shape为(n,m)。shape元组的长度即为秩
或者称为维度的数量，即ndim。ndarray.size
数组中元素的个数总和。等于shape元组中元素的乘积。ndarray.dtype
描述数组中的元素类型。可以使用标准的额Python类型生成或指定dtype。除此之外NumPy提供可一些独有的类型，如numpy.int32
，numpy.int16， numpy.float64等。ndarray.itemsize
数组中每个元素的字节数的大小。例如，float64类型元素的itemsize值为8=(64/8)，complex32类型元素的itemsize值为4=(32/8)。等同于ndarray.dtype.itemsize。ndarray.data
包含实际数组元素的缓冲区。通常我们不会使用这个属性，因为我们将会使用索引来获取数组中的元素。
实例：
>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type 'numpy.ndarray'>
建立数组
有许多方法可以用来创建数组，比如利用numpy的array方法从Python的list或tuple创建数组。如上图所示。
但是array方法不能直接接收一串数字，如下图所示：
>>> a = np.array(1,2,3,4) # 错
>>> a = np.array([1,2,3,4]) # 对
将二维序列转换为二维数组：
>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5, 2. , 3. ],
[ 4. , 5. , 6. ]])
也可以在创建数组时指定元素类型：
>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1.+0.j, 2.+0.j],
[ 3.+0.j, 4.+0.j]])
经常会碰到数组的元素实现不知道，仅直到数组的大小。因此，numpy提供一些功能创建拥有初始占位符的数组。尽可能减少数组的增长，这是个昂贵的操作。
```
>>> np.zeros( (3,4) )
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
>>> np.ones( (2,3,4), dtype=np.int16 ) # dtype can also be specified
array([[[ 1, 1, 1, 1],
[ 1, 1, 1, 1],
[ 1, 1, 1, 1]],
[[ 1, 1, 1, 1],
[ 1, 1, 1, 1],
[ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) ) # uninitialized, output may vary
array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],
[ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
为了创建数字序列，numpy提供了类似Python中range的方法，arange返回的是数组而不是列表。
>>> np.arange( 10, 30, 5 ) # 起始10，终止30，步长为5
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )
array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
当arange接收浮点参数时，由于有限的浮点精度，通常不能预测可获得的元素数量。因此，更好的选择是用linspace接收指定生成的元素数量作为参数，替代arange中的步长。
>>> from numpy import pi
>>> np.linspace( 0, 2, 9 ) # 返回从0到2中间的9个数，包括2
array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
>>> x = np.linspace( 0, 2*pi, 100 ) # 可以利用多个点评价函数
>>> f = np.sin(x)
打印数组
当打印数组时，numpy提供了一个类似Python嵌套列表的方法，但是遵守以下布局：
- 最后的维度(轴)从左至右打印
- 倒数第二维从上至下打印
其他维也从上至下打印，每个切片下由一个空行分隔
>>> a = np.arange(6) # 1d 维 >>> print(a) [0 1 2 3 4 5] >>> >>> b = np.arange(12).reshape(4,3) # 2d 维 >>> print(b) [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] >>> >>> c = np.arange(24).reshape(2,3,4) # 3d 维 >>> 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]]]``` >>> print(np.arange(10000)) [ 0 1 2 ..., 9997 9998 9999] >>> >>> print(np.arange(10000).reshape(100,100)) [[ 0 1 2 ..., 97 98 99] [ 100 101 102 ..., 197 198 199] [ 200 201 202 ..., 297 298 299] ..., [9700 9701 9702 ..., 9797 9798 9799] [9800 9801 9802 ..., 9897 9898 9899] [9900 9901 9902 ..., 9997 9998 9999]]如果数组元素个数太多，numpy会自动忽略中间的元素以省略号表示，仅打印两边的元素。
如果想强制数组打印所有元素，可以设置set_printoptions参数：>>> np.set_printoptions(threshold=10000)
基本操作
数组的算数运算适用于元素方式，即运算执行在每个元素上：
>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
>>> a<35
>>>
array([ True, True, False, False], dtype=bool)
不同于其他矩阵运算，在numpy数组中，*乘法运算符操作与每个元素。而矩阵的乘积可以使用dot函数或dot方法运行：
>>> A = np.array( [[1,1],
... [0,1]] )
>>> B = np.array( [[2,0],
... [3,4]] )
>>> A*B # 元素相乘
array([[2, 0],
[0, 4]])
>>> A.dot(B) # 矩阵乘积
array([[5, 4],
[3, 4]])
>>> np.dot(A, B) # 矩阵乘积
array([[5, 4],
[3, 4]])
如+=、*=等操作符，在操作执行的地方替代数组元素而不是产生一个新的数组：
>>> a = np.ones((2,3), dtype=int)
>>> b = np.random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
[3, 3, 3]])
>>> b += a
>>> b
array([[ 3.417022 , 3.72032449, 3.00011437],
[ 3.30233257, 3.14675589, 3.09233859]])
>>> a += b # b不能自动转换为int类型
Traceback (most recent call last):
...
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'
若运算的数组时不同的数据类型，则遵循向上转型，即结果数组的元素类型为更一般或更精确的数据类型：
>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1. , 2.57079633, 4.14159265])
>>> c.dtype.name
'float64'
>>> d = np.exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
-0.54030231-0.84147098j])
>>> d.dtype.name
'complex128'
ndarray类提供了许多一元操作方法，比如元素求和，求最小元素等：
>>> a = np.random.random((2,3))
>>> a
array([[ 0.18626021, 0.34556073, 0.39676747],
[ 0.53881673, 0.41919451, 0.6852195 ]])
>>> a.sum()
2.5718191614547998
>>> a.min()
0.1862602113776709
>>> a.max()
0.6852195003967595
通常上述操作将数组视为包含数字的列表，忽略其shape类型。进一步，通过制定轴参数axis ，你可以在指定的维度上操作这些运算：
>>> b = np.arange(12).reshape(3,4)
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>>
>>> b.sum(axis=0) # 每一列的求和
array([12, 15, 18, 21])
>>>
>>> b.min(axis=0) # 每列的最小值
array([0 1 2 3])
>>>
>>> b.min(axis=1) # 每行的最小值
array([0, 4, 8])
>>>
>>> b.cumsum(axis=1) # 沿着行累积求和
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
常用函数
numpy提供了我们常见的数学公式如：sin、cos、exp，称为“universal functions”(ufunc)。这些函数作用在数组元素上：
>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([ 1. , 2.71828183, 7.3890561 ])
>>> np.sqrt(B)
array([ 0. , 1. , 1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([ 2., 0., 6.])
其他函数还有：
all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot, vectorize, where
索引、切片、迭代
一维数组的这些操作和Python的list操作一样：
>>> a = np.arange(10)**3
>>> a
array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1000 # 等于 a[0:6:2] = -1000; 表示从初始位置到第六个之前, 以2为步长将元素设为-1000
>>> a
array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])
>>> a[ : :-1] # 翻转 a的元素顺序
array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
>>> for i in a:
... print(i**(1/3.))
...
0.0
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
多维数组可以每轴有一个索引，这些指数存在于一个元组中，以逗号分离：
>>> def f(x,y):
... return 10*x+y
...
# fromfunction(函数,shape维度,元素类型)，其中函数的参数个数由shape维度的秩决定决定，函数参数的值为数组中元素的下标。比如shape为(2,2),函数参数有2个，则函数的参数值分别为：(0,0)、(0,1)、(1,0)、(1,1)。
>>> 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]])
>>> b[2,3]
23
>>> b[0:5, 1] # 第二列的元素
array([ 1, 11, 21, 31, 41])
>>> b[ : ,1] # 第二列的元素
array([ 1, 11, 21, 31, 41])
>>> b[1:3, : ] # 第二行和第三行的元素
array([[10, 11, 12, 13],
[20, 21, 22, 23]])
>>> b[-1] # 最后一行的元素，等于b[-1,:]
array([40, 41, 42, 43])
b[i]被认为i后面有:所有实例需要去表示这个轴。numpy也允许以b[i,...]的形式表示。dots (...)函数表示更具需要产生一个完整的索引元组表示尽可能多的冒号。例如，如果数组x的秩为5，即有5个轴（维度），那么：
x[1,2,...]即等于x[1,2,:,:,:]x[...,3]即等于x[:,:,:,:,3]x[4,...,5,:]即等于x[4,:,:,5,:]
>>> c = np.array( [[[ 0, 1, 2], # （2,2,3）两个堆叠的二维数组
... [ 10, 12, 13]],
... [[100,101,102],
... [110,112,113]]])
>>> c.shape
(2, 2, 3)
>>> c[1,...] # c[1,:,:] 等于 c[1]
array([[100, 101, 102],
[110, 112, 113]])
>>> c[...,2] # 等于 c[:,:,2]
array([[ 2, 13],
[102, 113]])
多维数组的迭代完成对第一个轴的遍历：
>>> for row in b:
... print(row)
...
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]
如果想对数组中的每个元素进行操作，可以使用flat属性，它是针对数组中每个元素的迭代器：
>>> for element in b.flat:
... print(element)
...
0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43
shape维数操作
改变数组的shape形状
一个数组的shape维数值等于其每一轴的元素的个数：
>>> a = np.floor(10*np.random.random((3,4)))
>>> a
array([[ 2., 8., 0., 6.],
[ 4., 5., 1., 1.],
[ 8., 9., 3., 6.]])
>>> a.shape
(3, 4)
一个数组的shape维度可以被很多命令改变，例如：
>>> a.ravel() # 扁平化数组，转换为一维数组
array([ 2., 8., 0., 6., 4., 5., 1., 1., 8., 9., 3., 6.])
>>> a.shape = (6, 2)
>>> a.T # 数组转置
array([[ 2., 0., 4., 1., 8., 3.],
[ 8., 6., 5., 1., 9., 6.]])
ravel()方法后数组元素的顺序通常是“C-style”，也就是说，最右边的索引值先变化，所以元素a[0,0]后紧跟的是a[0,1]。如果数组被reshape为其他维度形状，依然保持“C-style”。numpy通常将产生的数组以这种顺序保存，所以ravel()方法不需要复制他的参数，但是如果数组是由其他数组的切片产生，或者有不寻常的选项创建，ravel()方法将会覆盖掉数组之前的值。函数ravel()和reshape()也可以指定一个可选参数，使用FORTRAN-style数组，即最左边的索引最先变化。
reshape函数返回其参数指定的重塑的维度形状，不改变数组本身；然而ndarray.resize方法返回修改数组本身：
>>> a
array([[ 2., 8.],
[ 0., 6.],
[ 4., 5.],
[ 1., 1.],
[ 8., 9.],
[ 3., 6.]])
>>> a.reshape(2, 6)
array([[ 2., 8., 0., 6., 4., 5.],
[ 1., 1., 8., 9., 3., 6.]])
>>> a # 数组a没有改变
array([[ 2., 8.],
[ 0., 6.],
[ 4., 5.],
[ 1., 1.],
[ 8., 9.],
[ 3., 6.]])
>>> a.resize((2,6))
>>> a # 数组a被改变
array([[ 2., 8., 0., 6., 4., 5.],
[ 1., 1., 8., 9., 3., 6.]])
如果reshape中有维度参数为“-1”，则其维度的个数会自动计算：
>>> a.reshape(3,-1)
array([[ 2., 8., 0., 6.],
[ 4., 5., 1., 1.],
[ 8., 9., 3., 6.]])
将不同的数组叠加
数组可以沿着不同的轴被叠加在一起
>>> a = np.floor(10*np.random.random((2,2)))
>>> a
array([[ 8., 8.],
[ 0., 0.]])
>>> b = np.floor(10*np.random.random((2,2)))
>>> b
array([[ 1., 8.],
[ 0., 4.]])
>>> np.vstack((a,b)) # 垂直按行叠加
array([[ 8., 8.],
[ 0., 0.],
[ 1., 8.],
[ 0., 4.]])
>>> np.hstack((a,b)) # 平行按列叠加
array([[ 8., 8., 1., 8.],
[ 0., 0., 0., 4.]])
函数column_stack等同于hstack方法：
>>> from numpy import newaxis
>>> np.column_stack((a,b)) # With 2D arrays
array([[ 8., 8., 1., 8.],
[ 0., 0., 0., 4.]])
>>> a = np.array([4.,2.])
>>> b = np.array([2.,8.])
>>> a[:,newaxis] # 产生一个二维列向量
array([[ 4.],
[ 2.]])
>>> np.column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4., 2.],
[ 2., 8.]])
>>> np.vstack((a[:,newaxis],b[:,newaxis]))
array([[ 4.],
[ 2.],
[ 2.],
[ 8.]])
对于超过两维的数组，hstack沿着第二轴叠加，vstack沿着第一轴叠加，concatenate提供一个可选的轴数参数使沿着这个轴数叠加。
说明：
在复杂的情况下，r_和c_对于创建沿着某一轴叠加的数组很有用。允许使用范围字符“：”。
>>> np.r_[1:4,0,4]
array([1, 2, 3, 0, 4])
当使用数组作为参数时，r_和c_方法和vstack和hstack功能相似，但是前者可以指定参数是数组沿着指定的轴数链接。r_和c_详读：r_或c_
将数组划分为几个小数组
使用hsplit方法可以将数组沿着水平方向切分，返回制定shape维度的子数组，或者在切分后制定列数：
>>> a = np.floor(10*np.random.random((2,12)))
>>> a
array([[ 9., 5., 6., 3., 6., 8., 0., 7., 9., 7., 2., 7.],
[ 1., 4., 9., 2., 2., 1., 0., 6., 2., 2., 4., 0.]])
>>> np.hsplit(a,3) # 分割3份
[array([[ 9., 5., 6., 3.],
[ 1., 4., 9., 2.]]), array([[ 6., 8., 0., 7.],
[ 2., 1., 0., 6.]]), array([[ 9., 7., 2., 7.],
[ 2., 2., 4., 0.]])]
>>> np.hsplit(a,(3,4)) # 将第三列切分出来
[array([[ 9., 5., 6.],
[ 1., 4., 9.]]), array([[ 3.],
[ 2.]]), array([[ 6., 8., 0., 7., 9., 7., 2., 7.],
[ 2., 1., 0., 6., 2., 2., 4., 0.]])]
vsplit方法沿着垂直方向切分，array_split可以指定沿着哪个轴切分。
复制和视图
当操作数组时，有时候数组会复制产生一个新的数组有时候则不会，新手对此肯定会很困惑，一下有三个实例：
不复制
简单的分配不复制对象及其数据：
>>> a = np.arange(12)
>>> b = a # 不产生新的对象
>>> b is a # a、b是相同的ndarray对象的两个不同名称
True
>>> b.shape = 3,4 # 改变b的维度也将改变a的维度
>>> a.shape
(3, 4)
Python传递可变对象作为引用，因此函数调用没有复制新的对象：
>>> def f(x):
... print(id(x))
...
>>> id(a) # id是一个对象的唯一标识
148293216
>>> f(a)
148293216
视图或浅层拷贝
不同的数组对象可以共享相同的数据，view方法产生一个有相同数据的数组对象：
>>> c = a.view()
>>> c is a
False
>>> c.base is a # c是a的一个数据视图
True
>>> c.flags.owndata
False
>>>
>>> c.shape = 2,6 # a的shape维度没有改变
>>> a.shape
(3, 4)
>>> c[0,4] = 1234 # a的数据发生改变
>>> a
array([[ 0, 1, 2, 3],
[1234, 5, 6, 7],
[ 8, 9, 10, 11]])
数组的切片也是数组的一个视图：
>>> s = a[ : , 1:3] # 切片产生数组a的第二、第三列，s是一个视图
>>> s[:] = 10 # s[:]是s的视图。注意s=10是将将s实例指向10，s[:]=10才是将切片数组s中的每个元素都设为10
>>> a
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
深层拷贝
方法copy实现数组及其数据的复制。
>>> d = a.copy() # 一个包含数据的新数组对象被创建
>>> d is a
False
>>> d.base is a # 数组d不共享数组a的任何数据
False
>>> d[0,0] = 9999
>>> a
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
函数、方法概览
下面列出一下常用的NumPy函数或方法，全而细的方法和函数见Routines
创建数组：
arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r, zeros, zeros_like
转换：
ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat
操作：
array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack
Questions：
all, any, nonzero, where
排序：
argmax, argmin, argsort, max, min, ptp, searchsorted, sort
Operations：
choose, compress, cumprod, cumsum, inner, ndarray.fill, imag, prod, put, putmask, real, sum
基本统计：
cov, mean, std, var
基本线性代数：
cross, dot, outer, linalg.svd, vdot