numpy基本用法

对于python中的numpy模块，一般用其提供的ndarray对象。 

创建一个ndarray对象很简单，只要将一个list作为参数即可。 

例如

 

import numpy as np #引入numpy库

#创建一维的narray对象
a = np.array([1,2,3,4,5])

#创建二维的narray对象
a2 = np.array([[1,2,3,4,5],[6,7,8,9,10]])

#创建多维对象以其类推

 

  获取矩阵行数列数（二维情况）

习惯了采用matlab进行数模的编程，要对矩阵进行遍历时，一般先获取矩阵的行数和列数。要获取narray对象的各维的长度，可以通过narray对象的shape属性

import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])

print(a.shape) #结果返回一个tuple元组 (2L, 5L)
print(a.shape[0]) #获得行数，返回 2
print(a.shape[1]) #获得列数，返回 5

 

 矩阵的截取 

 按行列截取 

矩阵的截取和list相同，可以通过[]（方括号）来截取

import numpy as np
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])

print(a[0:1]) #截取第一行,返回 [[1 2 3 4 5]]
print(a[1,2:5]) #截取第二行，第三、四列，返回 [8 9]

print(a[1,:]) #截取第二行,返回 [ 6  7  8  9 10]

 

 按条件截取 

按条件截取其实是在[]（方括号）中传入自身的布尔语句 

例如

import numpy as np

a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
b = a[a>6] # 截取矩阵a中大于6的元素，范围的是一维数组
print(b) # 返回 [ 7  8  9 10]

# 其实布尔语句首先生成一个布尔矩阵，将布尔矩阵传入[]（方括号）实现截取
print(a>6)
# 返回
[[False False False False False]
[False  True  True  True  True]]

 

按条件截取应用较多的是对矩阵中满足一定条件的元素变成特定的值。 

例如将矩阵中大于6的元素变成0。

import numpy as np

a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a)
#开始矩阵为
[[ 1  2  3  4  5]
[ 6  7  8  9 10]]

a[a>6] = 0
print(a)
#大于6清零后矩阵为
[[1 2 3 4 5]
[6 0 0 0 0]]

 

 矩阵的合并 

矩阵的合并可以通过numpy中的hstack方法和vstack方法实现

import numpy as np

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

#!注意 参数传入时要以列表list或元组tuple的形式传入
print(np.hstack([a1,a2]))
#横向合并，返回结果如下
[[1 2 5 6]
[3 4 7 8]]

print(np.vstack((a1,a2)))
#纵向合并，返回结果如下
[[1 2]
[3 4]
[5 6]
[7 8]]

 矩阵的合并也可以通过concatenatef方法。

np.concatenate( (a1,a2), axis=0 )  等价于  np.vstack( (a1,a2) )

np.concatenate( (a1,a2), axis=1 )  等价于  np.hstack( (a1,a2) )

 通过函数创建矩阵 

numpy模块中自带了一些创建ndarray对象的函数，可以很方便的创建常用的或有规律的矩阵。

arange

import numpy as np

a = np.arange(10) # 默认从0开始到10（不包括10），步长为1
print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]

a1 = np.arange(5,10) # 从5开始到10（不包括10），步长为1
print(a1) # 返回 [5 6 7 8 9]

a2 = np.arange(5,20,2) # 从5开始到20（不包括20），步长为2
print(a2) # 返回 [ 5  7  9 11 13 15 17 19]

 

 linspace 

linspace()和matlab的linspace很类似，用于创建指定数量等间隔的序列，实际生成一个等差数列。

import numpy as np

a = np.linspace(0,10,7) # 生成首位是0，末位是10，含7个数的等差数列
print(a)
# 结果
[  0.           1.66666667   3.33333333   5.         6.66666667  8.33333333  10.        ]

 

 logspace 

linspace用于生成等差数列，而logspace用于生成等比数列。 

下面的例子用于生成首位是100，末位是102，含5个数的等比数列。

import numpy as np

a = np.logspace(0,2,5)
print(a)
# 结果
[   1.      3.16227766   10.           31.6227766   100.  ]

 ones、zeros、eye、empty 

ones创建全1矩阵 

zeros创建全0矩阵 

eye创建单位矩阵 

empty创建空矩阵（实际有值）

import numpy as np

a_ones = np.ones((3,4)) # 创建3*4的全1矩阵
print(a_ones)
# 结果
[[ 1.  1.  1.  1.]
[ 1.  1.  1.  1.]
[ 1.  1.  1.  1.]]

a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵
print(a_zeros)
# 结果
[[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]]

a_eye = np.eye(3) # 创建3阶单位矩阵
print(a_eye)
# 结果
[ 1.  0.  0.]
[ 0.  1.  0.]
[ 0.  0.  1.]]

a_empty = np.empty((3,4)) # 创建3*4的空矩阵
print(a_empty)
# 结果
[[  1.78006111e-306  -3.13259416e-294   4.71524461e-309   1.94927842e+289]
[  2.10230387e-309   5.42870216e+294   6.73606381e-310   3.82265219e-297]
[  6.24242356e-309   1.07034394e-296   2.12687797e+183   6.88703165e-315]]

 

 fromstring 

fromstring()方法可以将字符串转化成ndarray对象，需要将字符串数字化时这个方法比较有用，可以获得字符串的ascii码序列。

a = "abcdef"
b = np.fromstring(a,dtype=np.int8) # 因为一个字符为8为，所以指定dtype为np.int8
print(b) # 返回 [ 97  98  99 100 101 102]

 

 fromfunction 

fromfunction()方法可以根据矩阵的行号列号生成矩阵的元素。 

例如创建一个矩阵，矩阵中的每个元素都为行号和列号的和。

import numpy as np

def func(i,j):
return i+j

a = np.fromfunction(func,(5,6))
# 第一个参数为指定函数，第二个参数为列表list或元组tuple,说明矩阵的大小
print(a)
# 返回
[[ 0.  1.  2.  3.  4.  5.]
[ 1.  2.  3.  4.  5.  6.]
[ 2.  3.  4.  5.  6.  7.]
[ 3.  4.  5.  6.  7.  8.]
[ 4.  5.  6.  7.  8.  9.]]
#注意这里行号的列号都是从0开始的

 

 矩阵的运算 

 常用矩阵运算符 

numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。

运算符	说明
+	矩阵对应元素相加
-	矩阵对应元素相减
*	矩阵对应元素相乘
/	矩阵对应元素相除，如果都是整数则取商
%	矩阵对应元素相除后取余数
**	矩阵每个元素都取n次方，如**2：每个元素都取平方

例如

import numpy as np
a1 = np.array([[4,5,6],[1,2,3]])
a2 = np.array([[6,5,4],[3,2,1]])

print(a1+a2) # 相加
# 结果
[[10 10 10]
[ 4  4  4]]

print(a1/a2) # 整数相除取商
# 结果
[[0 1 1]
[0 1 3]]

print(a1%a2) # 相除取余数
# 结果
[[4 0 2]
[1 0 0]]

 

 常用矩阵函数 

同样地，numpy中也定义了许多函数，使用这些函数可以将函数作用于矩阵中的每个元素。 
表格中默认导入了numpy模块，即 

import numpy as np

a为ndarray对象。

矩阵函数	说明
np.sin(a)	对矩阵a中每个元素取正弦,sin(x)
np.cos(a)	对矩阵a中每个元素取余弦,cos(x)
np.tan(a)	对矩阵a中每个元素取正切,tan(x)
np.arcsin(a)	对矩阵a中每个元素取反正弦,arcsin(x)
np.arccos(a)	对矩阵a中每个元素取反余弦,arccos(x)
np.arctan(a)	对矩阵a中每个元素取反正切,arctan(x)
np.exp(a)	对矩阵a中每个元素取指数函数,ex
np.sqrt(a)	对矩阵a中每个元素开根号√x

例如

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(np.sin(a))
# 结果
[[ 0.84147098  0.90929743  0.14112001]
[-0.7568025  -0.95892427 -0.2794155 ]]

print(np.arcsin(a))
# 结果
C:\Users\Administrator\Desktop\learn.py:6: RuntimeWarning: invalid value encountered in arcsin
print(np.arcsin(a))
[[ 1.57079633         nan         nan]
[        nan         nan         nan]]

当矩阵中的元素不在定义域范围内，会产生RuntimeWarning，结果为nan(not a number)。

 

[−1,1]

  矩阵乘法（点乘）

矩阵乘法必须满足矩阵乘法的条件，即第一个矩阵的列数等于第二个矩阵的行数。 

矩阵乘法的函数为 dot 

例如

import numpy as np

a1 = np.array([[1,2,3],[4,5,6]]) # a1为2*3矩阵
a2 = np.array([[1,2],[3,4],[5,6]]) # a2为3*2矩阵

print(a1.shape[1]==a2.shape[0]) # True, 满足矩阵乘法条件
print(a1.dot(a2))
# a1.dot(a2)相当于matlab中的a1*a2
# 而python中的a1*a2相当于matlab中的a1.*a2
# 结果
[[22 28]
[49 64]]

 

 矩阵的转置 aT

import numpy as np

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

print(a.transpose())
# 结果
[[1 4]
[2 5]
[3 6]]

 矩阵的转置还有更简单的方法，就是a.T

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.T)
# 结果
[[1 4]
[2 5]
[3 6]]

 

 矩阵的逆 a−1

求矩阵的逆需要先导入

numpy.linalg

，用linalg的inv函数来求逆。 

矩阵求逆的条件是矩阵的行数和列数相同。

import numpy as np
import numpy.linalg as lg

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

print(lg.inv(a))
# 结果
[[ -4.50359963e+15   9.00719925e+15  -4.50359963e+15]
[  9.00719925e+15  -1.80143985e+16   9.00719925e+15]
[ -4.50359963e+15   9.00719925e+15  -4.50359963e+15]]

a = np.eye(3) # 3阶单位矩阵
print(lg.inv(a)) # 单位矩阵的逆为他本身
# 结果
[[ 1.  0.  0.]
[ 0.  1.  0.]
[ 0.  0.  1.]]

 

  矩阵信息获取（如平均值）

 最大最小值 

获得矩阵中元素最大最小值的函数分别是

max

和

min

，可以获得整个矩阵、行或列的最大最小值。 

例如

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #获取整个矩阵的最大值 结果： 6
print(a.min()) #结果：1

# 可以指定关键字参数axis来获得行最大（小）值或列最大（小）值
# axis=0 行方向最大（小）值，即获得每列的最大（小）值
# axis=1 列方向最大（小）值，即获得每行的最大（小）值
# 例如

print(a.max(axis=0))
# 结果为 [4 5 6]

print(a.max(axis=1))
# 结果为 [3 6]

# 要想获得最大最小值元素所在的位置，可以通过argmax函数来获得
print(a.argmax(axis=1))
# 结果为 [2 2]

 

 平均值 

获得矩阵中元素的平均值可以通过函数

mean()

。同样地，可以获得整个矩阵、行或列的平均值。

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #结果为： 3.5

# 同样地，可以通过关键字axis参数指定沿哪个方向获取平均值
print(a.mean(axis=0)) # 结果 [ 2.5  3.5  4.5]
print(a.mean(axis=1)) # 结果 [ 2.  5.]

 

 方差 

方差的函数为

var()

,方差函数

var()

相当于函数

mean(abs(x - x.mean())**2)

,其中x为矩阵。

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.var()) # 结果 2.91666666667

print(a.var(axis=0)) # 结果 [ 2.25  2.25  2.25]
print(a.var(axis=1)) # 结果 [ 0.66666667  0.66666667]

 

 标准差 

标准差的函数为

std()

。 

std()

相当于

sqrt(mean(abs(x - x.mean())**2))

，或相当于

sqrt(x.var())

。

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.std()) # 结果 1.70782512766

print(a.std(axis=0)) # 结果 [ 1.5  1.5  1.5]
print(a.std(axis=1)) # 结果 [ 0.81649658  0.81649658]

 

 

 中值 

中值指的是将序列按大小顺序排列后，排在中间的那个值，如果有偶数个数，则是排在中间两个数的平均值。

例如序列[5,2,6,4,2]，按大小顺序排成 [2,2,4,5,6]，排在中间的数是4，所以这个序列的中值是4。

又如序列[5,2,6,4,3,2]，按大小顺序排成 [2,2,3,4,5,6]，因为有偶数个数，排在中间两个数是3、4，所以这个序列中值是3.5。

中值的函数是median()，调用方法为numpy.median(x,[axis])，axis可指定轴方向，默认axis=None，对所有数去中值。

import numpy as np
x = np.array([[1,2,3],[4,5,6]])

print(np.median(x))  # 对所有数取中值
# 结果
3.5

print(np.median(x,axis=0))  # 沿第一维方向取中值
# 结果
[ 2.5  3.5  4.5]

print(np.median(x,axis=1))  # 沿第二维方向取中值
# 结果
[ 2.  5.]

 求和 

矩阵求和的函数是sum()，可以对行，列，或整个矩阵求和

import numpy as np

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

print(a.sum())           # 对整个矩阵求和
# 结果 21

print(a.sum(axis=0)) # 对行方向求和
# 结果 [5 7 9]

print(a.sum(axis=1)) # 对列方向求和
# 结果 [ 6 15]

 

 累积和  

某位置累积和指的是该位置之前(包括该位置)所有元素的和。

例如序列[1,2,3,4,5]，其累计和为[1,3,6,10,15]，即第一个元素为1，第二个元素为1+2=3，……，第五个元素为1+2+3+4+5=15。

矩阵求累积和的函数是cumsum()，可以对行，列，或整个矩阵求累积和。

import numpy as np

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

print(a.cumsum())            # 对整个矩阵求累积和
# 结果 [ 1  3  6 10 15 21]

print(a.cumsum(axis=0))  # 对行方向求累积和
# 结果
[[1 2 3]
[5 7 9]]

print(a.cumsum(axis=1))  # 对列方向求累积和
# 结果
[[ 1  3  6]
[ 4  9 15]]