目录
第一关: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
)如下:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
那么该ndarray
的shape
是(3, 5)
(代表3
行5
列);
ndim
是2
(因为矩阵有行和列两个维度);
size
是15
(因为矩阵总共有15
个元素);
dtype
是int32
(因为矩阵中元素都是整数,并且用32
位整型足够表示矩阵中的元素)。
示例代码如下:
# 导入numpy并取别名为np
import numpy as np
# 构造ndarray
a = np.arange(15).reshape(3, 5)
# 打印a的shape,ndim,size,dtype
print(a.shape)
print(a.ndim)
print(a.size)
print(a.dtype)
三、如何实例化ndarray对象:
实例化ndarray
对象的函数有很多种,但最为常用的函数是array
,zeros
,ones
以及empty
。
使用array函数实例化ndarray对象
如果你手头上有一个python
的list
,想要将这个list
转成ndarray
,此时可以使用NumPy
中的array
函数将list
中的值作为初始值,来实例化一个ndarray
对象。代码如下:
import numpy as np
# 使用列表作为初始值,实例化ndarray对象a
a = np.array([2,3,4])
# 打印ndarray对象a
print(a)
使用zeros,ones,empty函数实例化ndarray对象
通常在写代码的时候,数组中元素的值一般都喜欢先初始化成0
,如果使用array
的方式实例化ndarray
对象的话,虽然能实现功能,但显得很麻烦( 首先要有一个全是0
的list
)。那有没有简单粗暴的方式呢,有!!那就是zeros
函数,你只需要把ndarray
的shape
作为参数传进去即可。代码如下:
import numpy as np
# 实例化ndarray对象a,a是一个3行4列的矩阵,矩阵中元素全为0
a = np.zeros((3, 4))
# 打印ndarray对象a
print(a)
如果想把数组中的元素全部初始化成1
,聪明的你应该能想到就是用ones
函数,ones
的用法与zeros
一致。代码如下:
import numpy as np
# 实例化ndarray对象a,a是一个3行4列的矩阵,矩阵中元素全为1
a = np.ones((3, 4))
# 打印ndarray对象a
print(a)
如果01大法
满足不了你,想要用随机值作为初始值来实例化ndarray
对象,empty
函数能够满足你。empty
的使用方式与zeros
和ones
如出一辙,代码如下:
import numpy as np
# 实例化ndarray对象a,a是一个2行3列的矩阵,矩阵中元素全为随机值
a = np.empty((2, 3))
# 打印ndarray对象a
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 *********#
第二关:形状操作
任务描述:
本关任务:根据本关所学知识,补全右侧代码编辑器中缺失的代码,完成程序的编写并通过所有测试用例。
相关知识:
为了完成本关任务,你需要掌握:怎样改变ndarray
对象的形状。
怎样改变ndarray对象的形状:
改变形状
上一关介绍了怎样实例化ndarray
对象,比如想实例化一个3
行4
列的二维数组,并且数组中的值全为0
。就可能会写如下代码:
import numpy as np
a = np.zeros((3, 4))
那如果想把a
变成4
行3
列的二维数组,怎么办呢?比较聪明的同学可能会想到这样的代码:
import numpy as np
a = np.zeros((3, 4))
# 直接修改shape属性
a.shape = [4, 3]
最后你会发现,这样的代码可以完成功能,但是这种直接改属性的方式太粗暴了,不符合良好的编程规范。
更加优雅的解决方式是使用NumPy
为我们提供了一个用来改变ndarray
对象的shape
的函数,叫 reshape
。
NumPy
为了照顾偏向于面向对象或者这偏向于面向过程这两种不同风格的程序员,提供了2
种调用 reshape
函数的方式(其实很多函数都提供了两种风格的接口)。
如果你更偏向于面向对象,那么你可以想象成ndarray
对象中提供好了一个叫reshape
成员函数。代码如下:
import numpy as np
a = np.zeros((3, 4))
# 调用a的成员函数reshape将3行4列改成4行3列
a = a.reshape((4, 3))
如果你更偏向于面向过程,NumPy
在它的作用域内实现了reshape
函数。代码如下:
import numpy as np
a = np.zeros((3, 4))
# 调用reshape函数将a变形成4行3列
a = np.reshape(a, (4, 3))
PS
:不管是哪种方式的reshape
,都不会改变原ndarray
的形状,而是将源ndarray
进行深拷贝并进行变形操作,最后再将变形后的数组返回出去。也就是说如果代码是np.reshape(a, (4, 3))
那么a
的形状不会被修改!
如果想优雅的直接改变源ndarray
的形状,可以使用resize
函数。代码如下:
import numpy as np
a = np.zeros((3, 4))
# 将a从3行4列的二维数组变成一个有12个元素的一维数组
a.resize(12)
小技巧
有的时候懒得去算每个维度上的长度是多少,比如现在有一个6
行8
列的ndarray
,然后想把它变形成有2
列的ndarray
(行的数量我懒得去想),此时我们可以在行的维度上传个-1
即可,代码如下:
import numpy as np
a = np.zeros((6, 8))
# 行的维度上填-1,会让numpy自己去推算出行的数量,很明显,行的数量应该是24
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]
import numpy as np
a = np.zeros((3, 4))
``````python
import numpy as np
a = np.zeros((3, 4))
``````python
import numpy as np
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 *********#
第三关:基础操作
任务描述:
本关任务:根据本关所学知识,补全右侧代码编辑器中缺失的代码,完成程序的编写并通过所有测试用例。
相关知识:
为了完成本关任务,你需要掌握:
- 算术运算;
- 矩阵运算;
- 简单统计。
一、算术运算:
如果想要对ndarray
对象中的元素做elementwise
(逐个元素地)的算术运算非常简单,加减乘除即可。代码如下:
import numpy as np
a = np.array([0, 1, 2, 3])
# a中的所有元素都加2,结果为[2, 3, 4, 5]
b = a + 2
# a中的所有元素都减2,结果为[-2, -1, 0, 1]
c = a - 2
# a中的所有元素都乘以2,结果为[0, 2, 4, 6]
d = a * 2
# a中的所有元素都平方,结果为[0, 1, 4, 9]
e = a ** 2
# a中的所有元素都除以2,结果为[0, 0.5, 1, 1.5]
f = a / 2
# a中的所有元素都与2比,结果为[True, True, False, False]
g = a < 2
二、矩阵运算:
相同shape
的矩阵A
与矩阵B
之间想要做elementwise
运算也很简单,加减乘除即可。代码如下:
import numpy as np
a = np.array([[0, 1], [2, 3]])
b = np.array([[1, 1], [3, 2]])
# a与b逐个元素相加,结果为[[1, 2], [5, 5]]
c = a + b
# a与b逐个元素相减,结果为[[-1, 0], [-1, 1]]
d = a - b
# a与b逐个元素相乘,结果为[[0, 1], [6, 6]]
e = a * b
# a的逐个元素除以b的逐个元素,结果为[[0., 1.], [0.66666667, 1.5]]
f = a / b
# a与b逐个元素做幂运算,结果为[[0, 1], [8, 9]]
g = a ** b
# a与b逐个元素相比较,结果为[[True, False], [True, False]]
h = a < b
细心的同学应该发现了,*
只能做elementwise
运算,如果想做真正的矩阵乘法运算显然不能用*
。NumPy
提供了@
和dot
函数来实现矩阵乘法。代码如下:
import numpy as np
A = np.array([[1, 1], [0, 1]])
B = np.array([[2, 0], [3, 4]])
# @表示矩阵乘法,矩阵A乘以矩阵B,结果为[[5, 4], [3, 4]]
print(A @ B)
# 面向对象风格,矩阵A乘以矩阵B,结果为[[5, 4], [3, 4]]
print(A.dot(B))
# 面向过程风格,矩阵A乘以矩阵B,结果为[[5, 4], [3, 4]]
print(np.dot(A, B))
三、简单统计:
有的时候想要知道ndarray
对象中元素的和是多少,最小值是多少,最小值在什么位置,最大值是多少,最大值在什么位置等信息。这个时候可能会想着写一个循环去遍历ndarray
对象中的所有元素来进行统计。NumPy
为了解放我们的双手,提供了sum
,min
,max
,argmin
,argmax
等函数来实现简单的统计功能,代码如下:
import numpy as np
a = np.array([[-1, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 13]])
# 计算a中所有元素的和,结果为67
print(a.sum())
# 找出a中最大的元素,结果为13
print(a.max())
# 找出a中最小的元素,结果为-1
print(a.min())
# 找出a中最大元素在a中的位置,由于a中有12个元素,位置从0开始计,所以结果为11
print(a.argmax())
# 找出a中最小元素在a中位置,结果为0
print(a.argmin())
有的时候,我们在统计时需要根据轴来统计。举个例子,公司员工的基本工资,绩效工资,年终奖的信息如下:
工号 | 基本工资 | 绩效工资 | 年终奖 |
---|---|---|---|
1 | 3000 | 4000 | 20000 |
2 | 2700 | 5500 | 25000 |
3 | 2800 | 3000 | 15000 |
这样一个表格很明显,可以用ndarray
来存储。代码如下:
import numpy as np
info = np.array([[3000, 4000, 20000], [2700, 5500, 25000], [2800, 3000, 15000]])
info
实例化之后就有了维度和轴的概念,很明显info
是个二维数组,所以它的 维度是2
。维度为2
换句话来说就是info
有两个轴:0
号轴与1
号轴(轴的编号从0
开始算)。轴所指的方向如下图所示:
如果想要统计下这3
位员工中基本工资、绩效工资与年终奖的最小值与最大值(也就是说分别统计出每一列中的最小与最大值)。我们可以沿着0
号轴来统计。想要实现沿着哪个轴来统计,只需要修改axis
即可,代码如下:
import numpy as np
info = np.array([[3000, 4000, 20000], [2700, 5500, 25000], [2800, 3000, 15000]])
# 沿着0号轴统计,结果为[2700, 3000, 15000]
print(info.min(axis=0))
# 沿着0号轴统计,结果为[3000, 5500, 25000]
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 *********#
a=np.array(input_data).argmax(axis=1)
print(a)
#********* End *********#
第四关:随机数生成
任务描述:
本关任务:根据本关所学知识,补全右侧代码编辑器中缺失的代码,完成程序的编写并通过所有测试用例。
相关知识:
为了完成本关任务,你需要掌握:
-
简单随机数生成;
-
概率分布随机数生成;
-
随机种子。
简单随机数生成:
NumPy
的random
模块下提供了许多生成随机数的函数,如果对于随机数的概率分布没有什么要求,则通常可以使用random_sample
、choice
、randint
等函数来实现生成随机数的功能。
random_sample
random_sample
用于生成区间为[0, 1]
的随机数,需要填写的参数size
表示生成的随机数的形状,比如size=[2, 3]
那么则会生成一个2
行3
列的ndarray
,并用随机值填充。示例代码如下:
import numpy as np
'''
结果可能为[[0.32343809, 0.38736262, 0.42413616]
[0.86190206, 0.27183736, 0.12824812]]
'''
print(np.random.random_sample(size=[2, 3]))
choice
如果想模拟像掷骰子、扔硬币等这种随机值是离散值,而且知道范围的可以使用choice
实现。choice
的主要参数是a
、size
和replace
。a
是个一维数组,代表你想从a
中随机挑选;size
是随机数生成后的形状。假如模拟5
次掷骰子,replace
用来设置是否可以取相同元素,True
表示可以取相同数字;False
表示不可以取相同数字,默认是True
,代码如下:
import numpy as np
'''
掷骰子时可能出现的点数为1, 2, 3, 4, 5, 6,所以a=[1,2,3,4,5,6]
模拟5此掷骰子所以size=5
结果可能为 [1 4 2 3 6]
'''
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
次掷骰子,代码如下:
import numpy as np
'''
掷骰子时可能出现的点数为1, 2, 3, 4, 5, 6,所以low=1,high=7
模拟5此掷骰子所以size=5
结果可能为 [6, 4, 3, 1, 3]
'''
print(np.random.randint(low=1, high=7, size=5)
概率分布随机数生成:
如果对于产生的随机数的概率分布有特别要求,NumPy
同样提供了从指定的概率分布中采样得到的随机值的接口。在这里主要介绍高斯分布。
高斯分布又称为正态分布,其分布图形如下:
上图中横轴为随机变量的值(在这里可以看成是产生的随机值),纵轴表示随机变量对应的概率(在这里可以看成是随机值被挑选到的概率)。
其实在日常生活中有很多现象或多或少都符合高斯分布。比如某个地方的高考分数,一般来说高考分数非常低和高考分数非常高的学生都比较少,而分数中规中矩的学生比较多,如果所统计的数据足够大,那么高考分数的概率分布也会和上图一样,中间高,两边低。
想要实现根据高斯分布来产生随机值,可以使用normal
函数。示例代码如下:
import numpy as np
'''
根据高斯分布生成5个随机数
结果可能为:[1.2315868, 0.45479902, 0.24923969, 0.42976352, -0.68786445]
从结果可以看出0.4左右得值出现的次数比较高,1和-0.7左右的值出现的次数比较低。
'''
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
个随机值,代码如下:
import numpy as np
print(np.random.normal(loc=1, scale=10, size=5)
随机种子:
前面说了这么多随机数生成的方法,那么随机数是怎样生成的呢?其实计算机产生的随机数是由随机种子根据一定的计算方法计算出来的数值。所以只要计算方法固定,随机种子固定,那么产生的随机数就不会变!
如果想要让每次生成的随机数不变,那么就需要设置随机种子(随机种子其实就是一个0
到232−1
的整数)。设置随机种子很长简单,调用seed
函数并设置随机种子即可,代码如下:
import numpy as np
# 设置随机种子为233
np.random.seed(seed=233)
data = [1, 2, 3, 4]
# 随机从data中挑选数字,结果为4
print(np.random.choice(data))
# 随机从data中挑选数字,结果为4
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 *********#
num=np.random.choice(input_data,len(input_data),replace=False)
for i in num:
result.append(i)
#********* End *********#
return result
第五关:索引与切片
任务描述:
本关任务:根据本关所学知识,补全右侧代码编辑器中缺失的代码,完成ROI
提取的功能。
相关知识:
为了完成本关任务,你需要掌握:
- 索引;
- 遍历;
- 切片。
一、索引:
ndarray
的索引其实和python
的list
的索引极为相似。元素的索引从0
开始。代码如下:
import numpy as np
# a中有4个元素,那么这些元素的索引分别为0,1,2,3
a = np.array([2, 15, 3, 7])
# 打印第2个元素
# 索引1表示的是a中的第2个元素
# 结果为15
print(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列的元素
# 结果为5
print(b[1][1])
二、遍历:
ndarray
的遍历方式与python
的list
的遍历方式也极为相似,示例代码如下:
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]
。
切片示例代码如下:
mport numpy as np
# a中有4个元素,那么这些元素的索引分别为0,1,2,3
a = np.array([2, 15, 3, 7])
'''
将索引从1开始到最后的所有元素切片出来并打印
结果为[15 3 7]
'''
print(a[1:])
'''
将从倒数第2个开始到最后的所有元素切片出来并打印
结果为[3 7]
'''
print(a[-2:])
'''
将所有元素倒序切片并打印
结果为[ 7 3 15 2]
'''
print(a[::-1])
# b是个2行3列的二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
'''
将第2行的第2列到第3列的所有元素切片并打印
结果为[[5 6]]
'''
print(b[1:, 1:3])
'''
将第2列到第3列的所有元素切片并打印
结果为[[2 3]
[5 6]]
'''
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 *********#
a = data[x:x+h+1,y:y+w+1]
return a
#********* End *********#