numpy常用函数4-matrix类
目录
- 介绍
-
- 通用函数
-
- 通用函数概念（感觉不如矢量化方法方便：np.vectorize)
- frompyfunc->ufunc对象
- 求和通用函数：add()
- 除法通用函数：divide/true_divide/floor_divide
介绍
矩阵是numpy.matrix类类型的对象，该类继承自numpy.ndarray，任何针对多维数组的操作，对矩阵同样有效，但是作为子类矩阵又结合其自身的特点，做了必要的扩充，比如：乘法计算、求逆等。
矩阵对象的创建可以通过以下三种方式：
- numpy.matrix(任何可被解释为矩阵的二维容器,
copy=是否复制数据(缺省值为True，即复制数据))
->矩阵对象
如果copy的值为True(缺省)，所得到的矩阵对象与参数中的源容器拥有独立的数据拷贝，如果copy为False，则共享同一份数据。另，如果使用的是python自带的列表的数组，则copy的作用无效，一定会生成独立数据拷贝。 - numpy.mat(任何可被解释为矩阵的二维容器)等价于numpy.matrix(…, copy=False)
由该函数创建的矩阵对象与参数中的源容器一定共享数据，无法拥有独立的数据拷贝。 - numpy.bmat(拼块规则)
->包含若干小矩阵数据的大矩阵，拼接规则由参数指定
->拼接格式：g = np.bmat(‘b e; e b’) ：b,e,这些都是矩阵的名字
->拼接之后，不会产生新的维度。
以上函数也可以接受字符串形式的矩阵描述：数据项通过空格分隔，数据行通过分号分隔。例如：
‘1 2 3; 4 5 6’
/ 1 2 3
\ 4 5 6 /
强调：数组不是矩阵！。numpy.array生成的是数组不是矩阵。两者有差别的
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([
[1, 2, 6],
[3, 5, 7],
[4, 8, 9]])
print(a, type(a))
b = np.matrix(a)
print(b, type(b))
b += 10
print(b)
print(a)
c = np.matrix(a, copy=False)
print(c, type(c))
c += 10
print(c)
print(a)
d = np.mat(a)
print(d, type(d))
d -= 10
print(d)
print(a)
e = np.mat('1 2 6; 3 5 7; 4 8 9')
print(e)
f = np.bmat('b e')
print(f)
g = np.bmat('b e; e b')
print(g)
#
# 多维数组的乘法：对应位置的元素相乘
#
# 1 2 6 1 2 6 1 4 36
# 3 5 7 X 3 5 7 = 9 25 49
# 4 8 9 4 8 9 16 64 81
#
h = a * a
print(h)
#
# 矩阵的乘法：乘积矩阵的第i行第j列的元素等于
# 被乘数矩阵的第i行与乘数矩阵的第j列的点积
#
# 1 2 6
# X---->3 5 7
# | 4 8 9
# 1 2 6 31 60 74
# 3 5 7 46 87 116
# 4 8 9 64 120 161
#
i = e * e
print(i)
j = e.I
print(j)
print(e * j)
# a.I
k = a.dot(a)
print(k)
l = np.linalg.inv(a)
print(l)
通用函数
通用函数概念（感觉不如矢量化方法方便：np.vectorize)
通用函数的本质就是一个ufunc类的实例化对象，在该对象的内部又封装了另一个函数，且该对象可被当作函数调用，而实际被调用的…
frompyfunc->ufunc对象
def 标量函数(标量参数1, 标量参数2, …):
…
return 标量返回值1, 标量返回值2, …
矢量参数1
矢量参数2
…
numpy.frompyfunc(标量函数, 参数个数, 返回值个数)
->矢量函数 # numpy.ufunc类类型的对象，可调用对象
矢量函数(矢量参数1, 矢量参数2, …)
->矢量返回值1, 矢量返回值2
例：
import numpy as np
def foo(x, y):
return x + y, x - y, x * y
# 采用闭包的方式，可以提前初始化部分变量的值，运用很广泛但是这里没啥用。这里用闭包还不如\
#直接用np.vectorize装饰器。。。个人愚见
def hum(x):
def fun(y):
return x + y, x - y, x * y
return np.frompyfunc(fun, 1, 1)
x, y = 1, 4
print(foo(x, y))
X, Y = np.array([1, 2, 3]), np.array([4, 5, 6])
bar = np.frompyfunc(foo, 2, 3)
print(bar(X, Y))
print(np.frompyfunc(foo, 2, 3)(X, Y))
print(hum(100)(X))
求和通用函数：add()
通用函数是一个可被当作函数调用的对象，因此既可被视作函数，也可拥有自己的属性和方法。
- np.add(数组，数组)# 对应元素求和
add.reduce() - 累加和 将所有数字加在一起，返回一个总值 - add.accumulate() - 累加和过程，每一个位置都是自己和前面值相加的结果
如：原值[1,2,3,4,5]
返回值：[1,3,6,10,15] - add.reduceat() - 分段累加和,求对应位置和下一个位置的和，返回一个数组
e = np.add.reduceat(a, [0, 2, 4]) - add.outer() - 外和
f = np.add.outer([10, 20, 30], a) - np.outer()求积
g = np.outer([10, 20, 30], a)，具体演示如下
例：
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(1, 7)
print(a)
b = a + a
print(b)
b = np.add(a, a)
print(b)
c = np.add.reduce(a)
print(c)
d = np.add.accumulate(a)
print(d)
# 0 2 4
# 1 2 3 4 5 6
e = np.add.reduceat(a, [0, 2, 4])
print(e)
# + 1 2 3 4 5 6
# 10 11 12 13 14 15 16
# 20 21 22 23 24 25 26
# 30 31 32 33 34 35 36
f = np.add.outer([10, 20, 30], a)
print(f)
# x 1 2 3 4 5 6
# 10 10 20 30 40 50 60
# 20 20 40 60 80 100 120
# 30 30 60 90 120 150 180
g = np.outer([10, 20, 30], a)
print(g)
除法通用函数：divide/true_divide/floor_divide
[5 5 -5 -5]<真除>[2 -2 2 -2] = [2.5 -2.5 -2.5 2.5]
numpy.true_divide()
numpy.divide()
/
[5 5 -5 -5]<地板除>[2 -2 2 -2] = [2 -3 -3 2]
numpy.floor_divide()
//
天花板除和截断除需要两步：先进行真除，在调方法进行转换。
[5 5 -5 -5]<天花板除>[2 -2 2 -2] = [3 -2 -2 3]
天花板取整(真除的结果)：numpy.ceil()
[5 5 -5 -5]<截断除>[2 -2 2 -2] = [2 -2 -2 2]:将小数点后面的值抹掉
截断取整(真除的结果)：numpy.trunc()
例：
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([5, 5, -5, -5])
b = np.array([2, -2, 2, -2])
print(a, b)
# c = np.true_divide(a, b)
# c = np.divide(a, b)
c = a / b
print(c)
# d = np.floor_divide(a, b)
d = a // b
print(d)
e = np.ceil(a / b).astype(int)
print(e)
f = np.trunc(a / b).astype(int)
print(f)