python中的numpy模块

创建矩阵(采用ndarray对象)

对于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对象的函数,可以很方便的创建常用的或有规律的矩阵。

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)。

矩阵乘法(点乘)

矩阵乘法必须满足矩阵乘法的条件,即第一个矩阵的列数等于第二个矩阵的行数。  矩阵乘法的函数为 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]]

矩阵的转置

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]]

转置和轴对换

转置可以对数组进行重置,返回的是源数据的视图(不会进行任何复制操作)。

转置有三种方式,transpose方法、T属性以及swapaxes方法。

1 .T,适用于一、二维数组

In [1]: import numpy as np

In [2]: arr = np.arange(20).reshape(4,5)#生成一个4行5列的数组


In [3]: arr
Out[3]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])


In [4]: arr.T #求转置
Out[4]:
array([[ 0,  5, 10, 15],
       [ 1,  6, 11, 16],
       [ 2,  7, 12, 17],
       [ 3,  8, 13, 18],
       [ 4,  9, 14, 19]])

2. 高维数组

对于高维数组,transpose需要用到一个由轴编号组成的元组,才能进行转置。这里,着实好好理解了一下。开始的时候怎么都想不明白。因为他跟矩阵转置理解起来不太一样。

主要参考: AbstractSky的博客 Albert Chen 经管之家

对多维数组来说,确定最底层的一个基本元素位置需要用到的索引个数即是维度。这句话的理解可以结合我索引和切片的那篇文章理解。

我是这样的理解的,比如说三维的数组,那就对维度进行编号,也就是0,1,2。这样说可能比较抽象。这里的0,1,2可以理解为对shape返回元组的索引。 比如:

In [59]: arr1 = np.arange(12).reshape(2,2,3)

In [60]: arr1
Out[60]:
array([[[ 0,  1,  2],
        [ 3,  4,  5]],

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

In [61]: arr1.shape #看形状
Out[61]: (2, 2, 3) #说明这是一个2*2*3的数组(矩阵),返回的是一个元组,可以对元组进行索引,也就是0,1,2

形状

索引

2

0

2

1

3

2

所以说,transpose参数的真正意义在于这个shape元组的索引。

那么它的转置就应该是

In [62]: arr1.transpose((1,0,2))
Out[62]:
array([[[ 0,  1,  2],
        [ 6,  7,  8]],

       [[ 3,  4,  5],
        [ 9, 10, 11]]])

比如,数值6开始的索引是[1,0,0],变换后变成了[0,1,0]。 这也说明了,transpose依赖于shape

但是,对于为什么转置最后一个索引是不动的,颇为不解。数组或者说矩阵的这块有点太抽象了。虽然我线代成绩不错,但是这玩意不太一样啊。

3.swapaxes

虽然还有点不解的地方,但是,理解了上方那部分之后,swapaxes方法也就很好理解了。它接受一对轴编号。进行轴对换。其实也就是shape参数。

In [67]: arr2 = np.arange(16).reshape(2,2,4)           
                                                       
In [68]: arr2                                          
Out[68]:                                               
array([[[ 0,  1,  2,  3],                              
        [ 4,  5,  6,  7]],                             
                                                       
       [[ 8,  9, 10, 11],                              
        [12, 13, 14, 15]]])                            
                                                       
In [69]: arr2.shape                                    
Out[69]: (2, 2, 4)                                     
                                                       
In [70]: arr2.swapaxes(1,2)                            
Out[70]:                                               
array([[[ 0,  4],                                      
        [ 1,  5],                                      
        [ 2,  6],                                      
        [ 3,  7]],                                     
                                                       
       [[ 8, 12],                                      
        [ 9, 13],                                      
        [10, 14],                                      
        [11, 15]]])   

In [4]: arr2.swapaxes(1,0)#转置,对比transpose(1,0,2)
Out[4]:
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])                                 

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券