本文共 7899 字，大约阅读时间需要 26 分钟。
前言，这是自己为了提高英文阅读以及对numpy的认识，手工翻译的，可能其中一些地方有误，还望理解。
前提:
在开始这个教程之前，你应该懂一点Python，如果你想要温习一下你的记忆，可以瞧瞧
如果你希望运行这篇教程里的实例，你必须在你的电脑装过一些必要的环境及模块，可以参考
基础
Numpy的主要对象是同种元素的多维数组。这是一个所有元素都是同一种类型，通过正整数元组索引的元素表格（通常元素是数字）。在Numpy中纬度（dimensions）叫做轴（axes），轴的个数叫做秩（rank）。
例如，在3D空间一个点的坐标[1,2,3]是一个秩为1的数组，因为它只有一个轴。轴的长度为3。在而下面的例子中，这个数组的秩为2（它是二维的）。它的第一纬度（轴）长度为2，第二纬度的长度为3。
[[ 1., 0., 0.],
[ 0., 1., 2.]]
Numpy的数组类被称为ndarray。通常又被称为数组。值得注意的，numpy.array与python内置的类array.array并不一样，内置的数组只能处理一维数组并且提供有限的功能。更多ndarray的重要属性有：
ndarray.ndim
数组的轴的数量（dimensions）。在python的世界里，纬度的数量被称为秩（rank）
ndarray.shape
数组的纬度。这是一个表明数组在每个纬度上的大小的整数元组。比如一个n排m列的矩阵，它的shape属性将是（n,m）。这个shape元组属性的长度因此是秩，或者说纬度的数量，ndim
ndarray.size
数组的数量总和。与shape属性中的元素乘积。
ndarray.dtype
用来描述数组中元素的对象。一个能够创建或者指定的dtype的python标准类型。另外numpy还提供自己的数据类型，如numpy.int32，numpy16，以及numpy.float等其他类型。
ndarray.itemsize
每个数组元素的字节大小，比如，一个数组中的float64类型的元素的itemsize为8（64/8），而complex32类型的元素的itemsize为4（32/8）。这些与ndarray.dtype.itemsize相等。
ndarray.data
数组中元素的实际缓存（buffer）。正常情况下，我们不需要用到这个属性，因为将会通过索引条件来调用。
例子
>>> 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'>
创建数组
这里有多种创建数组的方法。
例如，你可以通过一个Python内置的列表或者元组函数创建一个数组。产生的数组的类型由序列中的元素的类型推导出来的。
>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')
在调用数组的常见错误是传入数值型的实参，而不是传入一个数值型的列表作为一个实参。
实参与形参的区别：
>>> a = np.array(1,2,3,4) # WRONG>>> a = np.array([1,2,3,4]) # RIGHT
数组会嵌套了序列的一层序列的序列转换成二维数组，而序列中依次嵌套两层的序列转换成三维数组。依次类推。
>>> 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提供了一些函数在创建数组的时候初始化占位符的内容。这样使扩展数组以及运算成本最小化。
函数zeros创建一个全是0的数组，ones创建一个全是1的数组，empty创建一个初始内容根据内存状态而随即的随即内容。默认情况下，这些创建的数组的dtype都是float64
>>> 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 也能自定义
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) ) # 未初始化，内容不一致
array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],
[ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
创建一个数字序列，numpy提供一个类似range的函数，返回数组而不是列表
>>> np.arange( 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函数接收一个实参作为我们想要得到的元素数量。
>>> from numpy import pi
>>> np.linspace( 0, 2, 9 ) # 从0到2一个9个元素
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)
更多内容参考：
array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, numpy.random.rand, numpy.random.randn, fromfunction, fromfile
打印数组
当你打印数组的时候，numpy的显示类似于嵌套的列表，但是诚信以下布局。
一维的轴从左到右打印
二维的轴自上至下打印
二维以后的轴自上至下打印，每个切片通过空格与写一个隔开
>>> a = np.arange(6) # 一维数组
>>> print(a)
[0 1 2 3 4 5]
>>>
>>> b = np.arange(12).reshape(4,3) # 二维数组
>>> print(b)
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
>>>
>>> c = np.arange(24).reshape(2,3,4) # 三维数组
>>> 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]]]
点击，查看更多与reshape的细节
如果一个数组过于庞大，numpy会自动的跳过中间的一些内容，只打印四端。
>>> 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]]
如果希望强制打印所有内容，可以更改打印参数。
>>> np.set_printoptions(threshold='nan')
基本运算
数组的算术运算时机遇每个元素的，一个新的数组被创建并且填充运算结果
>>> 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函数或者方法执行
>>> 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 is not automatically converted to integer type
Traceback (most recent call last):
...
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'
Traceback (most recent call last):
...
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'
注：其实上面再不同的python版本会不一样，2.7.9不会出错
当两个不同类型的数组进行运算的时候，运算结果的数组会趋向于更复杂的？(不懂)
>>>
>>> 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
默认情况下，这些运算可以应用于数组，就像列表中的数值，而不是它的shapes，然而，通过指定它的轴线参数，你可以把运算应用到单独的其中一轴上。
>>> 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) # sum of each column
array([12, 15, 18, 21])
>>>
>>> b.min(axis=1) # min of each row
array([0, 4, 8])
>>>
>>> b.cumsum(axis=1) # cumulative sum along each row
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
注：二维数组，axis=0取竖直方向，axis=1取水平方向 （axis二维以上求指教！！！不会）
通用函数
Numpy提供常见的数学函数，如sin，cos，exp。
在numpy中，这些被称为universal functions（ufunc），在numpy内部，这些函数按元素在数组中计算，产生一个数组作为输出
>>> 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中的其他序列
>>> 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 # 从0到6启动每隔“第二位”对于-1000
>>> a
array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])
>>> a[ : :-1] # reversed a
array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
>>> for i in a:
... print(i**(1/3.))
...
nan
1.0
nan
3.0
nan
5.0
6.0
7.0
8.0
9.0
多维数组每个轴线都有索引。这些索引由一个逗号分隔的元组给出。
>>> 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]])
>>> b[2,3]
23
>>> b[0:5, 1] # b的每行中的第2列
array([ 1, 11, 21, 31, 41])
>>> b[ : ,1] # 与上面一样
array([ 1, 11, 21, 31, 41])
>>> b[1:3, : ] # 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,....]
（...）会被表述成很多的冒号：。
未完待续。。。。
转载地址：http://hiofm.baihongyu.com/