Numpy 初体验

第1关：Numpy 创建数组

任务描述

本关任务：使用 Numpy 创建一个多维数组。

相关知识

为了完成本关任务，你需要掌握：创建数组。

创建数组

在 Python 中创建数组有许多的方法，这里我们使用 Numpy 中的 arange 方法快速的新建一个数组：

1. import numpy as np
2. a = np.arange(5)

其中 import numpy as np 是指引入 Numpy 这个库，并取别名为 np。之所以取别名，是为了代码编写的方便。a=np.arange(5) 是指将数值 0 1 2 3 4 赋值给 a 这个变量，这样我们就快速的创建了一个一维数组。

创建多维数组的方法是:

1. import numpy as np
2. b = np.array([np.arange(6),np.arange(6)])

这里，我们使用两个 arange 方法，创建了两个 1x6 的一维数组，然后使用 numpy 的 array 方法，将两个一维数组组合成一个 2x6 的二维数组。从而达到了创建多维数组的目的。

numpy 创建的数组可以直接复制，具体代码示例如下：

1. import numpy as np
2. x = [y for y in range(6)]
3. b=np.array([x]*4)

该段代码会创建一个 4*6 的数组。

# 引入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关：Numpy 数组的基本运算

任务描述

本关任务：学会 Numpy 二维数组的一些基本操作。

相关知识

为了完成本关任务，你需要掌握：

1. 向量与向量之间；
2. 向量与标量之间。

Numpy 库可以直接进行一些四则运算，快速的处理两个 Numpy 数组：

1. a = np.array([[1,2,3],[4,5,6]])
2. b = np.array([[4,5,6],[1,2,3]])

向量与向量之间

1.加法

1. In:np.add(a,b) 或 a+b
2. Out:array([[5, 7, 9],
3. [5, 7, 9]])

2.减法

1. In:np.subtract(a,b) 或 a-b
2. Out:array([[-3, -3, -3],
3. [ 3, 3, 3]])

3.乘法（X乘）

1. In:np.multiply(a,b) 或 a * b
2. Out:array([[ 4, 10, 18],
3. [ 4, 10, 18]])

4.乘法（点乘）

1. a = np.array([[1,2,3],[4,5,6]])
2. b = np.array([4,5,6])
3. In: np.dot(a,b)
4. Out:array([32, 77])

5.除法

1. a = np.array([[1,2,3],[4,5,6]])
2. b = np.array([[4,5,6],[1,2,3]])
3. In:np.divide(a,b) 或 a/b
4. Out:array([[ 0.25, 0.4 , 0.5 ],
5. [ 4. , 2.5 , 2. ]])

向量与标量之间

a = np.array([[1,2,3],[4,5,6]])

1.加法

1. In: a +1
2. Out:array([[2, 3, 4],
3. [5, 6, 7]])

2.减法

1. In: a -1
2. Out:array([[0, 1, 2],
3. [3, 4, 5]])

3.乘法

1. In: a*2
2. Out:array([[ 2, 4, 6],
3. [ 8, 10, 12]])

4.除法

1. In: a/2
2. Out:array([[ 0.5, 1. , 1.5],
3. [ 2. , 2.5, 3. ]])

5.求余

1. In:a%2
2. Out:array([[1, 0, 1],
3. [0, 1, 0]])

6.矩阵转置

1. In:a.T
2. Out:array([[1, 4],
3. [2, 5],
4. [3, 6]])

7.矩阵的逆

矩阵可逆的充要条件是矩阵满秩。

1. import numpy as np
2. import numpy.linalg as lg
3. a = np.array([[1,2,3],[4,5,6],[7,8,9]])
4. In:lg.inv(a)
5. Out:array([[ 3.15251974e+15, -6.30503948e+15, 3.15251974e+15],
6. [ -6.30503948e+15, 1.26100790e+16, -6.30503948e+15],
7. [ 3.15251974e+15, -6.30503948e+15, 3.15251974e+15]])

编程要求

本关的任务是，补全右侧编辑器 Begin-End 内的代码，以实现向量与标量相加和相乘的的功能。具体要求如下：

• 函数接受三个参数，然后进行向量与标量之间的运算；

• 本关的测试样例参见下文；

• 本关设计的代码文件 cal.py 的代码框架如下：

1. # 引入numpy库
2. import numpy as np
3. # 定义opeadd函数
4. def opeadd(m,b,n):
5. '''实现加法
6. 参数：
7. m:是一个数组
8. b:是一个列表
9. n:是列表中的索引
10. 你需要做的是 m+b[n]
11. 返回值:
12. ret: 一个numpy数组
13. '''
14. ret = 0
15. # 请在此添加 创建多维数组 的代码 并赋值给ret
16. #********** Begin *********#
18. #********** End **********#
20. return ret
21. # 定义opemul函数
22. def opemul(m,b,n):
23. '''实现乘法
24. 参数：
25. m:是一个数组
26. b:是一个列表
27. n:是列表中的索引
28. 你需要做的是 m+b[n]
29. 返回值:
30. ret: 一个numpy数组
31. '''
32. ret = 0
33. # 请在此添加 创建多维数组 的代码 并赋值给ret
34. #********** Begin *********#
36. #********** End **********#
37. return ret

测试说明

本关的测试过程如下:

• 平台运行 step5/caltest.py 文件，并以标准输入方式提供测试输入；

• caltest.py 文件调用 cal 中的方法，平台获取 caltest.py 的输出，然后将其与预期输出作对比，如果一致，则测试通过；否则测试失败。

以下是平台对 step5/caltest.py 的测试样例：

a= np.array([[1,2,3],[4,5,6]]) b = [1,2,3] 测试输入： add； 预期输出：

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

测试输入：mul； 预期输出：

1. [[ 2 4 6]
2. [ 8 10 12]]

# 引入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

第3关：Numpy 数组的切片与索引

任务描述

本关任务：从数组中选择指定的元素。

相关知识

为了完成本关任务，你需要掌握：数组的切片与索引。

数组的切片与索引

一维 Numpy 数组的切片操作与 Python 列表的切片一样。下面首先来定义数字 0 1 2 直到 8 的数组，然后通过指定下标 3 到 7 来选择数组的部分元素，这实际上就是提取数组中值为 3 到 6 的元素。

1. In: import numpy as np
2. In: a = np.arange(9)
3. In: a[3:7]
4. Out: array([3,4,5,6])

同时用下标选择元素，下标范围从 0 到 7，并且下标每次递增 2，如下所示：

1. In: a[:7:2]
2. Out:array([0,2,4,6])

也可以像 Python 数组一样，用负值下标来反转数组：

1. In: a[::-1]
2. Out: array([8,7,6,5,4,3,2,1,0])

对于二维数组的索引，类似与 Python 数组的列表：

1. In: a=np.array([[1,2,3],[4,3,2]])
2. In: a[1][0]
3. Out:array([4])
4. In:a[1,:2] #获取第1维的前2个元素
5. Out:array([4, 3])

编程要求

本关的任务是，补全右侧编辑器 Begin-End 内的代码，以实现 Numpy 数组的索引功能的功能。具体要求如下：

• 函数接受两个参数，然后返回切片找出的指定元素；
• 本关的测试样例参见下文；
• 本关设计的代码文件 ce.py 的代码框架如下：

1. # 引入numpy库
2. import numpy as np
3. # 定义cnmda函数
4. def ce(a,m,n):
5. '''
6. 参数：
7. a:是一个Numpy数组
8. m:是第m维数组的索引
9. n:第m维数组的前n个元素的索引
10. 返回值:
11. ret: 一个numpy数组
12. '''
13. ret = 0
14. # 请在此添加切片的代码,实现找出多维数组a中第m个数组的前n个元素并赋值给ret
15. #********** Begin *********#
18. #********** End **********#
19. return ret

测试说明

本关的测试过程如下:

• 平台运行 step2/cetest.py 文件，并以标准输入方式提供测试输入；

• cetest.py 文件调用 ce 中的 ce 方法，平台获取 cetest.py 的输出，然后将其与预期输出作对比，如果一致，则测试通过；否则测试失败。

• 预处理的数组

[[1,2,3,4,5],[7,8,9,10,11],[12,13,14,15]]

以下是平台对 step2/cetest.py 的测试样例：

测试输入：
1； 3； 预期输出：

[7,8,9]

测试输入： 2； 2； 预期输出：

[12,13]

# 引入numpy库
import numpy as np
# 定义cnmda函数
def ce(a,m,n):
    '''
    参数：
    a:是一个Numpy数组
    m:是第m维数组的索引
    n:第m维数组的前n个元素的索引
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加切片的代码,实现找出多维数组a中第m个数组的前n个元素 并赋值给ret
    #********** Begin *********#
    ret = a[m,:n]
    #********** End **********#
    return ret

第4关：Numpy 数组的堆叠

任务描述

本关任务：改变 Numpy 数组的形状。

相关知识

为了完成本关任务，你需要掌握：

1. 改变数组形状；
2. 数组的堆叠。

使用 Numpy，我们可以方便的更改数组的形状，比如使用 reshape()、ravel()、flatten()、transpose() 函数等。 具体的使用如下：

改变数组形状

reshape()

1. import numpy as np
2. In: b = np.arange(24).reshape(2,3,4)
3. In: b
4. Out: array([[[ 0, 1, 2, 3],
5. [ 4, 5, 6, 7],
6. [ 8, 9, 10, 11]],
8. [[12, 13, 14, 15],
9. [16, 17, 18, 19],
10. [20, 21, 22, 23]]])

ravel()

拆解，将多维数组变成一维数组。

1. In: b.ravel()
2. Out: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
3. 17, 18, 19, 20, 21, 22, 23])

flatten()

拉直，其功能与 ravel() 相同，但是 flatten() 返回的是真实的数组，需要分配新的内存空间，而 ravel() 仅仅是改变视图。

1. In: b.flatten()
2. Out: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
3. 17, 18, 19, 20, 21, 22, 23])

shape()

使用元组改变数组形状。

1. In: b.shape = (6,4)
2. In: b
3. out: array([[ 0, 1, 2, 3],
4. [ 4, 5, 6, 7],
5. [ 8, 9, 10, 11],
6. [12, 13, 14, 15],
7. [16, 17, 18, 19],
8. [20, 21, 22, 23]])

transpose()

转置。

1. In: b.transpose()
2. Out: array([[ 0, 4, 8, 12, 16, 20],
3. [ 1, 5, 9, 13, 17, 21],
4. [ 2, 6, 10, 14, 18, 22],
5. [ 3, 7, 11, 15, 19, 23]])

数组的堆叠

从深度看，数组既可以横向叠放，也可以竖向叠放。因此，我们我们对数组进行堆叠，Numpy 数组对堆叠包含以下几个函数： 首先，创建两个数组。

1. In: a = np.arange(9).reshape(3,3)
2. In: a
3. Out: array([[0, 1, 2],
4. [3, 4, 5],
5. [6, 7, 8]])
6. In: b = a*2
7. In: b
8. Out: array([[ 0, 2, 4],
9. [ 6, 8, 10],
10. [12, 14, 16]])

hstack()

水平叠加。

1. In: np.hstack((a,b)) # 注意 这里是两层括号
2. Out: array([[ 0, 1, 2, 0, 2, 4],
3. [ 3, 4, 5, 6, 8, 10],
4. [ 6, 7, 8, 12, 14, 16]])

vstack()

垂直叠加。

1. In: np.vstack((a,b))
2. Out:array([[ 0, 1, 2],
3. [ 3, 4, 5],
4. [ 6, 7, 8],
5. [ 0, 2, 4],
6. [ 6, 8, 10],
7. [12, 14, 16]])

dstack()

深度叠加。

1. In: np.dstack((a,b))
2. Out: array([[[ 0, 0],
3. [ 1, 2],
4. [ 2, 4]],
6. [[ 3, 6],
7. [ 4, 8],
8. [ 5, 10]],
10. [[ 6, 12],
11. [ 7, 14],
12. [ 8, 16]]])

编程要求

本关的任务是，补全右侧编辑器 Begin-End 内的代码，分别实现 Numpy 数组的垂直叠加、水平叠加、深度叠加。具体要求如下：

• 函数接受两个参数，然后将两个参数进行叠加；
• 本关的测试样例参见下文；
• 本关设计的代码文件 manipulation.py 的代码框架如下：

1. # 引入numpy库
2. import numpy as np
3. # 定义varray函数
4. def varray(m,n):
5. '''
6. 参数：
7. m：是第一个数组
8. n：是第二个数组
9. 返回值:
10. ret: 一个numpy数组
11. '''
12. ret = 0
13. # 请在此添加代码实现数组的垂直叠加 并赋值给ret
14. #********** Begin *********#
17. #********** End **********#
18. return ret
19. # 定义darray函数
20. def darray(m,n):
21. '''
22. 参数：
23. m：是第一个数组
24. n：是第二个数组
25. 返回值:
26. ret: 一个numpy数组
27. '''
28. ret = 0
29. # 请在此添加代码实现数组的深度叠加并赋值给ret
30. #********** Begin *********#
33. #********** End **********#
34. return ret
35. # 定义harray函数
36. def harray(m,n):
37. '''
38. 参数：
39. m：是第一个数组
40. n：是第二个数组
41. 返回值:
42. ret: 一个numpy数组
43. '''
44. ret = 0
45. # 请在此添加代码实现数组的水平叠加并赋值给ret
46. #********** Begin *********#
49. #********** End **********#
50. return ret

测试说明

本关的测试过程如下:

• 平台运行 step3/manipulationtest.py 文件，并以标准输入方式提供测试输入；

• manipulationtest.py 文件调用 manipulation 中的三个方法，平台获取 manipulationtest.py 的输出，然后将其与预期输出作对比，如果一致，则测试通过；否则测试失败。

• 预处理数组： a = np.array([[1,2,3],[4,5,6]]) b = np.array([[3,4,5],[7,8,9]])

以下是平台对 step3/manipulationtest.py 的测试样例： 测试输入： v； 预期输出：

1. [[1 2 3]
2. [4 5 6]
3. [3 4 5]
4. [7 8 9]]

测试输入： d； 预期输出：

1. [[[1 3]
2. [2 4]
3. [3 5]]
5. [[4 7]
6. [5 8]
7. [6 9]]]

# 引入numpy库
import numpy as np
# 定义varray函数
def  varray(m,n):
    '''
    参数：
    m：是第一个数组
    n：是第二个数组
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加代码实现数组的垂直叠加并赋值给ret
    #********** Begin *********#
    ret = np.vstack((m,n))
    #********** End **********#
    return ret
# 定义darray函数
def  darray(m,n):
    '''
    参数：
    m：是第一个数组
    n：是第二个数组
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加代码实现数组的深度叠加并赋值给ret
    #********** Begin *********#
    ret = np.dstack((m,n))
    #********** End **********#
    return ret
 # 定义harray函数
def  harray(m,n):
    '''
    参数：
    m：是第一个数组
    n：是第二个数组
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加代码实现数组的水平叠加并赋值给ret
    #********** Begin *********#
    ret = np.hstack((m,n))
    #********** End **********#
    return ret

第5关：Numpy 的拆分

任务描述

本关任务：对 Numpy 数组进行拆分。

相关知识

为了完成本关任务，你需要掌握：拆分数组。

使用 Numpy，我们可以方便的对数组进行拆分，比如使用 hsplit()、vsplit()、dsplit()、split() 函数等。

拆分数组

准备数组。

1. import numpy as np
2. In: a= np.arange(9).reshape(3,3)
3. In: a
4. Out: array([[0, 1, 2],
5. [3, 4, 5],
6. [6, 7, 8]])

hsplit()

横向拆分。

1. In: np.hsplit(a,3)
2. Out:[array([[0],[3], [6]]),
3. . array([[1], [4],[7]]),
4. array([[2],[5], [8]])]

vsplit()

纵向拆分。

1. In: np.vsplit(a,3)
2. Out: [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

dsplit()

深度拆分。 深度拆分要求数组的秩大于等于 3。

1. c= np.arange(27).reshape(3,3,3)
2. In: np.dsplit(c,3)
3. Out:[array([[[ 0],
4. [ 3],
5. [ 6]],
7. [[ 9],
8. [12],
9. [15]],
11. [[18],
12. [21],
13. [24]]]), array([[[ 1],
14. [ 4],
15. [ 7]],
17. [[10],
18. [13],
19. [16]],
21. [[19],
22. [22],
23. [25]]]), array([[[ 2],
24. [ 5],
25. [ 8]],
27. [[11],
28. [14],
29. [17]],
31. [[20],
32. [23],
33. [26]]])]

编程要求

本关的任务是，补全右侧编辑器 Begin-End 内的代码，分别实现 Numpy 数组的纵向拆分、横向拆分、深度拆分。具体要求如下：

• 函数接受一个参数，然后将数组进行拆分；
• 本关的测试样例参见下文；
• 本关设计的代码文件 splitarray.py 的代码框架如下：

1. # 引入numpy库
2. import numpy as np
3. # 定义varray函数
4. def vsarray(m,n):
5. '''
6. 参数：
7. m：是第一个数组
8. n：是需要拆分到的维度
9. 返回值:
10. ret: 一个numpy数组
11. '''
12. ret = 0
13. # 请在此添加代码实现数组的纵向拆分并赋值给ret
14. #********** Begin *********#
17. #********** End **********#
18. return ret
20. # 定义hsarray函数
21. def hsarray(m,n):
22. '''
23. 参数：
24. m：是第一个数组
25. n：是需要拆分到的维度
26. 返回值:
27. ret: 一个numpy数组
28. '''
29. ret = 0
30. # 请在此添加代码实现数组的水平拆分并赋值给ret
31. #********** Begin *********#
34. #********** End **********#
35. return ret
36. # 定义dsarray函数
37. def dsarray(m,n):
38. '''
39. 参数：
40. m：是第一个数组
41. n：是需要拆分到的维度
42. 返回值:
43. ret: 一个numpy数组
44. '''
45. ret = 0
46. # 请在此添加代码实现数组的深度拆分并赋值给ret
47. #********** Begin *********#
50. #********** End **********#
51. return ret

测试说明

本关的测试过程如下:

• 平台运行 step5/splitarraytest.py 文件，并以标准输入方式提供测试输入；

• splitarraytest.py 文件调用 splitarray 中的三个方法方法，平台获取 splitarraytest.py 的输出，然后将其与预期输出作对比，如果一致，则测试通过；否则测试失败。

• 预处理数组：

a= np.arange(9).reshape(3,3)

c = np.arange(27).reshape(3,3,3)

以下是平台对 step4/splitarraytest.py 的测试样例：

测试输入： v；

预期输出： [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

测试输入： h；

预期输出： [array([[0],[3],[6]]), array([[1],[4],[7]]), array([[2],[5],[8]])]

# 引入numpy库
import numpy as np
# 定义varray函数
def  vsarray(m,n):
    '''
    参数：
    m：是第一个数组
    n：是需要拆分到的维度
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加代码实现数组的纵向拆分并赋值给ret
    #********** Begin *********#
    ret = np.vsplit(m,n)
    #********** End **********#
    return ret
# 定义darray函数
def  dsarray(m,n):
    '''
    参数：
    m：是第一个数组
    n：是需要拆分到的维度
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加代码实现数组的深度拆分并赋值给ret
    #********** Begin *********#
    ret = np.dsplit(m,n)
    #********** End **********#
    return ret
 # 定义harray函数
def  hsarray(m,n):
    '''
    参数：
    m：是第一个数组
    n：是需要拆分到的维度
    返回值:
    ret: 一个numpy数组
    '''
    ret = 0
    # 请在此添加代码实现数组的水平拆分并赋值给ret
    #********** Begin *********#
    ret = np.hsplit(m,n)
    #********** End **********#
    return ret