『Python』Numpy学习指南第五章_矩阵和通用函数

Posted 2020-09-18

简单的矩阵生成以及合并操作：

np.mat(‘1 2 3;4 5 6;7 8 9‘)
np.bmat(‘A B;B A‘)
np.arange(1,10).reshape(3,3)

 1 import numpy as np
 2 
 3 
 4 
 5 ‘‘‘通用函数‘‘‘
 6 
 7 # 字符串创建矩阵
 8 # 也可以使用数组创建
 9 A = np.mat(‘1 2 3;4 5 6;7 8 9‘)
10 # 数组创建矩阵
11 A = np.mat(np.arange(1,10).reshape(3,3))     # ndarray可以直接转化为矩阵
12 print(‘创建矩阵：\n‘,A)
13 print(‘转置矩阵：\n‘,A.T)
14 print(‘矩阵求逆：\n‘,A.I)
15 
16 # 字符串创建复合矩阵
17 A = np.eye(2)
18 B = A*2
19 print(np.bmat(‘A B;B A‘))

创建矩阵：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
转置矩阵：
 [[1 4 7]
 [2 5 8]
 [3 6 9]]
矩阵求逆：
 [[ -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]]
[[ 1.  0.  2.  0.]
 [ 0.  1.  0.  2.]
 [ 2.  0.  1.  0.]
 [ 0.  2.  0.  1.]]

 

通用函数生成以及4个方法：

np.frompyfunc(ultimate_answer,1,1)

 

np.add.reduce(a)

np.add.accumulate(a)

np.add.reduceat(a,[0,5,2,7])

np.add.outer(np.arange(3),np.arange(9))

 

 1 ‘‘‘通用函数‘‘‘
 2 
 3 # 输入一组标量，输出一组标量的基本数学运算操作
 4 # frompyfunc方法创建通用函数（此时和原函数并无什么差异）
 5 def ultimate_answer(a):
 6     result = np.zeros_like(a)
 7     result.flat = 42
 8     return result
 9 ufunc = np.frompyfunc(ultimate_answer,1,1)
10 print(ultimate_answer(np.arange(4).reshape(2,2)))
11 print(ufunc(np.arange(4).reshape(2,2)))
12 
13 
14 # 通用函数的方法
15 # 只对连个输入一个输出的函数有效
16 
17 # reduce
18 # 连续递归的作用通用函数于数组元素上
19 a = np.arange(9)
20 print(‘Reduce：‘,np.add.reduce(a))
21 
22 # accumulate
23 # 同上，但返回每一步的结果
24 print(‘Accumulate:‘,np.add.accumulate(a))
25 
26 # reduceat
27 # 使用索引分区递归
28 # [0,5],[5,2](直接返回索引5),[2,7],[7:]
29 print(‘Reduceat：‘,np.add.reduceat(a,[0,5,2,7]))
30 
31 # outer
32 # 输入两个数组
33 # 将后一个数组的每一个元素和前一个数组的每一个元素做运算
34 print(‘Outer：\n‘,np.add.outer(np.arange(3),np.arange(9)))

[[42 42]
 [42 42]]
[[array(42) array(42)]
 [array(42) array(42)]]
Reduce： 36
Accumulate: [ 0  1  3  6 10 15 21 28 36]
Reduceat： [10  5 20 15]
Outer：
 [[ 0  1  2  3  4  5  6  7  8]
 [ 1  2  3  4  5  6  7  8  9]
 [ 2  3  4  5  6  7  8  9 10]]

 

np.remainder(a,2)

np.mod(a,2)

a % 2

np.mod(a,-2)

np.fmod(a,-2)

 1 ‘‘‘算数运算‘‘‘
 2 
 3 # 算数运算符隐式关联通用函数
 4 # +:add
 5 # -:substract
 6 # *:multiply
 7 # 除法
 8 a = np.array([2,6,5])
 9 b = np.array([1,2,3])
10 # 3.x中divide和/等价
11 print(‘Divide：\n‘,np.divide(a,b),np.divide(b,a))
12 print(‘‘,a/b,b/a)
13 print(‘‘,a//b,b//a)        # 地板除
14 
15 # 求余
16 a = np.arange(-4,4)
17 # 三种等价求余操作
18 # 余数符号等于除数符号
19 print(‘Remainder:‘,np.remainder(a,2))
20 print(‘Mod      :‘,np.mod(a,2))
21 print(‘%        :‘,a % 2)
22 # fmod求余操作
23 # 余数符号由被除数确定
24 print(‘Mod      :‘,np.mod(a,-2))
25 print(‘Fmod     :‘,np.fmod(a,-2))

Divide：
 [ 2.          3.          1.66666667] [ 0.5         0.33333333  0.6       ]
 [ 2.          3.          1.66666667] [ 0.5         0.33333333  0.6       ]
 [2 3 1] [0 0 0]
Remainder: [0 1 0 1 0 1 0 1]
Mod      : [0 1 0 1 0 1 0 1]
%        : [0 1 0 1 0 1 0 1]
Mod      : [ 0 -1  0 -1  0 -1  0 -1]
Fmod     : [ 0 -1  0 -1  0  1  0  1]

 

np.matrix([[1,1],[1,0]])

np.rint((phi**n-(-1/phi)**n)/sqrt5)

 1 ‘‘‘斐波那契数列‘‘‘
 2 
 3 # 矩阵方式求数列
 4 F = np.mat([[1,1],[1,0]])
 5 F = np.matrix([[1,1],[1,0]])
 6 print(‘F:\n‘,F)
 7 print(‘斐波那契数列第八个值是：‘,(F**7)[0,0])       # matrix只能[x,y],不能[x][y]
 8 
 9 # 比奈公式求数列
10 n = np.arange(1,9)
11 sqrt5 = np.sqrt(5)                               # 开根号
12 phi = (1+sqrt5)/2
13 fibonacci = np.rint((phi**n-(-1/phi)**n)/sqrt5)  # 四舍五入取整，但结果仍然是float
14 print(fibonacci)

F:
 [[1 1]
 [1 0]]
斐波那契数列第八个值是： 21
[  1.   1.   2.   3.   5.   8.  13.  21.]

 

np.sin(a*t+np.pi/2)

 1 ‘‘‘利萨茹曲线-熟悉三角函数的使用‘‘‘
 2 
 3 # x = A sin(at + n/2)
 4 # y = B sin(bt)
 5 import matplotlib.pyplot as plt
 6 
 7 A,B,a,b = (1,1,10,13)
 8 t = np.linspace(-np.pi,np.pi,201)                 # np.pi
 9 x = np.sin(a*t+np.pi/2)
10 y = np.sin(b*t)
11 plt.plot(x,y)
12 plt.xlim([-1,1])
13 plt.ylim([-1,1])
14 # plt.show()

 

使用矢量化函数取缔循环提升效率

‘‘‘绘制方波‘‘‘

t = np.linspace(-np.pi,np.pi,201)
k = np.arange(1,99)
k = 2*k - 1
f = np.zeros_like(t)
# for i in range(len(t)):
#     f[i] = np.sum(np.sin(k*t[i])/k)
# f = (4/np.pi)*f

def func(t):
    return np.sum(np.sin(k*t)/k)
func = np.vectorize(func)
f = func(t)
f = (4/np.pi)*f

plt.plot(t,f)
# plt.show()

 

位操作，虽然感觉对我这种计算机组成原理学的一般(为了研究生复试看了一个月，这书学过的都知道多坑何况我这种背景知识几近全无的人)的人没啥大用，但既然书里面都写了我就放这里吧。

x^y

x&(x-1)

x&((1<<2)-1)

 1 ‘‘‘位操作‘‘‘
 2 
 3 # ^异或操作
 4 # &和操作
 5 # <<左移操作
 6 x = np.arange(-9,9)
 7 y = -x
 8 print(x,‘\n‘,(x^y)<0)
 9 print(x,‘\n‘,x&(x-1)==0)
10 print(x,‘\n‘,x&((1<<2)-1))

 

[-9 -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8] 
 [ True  True  True  True  True  True  True  True  True False  True  True
  True  True  True  True  True  True]
[-9 -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8] 
 [False False False False False False False False False  True  True  True
 False  True False False False  True]
[-9 -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8] 
 [3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0]