本次的主要内容有：
- 对线性代数函数例如逆矩阵函数，特征值以及特征值向量函数等的应用
- fromfunction（）函数的使用
求解给定矩阵的逆矩阵并验证
a = np.random.randint(1, 5, (3,3)) # 注意这样的话要多试几次，因为随机数生成的矩阵可能会是奇异矩阵。。
print('Arrray a:')
print(a)
b = np.linalg.inv(a)
print('Inverse Matrix:')
print(b)
print(np.dot(a, b)) # 验证一下矩阵相乘的结果是不是单位阵
assert np.allclose(np.dot(a, b), np.eye(3)) # 或者用这种方式
输出：
Arrray a:
[[1 4 4]
[1 2 4]
[2 4 4]]
Inverse Matrix:
[[-1. 0. 1. ]
[ 0.5 -0.5 0. ]
[ 0. 0.5 -0.25]]
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
使用Numpy计算矩阵的特征值以及特征向量
线性代数的方法直接调用即可
a = np.array([[1,2,3], [4,5,6], [7,8,9]])
print('Array a:')
print(a)
w, v = np.linalg.eig(a)
print('Eigen value:')
print(w)
print('Eigen vector:')
print(v)
输出：
Array a:
[[1 2 3]
[4 5 6]
[7 8 9]]
Eigen value:
[ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
Eigen vector:
[[-0.23197069 -0.78583024 0.40824829]
[-0.52532209 -0.08675134 -0.81649658]
[-0.8186735 0.61232756 0.40824829]]
使用Numpy计算Ndarray两相邻元素的差值
diff函数的应用，也就是计算相邻的元素之间的差，所以每一次计算都会比之前的数组减少一个元素
a = np.random.randint(1, 10, 10)
print('Array a:')
print(a)
# 计算一次差值
print(np.diff(a, n=1))
# 计算两次差值
print(np.diff(a, n=2))
# 计算三次差值
print(np.diff(a, n=3))
输出：
Array a:
[1 5 1 2 6 1 2 3 2 8]
[ 4 -4 1 4 -5 1 1 -1 6]
[-8 5 3 -9 6 0 -2 7]
[ 13 -2 -12 15 -6 -2 9]
使用Numpy将Ndarray相邻元素依次累加
对于一个数组，输出一个数组，输出数组的每一个元素对应从第一个元素累加到这个位置元素的和
a = np.random.randint(1, 10, 10)
print('Array a:')
print(a)
print(np.cumsum(a))
输出：
Array a:
[8 9 1 2 9 6 2 1 6 9]
[ 8 17 18 20 29 35 37 38 44 53]
Numpy好变态啊。。这种函数都有。。。
使用Numpy按列连接两个数组
这里注意两种方法区别：
a = np.array([1,2,3])
b = np.array([4,5,6])
print([a,b])
c = [a, b]
print(type(c)) # 注意看这里 简单写在一块之后输出的是列表
print(np.array(c))
print(type(np.array(c)))
d = np.c_[a, b] # 使用 numpy.c_函数直接生成的就是数组
print(d)
print(d.T)
print(type(d))
输出：
[array([1, 2, 3]), array([4, 5, 6])]
<class 'list'>
[[1 2 3]
[4 5 6]]
<class 'numpy.ndarray'>
[[1 4]
[2 5]
[3 6]]
[[1 2 3]
[4 5 6]]
<class 'numpy.ndarray'>
使用Numpy按行连接两个数组
与按列的方式是对应的，一个是column的简写，一个是row的间歇嘛，不过要注意函数后边是中括号。
a = np.array([1,2,3])
b = np.array([4,5,6])
print(np.r_[a, b])
输出：
[1 2 3 4 5 6]
使用Numpy打印九九乘法表
果然，不管是学习哪种语言，九九乘法表都是与hello world一样的存在啊
不过使用Numpy有超级简单的实现方式：
np.fromfunction(lambda i, j: (i + 1) * (j + 1), (9, 9))
输出：
array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.],
[ 2., 4., 6., 8., 10., 12., 14., 16., 18.],
[ 3., 6., 9., 12., 15., 18., 21., 24., 27.],
[ 4., 8., 12., 16., 20., 24., 28., 32., 36.],
[ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
[ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
[ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
[ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
[ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])
好吧，其实跟我们传统的乘法表不太一样。。
这里主要是要注意fromfunciton函数的使用，这个函数我们可以非常方便地使用函数规则创建数组，先看几个例子：
例子一：
def f(x, y):
return 10*x + y
b =np.fromfunction(f, (5,4), dtype=np.int)
print(b)
输出：
[[ 0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]]
例子二：
a = np.fromfunction(lambda i,j: i==j ,(3,3), dtype=np.int)
print(a)
[[ True False False]
[False True False]
[False False True]]
我觉得看完这两个例子，基本就搞清楚基本用法了，第一个参数指定了规则，也就是函数了，第二个参数制定了输出的形状，第三个参数则是指定了传入函数数据的类型。一般这个函数与lambda函数放在一起使用，会使程序简洁一些。
以上~