为什么要用numpy

Python中提供了list容器，可以当作数组使用。但列表中的元素可以是任何对象，因此列表中保存的是对象的指针，这样一来，为了保存一个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说，这种结构显然不够高效。

Python虽然也提供了array模块，但其只支持一维数组，不支持多维数组，也没有各种运算函数。因而不适合数值运算。

NumPy的出现弥补了这些不足。

import numpy as np

数组创建

常规创建方法a = np.array([2,3,4])

b = np.array([2.0,3.0,4.0])

c = np.array([[1.0,2.0],[3.0,4.0]])

d = np.array([[1,2],[3,4]],dtype=complex) # 指定数据类型

print a, a.dtype

print b, b.dtype

print c, c.dtype

print d, d.dtype

输出结果

[2 3 4] int32

[ 2. 3. 4.] float64

[[ 1. 2.]

[ 3. 4.]] float64

[[ 1.+0.j 2.+0.j]

[ 3.+0.j 4.+0.j]] complex128

创建数组的常用函数print np.arange(0,7,1,dtype=np.int16) # 0为起点，间隔为1时可缺省(引起歧义下不可缺省)

print np.ones((2,3,4),dtype=np.int16) # 2页，3行，4列，全1，指定数据类型

print np.zeros((2,3,4)) # 2页，3行，4列，全0

print np.empty((2,3)) #值取决于内存

print np.arange(0,10,2) # 起点为0，不超过10，步长为2

print np.linspace(-1,2,5) # 起点为-1，终点为2，取5个点

print np.random.randint(0,3,(2,3)) # 大于等于0，小于3，2行3列的随机整数

输出结果

[0 1 2 3 4 5 6]

[[[1 1 1 1]

[1 1 1 1]

[1 1 1 1]]

[[1 1 1 1]

[1 1 1 1]

[1 1 1 1]]]

[[[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]]

[[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]

[ 0. 0. 0. 0.]]]

[[ 1.39069238e-309 1.39069238e-309 1.39069238e-309]

[ 1.39069238e-309 1.39069238e-309 1.39069238e-309]]

[0 2 4 6 8]

[-1. -0.25 0.5 1.25 2. ]

[[1 0 1]

[0 1 0]]

类型转换print float(1)

print int(1.0)

print bool(2)

print float(True)

输出结果

1.0

1

True

1.0

数组输出

从左到右，从上向下

一维数组打印成行，二维数组打印成矩阵，三维数组打印成矩阵列表

print np.arange(1,6,2)

print np.arange(12).reshape(3,4) # 可以改变输出形状

print np.arange(24).reshape(2,3,4)# 2页，3行，4页

输出结果

[1 3 5]

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]]

基本运算##元素级运算

a = np.array([1,2,3,4])

b = np.arange(4)

print a, b

print a-b

print a*b

print a**2

print 2*np.sin(a)

print a>2

print np.exp(a) # 指数

输出结果

[1 2 3 4] [0 1 2 3]

[1 1 1 1]

[ 0 2 6 12]

[ 1 4 9 16]

[ 1.68294197 1.81859485 0.28224002 -1.51360499]

[False False True True]

[ 2.71828183 7.3890561 20.08553692 54.59815003]

##矩阵运算(二维数组)

a = np.array([[1,2],[3,4]]) # 2行2列

b = np.arange(6).reshape((2,-1)) # 2行3列

print a,b

print a.dot(b) # 2行3列

输出结果

[[1 2]

[3 4]] [[0 1 2]

[3 4 5]]

[[ 6 9 12]

[12 19 26]]

##非数组运算，调用方法

a = np.random.randint(0,5,(2,3))

print a

print a.sum(),a.sum(axis=1),a.sum(0) # axis用于指定运算轴(默认全部，可指定0或1)

print a.min(),a.max(axis=1),a.mean(axis=1) # axis = 0: 按列计算，axis = 1: 按行计算

print a.cumsum(1) # 按行计算累积和

输出结果

[[2 3 3]

[0 2 1]]

11 [8 3] [2 5 4]

0 [3 2] [ 2.66666667 1. ]

[[2 5 8]

[0 2 3]]

索引，切片，迭代##一维数组

a = np.arange(0,10,1)**2

print a

print a[0],a[2],a[-1],a[-2] # 索引从0开始，-1表示最后一个索引

print a[2:5],a[-5:-1] # 包括起点，不包括终点

a[-1] = 100; print a # 赋值

a[1:4]=100; print a # 批量赋值

a[:6:2] = -100; print a # 从开始到第6个索引，每隔一个元素(步长=2)赋值

print a[: :-1];print a # 将a逆序输出，a本身未发生改变

b = [np.sqrt(np.abs(i)) for i in a]; print b # 通过遍历赋值

输出结果

[ 0 1 4 9 16 25 36 49 64 81]

0 4 81 64

[ 4 9 16] [25 36 49 64]

[ 0 1 4 9 16 25 36 49 64 100]

[ 0 100 100 100 16 25 36 49 64 100]

[-100 100 -100 100 -100 25 36 49 64 100]

[ 100 64 49 36 25 -100 100 -100 100 -100]

[-100 100 -100 100 -100 25 36 49 64 100]

[10.0, 10.0, 10.0, 10.0, 10.0, 5.0, 6.0, 7.0, 8.0, 10.0]

##多维数组

a = np.arange(0,20).reshape((4,5))

print a, a[2,3], a[:,1], a[1:4,2], a[1:3,:]

print a[-1] # 相当于a[-1,:],即索引少于轴数时，确实的索引默认为整个切片

b = np.arange(0,24).reshape((2,3,4))

print b,b[1] # 相当于b[1,:,:] 和b[1,...]

print '-------------------'

for row in a:

print row # 遍历以第一个轴为基础

输出结果

[[ 0 1 2 3 4]

[ 5 6 7 8 9]

[10 11 12 13 14]

[15 16 17 18 19]] 13 [ 1 6 11 16] [ 7 12 17] [[ 5 6 7 8 9]

[10 11 12 13 14]]

[15 16 17 18 19]

[[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]

[0 1 2 3 4]

[5 6 7 8 9]

[10 11 12 13 14]

[15 16 17 18 19]

形状操作a = np.floor(10*np.random.random((3,4)))

print a, a.shape #输出a的形状

print a.ravel() # 输出平坦化后的a(a本身不改变)

a.shape = (6,2); print a # 改变a的形状

print a.transpose() # 输出a的转置

输出结果

[[ 0. 4. 3. 2.]

[ 1. 1. 3. 3.]

[ 4. 4. 6. 5.]] (3, 4)

[ 0. 4. 3. 2. 1. 1. 3. 3. 4. 4. 6. 5.]

[[ 0. 4.]

[ 3. 2.]

[ 1. 1.]

[ 3. 3.]

[ 4. 4.]

[ 6. 5.]]

[[ 0. 3. 1. 3. 4. 6.]

[ 4. 2. 1. 3. 4. 5.]]

##补充：reshape和resize

a = np.array([[1,2,3],[4,5,6]])

b = a

a.reshape((3,2))# 不改变数组本身的形状

print a

b.resize((3,2))# 改变数组本身形状

print b

输出结果

[[1 2 3]

[4 5 6]]

[[1 2]

[3 4]

[5 6]]