numpy常用函数4-matrix类

介绍

矩阵是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)