《数学要素： 从加减乘除到机器学习》第一章笔记

看了b站生姜DrGinger大佬的数学要素系列视频(https://space.bilibili.com/513194466),惊为天人，决定开始拜读，以下是第一章学习笔记。

第一章 万物皆数 | (数学要素) | 从加减乘除到机器学习

学习之前需要掌握的一些python基础 | 运算符、数据类型和常用函数

python3中的算术运算符

+ # 加号

- # 减号

* # 乘号

/ # 除号，python2中结果弃余数取整，python3中结果为浮点数。

% # 除法取余数

x = 3 # 程序自动寻找一块内存空间，将内存空间命名为x，并在x这个内存空间内存储一个值：3

x # 输入赋值后的变量名，变量的值会显示在控制台或者终端

x = 3
x

3

a = 3 
b = 4
a + b #Python可以直接计算加法

7

a = 3 
b = 4
a - b #减法

-1

a = 3 
b = 4
a * b #乘法

12

a = 3 
b = 4
a / b #除法(python3)

0.75

上面这个计算的结果是浮点数，在python中我们可以利用type()检验变量的类型，int就是整型，float就是浮点型

x = 3.5
type(x)

float

x = 4
type(x)

int

a = 3 
b = 4
a % b #取余

3

一个小问题

x = 3 
y = 4
x
y # 在多个行输入变量名，程序只会展示你输入的最后一个变量的值

4

# 为了解决上述问题，我们使用print()函数
x = 3 
y = 4
print(x)
print(y)

3
4

布尔值和比较运算符

  无论是在数学计算还是编程，我们经常需要判断数与数之间的大小关系,为此要用到比较运算符和一种特殊的变量类型：bool变量。

• $>$ 大于

• $<$ 小于

• $>=$ 大于等于

• $<=$ 小于等于

• $==$ 等于

• 条件为真(布尔值)：True

• 条件为假(布尔值)：False

a = 5 
b = 6
a > b

False

a = 5
b = 6
type(a > b)

bool

字符串

以上，已经接触过python中的三种数据类型：整型变量int，浮点型变量float和布尔型变量bool

下面我们简单介绍一下字符串类型str

x = "I‘m learning Python."
y = 'Great language.'
x,y

('I‘m learning Python.', 'Great language.')

x = "I‘m learning Python."
y = 'Great language.'
a = type(x)
b = type(y)
print(a,b)
print(x,y)
print(x + y)

 
I‘m learning Python. Great language.
I‘m learning Python.Great language.

逻辑运算符

• and 且
• or 或
• not 非
• is 是

列表

# 列表
list = [1 , 2, 3, 4]
print(type(list))
print(list)
print(list[3])

[1, 2, 3, 4]
4

# append可以添加元素，该元素可以也是列表
list.append(5)
print(list)
list.append([3,6,7])
print(list)

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, [3, 6, 7]]

# extend可以用来添加一个元素
list.extend('f')
print(list)
# extend也可以通过列表形式添加多个元素
list.extend([3,4,3])
print(list)

[1, 2, 3, 4, 5, [3, 6, 7], 'f']
[1, 2, 3, 4, 5, [3, 6, 7], 'f', 3, 4, 3]

# print(list[a:b]),打印列表中的第a+1到第b+1个元素
print(list[3:7])

[4, 5, [3, 6, 7], 'f']

list = [0,3,5,9,7]
print(list)
# list.sort()，对列表数据进行从小到大的排序
list.sort()
print(list)
# list.sort(reverse =True),让列表中的数字从大到小排列
list.sort(reverse=True)
print(list)
del list # 清除变量

[0, 3, 5, 9, 7]
[0, 3, 5, 7, 9]
[9, 7, 5, 3, 0]

元祖:不支持修改的元素

y = (4,6,5)
y[1] = 4
y

执行后，会提示如下错误：

TypeError                  Traceback (most recent call last)  
~/name.py in <module>                                                         
      1 y = (4,6,5)  
----> 2 y[1] = 4  
      3 y  
TypeError:'tuple' object does not support item assignment

也就是说，元组类型的元素(tuple)不支持重新赋值。

字典：具有映射关系的数据结构

wages = {'steve':1000,'red':120,'white':230}
print(wages['steve'])

RGB = {'red':(255,0,0),'green':(0,255,0),'blue':(0,0,255)}
print(RGB['red'])

# 字典增加元素

RGB['black']=(255,255,255)
RGB['white']=(0,0,0)

print(RGB['black'])

# 删除字典元素

del RGB['black']

# 获取某元素的值,没有则返回空值None

print(RGB.get('black'))

1000
(255, 0, 0)
(255, 255, 255)
None

range()函数的使用

# range函数所有参数均为整数，结果返回一个range类型的整数等差序列，一般用在循环结构中。

# 利用a=list(range())可以创建一个数表a，用来储存range()中的值。可以用三种方法使用range()

# 第一种，range(stop)，初始值为0，终止值为stop-1，公差为1，此时，返回序列为{0，1，2，3, … ，stop-1}

a = list(range(20))

print(a)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

# 第二种，range(begin,stop)，初始值为begin，终止值为stop-1,公差为1，此时，返回序列为{begin，begin+1, … ，stop-1}

a = list(range(0,10))

b = list(range(3,10))

print(a)

print(b)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9]

# 第三种，range(begin,stop,step)，初始值为begin，终止值小于stop,公差为step。
# 此时，返回序列为{begin，begin+step,begin+2*step, … ，x},x=begin+n*step,stop-step<=x

a = list(range(1,9,3))

print(a)

b = list(range(8,2,-1))

print(b)

c = list(range(8,2,-2))

print(c)

# 当确定区间【2，8】后，由于2<8，公差取-1后，该序列为空集，显示为[]
d =list(range(2,8,-1))

print(d)

[1, 4, 7]
[8, 7, 6, 5, 4, 3]
[8, 6, 4]
[]

zip()函数的使用

利用zip()函数，我们可以定义一个映射关系
$$y=f(x)$$

将函数的自变量a取值做成列表: $a=[x_1,x_2,\dots ,x_n]$
将对应的函数值b也做成列表: $b=[y_1,y_2,\dots ,y_n]$
则f=zip(a,b)会返回一组元祖类型数据，其值为$(x_1,y_1),(x_2,y_2),\dots ,(x_n,y_n)$
在python3版本中，使用print(f)，会给出f这个映射在内存中的地址，如果想观察f的值，需要使用list()函数做转换
如果给定的x的数与y的数目不相等，多余的数不会出现在映射中。

# a、b中的元素可以是一维的
a = [1,2,3,5,6]
b = [4,5,6,7,8]

f = zip(a,b)
print(f)
print(list(f))

[(1, 4), (2, 5), (3, 6), (5, 7), (6, 8)]

# a中的元素可以是多维的
a = [(1,4),(2,3),(5,7)]
b = [6,8,9]
f = zip(a,b)
print(f)
print(list(f))

[((1, 4), 6), ((2, 3), 8), ((5, 7), 9)]

# b中的元素可以是多维的
a = [(1,4),(2,3),(5,7)]
b = [(6,6),(7,9),(8,5)]
f = zip(a,b)
print(f)
print(list(f))

[((1, 4), (6, 6)), ((2, 3), (7, 9)), ((5, 7), (8, 5))]

第1节 数字分类：从自然数到复数

• 集合

集合 (set) ,简称集，是指某种具有特定性质元素的总体。

• 自然数和整数

自然数集 (the set of natural numbers) 记作$\mathbb{N}$
$\mathbb{N}=\{1,2,3,\dots ,n,\dots \}$
整数集 (the set of integer) 记作$\mathbb{Z}$
$\mathbb{Z}=\{0,-1,+1,-2,+2,-3,+3,\dots ,-n,+n,\dots \}$

• 有理数与实数

有理数集 (the set of rational numbers) 记作$\mathbb{Q}$
有理数 (rational numbers) 都可以表示成$q=\frac{a}{b}((a\in \mathbb{Z})\wedge (b\in \mathbb{Z}/0))$的形式。
给定单位长度，通过几何方法可以作出任意有理数长度的线段,也就是说，有理数是可以准确测量的，因此有理数又称可公度数，可以被写成无限循环小数的形式。
与之对应，不能准确测量的数，叫做不可公度数，即无理数 (irrational numbers) 无理数都是无限不循环小数。
有理数集和无理数集，组成实数集 (the set of real numbers) 记作$\mathbb{R}$

• 复数

复数 (complex numbers) 包括实数 (real numbers) 和虚数 (imaginary numbers) ,复数集 (the set of complex numbers) 的记号为$\mathbb{C}$
复数的具体形式如下：
$$a+bi$$
$a$和$b$是实数，$i$是虚数单位 (imaginary unit)
$$i^2=-1$$

python3 math库中的特殊常量

$math是Python的库$

欧拉常数，即自然常数$e$: math.e

圆周率$\pi :$ math.pi

$\sqrt{2}:$math.sqrt(2)

# import math library
import math

# print the value of pi
print("Pi = ",math.pi)

# print the value of e
print("e= ",math.e)

# print the value of square of 2
print("sqrt(2)= ",math.sqrt(2))

Pi =  3.141592653589793
e=  2.718281828459045
sqrt(2)=  1.4142135623730951

python3 mpmath库中的特殊常量

$mpmath是Python的第三方库，用于求任意精度浮点数,mp.dps=n,十进制下保留n位有效数字$

欧拉常数，即自然常数$e$: mpmath.e

圆周率$\pi :$ mpmath.pi

$\sqrt{2}:$mpmath.sqrt(2)

from mpmath import mp
mp.dps = 1000 + 1

# 圆周率，小数点后1000位
print('print 1000 digits of pi behind decimal point')
print(mp.pi)
print('\n')

# 自然常数e,小数点后1000位
print('print 1000 digits of e behind decimal point')
print(mp.e)

print 1000 digits of pi behind decimal point
3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989


print 1000 digits of e behind decimal point
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274274663919320030599218174135966290435729003342952605956307381323286279434907632338298807531952510190115738341879307021540891499348841675092447614606680822648001684774118537423454424371075390777449920695517027618386062613313845830007520449338265602976067371132007093287091274437470472306969772093101416928368190255151086574637721112523897844250569536967707854499699679468644549059879316368892300987931277361782154249992295763514822082698951936680331825288693984964651058209392398294887933203625094431173012381970684161403970198376793206832823764648042953118023287825098194558153017567173613320698112509961818815930416903515988885193458072738667385894228792284998920868058257492796104841984443634632449684875602336248270419786232090021609902353043699418491463140934317381436405462531520961836908887070167683964243781405927145635490613031072085103837505101157477041718986106873969655212671546889570350354

is_integer() 判断输入是否为整数

# input("******")在屏幕上显示******，并且接受一个输入```
# float(x),将变量x的值转化为1个浮点数
# num = a,将变量a的值赋值给num
num =float(input("Enter a number"))

# num.is_integer(),num作为数值变量，也是一种特殊的类，在Python该类中具有可以判断是否为整数的特性。##

if num.is_integer():
    if (num % 2) == 0:
        print("{0} is even ".format(int(num)))
    else:
        print("{0} is odd ".format(int(num)))
else:
    print("{0} is not an integer ".format(num))

Enter a number 15


15 is odd 

第2节 加法和减法：最基本的数学运算

加法运算

num1 = 2
num2 = 3

# add two numbers
sum = num1 + num2

# display the computation，format() 方法格式化指定的值，并将其插入字符串的占位符内,这些值可以是任何类型的变量。
print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))

The sum of 2 and 3 is 5

加法运算(由用户输入数据)

a = float(input("Give me a number a:"))
b = float(input("Give me a number b:"))

sum = a + b

print('The sum of {0} and {1} is {2}'.format(a, b, sum))

Give me a number a: 23
Give me a number b: 15


The sum of 23.0 and 15.0 is 38.0

累计求和

linspace(a,b,n)是numpy中定义的一个函数。

个人理解,该函数的实际意义是：

$以a为起点，定义为x_0,以b为终点，定义为x_n,将[x_1,x_n]区间(n-1)等分，转化为$

$$[x_1,x_2,x_3,\dots ,x_n](\forall i,j\in \{1,2,3,\dots ,n\}|(x_{i+1}-x_i=x_{j+1}-x_j))$$

$[x_1,x_2,x_3,\dots ,x_n]$是numpy库定义的一个特殊的类 class numpy.ndarray

# 导入numpy包，在程序中将numpy简写为np
import numpy as np

a_i = np.linspace(3,10,10)
print(a_i)
print(type(a_i))
del a_i

[ 3.          3.77777778  4.55555556  5.33333333  6.11111111  6.88888889
  7.66666667  8.44444444  9.22222222 10.        ]

cunsum()是numpy中定义的一个函数，用于累计求和，简单地说，就是对一组数字求和时，保留每一步的值。

import numpy as np
a_i = np.linspace(1,10,10)
print(a_i)


a_i_cumsum1 = a_i.cumsum()
a_i_cumsum2 = np.cumsum(a_i)

print(a_i_cumsum1)
print(a_i_cumsum2)

print(type(a_i_cumsum1),type(a_i_cumsum2))

[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
[ 1.  3.  6. 10. 15. 21. 28. 36. 45. 55.]
[ 1.  3.  6. 10. 15. 21. 28. 36. 45. 55.]
 

减法运算

num1 = 5
num2 = 3

# add two numbers
difference = num1 - num2

# display the computation，format() 方法格式化指定的值，并将其插入字符串的占位符内,这些值可以是任何类型的变量。
print('The difference of {0} and {1} is {2}'.format(num1, num2, difference))

The difference of 5 and 3 is 2

减法运算(由用户输入数据)

a = float(input("Give me a number a:"))
b = float(input("Give me a number b:"))

difference = a - b

print('The difference of {0} and {1} is {2}'.format(a, b, difference))

Give me a number a: 12
Give me a number b: 6


The difference of 12.0 and 6.0 is 6.0

第3节 向量

• $行向量：n个数字排成一行，称为n维行向量$

3维行向量，也可以称作$1\times 3$矩阵：
$${\left[\begin{array}{c}123\end{array}\right]}_{1\times 3}$$

• $列向量：n个数字排成一列，称为n维列向量$

3维列向量，也可以称作$3\times 1$矩阵：
$${\left[\begin{array}{c}2\\ 8\\ 9\end{array}\right]}_{3\times 1}$$

利用numpy定义行向量和列向量

import numpy as np

# 定义行向量
a = np.array([[1,2,3]])

# 定义列向量
b = np.array([[1],[2],[3]])

print(a)

print(b)

[[1 2 3]]
[[1]
 [2]
 [3]]

利用numpy求转置

• 行向量转置得到列向量，列向量转置得到行向量。比如说

$${\left[\begin{array}{c}123\end{array}\right]}^T=\left[\begin{array}{c}1\\ 2\\ 3\end{array}\right]$$
$${\left[\begin{array}{c}1\\ 2\\ 3\end{array}\right]}^T=\left[\begin{array}{c}123\end{array}\right]$$

# 行向量的转置a
a_row = np.array([[1,2,3]])
print(a_row)
c = a_row.T
print(c)

print('\n')

# 列向量的转置
b_col = np.array([[1],[2],[3]])
print(b_col)
d = b_col.T
print(d)

[[1 2 3]]
[[1]
 [2]
 [3]]


[[1]
 [2]
 [3]]
[[1 2 3]]

第4节 矩阵：数字排成长方形

• 矩阵(matrix)其实就是长方形的数表。

${\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]}_{2\times 3},{\left[\begin{array}{cc}1& 2\\ 3& 4\\ 5& 6\end{array}\right]}_{3\times 2},{\left[\begin{array}{cc}1& 2\\ 3& 4\end{array}\right]}_{2\times 2}$

• 一个$n\times D$矩阵$X$,可以展开写成如下形式。$n$代表样本数，$D$代表研究的特征数

$$X_{n\times D}={\left[\begin{array}{cccc}{x}_{1,1}& x_{1,2}& \dots & x_{1,D}\\ x_{2,1}& x_{2,2}& \dots & x_{2,D}\\ ⋮& ⋮& \ddots & ⋮\\ x_{n,1}& x_{n,2}& \dots & x_{n,D}\end{array}\right]}_{n\times D}$$

利用numpy.array()定义矩阵

import numpy as np
# 利用numpy中的array()函数定义矩阵
A = np.array([[1, 2, 3],
              [4, 5, 6]])
print(A)

[[1 2 3]
 [4 5 6]]

提取矩阵的某一列元素

# 提取第1列元素,[:,0]代表行号由0到尾,列号取1(python中从0开始数),直接提取数据
A_first_col = A[:,0] 
print(A_first_col)
# 提取第2列元素,[:,1]代表行号由0到尾,列号取2(python中从0开始数),直接提取数据
A_2_col = A[:,1] 
print(A_2_col)
# 提取第3列元素,[:,2]代表行号由0到尾,列号取3(python中从0开始数),直接提取数据
A_3_col = A[:,2] 
print(A_3_col)

[1 4]
[2 5]
[3 6]

# 提取第1列元素,[:,[0]]代表行号由0到尾,列号取1，仍按列排
A_1_col_V = A[:,[0]]
print(A_1_col_V)

# 提取第2列元素,[:,[1]]代表行号由0到尾,列号取2，仍按列排
A_2_col_V = A[:,[1]]
print(A_2_col_V)
# 提取第3列元素,[:,[2]]代表行号由0到尾,列号取3，仍按列排
A_3_col_V = A[:,[2]]
print(A_3_col_V)

[[1]
 [4]]
[[2]
 [5]]
[[3]
 [6]]

提取矩阵的某一行元素

A_1_row = A[0,:]
print(A_1_row)
A_2_row = A[1,:]
print(A_2_row)

[1 2 3]
[4 5 6]

A_1_row_r = A[[0],:]
print(A_1_row_r)
A_2_row_r = A[[1],:]
print(A_2_row_r)

[[1 2 3]]
[[4 5 6]]

提取矩阵的某个元素

A_2_2 = A[1,1]
print(A_2_2)

5

第5节 矩阵：一排行向量 or 一排列向量

• 矩阵可以看成是若干列向量左右排列，也可以看成是若干行向量上下叠放。一个$2\times 3$的矩阵可以看成3个2维列向量左右排列，也可以看出2个3维行向量上下排列。

$${\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]}_{2\times 3}=\left[\begin{array}{c}\left[\begin{array}{c}1\\ 4\end{array}\right]\left[\begin{array}{c}2\\ 5\end{array}\right]\left[\begin{array}{c}3\\ 6\end{array}\right]\end{array}\right]=\left[\begin{array}{c}\left[\begin{array}{ccc}1& 2& 3\end{array}\right]\\ \left[\begin{array}{ccc}4& 5& 6\end{array}\right]\end{array}\right]$$

• 矩阵转置(matrix transpose)指将矩阵行列互换得到的新矩阵。

$${\left[\begin{array}{cc}1& 2\\ 3& 4\\ 5& 6\end{array}\right]}_{3\times 2}^T={\left[\begin{array}{ccc}1& 3& 5\\ 2& 4& 6\end{array}\right]}_{2\times 3}$$

第6节 矩阵形状：每种形状都有特殊性质和用途

• 如果列向量的元素都是1，一般记作1，称为全1列向量，或全1向量:

• ${\left[\begin{array}{c}1,1,\dots ,1\end{array}\right]}^T$

• 如果列向量的元素都是0，一般记作0，称为零向量

• ${\left[\begin{array}{c}0,0,\dots ,0\end{array}\right]}^T$

• 零矩阵(null matrix):所有元素都为0的矩阵，记作 $O$

• $Null$ $matrix$ $\left[\begin{array}{ccc}0& 0& 0\\ 0& 0& 0\\ 0& 0& 0\end{array}\right]$

• $n$阶方阵(square matrix) :行数和列数都是$n$的矩阵

• 对角矩阵(diagonal matrix) ：一般是除主对角线外的元素均为$0$的方阵

• $Diagonal$ $matrix$ $\left[\begin{array}{ccc}1& 0& 0\\ 0& 3& 0\\ 0& 0& 5\end{array}\right]$

• 单位矩阵(identity matrix) :主对角线元素都是$1$，其他元素都是$0$的方阵，记作 $I$

• $Identity$ $matrix$ $\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right]$

• 对称矩阵(symmetric matrix) :矩阵元素以主对角线为轴对称的方阵

• $Symmetrix$ $matrix$ $\left[\begin{array}{ccc}\ast & a& c\\ a& \ast & b\\ c& b& \ast \end{array}\right]$

第7节 矩阵加减的{条件 | 算法}：{行数相等、列数相等 | 对应位置，批量加减}

向量加减

$\left[\begin{array}{ccc}1& 2& 3\end{array}\right]+\left[\begin{array}{ccc}4& 5& 6\end{array}\right]=\left[\begin{array}{ccc}1+4& 2+5& 3+6\end{array}\right]=\left[\begin{array}{ccc}5& 7& 9\end{array}\right]$

$\left[\begin{array}{ccc}1& 2& 3\end{array}\right]-\left[\begin{array}{ccc}4& 5& 6\end{array}\right]=\left[\begin{array}{ccc}1-4& 2-5& 3-6\end{array}\right]=\left[\begin{array}{ccc}-3& -3& -3\end{array}\right]$

$\left[\begin{array}{c}1\\ 2\\ 3\end{array}\right]+\left[\begin{array}{c}4\\ 5\\ 6\end{array}\right]=\left[\begin{array}{c}1+4\\ 2+5\\ 4+6\end{array}\right]=\left[\begin{array}{c}5\\ 7\\ 9\end{array}\right]$

用python做向量加减法运算

# 给定行向量list1,list2
list1=[1, 2, 3]
list2=[4, 5, 6]

# 用zip(list1,list2)函数构造映射([1,4],[2,3][5,6]),再对应相加
print([x + y for x, y in zip(list1, list2)])

# 利用lamdba运算
print(list(map(lambda x,y:x+y, list1, list2)))

# 导入numpy包
import numpy as np

# 把list1,list2转化为np.array格式，打印向量和
x = np.array(list1)
y = np.array(list2)
print(x+y)

# 运用np.add方法做向量加法
print(np.add(list1,list2))

[5, 7, 9]
[5, 7, 9]
[5 7 9]
[5 7 9]

矩阵加减

${\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]}_{2\times 3}+{\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\end{array}\right]}_{2\times 3}={\left[\begin{array}{ccc}1+1& 2+0& 3+0\\ 4+0& 5+1& 6+0\end{array}\right]}_{2\times 3}={\left[\begin{array}{ccc}2& 2& 3\\ 4& 6& 6\end{array}\right]}_{2\times 3}$

${\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]}_{2\times 3}-{\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\end{array}\right]}_{2\times 3}={\left[\begin{array}{ccc}1-1& 2-0& 3-0\\ 4-0& 5-1& 6-0\end{array}\right]}_{2\times 3}={\left[\begin{array}{ccc}0& 2& 3\\ 4& 4& 6\end{array}\right]}_{2\times 3}$

用for循环做矩阵加法(不推荐)

# 利用数组构建矩阵A,B

A = [[1, 2, 3],
     [4, 5, 6]]

B = [[1, 0, 0],
     [0, 1, 0]]

# len(A)A中有几个数组元素，在本例中，即矩阵A的行数
# len(A[0]),A的第一个数组中有几个元素，在本例中，即矩阵A的列数
A_plus_B = [[A[i][j] + B[i][j]  
            for j in range(len(A[0]))] 
            for i in range(len(A))]

print(A_plus_B)

[[2, 2, 3], [4, 6, 6]]

用numpy做矩阵加法(推荐)

import numpy as np

A = [[1, 2, 3],
     [4, 5, 6]]

B = [[1, 0, 0],
     [0, 1, 0]]

print(np.array(A) + np.array(B))

print(np.add(A, B))

[[2 2 3]
 [4 6 6]]
[[2 2 3]
 [4 6 6]]