Numpy学习笔记——Numpy基础

2.1 NumPy 数组对象

NumPy中的ndarray是一个多维数组对象，该对象由两部分组成：
实际的数据；
描述这些数据的元数据。

NumPy数组一般是同质的。
用arange函数创建数组并获取其维度：
arr.shape:返回的tuple元组

In: a = arange(5)
In: a.dtype
Out: dtype('int64')
In: a.shape

2.2 创建多维数组

array函数可以依据给定的对象生成数组。给定的对象应是类数组，如Python中的列表，返回的是numpy.ndarray。

In: m = array([arange(2), arange(2)])
In: m
Out:
array([[0, 1],
       [0, 1]])
In: m.shape
Out: (2, 2)

2.2.1 选取数组元素

给array函数传递的对象是一个嵌套的列表,

In: a = array([[1,2],[3,4]])
In: a
Out:
array([[1, 2],
       [3, 4]])
In: a[0,0]
Out: 1

2.2.2 NumPy 数据类型

bool 用一位存储的布尔类型（值为TRUE或FALSE）
inti 由所在平台决定其精度的整数（一般为int32或int64）
int8 整数，范围为.128至127
int16 整数，范围为.32 768至32 767
int32 整数，范围为.231至231 .1
int64 整数，范围为.263至263 .1
uint8 无符号整数，范围为0至255
uint16 无符号整数，范围为0至65 535
uint32 无符号整数，范围为0至232.1
uint64 无符号整数，范围为0至264.1
float16 半精度浮点数（16位）：其中用1位表示正负号，5位表示指数，10位表示尾数
float32 单精度浮点数（32位）：其中用1位表示正负号，8位表示指数，23位表示尾数
float64或float 双精度浮点数（64位）：其中用1位表示正负号，11位表示指数，52位表示尾数
complex64 复数，分别用两个32位浮点数表示实部和虚部
complex128或complex 复数，分别用两个64位浮点数表示实部和虚部

每一种数据类型均有对应的类型转换函数：
需要注意的是，复数是不能转换为整数的,同样，复数也不能转换为浮点数。不过，浮点数却可以转换为复数，例如complex(1.0).有j的部分为复数的虚部。

In: float64(42)
Out: 42.0
In: int8(42.0)
Out: 42
In: bool(42)
Out: True
In: bool(0)
Out: False
In: bool(42.0)
Out: True
In: float(True)
Out: 1.0
In: float(False)
Out: 0.0

在NumPy中，许多函数的参数中可以指定数据类型:

In: arange(7, dtype=uint16)
Out: array([0, 1, 2, 3, 4, 5, 6], dtype=uint16)

2.2.3 数据类型对象

数据类型对象是numpy.dtype类的实例,数据类型对象可以给出单个数组元素在
内存中占用的字节数

In: a.dtype.itemsize
Out: 8

2.2.4 字符编码

创建了一个单精度浮点数数组:

In: arange(7, dtype='f')
Out: array([ 0., 1., 2., 3., 4., 5., 6.], dtype=float32)

In: arange(7, dtype='D')
Out: array([ 0.+0.j, 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j])

2.2.5 自定义数据类型

可以使用Python中的浮点数类型：
完整的NumPy数据类型列表可以在sctypeDict.keys()中找到

In: dtype(float)
Out: dtype('float64')

2.2.6 dtype 类的属性

获取数据类型的字符编码:

In: t = dtype('Float64')
In: t.char
Out: 'd'
In: t.type
Out: <type 'numpy.float64'>
In: t.str
Out: '<f8'

2.3 动手实践：创建自定义数据类型

创建数据类型:

t = np.dtype([('name', np.str_, 40), ('numitems', np.int32), ('price',np.float32)])

查看数据类型:

In: t['name']
Out: dtype('|S40')

创建自定义数据类型的数组

In: itemz = array([('Meaning of life DVD', 42, 3.14), ('Butter', 13,2.72)], dtype=t)
In: itemz[1]
Out: ('Butter', 13, 2.7200000286102295)

2.4 一维数组的索引和切片

In: a = arange(9)
In: a[3:7]
Out: array([3, 4, 5, 6])
In: a[:7:2]
Out: array([0, 2, 4, 6])
In: a[::-1]
Out: array([8, 7, 6, 5, 4, 3, 2, 1, 0])

2.5 多维数组的切片和索引

用arange函数创建一个数组并改变其维度：
下面是一个从1维数组变为3维数组，2表示第一维上有两个元素，3表示第二维上有3个元素…是一个2×3×4的三维数组

In: b = arange(24).reshape(2,3,4)
In: b[0,0,0]
In: b
Out:
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]]])
Out: 0
In: b[:,0,0]
Out: array([ 0, 12])
//多个冒号可以用一个省略号（...）来代替
In: b[0, :, :]
In: b[0, ...]

2.6 动手实践：改变数组的维度

ravel:将数组展平,是返回数组的一个视图，flatten函数会请求分配内存来保存结果

In: b
Out:
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]]])
In: b.ravel()
Out:
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])
In: b.flatten()
Out:
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])
//用一个正整数元组来设置数组的维度
In: b.shape = (6,4)

transpose 转置矩阵
resize resize和reshape函数的功能一样，但resize会直接修改所操作的数组

In: b.transpose()
In: b.resize((2,12))

2.7 数组的组合

(1) 水平组合

In: a = arange(9).reshape(3,3)
In: a
Out:
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
In: b = 2 * a
In: b
Out:
array([[ 0, 2, 4],
       [ 6, 8, 10],
       [12, 14,16]])
In: hstack((a, b))
Out:
array([[ 0, 1, 2, 0, 2, 4],
       [ 3, 4, 5, 6, 8,10],
       [ 6, 7, 8,12,14,16]])
In: concatenate((a, b), axis=1)

(2) 垂直组合:

In: vstack((a, b))
Out:
array([[ 0, 1, 2],
       [ 3, 4, 5],
       [ 6, 7, 8],
       [ 0, 2, 4],
       [ 6, 8,10],
       [12,14,16]])

In: concatenatel((a, b), axis = 0)
Out:
array([[ 0, 1, 2],
       [ 3, 4, 5],
       [ 6, 7, 8],
       [ 0, 2, 4],
       [ 6, 8,10],
       [12,14,16]])

(3) 深度组合

In: dstack((a, b))
Out:
array([[[0, 0],
        [1, 2],
        [2, 4]],
       [[3, 6],
        [4, 8],
        [5,10]],
       [[6,12],
        [7,14],
        [8,16]]])

(4) 列组合 column_stack函数对于一维数组将按列方向进行组合:

In: oned = arange(2)
In: oned
Out: array([0, 1])
In: twice_oned = 2 * oned
In: twice_oned
Out: array([0, 2])
In: column_stack((oned, twice_oned))
Out:
array([[0, 0],
       [1, 2]])
In: column_stack((a, b))
Out:
array([[ 0, 1, 2, 0, 2, 4],
       [ 3, 4, 5, 6, 8,10],
       [ 6, 7, 8,12,14,16]])
//可以用==运算符来比较两个NumPy数组
In: column_stack((a, b)) == hstack((a, b))

(5) 行组合 当然，NumPy中也有按行方向进行组合的函数

In: row_stack((oned, twice_oned))
Out:
array([[0, 1],
       [0, 2]])

2.9 数组的分割

(1) 水平分割

In: a
Out:
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
In: hsplit(a, 3)
Out:
[array([[0],
        [3],
        [6]]),
array ([[1],
        [4],
        [7]]),
array ([[2],
        [5],
        [8]])]
In: split(a, 3, axis=1)

(2) 垂直分割:

In: vsplit(a, 3)
Out: [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
In: split(a, 3, axis=0)

(3) 深度分割:

In: c = arange(27).reshape(3, 3, 3)
In: c
Out:
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]]])
In: dsplit(c, 3)

2.11 数组的属性

ndim属性，给出数组的维数，或数组轴的个数
size属性，给出数组元素的总个数
itemsize属性，给出数组中的元素在内存中所占的字节数
T属性的效果和transpose函数一样:

In: b.T

在NumPy中，复数的虚部是用j表示的:

In: b = array([1.j + 1, 2.j + 3])

real属性，给出复数数组的实部:

In: b.real

imag属性，给出复数数组的虚部:

In: b.imag

flat属性将返回一个numpy.flatiter对象，这是获得flatiter对象的唯一方式,“扁平迭代器”可以让我们像遍历一维数组一样去遍历任意的多维数组:

In: b = arange(4).reshape(2,2)
In: f = b.flat
In: for item in f: print item
In: b.flat[2]
In: b.flat[[1,3]]

2.12 动手实践：数组的转换

使用tolist函数将NumPy数组转换成Python列表:

 In: b.tolist()