NumPy基础及取值操作 educoder头歌实践作业

第1关：ndarray对象

• 任务描述
• 相关知识
  • 怎样安装NumPy
  • 什么是ndarray对象
  • 如何实例化ndarray对象
    • 使用array函数实例化ndarray对象
    • 使用zeros，ones，empty函数实例化ndarray对象
• 编程要求
• 测试说明

---

任务描述

本关任务：根据本关所学知识，补全右侧代码编辑器中缺失的代码，完成程序的编写并通过所有测试用例。

相关知识

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

• 怎样安装NumPy；

• 什么是ndarray对象；

• 如何实例化ndarray对象。

怎样安装NumPy

本地想要安装NumPy其实非常简单，进入命令行，输入pip install numpy即可。

什么是ndarray对象

NumPy为什么能够受到各个数据科学从业人员的青睐与追捧，其实很大程度上是因为NumPy在向量计算方面做了很多优化，接口也非常友好（总之就是用起来很爽）。而这些其实都是在围绕着NumPy的一个 核心数据结构ndarray 。

ndarray的全称是N-Dimension Arrary，字面意义上其实已经表明了一个ndarray对象就是一个N维数组。但要注意的是，ndarray是同质的。同质的意思就是说 N维数组里的所有元素必须是属于同一种数据类型的 。 (PS: python中的list是异质的) 。

ndarray对象实例化好了之后，包含了一些基本的属性。比如shape，ndim，size，dtype。其中：

• shape:ndarray对象的形状，由一个tuple表示；

• ndim:ndarray对象的维度；

• size:ndarray对象中元素的数量；

• dtype:ndarray对象中元素的数据类型，例如int64，float32等。

来看个例子，假设现在有一个3行5列的矩阵（ndarray）如下：

1. array([[ 0, 1, 2, 3, 4],
2. [ 5, 6, 7, 8, 9],
3. [10, 11, 12, 13, 14]])

那么该ndarray的shape是(3, 5)(代表3行5列)；

ndim是2(因为矩阵有行和列两个维度)；

size是15(因为矩阵总共有15个元素)；

dtype是int32(因为矩阵中元素都是整数，并且用32位整型足够表示矩阵中的元素)。

示例代码如下：

1. # 导入numpy并取别名为np
2. import numpy as np
4. # 构造ndarray
5. a = np.arange(15).reshape(3, 5)
7. # 打印a的shape，ndim，size，dtype
8. print(a.shape)
9. print(a.ndim)
10. print(a.size)
11. print(a.dtype)

如何实例化ndarray对象

实例化ndarray对象的函数有很多种，但最为常用的函数是array，zeros，ones以及empty。

使用array函数实例化ndarray对象

如果你手头上有一个python的list，想要将这个list转成ndarray，此时可以使用NumPy中的array函数将list中的值作为初始值，来实例化一个ndarray对象。代码如下：

1. import numpy as np
3. # 使用列表作为初始值，实例化ndarray对象a
4. a = np.array([2,3,4])
6. # 打印ndarray对象a
7. print(a)

使用zeros，ones，empty函数实例化ndarray对象

通常在写代码的时候，数组中元素的值一般都喜欢先初始化成0，如果使用array的方式实例化ndarray对象的话，虽然能实现功能，但显得很麻烦（ 首先要有一个全是0的list ）。那有没有简单粗暴的方式呢，有！！那就是zeros函数，你只需要把ndarray的shape作为参数传进去即可。代码如下：

1. import numpy as np
3. # 实例化ndarray对象a，a是一个3行4列的矩阵，矩阵中元素全为0
4. a = np.zeros((3, 4))
6. # 打印ndarray对象a
7. print(a)

如果想把数组中的元素全部初始化成1，聪明的你应该能想到就是用ones函数，ones的用法与zeros一致。代码如下：

1. import numpy as np
3. # 实例化ndarray对象a，a是一个3行4列的矩阵，矩阵中元素全为1
4. a = np.ones((3, 4))
6. # 打印ndarray对象a
7. print(a)

如果01大法满足不了你，想要用随机值作为初始值来实例化ndarray对象，empty函数能够满足你。empty的使用方式与zeros和ones如出一辙，代码如下：

1. import numpy as np
3. # 实例化ndarray对象a，a是一个2行3列的矩阵，矩阵中元素全为随机值
4. a = np.empty((2, 3))
6. # 打印ndarray对象a
7. print(a)

编程要求

根据提示，在右侧编辑器Begin-End中填充代码，根据测试用例的输入，实例化出对应的ndarray对象并打印。

• 具体要求请参见后续测试样例。

请先仔细阅读右侧上部代码编辑区内给出的代码框架，再开始你的编程工作！

测试说明

平台会对你编写的代码进行测试，对比你输出的数值与实际正确的数值，只有所有数据全部计算正确才能进入下一关。

• shape：为需要实例化出来的ndarray对象的shape；

• data：表示需要实例化出来的ndarray对象中元素的值。

例如：{'shape':[1, 2], 'data':[[1, 2]]}表示ndarray对象的形状为1行2列，第1行第1列的值为1，第1行第2列的值为2。

测试输入： {'shape':[1, 2], 'data':[[1, 2]]}

预期输出： [[1 2]]

---

开始你的任务吧，祝你成功！

import numpy as np

 

def print_ndarray(input_data):

    '''

    实例化ndarray对象并打印

    :param input_data: 测试用例，类型为字典类型

    :return: None

    '''

    #********* Begin *********#

    a=np.array(input_data['data'])

    print(a)

    #********* End *********#

第2关：形状操作

• 任务描述
• 相关知识
  • 怎样改变ndarray对象的形状
    • 改变形状
    • 小技巧
• 编程要求
• 测试说明

---

任务描述

本关任务：根据本关所学知识，补全右侧代码编辑器中缺失的代码，完成程序的编写并通过所有测试用例。

相关知识

为了完成本关任务，你需要掌握：怎样改变ndarray对象的形状。

怎样改变ndarray对象的形状

改变形状

上一关介绍了怎样实例化ndarray对象，比如想实例化一个3行4列的二维数组，并且数组中的值全为0。就可能会写如下代码：

1. import numpy as np
3. a = np.zeros((3, 4))

那如果想把a变成4行3列的二维数组，怎么办呢？比较聪明的同学可能会想到这样的代码：

1. import numpy as np
3. a = np.zeros((3, 4))
5. # 直接修改shape属性
6. a.shape = [4, 3]

最后你会发现，这样的代码可以完成功能，但是这种直接改属性的方式太粗暴了，不符合良好的编程规范。

更加优雅的解决方式是使用NumPy为我们提供了一个用来改变ndarray对象的shape的函数，叫 reshape 。

NumPy为了照顾偏向于面向对象或者这偏向于面向过程这两种不同风格的程序员，提供了2种调用 reshape 函数的方式(其实很多函数都提供了两种风格的接口)。

如果你更偏向于面向对象，那么你可以想象成ndarray对象中提供好了一个叫reshape成员函数。代码如下:

1. import numpy as np
3. a = np.zeros((3, 4))
5. # 调用a的成员函数reshape将3行4列改成4行3列
6. a = a.reshape((4, 3))

如果你更偏向于面向过程，NumPy在它的作用域内实现了reshape函数。代码如下：

1. import numpy as np
3. a = np.zeros((3, 4))
5. # 调用reshape函数将a变形成4行3列
6. a = np.reshape(a, (4, 3))

PS:不管是哪种方式的reshape，都不会改变原ndarray的形状，而是将源ndarray进行深拷贝并进行变形操作，最后再将变形后的数组返回出去。也就是说如果代码是np.reshape(a, (4, 3))那么a的形状不会被修改！

如果想优雅的直接改变源ndarray的形状，可以使用resize函数。代码如下：

1. import numpy as np
3. a = np.zeros((3, 4))
5. # 将a从3行4列的二维数组变成一个有12个元素的一维数组
6. a.resize(12)

小技巧

有的时候懒得去算每个维度上的长度是多少，比如现在有一个6行8列的ndarray，然后想把它变形成有2列的ndarray(行的数量我懒得去想)，此时我们可以在行的维度上传个-1即可，代码如下：

1. import numpy as np
3. a = np.zeros((6, 8))
5. # 行的维度上填-1，会让numpy自己去推算出行的数量，很明显，行的数量应该是24
6. a = a.reshape((-1, 2))

也就是说在变形操作时，如果某个维度上的值为-1，那么该维度上的值会根据其他维度上的值自动推算。

PS：-1虽好，可不能贪杯！如果代码改成a = a.reshape((-1, -1))，NumPy会认为你是在刁难他，并向你抛出异常ValueError: can only specify one unknown dimension。

编程要求

根据提示，在右侧编辑器Begin-End中填充代码，根据测试用例的输入，将列表转换成ndarray后变形成一维数组并将其打印。

• 具体要求请参见后续测试样例。

请先仔细阅读右侧上部代码编辑区内给出的代码框架，再开始你的编程工作！

测试说明

平台会对你编写的代码进行测试，对比你输出的数值与实际正确的数值，只有所有数据全部计算正确才能进入下一关。

测试输入： [[1, 2, 3], [4, 5, 6]] 预期输出： [1, 2, 3, 4, 5, 6]

1. import numpy as np
3. a = np.zeros((3, 4))
4. ``````python
5. import numpy as np
7. a = np.zeros((3, 4))
8. ``````python
9. import numpy as np
11. a = np.zeros((3, 4))

---

开始你的任务吧，祝你成功！

import numpy as np

 

def reshape_ndarray(input_data):

    '''

    将ipnut_data转换成ndarray后将其变形成一位数组并打印

    :param input_data: 测试用例，类型为list

    :return: None

    '''

    #********* Begin *********#

    after_reshape=np.array(input_data).reshape(-1)

    print(after_reshape)

    #********* End *********#

第3关：基础操作

• 任务描述
• 相关知识
  • 算术运算
  • 矩阵运算
  • 简单统计
• 编程要求
• 测试说明

---

任务描述

本关任务：根据本关所学知识，补全右侧代码编辑器中缺失的代码，完成程序的编写并通过所有测试用例。

相关知识

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

• 算术运算；
• 矩阵运算；
• 简单统计。

算术运算

如果想要对ndarray对象中的元素做elementwise(逐个元素地)的算术运算非常简单，加减乘除即可。代码如下：

1. import numpy as np
3. a = np.array([0, 1, 2, 3])
5. # a中的所有元素都加2，结果为[2, 3, 4, 5]
6. b = a + 2
8. # a中的所有元素都减2，结果为[-2, -1, 0, 1]
9. c = a - 2
11. # a中的所有元素都乘以2，结果为[0, 2, 4, 6]
12. d = a * 2
14. # a中的所有元素都平方，结果为[0, 1, 4, 9]
15. e = a ** 2
17. # a中的所有元素都除以2，结果为[0, 0.5, 1, 1.5]
18. f = a / 2
20. # a中的所有元素都与2比，结果为[True, True, False, False]
21. g = a < 2

矩阵运算

相同shape的矩阵A与矩阵B之间想要做elementwise运算也很简单，加减乘除即可。代码如下：

1. import numpy as np
3. a = np.array([[0, 1], [2, 3]])
4. b = np.array([[1, 1], [3, 2]])
6. # a与b逐个元素相加，结果为[[1, 2], [5, 5]]
7. c = a + b
9. # a与b逐个元素相减，结果为[[-1, 0], [-1, 1]]
10. d = a - b
12. # a与b逐个元素相乘，结果为[[0, 1], [6, 6]]
13. e = a * b
15. # a的逐个元素除以b的逐个元素，结果为[[0., 1.], [0.66666667, 1.5]]
16. f = a / b
18. # a与b逐个元素做幂运算，结果为[[0, 1], [8, 9]]
19. g = a ** b
21. # a与b逐个元素相比较，结果为[[True, False], [True, False]]
22. h = a < b

细心的同学应该发现了，*只能做elementwise运算，如果想做真正的矩阵乘法运算显然不能用*。NumPy提供了@和dot函数来实现矩阵乘法。代码如下：

1. import numpy as np
3. A = np.array([[1, 1], [0, 1]])
4. B = np.array([[2, 0], [3, 4]])
6. # @表示矩阵乘法，矩阵A乘以矩阵B，结果为[[5, 4], [3, 4]]
7. print(A @ B)
9. # 面向对象风格，矩阵A乘以矩阵B，结果为[[5, 4], [3, 4]]
10. print(A.dot(B))
12. # 面向过程风格，矩阵A乘以矩阵B，结果为[[5, 4], [3, 4]]
13. print(np.dot(A, B))

简单统计

有的时候想要知道ndarray对象中元素的和是多少，最小值是多少，最小值在什么位置，最大值是多少，最大值在什么位置等信息。这个时候可能会想着写一个循环去遍历ndarray对象中的所有元素来进行统计。NumPy为了解放我们的双手，提供了sum，min，max，argmin，argmax等函数来实现简单的统计功能，代码如下：

1. import numpy as np
3. a = np.array([[-1, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 13]])
5. # 计算a中所有元素的和，结果为67
6. print(a.sum())
8. # 找出a中最大的元素，结果为13
9. print(a.max())
11. # 找出a中最小的元素，结果为-1
12. print(a.min())
14. # 找出a中最大元素在a中的位置，由于a中有12个元素，位置从0开始计，所以结果为11
15. print(a.argmax())
17. # 找出a中最小元素在a中位置，结果为0
18. print(a.argmin())

有的时候，我们在统计时需要根据轴来统计。举个例子，公司员工的基本工资，绩效工资，年终奖的信息如下：

工号	基本工资	绩效工资	年终奖
1	3000	4000	20000
2	2700	5500	25000
3	2800	3000	15000

这样一个表格很明显，可以用ndarray来存储。代码如下：

1. import numpy as np
3. info = np.array([[3000, 4000, 20000], [2700, 5500, 25000], [2800, 3000, 15000]])

info实例化之后就有了维度和轴的概念，很明显info是个二维数组，所以它的 维度是2 。维度为2换句话来说就是info有两个轴：0号轴与1号轴（轴的编号从0开始算）。轴所指的方向如下图所示：

如果想要统计下这3位员工中基本工资、绩效工资与年终奖的最小值与最大值（也就是说分别统计出每一列中的最小与最大值）。我们可以沿着0号轴来统计。想要实现沿着哪个轴来统计，只需要修改axis即可，代码如下：

1. import numpy as np
3. info = np.array([[3000, 4000, 20000], [2700, 5500, 25000], [2800, 3000, 15000]])
5. # 沿着0号轴统计，结果为[2700, 3000, 15000]
6. print(info.min(axis=0))
8. # 沿着0号轴统计，结果为[3000, 5500, 25000]
9. print(info.max(axis=0))

PS:当没有修改axis时，axis的值默认为None。意思是在统计时会把ndarray对象中所有的元素都考虑在内。

编程要求

根据提示，在右侧编辑器Begin-End处补充代码，根据测试用例的输入，打印每行的最大值的位置。

• 具体要求请参见后续测试样例。

请先仔细阅读右侧上部代码编辑区内给出的代码框架，再开始你的编程工作！

测试说明

平台会对你编写的代码进行测试，对比你输出的数值与实际正确的数值，只有所有数据全部计算正确才能进入下一关。

测试输入： [[0.2, 0.7, 0.1], [0.1, 0.3, 0.6]] 预期输出： [1 2]

开始你的任务吧，祝你成功！

import numpy as np

 

def get_answer(input_data):

    '''

    将input_data转换成ndarray后统计每一行中最大值的位置并打印

    :param input_data: 测试用例，类型为list

    :return: None

    '''

    #********* Begin *********#

    print(np.array(input_data).argmax(axis=1))

    #********* End *********#

第4关：随机数生成

• 任务描述
• 相关知识
  • 简单随机数生成
    • random_sample
    • choice
    • randint
  • 概率分布随机数生成
  • 随机种子
• 编程要求
• 测试说明

---

任务描述

本关任务：根据本关所学知识，补全右侧代码编辑器中缺失的代码，完成程序的编写并通过所有测试用例。

相关知识

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

• 简单随机数生成；

• 概率分布随机数生成；

• 随机种子。

简单随机数生成

NumPy的random模块下提供了许多生成随机数的函数，如果对于随机数的概率分布没有什么要求，则通常可以使用random_sample、choice、randint等函数来实现生成随机数的功能。

random_sample

random_sample用于生成区间为[0, 1]的随机数，需要填写的参数size表示生成的随机数的形状，比如size=[2, 3]那么则会生成一个2行3列的ndarray，并用随机值填充。示例代码如下：

1. import numpy as np
3. '''
4. 结果可能为[[0.32343809, 0.38736262, 0.42413616]
5. [0.86190206, 0.27183736, 0.12824812]]
6. '''
7. print(np.random.random_sample(size=[2, 3]))

choice

如果想模拟像掷骰子、扔硬币等这种随机值是离散值，而且知道范围的可以使用choice实现。choice的主要参数是a、size和replace。a是个一维数组，代表你想从a中随机挑选；size是随机数生成后的形状。假如模拟5次掷骰子，replace用来设置是否可以取相同元素，True表示可以取相同数字；False表示不可以取相同数字，默认是True，代码如下：

1. import numpy as np
3. '''
4. 掷骰子时可能出现的点数为1, 2, 3, 4, 5, 6，所以a=[1,2,3,4,5,6]
5. 模拟5此掷骰子所以size=5
6. 结果可能为 [1 4 2 3 6]
7. '''
8. print(np.random.choice(a=[1, 2, 3, 4, 5, 6], size=5,replace=False))

randint

randint的功能和choice差不多，只不过randint只能生成整数，而choice生成的数与a有关，如果a中有浮点数，那么choice会有概率挑选到浮点数。

randint的参数有3个，分别为low，high和size。其中low表示随机数生成时能够生成的最小值，high表示随机数生成时能够生成的最大值减1。也就是说randint生成的随机数的区间为[low, high)。假如模拟5次掷骰子，代码如下：

1. import numpy as np
3. '''
4. 掷骰子时可能出现的点数为1, 2, 3, 4, 5, 6，所以low=1,high=7
5. 模拟5此掷骰子所以size=5
6. 结果可能为 [6, 4, 3, 1, 3]
7. '''
8. print(np.random.randint(low=1, high=7, size=5)

概率分布随机数生成

如果对于产生的随机数的概率分布有特别要求，NumPy同样提供了从指定的概率分布中采样得到的随机值的接口。在这里主要介绍高斯分布。

高斯分布又称为正态分布，其分布图形如下：

上图中横轴为随机变量的值（在这里可以看成是产生的随机值），纵轴表示随机变量对应的概率（在这里可以看成是随机值被挑选到的概率）。

其实在日常生活中有很多现象或多或少都符合高斯分布。比如某个地方的高考分数，一般来说高考分数非常低和高考分数非常高的学生都比较少，而分数中规中矩的学生比较多，如果所统计的数据足够大，那么高考分数的概率分布也会和上图一样，中间高，两边低。

想要实现根据高斯分布来产生随机值，可以使用normal函数。示例代码如下：

1. import numpy as np
3. '''
4. 根据高斯分布生成5个随机数
5. 结果可能为：[1.2315868, 0.45479902, 0.24923969, 0.42976352, -0.68786445]
7. 从结果可以看出0.4左右得值出现的次数比较高，1和-0.7左右的值出现的次数比较低。
8. '''
9. print(np.random.normal(size=5)

其中normal函数除了size参数外，还有两个比较重要的参数就是loc和scale，它们分别代表高斯分布的均值和方差。loc影响的分布中概率最高的点的位置，假设loc=2，那么分布中概率最高的点的位置就是2。下图体现了loc对分布的影响，其中蓝色f分布的loc=0，红色分布的loc=5。

scale影响的是分布图形的胖瘦，scale越小，分布就越又高又瘦，scale越大，分布就越又矮又胖。下图体现了scale对分布的影响，其中蓝色分布的scale=0.5，红色分布的scale=1.0。

所以，想要根据均值为1，方差为10的高斯分布来生成5个随机值，代码如下：

1. import numpy as np
3. print(np.random.normal(loc=1, scale=10, size=5)

随机种子

前面说了这么多随机数生成的方法，那么随机数是怎样生成的呢？其实计算机产生的随机数是由随机种子根据一定的计算方法计算出来的数值。所以只要计算方法固定，随机种子固定，那么产生的随机数就不会变！

如果想要让每次生成的随机数不变，那么就需要设置随机种子（随机种子其实就是一个0到232−1的整数）。设置随机种子很长简单，调用seed函数并设置随机种子即可，代码如下：

1. import numpy as np
3. # 设置随机种子为233
4. np.random.seed(seed=233)
6. data = [1, 2, 3, 4]
8. # 随机从data中挑选数字，结果为4
9. print(np.random.choice(data))
11. # 随机从data中挑选数字，结果为4
12. print(np.random.choice(data))

编程要求

根据提示，在右侧编辑器Begin-End处补充代码，将测试用例输入打乱顺序并返回打乱结果。

• 具体要求请参见后续测试样例。

注意：评测程序内部已经设置好了随机种子，为了顺利评测，请使用np.random.choice()函数来实现打乱顺序。

请先仔细阅读右侧上部代码编辑区内给出的代码框架，再开始你的编程工作！

测试说明

平台会对你编写的代码进行测试，对比你输出的数值与实际正确的数值，只有所有数据全部计算正确才能进入下一关。

测试输入： [1, 2, 3, 4, 5, 6] 预期输出： [4, 3, 5, 1, 2, 6]

开始你的任务吧，祝你成功！

import numpy as np

 

def shuffle(input_data):

    '''

    打乱input_data并返回打乱结果

    :param input_data: 测试用例输入，类型为list

    :return: result，类型为list

    '''

    # 保存打乱的结果

    result = []

    #********* Begin *********#

    result=list(np.random.choice(a=input_data,size=len(input_data),replace=False))

    #********* End *********#

    return result

第5关：索引与切片

• 任务描述
• 相关知识
  • 索引
  • 遍历
  • 切片
• 编程要求
• 测试说明

---

任务描述

本关任务：根据本关所学知识，补全右侧代码编辑器中缺失的代码，完成ROI提取的功能。

相关知识

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

• 索引；
• 遍历；
• 切片。

索引

ndarray的索引其实和python的list的索引极为相似。元素的索引从0开始。代码如下：

1. import numpy as np
3. # a中有4个元素，那么这些元素的索引分别为0，1，2，3
4. a = np.array([2, 15, 3, 7])
6. # 打印第2个元素
7. # 索引1表示的是a中的第2个元素
8. # 结果为15
9. print(a[1])
11. # b是个2行3列的二维数组
12. b = np.array([[1, 2, 3], [4, 5, 6]])
14. # 打印b中的第1行
15. # 总共就2行，所以行的索引分别为0，1
16. # 结果为[1, 2, 3]
17. print(b[0])
19. # 打印b中的第2行第2列的元素
20. # 结果为5
21. print(b[1][1])

遍历

ndarray的遍历方式与python的list的遍历方式也极为相似，示例代码如下：

1. import numpy as np
3. a = np.array([2, 15, 3, 7])
5. # 使用for循环将a中的元素取出来后打印
6. for element in a:
7. print(element)
9. # 根据索引遍历a中的元素并打印
10. for idx in range(len(a)):
11. print(a[idx])
13. # b是个2行3列的二维数组
14. b = np.array([[1, 2, 3], [4, 5, 6]])
16. # 将b展成一维数组后遍历并打印
17. for element in b.flat:
18. print(element)
20. # 根据索引遍历b中的元素并打印
21. for i in range(len(b)):
22. for j in range(len(b[0])):
23. print(b[i][j])

切片

ndarray的切片方式与python的list的遍历方式也极为相似，对切片不熟的同学也不用慌，套路很简单，就是用索引。

假设想要将下图中紫色部分切片出来，就需要确定行的范围和列的范围。由于紫色部分行的范围是0到2，所以切片时行的索引范围是0:3(索引范围是左闭右开);又由于紫色部分列的范围也是0到2，所以切片时列的索引范围也是0:3(索引范围是左闭右开)。最后把行和列的索引范围整合起来就是[0:3, 0:3](,左边是行的索引范围)。当然有时为了方便，0可以省略，也就是[:3, :3]。

切片示例代码如下：

1. import numpy as np
3. # a中有4个元素，那么这些元素的索引分别为0，1，2，3
4. a = np.array([2, 15, 3, 7])
6. '''
7. 将索引从1开始到最后的所有元素切片出来并打印
8. 结果为[15 3 7]
9. '''
10. print(a[1:])
12. '''
13. 将从倒数第2个开始到最后的所有元素切片出来并打印
14. 结果为[3 7]
15. '''
16. print(a[-2:])
18. '''
19. 将所有元素倒序切片并打印
20. 结果为[ 7 3 15 2]
21. '''
22. print(a[::-1])
24. # b是个2行3列的二维数组
25. b = np.array([[1, 2, 3], [4, 5, 6]])
27. '''
28. 将第2行的第2列到第3列的所有元素切片并打印
29. 结果为[[5 6]]
30. '''
31. print(b[1:, 1:3])
33. '''
34. 将第2列到第3列的所有元素切片并打印
35. 结果为[[2 3]
36. [5 6]]
37. '''
38. print(b[:, 1: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的高。

测试输入： {'image':[[1, 2, 255, 255, 0], [255, 255, 0, 0, 3]], 'x':0, 'y':1, 'w':2, 'h':1}

预期输出：

[[ 2 255 255] [255 0 0]]

---

开始你的任务吧，祝你成功！

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 *********#

    b=data[x:x+h+1,y:y+w+1]

    return b

    #********* End *********#