2:numpy---ndarray - 爱码网

一：创建ndarray

　　有好几种创建数组的方法。

　　例如，你可以使用 array 函数从常规的Python列表和元组创造数组。所创建的数组类型由原序列中的元素类型推导而来。

　　>>> import numpy as np
　　>>> a = np.array( [2,3,4] )
　　>>> a
　　array([2, 3, 4])
　　>>> a.dtype
　　dtype('int32')
　　dtype('float64')  一个常见的错误包括用多个数值参数调用`array`而不是提供一个由数值组成的列表作为一个参数。
　　>>> a = np.array(1,2,3,4)    # WRONG
　　>>> a = np.array([1,2,3,4])  # RIGHT

　　数组将序列包含序列转化成二维的数组，序列包含序列包含序列转化成三维数组等等。

　　>>> data = [ [1.5,2,3], [4,5,6] ]

　　>>> b = np.array( data )
　　>>> b
　　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]])

　　通常，数组的元素开始都是未知的，但是它的大小已知。因此，NumPy提供了一些使用占位符创建数组的函数。这最小化了扩展数组的需要和高昂的运算代价。

　　函数 function 创建一个全是0的数组，函数 ones 创建一个全1的数组，函数empty 创建一个内容随机并且依赖与内存状态的数组【默认创建的数组类型(dtype)都是float64】

　　>>> zeros(( 3,4))
　　array([[0.,  0.,  0.,  0.],
 　　      [0.,  0.,  0.,  0.],
　　       [0.,  0.,  0.,  0.]])
　　>>> ones( (2,3,4), dtype=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)
　　>>> empty( (2,3) )
　　array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
　　       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

　　为了创建一个数列，NumPy提供一个类似arange的函数返回数组而不是列表:

　　>>> arange( 10, 30, 5 )
　　array([10, 15, 20, 25])
　　>>> arange( 0, 2, 0.3 )                 # it accepts float arguments
　　array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

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

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

二：numpy的数据类型【dtype】

　　数字，字符串，对象，unicode

　　dtype命名方式：类型名 + 表示各元素位长的数字

　　　　　　　　　　e.g:int 16 , float 64 ......

　　查看类型：dtype方法

　　　　　　　　　arr.dtype()　

　　类型转换：astype方法

　　　　　　　e.g：arr = np.array([1,2,3])

　　　　　　　　　 float_array = arr.astype(np.float64)

　　　　　　　注：浮点数转为整数则会去掉小数部分

　　　　　　　如果某字符串数组全为数字，可将其转为数值形式

　　　　　　　e.g:　strings = np.array(['1','2','3','4'])

　　　　　　　　　　numeric_string = arr.astype(float)

三：数组运算

　　ndarray的运算是基于元素的，也就是说并不需要编写循环就能够对每个数据元素进行处理：

　　e.g：

　　　　arr = np.array([ [1,2,3], [4,5,6] ,[7,8,9]])

　　　　arr*2　　　　#则每个元素都乘以2

四：索引和切片

　　arr = np.array([[1,2,3], [4,5,6] ,[7,8,9]])

　　names = np.array(['bob','john','will','bob','will','joe','joe'])

　　1）切片：

　　　　一维数组的切片和python list的一样

　　　　二维的可以在两个方向上切

　　　　　　e.g：

　　　　　　　　arr[0:2]

　　　　　　　　-->array([[1, 2, 3],
　　　　　　　　　　　 [4, 5, 6]])

　　　　　　　　arr[0:2,1]
　　　　　　　　-->array([2, 5])

　　　　　　　　arr[0:2,0:2]
　　　　　　　　-->array([[1, 2],
　　　　　　　　　　　　　[4, 5]])

　　　　　　　　注：可以利用切片进行批量赋值[切记操作都是元素性的]

　　　　　　　　arr[0:2,0:2] = 9
　　　　　　　　arr

　　　　　　　　-->array([[9, 9, 3],

　　　　　　　　　　　　 [9, 9, 6],
　　　　　　　　　　　　　[7, 8, 9]])

　　2）数值索引

　　　　和python list索引一样

　　　　若是一个两行三列的数组arr，可以通过arr[x]访问第x行， arr[x][y]访问第x行y列的元素

　　3）布尔索引　　　

　　　　names = np.array(['bob','john','will','bob','will','joe','joe'])

　　　　names == 'bob'
　　　　-->array([ True, False, False, True, False, False, False], dtype=bool) #意思即是会产生一个布尔型的array数组

　　　　data = np.random.randn(5,4)

　　　　data
　　　　-->array([[-0.00343354, 0.50658368, 0.26039623, -1.17846766],
　　　　　　　 [ 0.10990542, 0.52022534, -1.10899795, -2.11391774],
　　　　　　　 [-0.69619996, 0.25121838, -0.50346134, -0.4248276 ],
　　　　　　　 [ 0.48882343, -1.409604 , -0.38028868, 0.4928941 ],
　　　　　　　 [-0.03851536, -1.6177832 , 0.24822048, 0.79837076]])

　　　　data[names == "bob"]
　　　　-->array([[-0.00343354, 0.50658368, 0.26039623, -1.17846766],
　　　　　　　 [ 0.48882343, -1.409604 , -0.38028868, 0.4928941 ]])

　　　注：还可以和切片联合使用

　　　　date[names == "bob",2:]
　　　　-->array([[ 0.26039623, -1.17846766],
　　　　　　　　[-0.38028868, 0.4928941 ]])

　　4)花式索引【fancy indexing】：利用整数数组进行索引

　　　　　　arr = np.empty((8,4))

　　　　　　arr
　　　　　　-->array([[ 3.63521590e+228, 6.96747054e+252, 5.81241635e+180,2.30074046e-312],
　　　　　　　　　 [ 3.16276242e-316, 3.24199869e-316, 3.16276242e-316,2.30320756e-316],
　　　　　　　　　 [ 2.30321230e-316, 2.44349454e-316, 2.30320993e-316,3.18366574e-316],
　　　　　　　　　 [ 2.30320756e-316, 2.30321942e-316, 2.30320993e-316,3.18366574e-316],
　　　　　　　　　 [ 2.30320756e-316, 2.30321942e-316, 2.30320756e-316,2.44346371e-316],
　　　　　　　　　 [ 3.22628503e-316, 3.22637041e-316, 3.22628266e-316,2.44349928e-316],
　　　　　　　　　 [ 3.22635618e-316, 3.24213624e-316, 2.30320282e-316,3.16264621e-316],
　　　　　　　　　 [ 2.30320756e-316, 3.22635618e-316, 3.22637041e-316,3.22635618e-316]])

　　　　　　for i in range(8):

　　　　　　　　arr[i] = i

　　　　　　arr
　　　　　　-->array([[ 0., 0., 0., 0.],
　　　　　　　　　　[ 1., 1., 1., 1.],
　　　　　　　　　　[ 2., 2., 2., 2.],
　　　　　　　　　　[ 3., 3., 3., 3.],
　　　　　　　　　　[ 4., 4., 4., 4.],
　　　　　　　　　　[ 5., 5., 5., 5.],
　　　　　　　　　　[ 6., 6., 6., 6.],
　　　　　　　　　　[ 7., 7., 7., 7.]])

　　　　　　arr[[0,3,6]] #!!两个【【】】　　　　-号表示反向

　　　　　　-->array([[ 0., 0., 0., 0.],
　　　　　　　　　　[ 3., 3., 3., 3.],
　　　　　　　　　　[ 6., 6., 6., 6.]])

　　　　　　arr[[-0,-3,-6]]
　　　　　　-->array([[ 0., 0., 0., 0.],
　　　　　　　　　　[ 5., 5., 5., 5.],
　　　　　　　　　　[ 2., 2., 2., 2.]])

　　　　　　arr = np.arange(32).reshape((8,4)) #reshape方法对前面的一维数组元素重新排列

　　　　　　arr
　　　　　　-->array([[ 0, 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]])

　　　　　　arr[[1,5,7,2],[0,3,1,2]]　　　　　　　　　　#先选出行，再在对应行选出列元素
　　　　　　-->array([ 4, 23, 29, 10])

　　注：数组切片是原始数组的视图，也就是说数据不被复制，改动会直接反映到原数组上，与python里的切片不同！！

　　　　布尔索引与花式索引会创建副本

　　　　 2:numpy---ndarray

五：数组转置和轴对换

六：通用函数　　

　　abs：绝对值

　　sqr：平方根 <--------> square:平方

　　floor：取小于此数的最大整数 <-----> ceil

　　tan（h），cos（h），sin（h）：h表示反三角函数

　　e.g:

　　　　arr = np.arange(10)

　　　　np.sqrt(arr)
　　　　--->array([ 0. , 1. , 1.41421356, 1.73205081, 2. ,2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])

七：利用ndarray进行数据处理

　　e.g 1：计算sqrt（x^2+y^2）　　　　np.meshgrid()方法接收两个一维数组产生两个二维矩阵

　　　　　　points = np.arange(-5,5,1)

　　　　　　points
　　　　　　-->array([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4])

　　　　　　xs , ys = np.meshgrid(points,points)

　　　　　　ys
　　　　　　-->array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
　　　　　　　　　　[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
　　　　　　　　　　[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
　　　　　　　　　　[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
　　　　　　　　　　[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
　　　　　　　　　　[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
　　　　　　　　　　[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
　　　　　　　　　　[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
　　　　　　　　　　[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
　　　　　　　　　　[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]])

　　　　　　xs
　　　　　　-->array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
　　　　　　　　　　[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]])

　　　　　　z = np.sqrt(xs**2+ys**2)

　　　　　　z
　　　　　　-->array([[ 7.07106781, 6.40312424, 5.83095189, 5.38516481, 5.09901951,5. , 5.09901951, 5.38516481, 5.83095189, 6.40312424],
　　　　　　　　　　[ 6.40312424, 5.65685425, 5. , 4.47213595, 4.12310563,4. , 4.12310563, 4.47213595, 5. , 5.65685425],
　　　　　　　　　　[ 5.83095189, 5. , 4.24264069, 3.60555128, 3.16227766,3. , 3.16227766, 3.60555128, 4.24264069, 5. ],
　　　　　　　　　　[ 5.38516481, 4.47213595, 3.60555128, 2.82842712, 2.23606798,2. , 2.23606798, 2.82842712, 3.60555128, 4.47213595],
　　　　　　　　　　[ 5.09901951, 4.12310563, 3.16227766, 2.23606798, 1.41421356,1. , 1.41421356, 2.23606798, 3.16227766, 4.12310563],
　　　　　　　　　　[ 5. , 4. , 3. , 2. , 1. ,0. , 1. , 2. , 3. , 4. ],
　　　　　　　　　　[ 5.09901951, 4.12310563, 3.16227766, 2.23606798, 1.41421356,1. , 1.41421356, 2.23606798, 3.16227766, 4.12310563],
　　　　　　　　　　[ 5.38516481, 4.47213595, 3.60555128, 2.82842712, 2.23606798,2. , 2.23606798, 2.82842712, 3.60555128, 4.47213595],
　　　　　　　　　　[ 5.83095189, 5. , 4.24264069, 3.60555128, 3.16227766,3. , 3.16227766, 3.60555128, 4.24264069, 5. ],
　　　　　　　　　　[ 6.40312424, 5.65685425, 5. , 4.47213595, 4.12310563,4. , 4.12310563, 4.47213595, 5. , 5.65685425]])

　　e.g2:逻辑运算的数组表示

　　　　numpy.where函数即是x if condition else的矢量化版本：

　　　　arr = np.random.randn(4,4)

　　　　arr
　　　　-->array([[-1.51211007, 0.51280389, -0.62088368, -1.35715715],
　　　　　　　　　　[ 1.13127552, -0.98699052, -0.12450559, -0.81690629],
　　　　　　　　　　[ 1.08641757, 1.89675729, 0.54465751, -0.40756964],
　　　　　　　　　　[-1.92890717, -0.76061215, -1.67972853, 1.94591207]])

　　　　np.where(arr>0, 2 , arr) #将正值转化为2

　　　　-->array([[-1.51211007, 2. , -0.62088368, -1.35715715],
　　　　　　　　　　[ 2. , -0.98699052, -0.12450559, -0.81690629],
　　　　　　　　　　[ 2. , 2. , 2. , -0.40756964],
　　　　　　　　　　[-1.92890717, -0.76061215, -1.67972853, 2. ]])

　　e.g3：数学与统计方法：

　　　　对整个数组或某个轴向的数据进行统计计算

　　　　方法：sum，mean：算术平均数，std：标准差，var：方差，min，max，argmin最小值的索引，argmax，cumsum累积和，sumprod累计积

　　　　　　注：以上方法几乎都可以接受一个参数0或1，0代表列对待，1代表行对待

　　　　　　arr = np.array([[0,1,2],[3,4,5],[6,7,8]])

　　　　　　arr.min()
　　　　　　0

　　　　　　arr.sum()
　　　　　　36

　　　　　　arr.sum(1)
　　　　　　-->array([ 3, 12, 21])

　　　　　　arr.sum(0)
　　　　　　-->array([ 9, 12, 15])

　　　　　　arr.min(1)
　　　　　　-->array([0, 3, 6])

　　　　　　arr.min(0)
　　　　　　-->array([0, 1, 2])

　　e.g4:bool型数组的方法　　

　　　　（arr>0).sum(0)#在上面的那些方法中bool型会被强制转化为1或0

　　　　-->array([2, 3, 3])

　　　　(arr>0).sum()
　　　　8

　　e.g5:排序

　　　　sort方法

　　　　arr.sort（【0或1】）

e.g6：唯一化，unique（）函数，去掉重复函数

　　　　　　np.unique(arr)

e.g7:集合逻辑函数

　　　　inld(x,y):返回一个x集合的元素是否包含在y集合中的bool型数组

　　　　unionld(x,y):计算x，y的并集并返回有序结果

　　　　intersectld（x,y）:计算x,y的交集并且返回有序结果

　　　　setdiffld（x,y）:在x但不在y中的元素

　　　　setxorld（x,y）:仅在其中一个数组存在的元素

　　e.g8：随机数相关

　　　　　　numpy.random模块提供了许多生成随机数的方式

　　　　　　e.g：sample = np.random.normal(size=(4,4)) #即是生成一个标准正太分布的4X4数组

　　　　　　还有许多其他的生成方式就不赘述了

参考：http://blog.csdn.net/lsjseu/article/details/20359201；这篇文章十分详尽，我开头的创建ndarray是直接copy他的

　　　其他关于数据处理的例子来源为《利用python进行数据分析》