EduCoder实训机器学习
Numpy科学计算
第1关：数组创建
#### 相关知识
在 Python 中创建数组有许多的方法，这里我们使用 Numpy 中的`arange`方法快速的新建一个数组：
```Plain Text
import numpy as npa = np.arange(5)
```
其中`import numpy as np`是指引入`Numpy`这个库，并取别名为`np`。之所以取别名，是为了代码编写的方便。`a=np.arange(5)`是指将数值`0 1 2 3 4`赋值给`a`这个变量，这样我们就快速的创建了一个一维数组。
创建多维数组的方法是:
```Plain Text
import numpy as npb = np.array([np.arange(6),np.arange(6)])
```
这里，我们使用两个`arange`方法，创建了两个`1x6`的一维数组，然后使用`numpy`的`array`方法，将两个一维数组组合成一个`2x6`的二维数组。从而达到了创建多维数组的目的。
`numpy`创建的数组可以直接复制，具体代码示例如下：
```Plain Text
import numpy as npx = [y for y in range(6)]b=np.array([x]*4)
```
该段代码会创建一个`4*6`的数组。
#### 编程要求
本关的任务是，补全右侧编辑器中 `Begin-End` 区间的代码，以实现创建一个`m*n`的多维数组的功能。具体要求如下：
- 函数接受两个参数，然后创建与之对应的的多维数组；
- 本关的测试样例参见下文。
本关设计的代码文件`cnmda.py`的代码框架如下：
```Plain Text
# 引入numpy库import numpy as np# 定义cnmda函数def cnmda(m,n): ''' 创建numpy数组 参数： m:第一维的长度 n: 第二维的长度 返回值: ret: 一个numpy数组 ''' ret = 0 # 请在此添加创建多维数组的代码并赋值给ret #********** Begin *********# #********** End **********# return ret
```
#### 测试说明
本关的测试过程如下:
- 平台运行`step1/cnmdatest.py`文件，并以标准输入方式提供测试输入；
- `cnmdatest.py`文件调用`cnmda`中的`cnmda`方法，平台获取`cnmdatest.py`的输出，然后将其与预期输出作对比，如果一致，则测试通过；否则测试失败。
# 引入numpy库
import numpy as np
# 定义cnmda函数
def cnmda(m,n):
'''
创建numpy数组
参数：
m:第一维的长度
n: 第二维的长度
返回值:
ret: 一个numpy数组
'''
ret = 0
# 请在此添加创建多维数组的代码并赋值给ret
#********** Begin *********#
b=np.arange(n);
ret = np.array([b]*m)
#********** End **********#
return ret第2关：切片索引
#### 相关知识
为了完成本关任务，你需要掌握：
- 索引；
- 遍历；
- 切片。
##### 索引
`ndarray`的索引其实和`python`的`list`的索引极为相似。元素的索引从`0`开始。代码如下：
```Plain Text
import numpy as np
# a中有4个元素，那么这些元素的索引分别为0，1，2，3
a = np.array([2, 15, 3, 7])
# 打印第2个元素
# 索引1表示的是a中的第2个元素
# 结果为15print(a[1])
# b是个2行3列的二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
# 打印b中的第1行
# 总共就2行，所以行的索引分别为0，1
# 结果为[1, 2, 3]print(b[0])
# 打印b中的第2行第2列的元素
# 结果为5print(b[1][1])
```
##### 遍历
`ndarray`的遍历方式与`python`的`list`的遍历方式也极为相似，示例代码如下：
```Plain Text
import numpy as np
a = np.array([2, 15, 3, 7])
# 使用for循环将a中的元素取出来后打印
for element in a:
print(element)
# 根据索引遍历a中的元素并打印
for idx in range(len(a)):
print(a[idx])
# b是个2行3列的二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
# 将b展成一维数组后遍历并打印
for element in b.flat:
print(element)
# 根据索引遍历b中的元素并打印
for i in range(len(b)):
for j in range(len(b[0])):
print(b[i][j])
```
##### 切片
`ndarray`的切片方式与`python`的`list`的遍历方式也极为相似，对切片不熟的同学也不用慌，套路很简单，就是用索引。
假设想要将下图中紫色部分切片出来，就需要确定行的范围和列的范围。由于紫色部分行的范围是`0`到`2`，所以切片时行的索引范围是`0:3`(**索引范围是左闭右开**);又由于紫色部分列的范围也是`0`到`2`，所以切片时列的索引范围也是`0:3`(**索引范围是左闭右开**)。最后把行和列的索引范围整合起来就是`[0:3, 0:3]`(**`,`左边是行的索引范围**)。当然有时为了方便，`0`可以省略，也就是`[:3, :3]`。
切片示例代码如下：
#### 编程要求
在图像处理中，我们通常会将我们感兴趣的区域提取出来再进行处理，而这个感兴趣区域成为`ROI`(`Region Of Interest`)。本关的任务是根据提示，在右侧编辑器`Begin-End`处补充代码，根据测试用例的输入将`ROI`的提取并返回(`ROI`是一个矩阵)。
- 具体要求请参见后续测试样例。
请先仔细阅读右侧上部代码编辑区内给出的代码框架，再开始你的编程工作！
#### 测试说明
平台会对你编写的代码进行测试。你只需按要求完成`get_roi(data, x, y, w, h)`函数即可。其中：
- `data`：待提取`ROI`的原始图像数据(其实就是个二维数组)，类型为`ndarray`；
- `x`: `ROI`的左上角顶点的行索引，类型为`int`；
- `y`: `ROI`的左上角顶点的列索引，类型为`int`；
- `w`: `ROI`的宽，类型为`int`；
- `h`: `ROI`的高，类型为`int`。
测试用例是一个字典，字典中`image`部分表示原始图像的像素数据，`x`部分表示`ROI`的左上角顶点的行索引，`y`部分表示`ROI`的左上角顶点的列索引，`w`部分表示`ROI`的宽，`h`部分表示`ROI`的高。
import numpy as np
def get_roi(data, x, y, w, h):
'''
提取data中左上角顶点坐标为(x, y)宽为w高为h的ROI
:param data: 二维数组，类型为ndarray
:param x: ROI左上角顶点的行索引，类型为int
:param y: ROI左上角顶点的列索引，类型为int
:param w: ROI的宽，类型为int
:param h: ROI的高，类型为int
:return: ROI，类型为ndarray
'''
#********* Begin *********#
return data[x:x+h+1, y:y+w+1]
#********* End *********#
第3关：基本运算
#### 相关知识
`Numpy`库可以直接进行一些四则运算，快速的处理两个`Numpy`数组：
```Plain Text
a = np.array([[1,2,3],[4,5,6]])b = np.array([[4,5,6],[1,2,3]])
```
##### 向量与向量之间
###### 1.加法
```Plain Text
In:np.add(a,b) 或 a+bOut:array([[5, 7, 9], [5, 7, 9]])
```
###### 2.减法
```Plain Text
In:np.subtract(a,b) 或 a-bOut:array([[-3, -3, -3], [ 3, 3, 3]])
```
###### 3.乘法（X乘）
```Plain Text
In:np.multiply(a,b) 或 a * bOut:array([[ 4, 10, 18], [ 4, 10, 18]])
```
###### 4.乘法（点乘）
```Plain Text
a = np.array([[1,2,3],[4,5,6]])b = np.array([4,5,6])In: np.dot(a,b) Out:array([32, 77])
```
###### 5.除法
```Plain Text
a = np.array([[1,2,3],[4,5,6]])b = np.array([[4,5,6],[1,2,3]])In:np.divide(a,b) 或 a/bOut:array([[ 0.25, 0.4 , 0.5 ], [ 4. , 2.5 , 2. ]])
```
##### 向量与标量之间
`a = np.array([[1,2,3],[4,5,6]])`
###### 1.加法
```Plain Text
In: a +1Out:array([[2, 3, 4], [5, 6, 7]])
```
###### 2.减法
```Plain Text
In: a -1Out:array([[0, 1, 2], [3, 4, 5]])
```
###### 3.乘法
```Plain Text
In: a*2Out:array([[ 2, 4, 6], [ 8, 10, 12]])
```
###### 4.除法
###### 5.求余
###### 6.矩阵转置
###### 7.矩阵的逆
矩阵可逆的充要条件是矩阵满秩。
#### 编程要求
本关的任务是，补全右侧编辑器中 `Begin-End` 区间的代码，以实现向量与标量相加和相乘的的功能。具体要求如下：
- 函数接受三个参数，然后进行向量与标量之间的运算；
- 本关的测试样例参见下文；
- 本关设计的代码文件`cal.py`的代码框架如下：
#### 测试说明
本关的测试过程如下:
- 平台运行`step5/caltest.py`文件，并以标准输入方式提供测试输入；
- `caltest.py`文件调用`cal`中的方法，平台获取`caltest.py`的输出，然后将其与预期输出作对比，如果一致，则测试通过；否则测试失败。
# 引入numpy库
import numpy as np
# 定义opeadd函数
def opeadd(m,b,n):
'''
参数：
m:是一个数组
b:是一个列表
n:是列表中的索引
你需要做的是 m+b[n]
返回值:
ret: 一个numpy数组
'''
ret = 0
#********** Begin *********#
ret=m+b[n]
#********** End **********#
return ret
# 定义opemul函数
def opemul(m,b,n):
'''
参数：
m:是一个数组
b:是一个列表
n:是列表中的索引
你需要做的是 m*b[n]
返回值:
ret: 一个numpy数组
'''
ret = 0
#********** Begin *********#
ret=m*b[n]
#********** End **********#
return ret第4关：ufunc
相关知识
NumPy 中的 ufunc 对象也称为 ufunc 函数，它包含了对数组进行处理的通用函数。通用函数（ufunc）是针对 ndarray 数组对象执行元素级运算的函数，即通用函数会对数组中的每一个元素值作用后产生新的元素值，并返回新的元素值组成的数组，因此，通用函数（ufunc）都是以 NumPy 数组作为输出的。
通用函数（ufunc）的分类：
- 按照通用函数（ufunc）所接收的数组参数个数来划分，接收一个数组参数的称为一元通用函数，而接收两个数组参数的称为二元通用函数；
- 按照通用函数（ufunc）的运算功能划分，常用的通用函数（ufunc）运算有四则运算、比较运算和逻辑运算等。通用函数（ufunc）支持全部的四则运算，并且保留习惯的运算符，与数值运算使用方法相同，但要注意操作的对象是数组。
常用的一元通用函数
| 函数 | 说明 |
|---|---|
| ceil() | 计算各元素的 ceiling 值，即大于等于该值的最小整数 |
| floor() | 计算各元素的 floor 值,即小于等于该值的最大整数 |
| rint() | 将各元素的值四舍五入到最接近的整数，保留 dtype |
| modf() | 将数组的小数和整数部分以两个独立数组的形式返回 |
| isnan() | 返回一个"哪些值是 NaN （Not a Numbed）"的布尔型数组 |
| isfinite、isinf() | 分别返回一个表不"哪些元素是有穷的（非inf,非NaN ）”或“哪些元素是无穷” 的布尔型数组 |
| abs()、fabs() | 计算整数、浮点数或复数的绝对值，对于非复数值可以使用更快的 fabs |
| sqrt() | 计算各元素的平方根，相当于 arr**0.5 |
| square() | 计算各元素的平方，相当于 arr**2 |
| exp() | 计算各元素的指数 $e^x$ |
| log()、Ioh10()、Icg2()、 log1p() | 分别为自然对数（底数为 e )，底数为 10，底数为2， log(1+x） |
| sing() | 计算各元素的正负号，1 (正数)，0 (零)，-1 (负数） |
| cos()、cosh()、sin()、 sinh()、tan()、arccos()、arccosh()、arcsin()、 arcsinh()、arctan()、arctanh() | 三角函数和反三角函数 |
| logical_not() | 计算各元素取反，相当于 -arr |
常用的二元通用函数
| 函数 | 等价运算符 | 说明 |
|---|---|---|
| add() | + | 将数组中对应元素相加 |
| subtract() | - | 从第一数组中减去第二数组中的元素 |
| multipIy() | * | 将数组中对应元素相乘（数量积） |
| dot() | 数组中对应元素相乘的累加和（矢量积） | |
| divide()、floor_divide() | /、// | 将数组中对应元素相除或向下整除 |
| mod()、 remainder()、fmod() | % | 元素级的求模计算（除法的余数）；mod与remainder的功能完全一致；fmod处理负数的方式与remainder、mod和％不同， 所得余数的正负由被除数决走，与除数的正负无关 |
| maximum()、fmax() | 元素级的最大值计算，fmax 将忽略 NaN | |
| minimum()、fmin() | 元素级的最小值计算，fmin 将忽略 NaN | |
| power() | ** | 对第一个数组中的元素 A，根据第二个数组中的相应元素 B，计算AB |
| copysing() | 将第二个数组中的值的符号复制给第一个数组中的值 | |
| equal()、not_equal()、 greater()、greater_equal()、less()、less_equal() | ==、!=、> 、>=、<、<= | 执行元素级的比较运算，最终产生布尔型数组 |
| logical_and()、logical_or()、logical xor() | &、|、^ | 执行元素级的真值逻辑运算，返回布尔型值 |
注意：在二元通用函数中，当第二个参数为标量时或者维度不一致时，将进行广播（Broadcast）运算。
更多基本通用函数可以在本页面找到： >>点击传送<<
使用ufuncs的优势
-
ufunc用于在NumPy中实现矢量化，与迭代元素相比，性能大幅提升。
-
提供广播和其他方法，对计算非常有帮助。
-
将迭代语句转换为基于向量的操作，在CPU层级中已针对此类操作进行了优化，因此速度更快。
编程实例
以如下NumPy数组A为例，使用ufuncs函数对数组A进行计算：
A = np.random.randint(0, 10, (5, 6)) # 随机初始化一个5行6列的整数矩阵A'''A =array([[7, 2, 6, 8, 8, 8],[5, 7, 2, 5, 6, 7],[9, 2, 8, 0, 7, 9],[6, 0, 6, 1, 9, 1],[4, 2, 6, 7, 6, 2]])'''
-
对数组A的元素开根号：
B = np.sqrt(A)'''B =array([[2.64575131, 1.41421356, 2.44948974, 2.82842712, 2.82842712, 2.82842712],[2.23606798, 2.64575131, 1.41421356, 2.23606798, 2.44948974, 2.64575131],[3. , 1.41421356, 2.82842712, 0. , 2.64575131, 3. ],[2.44948974, 0. , 2.44948974, 1. , 3. , 1. ],[2. , 1.41421356, 2.44948974, 2.64575131, 2.44948974, 1.41421356]])'''
-
将数组A的平方根乘浮点数分解成整数和小数部分：
B, C = np.modf(np.sqrt(A))'''B =array([[0.64575131, 0.41421356, 0.44948974, 0.82842712, 0.82842712, 0.82842712],[0.23606798, 0.64575131, 0.41421356, 0.23606798, 0.44948974, 0.64575131],[0. , 0.41421356, 0.82842712, 0. , 0.64575131, 0. ],[0.44948974, 0. , 0.44948974, 0. , 0. , 0. ],[0. , 0.41421356, 0.44948974, 0.64575131, 0.44948974, 0.41421356]]),C =array([[2., 1., 2., 2., 2., 2.],[2., 2., 1., 2., 2., 2.],[3., 1., 2., 0., 2., 3.],[2., 0., 2., 1., 3., 1.],[2., 1., 2., 2., 2., 1.]])'''
-
将数组A与标量2相加：
B = np.add(A,2)'''B =array([[ 9, 4, 8, 10, 10, 10],[ 7, 9, 4, 7, 8, 9],[11, 4, 10, 2, 9, 11],[ 8, 2, 8, 3, 11, 3],[ 6, 4, 8, 9, 8, 4]])'''
编程要求
根据任务提示，在右侧编辑器Begin-End部分补充代码。
任务要求：
- 计算矩阵A的平方根并与标量2相加；
- 将矩阵A开根号后的小数部分与原矩阵A相加；
- 使用通用函数numpy.dot()计算矩阵A与矩阵A转置的矢量积；
import numpy as np
ndarray = np.ndarray
def task1(A: ndarray) -> ndarray:
'''
:param A n*m维的numpy数组
任务要求：计算矩阵A的平方根并与标量2相加；
'''
# ********** Begin *********
B = np.sqrt(A) + 2
# ********** End *********
return B
def task2(A: ndarray) -> ndarray:
'''
:param A n*m维的numpy数组
任务要求：将矩阵A开根号后的小数部分与原矩阵A相加；
'''
# ********** Begin *********
B = A + np.modf(np.sqrt(A))[0]
# ********** End *********
return B
def task3(A: ndarray) -> ndarray:
'''
:param A n*m维的numpy数组
任务要求：使用通用函数numpy.dot()计算矩阵A与矩阵A转置的矢量积；
提示：使用.T属性获得转置矩阵，例如A的转置矩阵为A.T
'''
# ********** Begin *********
B = np.dot(A, A.T)
# ********** End *********
return B第5关：文件读写
相关知识
通常情况下，数据是以文件形式存储的。常用的存储文件的格式有文本文件、CSV 格式文件和二进制格式文件等。在数据分析中，经常需要从文件中读取数据或将数据写入文件，因此，学会读写文件操作是深入学习 NumPy 的基础。下面将分别介绍如何使用 NumPy 函数来读写一维或二维数组的文本文件、CSV 格式文件、二进制格式文件和多维数据文件。
Numpy中常用的文件处理方法：
| 函数名 | |
|---|---|
| numpy.savetxt() | 将数据以文本格式保存到文件中 |
| numpy.loadtxt() | 读取文本格式的数据 |
| numpy.genfromtxt() | 读取文本格式的数据 |
| numpy.save() | 将数据以二进制形式保存到文件中 |
| numpy.load() | 读取二进制文件中的数据 |
NumPy 读写文本格式的数据
-
使用savetxt()方法将数据以文本格式保存到文件中
savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)
函数中参数说明如下：
- fname：文件名或者文件句柄。如果文件名以".gz"结尾，则该文件会被自动以gzip形式压缩。当然，"loadtxt"也可以解析被压缩的文件。
- X：一维或者二维数组。需要写入文本文件的数据。
- fmt：str或者str序列，可选参数。单一格式(%10.5f)，序列格式或多重格式字符串，例如。“Iteration %d—%10.5f”，在这种情况下“delimiter”参数被忽略。
- delimiter：str，可选参数。用于分隔列的字符串或者字符。
- newline：str，可选参数。用于分隔行的字符串或者字符。
- header：str，可选参数。将被添加到文件开头的字符串。
- footer：str，可选参数。将被添加到文件结尾的字符串。
- comments：str，可选参数。将作为前缀被添加到"header" 和 "footer"的字符串，用于将这部分标记为注释内容。默认是"#"。
- encoding：{None, str}, 可选参数。用于对输出文件的编码。不适用与输出流。如果编码格式不是"bytes" 或者"latin1"，那么将无法正常load。
-
使用
loadtxt()方法读取文本格式的数据：loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes')
函数中参数说明如下：
- fname：文件，str或者是pathlib.Path。
- dtype：返回的数据类型，默认float。
- comments：str，可选参数。注释说明。默认是"#"。
- delimiter：str，可选参数。数值的分隔符，默认是空格。
- skiprows：int，可选参数。跳过的行数，默认是0。
- usecols：int或者序列，可选参数。读取的列数，0为起点。例如，当usecols=（1,4,5），读取第2列，第5列和第6列。默认值是读取所有列。
- unpack：bool型，可选参数。若为为True，可以将数据进行拆分，例如x, y, z = loadtxt(...)。默认值是False。
- encoding: 用于对输入文件的解码。
注意：文件中的每一行数据的数量需要相同。
NumPy 读写二进制文件
在 NumPy 中，load() 和 save() 函数是专门用于读写二进制格式文件的，它们具有自动处理数组元素类型和形状的功能。savez() 函数能提供将多个数组存储至一个文件的能力，save() 函数保存之后后缀名为 npy，savez() 函数保存之后后缀名 .npz。
使用解压程序打开 npz 文件可以看到里面是若干个以“数组名称”命名的 NPY 格式的文件，数组名称默认为“arr_数字”的形式，在 savez() 函数中可以通过指明函数的参数名称来命名数组。
-
使用
save()或savez()函数写二进制格式文件numpy.save(file, arr, allow_pickle=True, fix_imports=True)
函数中参数说明如下：
-
file：文件或str，保存数据的文件或文件名。如果file是一个文件对象，则文件名不变。如果file是一个字符串，则
.npy扩展名将附加到文件名后面，如果它还没有； -
allow_pickle：bool，可选，允许使用Python pickles保存对象数组。禁止pickles的原因包括安全性（加载pickled数据可以执行任意代码）和可移植性（pickled对象可能无法在不同的Python安装上加载，例如，如果存储的对象需要不可用的库，并且并非所有pickled数据都兼容Python 2和Python 3）。默认值：True；
-
fix_imports：bool，可选，只有在强制Python 3中的对象数组中的对象以Python 2兼容的方式被pickle时才有用。如果fix_imports为True，pickle将尝试将新的Python 3名称映射到Python 2中使用的旧模块名称，以便使用Python 2可读取pickle数据流；
-
arr：array_like，要保存的数组数据。
将多个数组以未压缩的
.npz格式保存到单个文件中。numpy.savez(file, *args, **kwds)
函数中参数说明如下：
-
file：str或文件要保存数据的文件名（字符串）或打开文件（类文件对象）。如果file是一个字符串，则
.npz扩展名将附加到文件名之后（如果尚未存在）。 -
args：参数，可选，数组保存到文件。由于Python不可能知道
savez之外的数组的名称，因此数组将以名称“arr_0”，“arr_1”等保存。这些参数可以是任何表达式。 -
kwds：关键字参数，可选，数组保存到文件。数组将保存在带有关键字名称的文件中。
-
使用
load()函数读取二进制格式文件load()函数的格式如下：numpy.load(file, mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')
函数中参数说明如下：
- file：类文件对象或字符串，要读取的文件。类文件对象必须支持
seek()和read()方法。Pickled文件要求文件样对象也支持readline()方法。 - mmap_mode：{None，'r +'，'r'，'w +'，'c'}，可选，如果不是None，那么使用给定的模式对内存映射文件（有关模式的详细描述，请参阅numpy.memmap）。内存映射数组保存在磁盘上。但是，它可以像任何ndarray访问和切片。内存映射对于访问大文件的小片段而不将整个文件读入内存特别有用。
- allow_pickle：bool，可选，允许加载pickled对象数组存储在npy文件中。禁止pickles的原因包括安全性，因为加载pickled数据可以执行任意代码。如果不允，加载对象数组将失败。默认值：True
- fix_imports：bool，可选，仅当在Python 3上加载Python 2生成的pickled文件时有用，其中包括包含对象数组的npy / npz文件。如果fix_imports为True，pickle将尝试将旧的Python 2名称映射到Python 3中使用的新名称。
- encoding：str，可选，读取Python 2字符串时使用的编码。仅当在Python 3上加载Python 2生成的pickled文件时有用，其中包括包含对象数组的npy / npz文件。不允许使用“latin1”，“ASCII”和“bytes”以外的值，因为它们可能损坏数值数据。默认值：'ASCII'
编程要求
根据任务提示，在右侧编辑器Begin-End部分补充代码。
任务要求：
- 从指定路径的二进制文件中（"step5/FileHandling/files/A.npy"）读取NumPy矢量数组A，从从指定路径的txt文件中读取矢量数组B（"step5/FileHandling/files/B.txt"），然后使用通用函数numpy.add()对数组A和B进行求和，将结果保存到指定的二进制文件中（"step5/FileHandling/files/out.npy"）。
测试说明
平台会对你编写的代码和生成的文件进行测试，==请严格按照指定路径进行文件读写==：
测试输入：（"step5/FileHandling/files/A.npy"）和（"step5/FileHandling/files/B.txt"）中的数据 预期输出：（"step5/FileHandling/files/out.npy"）
import numpy as np
ndarray = np.ndarray
def task():
'''
任务要求：从指定路径的二进制文件中（"step5/FileHandling/files/A.npy"）读取NumPy矢量数组A，从从指定路径的txt文件中读取矢量数组B（"step5/FileHandling/files/B.txt"），然后使用通用函数numpy.add()对数组A和B进行求和，将结果保存到指定的二进制文件中（"step5/FileHandling/files/out.npy"）
提示1：使用np.load('path')加载二进制文件'step5/FileHandling/files/A.npy'
提示2：使用np.loadtxt('path', delimiter=',')加载文本文件'step5/FileHandling/files/B.txt'
提示3：使用使用np.save('path', C)将结果储存到二进制文件'step5/FileHandling/files/out.npy'中
提示3：A.npy和B.txt中矩阵维度一致
'''
########## Begin ##########
A = np.load('step5/FileHandling/files/A.npy')
B = np.loadtxt('step5/FileHandling/files/B.txt', delimiter=',')
C = A + B
np.save("step5/FileHandling/files/out.npy", C)
########## End ##########