python的常见矩阵除法_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⽅法。
通过函数创建矩阵
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.]]
linspace numpya_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：每个元素都取平⽅
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论