python数据挖掘包numpy基本操作

原地址英文版：https://docs.scipy.org/doc/numpy-dev/user/quickstart.html
中文版：http://blog.csdn.net/chen_shiqiang/article/details/51868115

---

安装

没有啥依赖包，普通安装模式：pip install -U numpy

基础

Numpy的主要对象是多维数组，数组内所有元素类型一致，在Numpy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank)。
例如，在3D空间一个点的坐标 [1, 2, 1] 是一个秩为1的数组，因为它只有一个轴，轴长度为3.同理，如下例子，数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3。

[[ 1., 0., 0.], [ 0., 1., 2.]]

NumPy’s数组类型为ndarray，也称为数组。Python基础库类array.array只处理一维数组，提供的功能函数也更少。ndarray更多重要属性如下：
* ndarray.ndim
数组轴数（维度），python中轴的个数被称作秩
* ndarray.shape
数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性
* ndarray.size
数组元素的总个数，等于shape属性中元组元素的乘积
* ndarray.dtype
一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型
* ndarray.itemsize
数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8)
* ndarray.data
包含实际数组元素的缓冲区，通常我们不需要使用这个属性，因为我们总是通过索引来使用数组中的元素。

实例

>>> from numpy import *>>> a = arange(15).reshape(3,5)>>> aarray([[ 0,  1,  2,  3,  4],       [ 5,  6,  7,  8,  9],       [10, 11, 12, 13, 14]])>>> a.shape(3, 5)>>> a.ndim2>>> a.data<read-write buffer for 0x1176b70, size 120, offset 0 at 0x7fb5ccf50170>>>> a.itemsize8>>> a.dtype.name'int64'>>> type(a)<type 'numpy.ndarray'>

补充：
range: 多用作循环，range（0,10）返回一个list；
xrange: 也是用作循环，只是xrang(0,10)不返回list，返回xrange对象。每次调用返回其中的一个值。
返回很大的数的时候或者频繁的需要break时候，xrange性能更好
arange: arange是numpy模块中的函数，使用前需要先导入此模块，arange(3):返回array类型对象

创建数组

array(object): object可为列表核元祖，当object为序列包含序列时进行二维转化，同理包含层次决定数组维度
array( object, dtype=complex )：dtype指定数据类型

>>> e = array([2,3,4])>>> earray([2, 3, 4])>>> e.dtypedtype('int64')>>> b = array([(1.5,2,3),(4,5.6)])>>> barray([(1.5, 2, 3), (4, 5.6)], dtype=object)>>> c = array([[1,2],[3,4]],dtype=complex)>>> carray([[ 1.+0.j,  2.+0.j],       [ 3.+0.j,  4.+0.j]])

创建特殊矩阵
zeros创建一个全是0的数组
ones 创建一个全1的数组
empty 创建一个内容随机并且依赖与内存状态的数组
arange的函数返回数组而不是列表
默认创建的数组类型(dtype)都是float64

>>> zeros((3,4))array([[ 0.,  0.,  0.,  0.],       [ 0.,  0.,  0.,  0.],       [ 0.,  0.,  0.,  0.]])>>> ones((2,3,4),dtype=int16)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)>>> empty((2,3))array([[  6.93761436e-310,   6.93761436e-310,   6.93761317e-310],       [  6.93761317e-310,   1.33397724e-322,   0.00000000e+000]])>>> arange(10,30,5)array([10, 15, 20, 25])

当 arange 使用浮点数参数时，由于有限的浮点数精度，通常无法预测获得的元素个数。因此，最好使用函数 linspace 去接收我们想要的元素个数来代替用range来指定步长。

其它函数array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, rand, randn, fromfunction, fromfile参考Numpy示例

打印数组

当你打印一个数组，NumPy以类似嵌套列表的形式显示它，但是呈以下布局：
- 最后的轴从左到右打印
- 次后的轴从顶向下打印
- 剩下的轴从顶向下打印，每个切片通过一个空行与下一个隔开
一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表

>>> arange(10,30,5)array([10, 15, 20, 25])>>> a = arange(6)>>> aarray([0, 1, 2, 3, 4, 5])>>> b = arange(12).reshape(4,3)>>> barray([[ 0,  1,  2],       [ 3,  4,  5],       [ 6,  7,  8],       [ 9, 10, 11]])>>> c = arange(24).reshape(2,3,4)>>> carray([[[ 0,  1,  2,  3],        [ 4,  5,  6,  7],        [ 8,  9, 10, 11]],       [[12, 13, 14, 15],        [16, 17, 18, 19],        [20, 21, 22, 23]]])

如果一个数组用来打印太大了，NumPy自动省略中间部分而只打印角落
禁用NumPy的这种行为并强制打印整个数组，你可以设置printoptions参数来更改打印选项: set_printoptions(threshold=’nan’)

基本运算

数组的算术运算是按元素的。新的数组被创建并且被结果填充(得到新的数组)
乘法
NumPy中的乘法运算符 * 指示按元素计算，矩阵乘法可以使用 dot 函数或创建矩阵对象实现

>>> A = arange(12).reshape(3,4)>>> Aarray([[ 0,  1,  2,  3],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])>>> B = arange(10,22,1).reshape(3,4)>>> Barray([[10, 11, 12, 13],       [14, 15, 16, 17],       [18, 19, 20, 21]])>>> A*Barray([[  0,  11,  24,  39],       [ 56,  75,  96, 119],       [144, 171, 200, 231]])

+=及*=
被用来更改已存在数组而不创建一个新的数组

>>> a = ones((2,3),dtype=int)>>> b = random.random((2,3))>>> a *=3>>> aarray([[3, 3, 3],       [3, 3, 3]])>>> b += 1>>> barray([[ 1.85573818,  1.09640797,  1.35737941],       [ 1.70591963,  1.38149673,  1.28000254]])>>> a += b>>> aarray([[4, 4, 4],       [4, 4, 4]])

运算函数：

>>> a = random.random((2,3))>>> aarray([[ 0.47258799,  0.67888664,  0.89625884],       [ 0.65408154,  0.20799711,  0.44150146]])>>> a.sum()3.3513135849749442>>> a.min()0.20799710512410585>>> a.max()0.89625883705977549

指定 axis 参数你可以吧运算应用到数组指定的轴上:

>>> b = arange(12).reshape(3,4)>>> barray([[ 0,  1,  2,  3],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])>>> b.sum(axis=0)array([12, 15, 18, 21])>>> 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]])

通用函数

常见的数学函数: sin 、cos、exp。按数组的元素运算，产生一个数组作为输出

>>> B = arange(3)>>> Barray([0, 1, 2])>>> exp(B)array([ 1.        ,  2.71828183,  7.3890561 ])>>> sqrt(B)array([ 0.        ,  1.        ,  1.41421356])>>> C = array([2.,-1.,4.])>>> add(B,C)array([ 2.,  0.,  6.])

更多函数all, alltrue, any, apply along axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, conjugate, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sometrue, sort, std, sum, trace, transpose, var, vdot, vectorize, where。

索引，切片和迭代

一维数组：可以被索引、切片和迭代

>>> a = arange(10)**3>>> aarray([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])>>> a[2]8>>> a[2:5]array([ 8, 27, 64])>>> a[:6:2]array([ 0,  8, 64])>>> a[::-1]array([729, 512, 343, 216, 125,  64,  27,   8,   1,   0])>>> 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 = 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]])>>> b[2,3]23>>> b[0:5, 1]                       # each row in the second column of barray([ 1, 11, 21, 31, 41])>>> b[ : ,1]                        # equivalent to the previous examplearray([ 1, 11, 21, 31, 41])>>> b[1:3, : ]                      # each column in the second and third row of barray([[10, 11, 12, 13],       [20, 21, 22, 23]])

对每个数组中元素进行运算，我们可以使用flat属性，该属性是数组元素的一个迭代器

>>> for ele in c.flat:...     print ele,... 0 1 8 27 64 125 216 343 512 729

更多[], …, newaxis, ndenumerate, indices, index exp

形状操作

更改数组形状：
ravel()：扁平化数组
reshape()：改变参数形状并返回
resize()：改变数组自身
reshape()：改变数组维度

>>> a = floor(10*random.random((3,4)))>>> aarray([[ 6.,  1.,  7.,  3.],       [ 4.,  5.,  7.,  2.],       [ 2.,  6.,  6.,  6.]])>>> a.ravel()array([ 6.,  1.,  7.,  3.,  4.,  5.,  7.,  2.,  2.,  6.,  6.,  6.])>>> a.shape = (6,2)>>> a.transpose()array([[ 6.,  7.,  4.,  7.,  2.,  6.],       [ 1.,  3.,  5.,  2.,  6.,  6.]])>>> a.resize((2,6))>>> aarray([[ 6.,  1.,  7.,  3.,  4.,  5.],       [ 7.,  2.,  2.,  6.,  6.,  6.]])

组合不同数组
vstack()：行增加
hstack()：列增加
column_stack: 以列将一维数组合成二维数组
row_stack: 一维数组以行组合成二维数组

>>> a = floor(10*random.random((2,2)))>>> aarray([[ 7.,  5.],       [ 2.,  3.]])>>> b = floor(10*random.random((2,2)))>>> barray([[ 4.,  0.],       [ 6.,  9.]])>>> vstack((a,b))array([[ 7.,  5.],       [ 2.,  3.],       [ 4.,  0.],       [ 6.,  9.]])>>> hstack((a,b))array([[ 7.,  5.,  4.,  0.],       [ 2.,  3.,  6.,  9.]])>>> column_stack((a,b))array([[ 7.,  5.,  4.,  0.],       [ 2.,  3.,  6.,  9.]])>>> a = array([4,2])>>> b = array([2,8])>>> a[:,newaxis]array([[4],       [2]])>>> newaxis>>> column_stack((a[:,newaxis],b[:,newaxis]))array([[4, 2],       [2, 8]])>>> vstack((a[:,newaxis],b[:,newaxis]))array([[4],       [2],       [2],       [8]])

当维度大于２：hstack沿着第二个轴组合，vstack沿着第一个轴组合。concatenate允许可选参数给出组合时沿着的轴。
r_[]及c_[] : r_[1:4,0,4] ⇒ array([1, 2, 3, 0, 4])
一个数组分割成几个小数组
hsplit: 将数组沿着它的水平轴分割，或者指定返回相同形状数组的个数，或者指定在哪些列后发生分割
vsplit: 沿着纵向的轴分割 array_split: 允许指定沿哪个轴分割

>>> a = floor(10*random.random((2,12)))>>> aarray([[ 1.,  3.,  6.,  2.,  6.,  1.,  8.,  1.,  3.,  3.,  7.,  4.],       [ 7.,  1.,  3.,  2.,  0.,  7.,  8.,  0.,  4.,  9.,  8.,  2.]])>>> hsplit(a,3)[array([[ 1.,  3.,  6.,  2.],       [ 7.,  1.,  3.,  2.]]), array([[ 6.,  1.,  8.,  1.],       [ 0.,  7.,  8.,  0.]]), array([[ 3.,  3.,  7.,  4.],       [ 4.,  9.,  8.,  2.]])]>>> hsplit(a,(3,4))[array([[ 1.,  3.,  6.],       [ 7.,  1.,  3.]]), array([[ 2.],       [ 2.]]), array([[ 6.,  1.,  8.,  1.,  3.,  3.,  7.,  4.],       [ 0.,  7.,  8.,  0.,  4.,  9.,  8.,  2.]])]>>> vsplit(a,(3,4))[array([[ 1.,  3.,  6.,  2.,  6.,  1.,  8.,  1.,  3.,  3.,  7.,  4.],       [ 7.,  1.,  3.,  2.,  0.,  7.,  8.,  0.,  4.,  9.,  8.,  2.]]), array([], dtype=float64), array([], dtype=float64)]

复制和视图

完全不拷贝：简单的赋值不拷贝数组对象或它们的数据

>>> a = arange(12)>>> b = a>>> b is aTrue>>> b.shape = 3,4>>> a.shape(3, 4)

说明：引用传递

视图和浅复制：不同的数组对象分享同一个数据。视图方法创造一个新的数组对象指向同一数据

>>> c = a.view()>>> c is aFalse>>> c.base is aTrue>>> c.flags.owndataFalse>>> c.shape = 2,6>>> a.shape(3, 4)>>> c[0,4] = 1234>>> aarray([[   0,    1,    2,    3],       [1234,    5,    6,    7],       [   8,    9,   10,   11]])>>> 

视图：改变数值时会影响原数组
切片数组返回它的一个视图

>>> s = a[:,1:3]>>> s[:] = 10>>> aarray([[   0,   10,   10,    3],       [1234,   10,   10,    7],       [   8,   10,   10,   11]])

深复制：完全复制数组和它的数据⇒ 与原数组完全没关系，深度复制

>>> d = a.copy()>>> d is aFalse>>> d.base is a False>>> d[0,0] = 9999>>> aarray([[   0,   10,   10,    3],       [1234,   10,   10,    7],       [   8,   10,   10,   11]])

总结

创建数组

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r , zeros, zeros_like
转化
astype, atleast 1d, atleast 2d, atleast 3d, mat
操作
array split, column stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack
询问
all, any, nonzero, where
排序
argmax, argmin, argsort, max, min, ptp, searchsorted, sort
运算
choose, compress, cumprod, cumsum, inner, fill, imag, prod, put, putmask, real, sum
基本统计
cov, mean, std, var
基本线性代数
cross, dot, outer, svd, vdot

进阶

暂时先不看，请看页首原文