Numpy 学习之路（1）——数组的创建

数组是Numpy操作的主要对象，也是python数据分析的主要对象，本系列文章是本人在学习Numpy中的笔记。

文章中以下都基于以下方式的numpy导入：

import numpy as np
from numpy import *

1、普通数组的创建——np.arange(), np.array(),

(1) arange()建立是顺序数组，函数原型：arange([start,]stop[,step],dtype=None)

其中start参数如果省略，则表示从0开始，默认的dtype为float32

#创建从0-19的一维数组ar_1
ar_1=np.arange(20)
#output: ar_1=array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,17, 18, 19])
#创建11-20,step=2的一维数组ar_2
ar_2=np.arange(11,21,2)
#output:ar_2=array([11, 13, 15, 17, 19])

(2)array()的主要用于创建多维数组，原型为：array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

• object : 是一个array_like象，包括list，tuple等__array__定制类可以返回类数组的对象。
• dtype：数据类型，默认为可以保存数据的最小类型，可以制定
• 其他的参数可以通过help来查看，这里就只介绍最常用的

#创建一个2*3的数组，数据类型为int32
ary_1=np.array([[2,2,3],[5,7,3]],dtype=int32)
#output：ary_1=([[2, 2, 3],
#                          [5, 7, 3]], dtype=int32)

#创建一个2*3*3的数组，数据类型默认：
ary_2=np.array([[[3,4,5],[3.3,4.2,4.2],[1.3,2.2,5.8]],[[2.3,1.9,5.7],[4.5,6.7,9.7],[2.2,1.2,7.99]]])
#output:
#array([[[ 3.  ,  4.  ,  5.  ],
#        [ 3.3 ,  4.2 ,  4.2 ],
#        [ 1.3 ,  2.2 ,  5.8 ]],
#
#       [[ 2.3 ,  1.9 ,  5.7 ],
#        [ 4.5 ,  6.7 ,  9.7 ],
#        [ 2.2 ,  1.2 ,  7.99]]])
ary_2.dtype
#output:dtype('float64')，#虽然由int和float， array是以可以保存这些数据的最小数据类型保存，所以是float32#当然也可以通过reshape等方式改变数组的维度，从而获得自己所需要的数组ary_3=np.arange(20,30).reshape(2,5)#output:ary_3#array([[20, 21, 22, 23, 24],#       [25, 26, 27, 28, 29]])

2. 特殊数组的创建：

（1）空数组：empty(),empty_like()

• empty(shape[,dtype=None,order=]), 创建一个形状构成为shape的空数组，dtype为数据类型，order为顺序形式：C（C语言）-row-major；F（Fortran）column-major。
• empty_like(array)， 依据给定数组(a)的形状和类型返回一个新的空数组。

#创建一个3*3的空数组：
e_1=np.empty([3,3])
#In [89]: print e_1
#[[  1.72723371e-077   2.68678134e+154   4.44659081e-323]
 #[  0.00000000e+000   0.00000000e+000   0.00000000e+000]
 #[  0.00000000e+000   0.00000000e+000   0.00000000e+000]]
#填充的数值都是随机的random

#通过empty_like创建与e_1一样形状的空数组
e_2=np.empty_like(e_1)
#In [93]: print e_2
#[[  1.72723371e-077   1.72723371e-077   2.00299617e-313]
 #[  1.72723371e-077   5.92878775e-323   3.18299369e-313]
 #[  0.00000000e+000   9.73471935e-309   0.00000000e+000]]

（2）其他特殊数组创建：eye, ones, zeros也有类似的结构，另外还有一个identity函数，用以创建方阵

• eye[N,[, M, k, dtype]), N为行数，M为列数（如果不设置默认为N），对角线序列号: 0 对应主对角线；,整数对应upper diagonal,负数对应lower diagonal；
• eye_like(array)，创建形状与array一样形状的对角线为1的数组

#创建3*3主对角线为1的方阵：
ey_1=np.eye(3,3,k=0)
print ey_1
#[[ 1.  0.  0.]
#[ 0.  1.  0.]
#[ 0.  0.  1.]]

#ey_2的对角线uper了一个位置（行）
ey_2=np.eye(3,3,k=1)
pringt ey_2
#[[ 0.  1.  0.]
#[ 0.  0.  1.]
#[ 0.  0.  0.]]

• ones(shape[,dtpe=,order]):按照给定的形状返回一个形状为shape的元素为1的数组
• ones_like(a)：返回一个形状跟a一样的元素为1的数组

one_1=np.ones([5,9])
print one_1
#In [99]: print one_1
#[[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
#[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
#[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
#[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
#[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]]

• zeros(shape[,dtype,order]): 按照给定的形状返回一个形状为shape的元素为0的数组
• zeros_like(a)：返回一个形状跟a一样的元素为0的数组

zero_1=np.zeros([2,3])
print zero_1
#[[ 0.  0.  0.]
#[ 0.  0.  0.]]

• identity(n[,dtype=])返回一个n维的方阵

In [103]: iden
Out[103]:
array([[ 1.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  1.]])

3. 结构体数组

通常，一个数组保存的元素都是同源的，即数组内所有元素都需为同一个类型。在实际的数据分析过程中，尤其是二维spreadsheet式格式的数据，同一行的数据由不同的类型构成。这就需要为这种数据定义一个个性的dtype。dtype实际上是一个类，可以通过赋予参数定义特殊的结构体数组类型。（个人觉得有点类似于SAS中的informat）

#定义一个名称为person的dtype，通过dtype
#一个peson由name,age和weight构成
person=np.dtype([('name',str,20),('age',int32),('weight',float32)])
print person
#[('name', 'S20'), ('age', '<i4'), ('weight', '<f4')]

#就可以创建dtype为person的数组了
student=array([('cnblog',10,12.2),('myBlog',40,30)],dtype=person)
#由于类型规定了参数的个数，所以需要用tuple来创建数组的行数（因为其不可变），否则可能会有一个readable的exception
print student
#[('cnblog', 10, 12.199999809265137) ('myBlog', 40, 30.0)]

4. 从文件创建（后续会有专门介绍）