真题与解析 202109四级青少年软件编程（Python）考级

最新推荐文章于 2025-12-11 08:58:14 发布

原创最新推荐文章于 2025-12-11 08:58:14 发布 · 143 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言 #算法 #python考级 #少儿学编程

真题与解析电子学会青少年Python历年考级资源专栏收录该内容

60 篇文章

订阅专栏

青少年软件编程（Python）等级考试试卷（四级）

202109真题与解析

分数：100 题数：38 测试时长：60分钟

一、单选题（共25题，每题2分，共50分）

1. 对于数列3，8，11，15，17，19，25，30，44，采用“二分查找”法查找8，需要查找多少次？（）

A、5

B、4

C、3

D、2

2. 下面哪一项不是pip指令？（）

A、pip install Scipy

B、pip uninstall Jieba

C、pip clear

D、pip list

3. 有如下Python语句，执行该语句后，结果是？（）

f=lambda x:5

print(f(3))

A、3

B、没有输出

C、5

D、None

4. 执行如下Python代码后，结果是？（）

def inverse(s,n=0):

while s:

n = n * 10 + s % 10

s = s // 10

return n

print(inverse(456,123))

A、654123

B、123456

C、123654

D、654321

5. 下列有关循环和递归的描述正确的是？（）

A、递归思想代码清晰简洁，可读性强

B、递归代码中不能有循环结构的语句

C、递归是从问题的起点出发，逐渐将复杂问题化为简单问题，最终求得问题

D、能用递归实现的，一定能用循环代码实现

6. 以下有关Python函数的定义表述中错误的是？（）

A、函数的定义必须在主程序调用语句之前出现

B、在形参列表中必须先列出有默认值的形参，再列出没有默认值的形参

C、实参是实际占用内存地址的，而形参不占用

D、def关键字后面加函数名定义函数，定义必须以冒号结尾

7. 如下代码运行后下面选项中描述错误的是？（）

def pph(a,b):

c=a**2+b

b=a

return c

a=10

b=100

c=pph(a,b)+a

print(a,' ',b,' ',c)

A、执行该函数后，变量a的值为10

B、执行该函数后，变量b的值为100

C、执行该函数后，变量c的值为200

D、该函数名称为pph

8. 阅读下列程序段，数列的第6项值为多少？（）

def fibona(x):

if x==1 or x==2:

f=1

for i in range(3,x+1):

f=fibona(x-1)+fibona(x-2)

return f

n=int(input("请输入数列第几项："))

m=fibona(n)

print("数列的第"+str(n)+"项的值为"+str(m))

A、1

B、8

C、21

D、34

9. 有如下Python的自定义函数，执行该程序后，结果是？（）

def calc(x,y,op):

return eval(str(x)+op+str(y)

print(calc(3,5,'+'))

A、8

B、35

C、None

D、-2

10. 有如下Python程序，执行该程序后，结果是？（）

x = 3

def calc():

x = 5

print(calc())

A、3

B、5

C、无输出

D、None

11. 应用分治算法的前提是？（）

A、问题的可分性和解的可归并性

B、问题的复杂性和解的简单性

C、问题的可分性和解的存在性

D、问题的复杂性和解的可归并性

12. 有一球从100米高度自由落下，每次落地后反跳回原高度的一半，再落下，求它在第10次落地前，反弹多高？用递归函数解决，下面选项正确的是？（）

A、def height(n):

if n == 1:

return 100

else:

return n*2

print(height(10))

B、def height(n):

if n == 1:

return 100

else:

return height(n-1)/2

print(height(10))

C、def height(n):

if n == 1:

return 100

else:

return height(n+1)/2

print(height(10))

D、def height(n):

if n == 1:

return 100

else:

return height(n-1)*2

print(height(10))

13. 有如下Python程序，执行该程序后，结果是？（）

g = lambda x,y=3,z=5:x+y+z

print(g(2))

A、2

B、5

C、7

D、10

14. 下面的程序输出1~100之间能被7整除但不能同时被5整除的所有整数。

k=1

while k<101:

if k%7==0 and k%5 !=0:

print(k)

k += 1

根据下面哪个选项的方法优化后，程序的运行效率最高？（）

A、将k=1改为k=7

B、将k

C、将k += 1改为k += 7

D、将k=1改为k=7，同时将k += 1改为k += 7

15. 下列程序段的运行结果为？（）

def f(n):

if n==1:

return 1

else:

return f(n-1)*3

print(f(5))

A、9

B、27

C、81

D、243

16. 下列选项中，关于如何安装第三方库的说法正确的是？（）

A、如果电脑没有联网，仍然可以使用pip工具安装本地的whl文件

B、必须使用命令行工具安装第三方库

C、第三方库只要可以用pip完整的下载下来，就可以成功安装

D、安装上Anaconda就安装了所有的第三方库

17. 运行以下程序输出的结果是？（）

y=2

def fun():

global y

y=1

print(y)

fun()

print(y)

A、

B、

C、

D、

18. 下面哪种算法使用了分治的方法？（）

A、插入排序

B、快速排序

C、选择排序

D、冒泡排序

19. 下面关于递归函数说法正确的是？（）

A、一般来说，递归函数的执行效率高于非递归函数

B、边界条件和递归关系是递归函数编写的关键

C、递归函数的嵌套调用次数没有限制

D、递归函数不可以改写为非递归函数

20. 观察此题示例代码，以下表述中错误的是？（）

nums = range(2,20)

for i in nums:

nums=list( filter(lambda x:x==i or x % i,nums))

print(nums)

A、filter()函数输出后是一个数组而不是列表

B、示例代码中的关键字lambda表示匿名函数

C、lambda x:x==i or x % i,nums中冒号:之前的x是这个函数的参数

D、匿名函数需要return来返回值，表达式本身结果就是返回值

21. 在一个平面中，有n个圆两两相交，但任二个圆不相切，任三个圆无公共点，以下函数能计算出n个圆把平面分成的区域个数，空格处填写的语句是？（）

def c(n):

if n=1:

return 2

else:

return

A、c(n-1)+2*(n-1)

B、c(n-1)+ c(n-2)

C、c(n-1)+2*n

D、c(n-1)+2*(n+1)

22. 有如下Python程序段，执行该程序后，结果是？（）

def fun(*p):

return sum(p)

print(fun(1,3,5))

A、4

B、6

C、8

D、9

23. 以下关于全局变量和局部变量的表述正确的是？（）

A、如果在函数中定义的局部变量与全局变量同名，则全局变量屏蔽局部变量

B、可以通过global关键字，通过全局变量修改局部变量

C、nonlocal关键字用来在函数或局部作用域使用内层（非全局）变量

D、全局变量的作用域一定比局部变量的作用域大

24. 关于以下程序，下列表述中错误的一项是？（）

c=1

def fun(n):

a=1

for b in range(1,n):

a*=b

return a

n=int(input('Enter n='))

print(fun(n),c)

A、c是全局变量，a是局部变量

B、n是形式参数，当n=5时，程序输出120 1

C、程序实现求阶乘

D、range()函数是python内置函数

25. 以下程序的运行结果是？（）

def f(x,y,z):

print(x,y,z)

f(z=3,x=2,y=1)

A、3 2 1

B、1 2 3

C、2 1 3

D、3 1 2

二、判断题（共10题，每题2分，共20分）

26. 所有的Python第三方库均可以使用pip工具进行安装。()

27. 算法的时间复杂度与空间复杂度没有必然关系。()

28. 在创建自定义函数时，即使函数没有参数，也必须保留一对空的"()"。()

29. 执行以下代码：()

def fun( mylist ):

mylist.append([1,2,3,4])

print("函数内取值: ", mylist)

return

mylist = [5,6,7]

fun( mylist )

print("函数外取值: ", mylist)

程序输出的结果为：函数内取值:[5, 6, 7, [1, 2, 3, 4]]

函数外取值:[5, 6, 7, [1, 2, 3, 4]]。

30. 定义Python函数时，如果函数中没有return语句，则该函数返回值是None。()

31. 执行以下代码：()

sum=0

def fun(arg1,arg2):

sum=arg1+arg2

print(sum)

return sum

fun(5,10)

print(sum)

程序输出的结果为：15

32. 对于一个复杂问题，如果所分解出的各个子问题之间相互不独立，则不适合使用分治算法。()

33. 执行以下代码：()

def fun( name, age = 30 ):

print("Name:", name)

print("Age:", age)

return

fun( age=40, name="summy" )

fun( name="summy" )

程序输出的结果为：

Name: summy Age: 40

Name: summy

Age: 40。

34. 下列程序段运行后的结果是2。()

def change(a,b):

a,b=b,a

return a

a=2

b=3

print(change(change(a,b),a))

35. 对于斐波那契数列：1，1，2，3，5，……，我们只能采用迭代公式以递推的方式求解。()

三、编程题（共3题，共30分）

36. 在编写抽奖程序时，为了保证一个人只有一次中奖机会，要检查新抽出来的数字是不是已经被抽中过了。一种办法是将已经中过奖的人员编号存放在test_list里面，然后每抽出一个新的人员编号，判断它是否在中奖人员列表中。

如果没有在中奖人员列表中，说明中奖号码有效，并将它保存进中奖人员列表；如果已经在里面了，就再生成一个新的人员编号。

请你补全下面的代码，实现判断一个数字是否在列表中的功能。

#子问题算法（子问题规模为1）

def is_in_list(init_list,num):

if init_list[0] == num:

return True

else:

return False

#分治法

def find_out(init_list,num):

n = len(init_list)

if ____①______ #如果问题的规模等于1，直接解决

return is_in_list(init_list,num)

#分解（子问题规模为n/2）

left_list,right_list = _________②____________

#递归，分治，合并

res=find_out(left_list,num) __③__ find_out(right_list,num)

return res

if __name__ == "__main__":

#测试数据

test_list = [18,43,21,3,28,2,46,25,32,40,14,36]

#查找

print(_____④_____)

程序运行结果：

True

37. 乘法运算等于多个加法运算的和。比如，3×2可以理解为3+3，也可以理解为2+2+2 。

下面的程序使用递归算法演示了计算两个自然数的乘积的过程。请你补全代码。

输入：分两次输入自然数num1，num2

输出：num1×num2 =乘积

def cheng_fa(num1,num2,value):

if ①

value += 0

else:

value += num1

②

value = cheng_fa(num1,num2,value)

return ③

num1=int(input('输入第1个数:'))

num2=int(input('输入第2个数:'))

value=0

value = cheng_fa(num1,num2,value)

print('{} X {} = {}'.format(num1,num2,value))

程序运行结果：

输入第1个数：3

输入第2个数：7

3 X 7 = 21

38. 外卖送餐服务越来越受到人们的喜爱，外卖小哥们也成了路上的一道风景。当顾客使用外卖软件点餐时，会出现一个预计送达时间，包括了餐厅制作食物的时间，路上的骑行时间等等。

一种常用的计算路上骑行时间的方法是用曼哈顿距离(manhatton distance)除以平均骑行速度。平面上点A(x1,y1)与点B(x2,y2)的曼哈顿距离为：|x1-x2|+|y1-y2|。

假设一名外卖小哥的平均骑行速度为30km/h。下面的程序模拟计算外卖小哥的路上骑行时间，请你补充完整。

输入：分两次输入A点和B点的坐标值

输出：A、B两点间的曼哈顿距离和路上骑行时间。

#求绝对值

def my_abs(n):

if ①

return n

else:

return ②

#主程序

v=30 #平均骑行速度

x1=float(input('输入A点的x坐标（米）：'))

y1=float(input('输入A点的y坐标（米）：'))

x2=float(input('输入B点的x坐标（米）：'))

y2=float(input('输入B点的y坐标（米）：'))

#计算曼哈顿距离mht

mht = ③

#计算路上骑行时间

time_on_the_road = ④

print('A、B两点的曼哈顿距离为{}米'.format(mht))

print('预计路上骑行时间需要{}分钟'.format(time_on_the_road))

程序运行结果：

输入A点的坐标（米），以逗号分隔：-1000,1000

输入B点的坐标（米），以逗号分隔：1000,-1000

A、B两点的曼哈顿距离为4000米

预计路上骑行时间需要8.0分钟

参考答案及解析：

一、单选题

1. 答案：D

- 解析：按二分查找法的规律，每次先查找中间值，进行比较。

2. 答案：C

- 解析：pip指令有install（安装）、uninstall（卸载）、list（列出已安装的包）等，没有clear指令。

3. 答案：C

- 解析：lambda函数定义了一个参数为x，返回值为5的匿名函数，调用f(3)返回5。

4. 答案：C

- 解析：调用函数inverse(456,123)，将456逐位取出，并累加到123的后面，故选C

5. 答案：A

- 解析：递归是从问题的目标出发，逐渐将复杂问题化为简单问题，最终求得问题

6. 答案：B

- 解析：在形参列表中，必须先列出没有默认值的形参，再列出有默认值的形参。

7. 答案：C

- 解析：函数pph计算a的平方加上b的值，并将b赋值为a。调用pph(a,b)+a，即pph(10,100)+10=(10**2+100)+10=200，但选项C的值为200，描述正确。然而题目要求选择错误的选项，所以这题无答案。如果题目中存在笔误，将选项C改为其他错误描述，那么根据正确的计算结果，应该是210，此时选择选项C。

8. 答案：B

- 解析：这是一个计算斐波那契数列的函数，输入6，依次计算可得数列的第6项值为8。

9. 答案：A

- 解析：函数calc使用eval函数将输入的数字和运算符进行计算，calc(3,5,'+')计算3+5的结果为8。

10. 答案：D

- 解析：函数calc中定义了局部变量x，与全局变量x不同，函数没有返回值，所以输出None。

11. 答案：A

- 解析：应用分治算法的前提是问题具有可分性，即可以分解为较小规模的子问题，并且子问题的解可以归并得到原问题的解。

12. 答案：B

- 解析：递归函数height计算球在第n次落地前反弹的高度，当n为1时返回100，否则返回上一次反弹高度的一半。

13. 答案：D

- 解析：lambda函数g接受一个参数x，默认参数y为3，z为5，计算x+y+z的值，调用g(2)得到2+3+5=10。

14. 答案：D

- 优化程序效率可以从起始值和步长考虑，将k初始值设为7，并每次增加7，可以减少不必要的循环次数，提高效率。

15. 答案：C

- 解析：函数f是递归函数，每次调用将结果乘以3，f(5)=f(4)*3=f(3)*3*3=f(2)*3*3*3=f(1)*3*3*3*3=1*3*3*3*3=81

16. 答案：A

- 解析：如果电脑没有联网，可以使用pip工具安装本地的whl文件；不一定必须使用命令行工具安装第三方库，也有其他安装方式；第三方库即使可以用pip完整下载下来，也可能由于依赖问题等无法成功安装；安装上Anaconda并不意味着安装了所有的第三方库。

17. 答案：D

- 解析：函数fun中使用global关键字将全局变量y的值改为1，所以两次输出y的值都是1。

18. 答案：B

- 快速排序是一种分治算法，通过选取一个基准值，将数组分为两部分，分别对两部分进行递归排序。

19. 答案：B

- 一般来说，递归函数的执行效率低于非递归函数；递归函数的嵌套调用次数受到栈空间大小的限制；递归函数可以改写为非递归函数；边界条件和递归关系是递归函数编写的关键。

20. 答案：D

- 关键字lambda表示匿名函数，冒号之前的表示它们是这个函数的参数，匿名函数不需要return来返回值，表达式本身结果就是返回值。在定义匿名函数时，需要将它直接赋值给一个变量，然后再像一般函数调用。

21. 答案：A

- 计算n个圆把平面分成的区域个数，当n>1时，区域个数等于n-1个圆分割的区域个数加上2*(n-1)，因为每增加一个圆，与其他n-1个圆最多有2*(n-1)个交点，这些交点将圆分成2*(n-1)段弧，每段弧将原来的区域一分为二。

22. 答案：D

- 函数fun接受可变参数，使用sum函数求和，调用fun(1,3,5)得到1+3+5=9。

23. 答案：D

- 如果在函数中定义的局部变量与全局变量同名，则局部变量屏蔽全局变量。可以通过global关键字，通过局部变量修改全局变量。nonlocal关键字用来在函数或局部作用域使用外层（非全局）变量。局部变量的作用域是指程序内部，全局变量的作用域是整个程序。

24. 答案：B

- 当n=5时，程序输出120 1，因为函数fun计算阶乘，输入5时返回5! = 120，全局变量c的值为1，所以输出120 1。

25. 答案：C

- 函数调用时可以通过参数名指定参数值，f(z=3,x=2,y=1)按照指定的参数顺序输出2 1 3。

二、判断题

26. 答案：错

- 不是所有的Python第三方库均可以使用pip工具进行安装，有些库可能需要特定的安装方法。

27. 答案：对

- 算法的时间复杂度与空间复杂度没有必然关系，时间复杂度主要衡量算法的运行时间，空间复杂度主要衡量算法所需的存储空间。

28. 答案：对

- 在创建自定义函数时，即使函数没有参数，也必须保留一对空的“()”。

29. 答案：对

- 函数fun将列表mylist作为参数，在函数内部修改了列表，由于列表是可变对象，所以函数外的mylist也被修改。

30. 答案：对

- 定义Python函数时，如果函数中没有return语句，则该函数返回值是None。

31. 答案：错

- 函数fun中的局部变量sum与全局变量sum同名，函数中的操作只修改了局部变量sum，全局变量sum的值没有改变，输出结果应该是15和0。

32. 答案：对

- 如果所分解出的各个子问题之间相互不独立，则不适合使用分治算法，因为分治算法要求子问题相互独立。

33. 答案：错

- 第一次调用fun(age=40, name="summy")输出“Name: summy Age: 40”，第二次调用fun(name="summy")输出“Name: summy Age: 30”，因为没有传入age参数时，使用默认值30。

34. 答案：对

- 自定义函数change（a,b）的作用是交换变量a,b的值并返回变量a的值，change(2,3)返回的值为3，change(3,2)返回的值为2。

35. 答案：错

- 对于斐波那契数列，可以采用迭代公式以递推的方式求解，也可以使用递归方式求解。

三、编程题

36.参考答案：

(1)n==1: 或其他正确答案； (2分)

(2)init_list[:n//2],init_list[n//2:] 或其他正确答案；(2分)

(3)or 或其他正确答案；(2分)

(4)find_out(test_list,25) 或其他正确答案。(2分)

解析：

(1) n==1：当问题规模为 1 时，即列表中只有一个元素，可以直接使用子问题算法is_in_list进行判断。如果列表长度为 1，直接判断这个唯一的元素是否等于要查找的数字。

(2) init_list [:n//2],init_list [n//2:]：这里是将列表分成左右两部分，通过切片操作实现。init_list[:n//2]表示取列表的前一半元素作为左子列表，init_list[n//2:]表示取列表从中间位置开始到末尾的元素作为右子列表。

(3) or ：在递归调用find_out函数分别处理左右子列表后，使用逻辑或运算符or连接两个结果。这是因为只要在左子列表或右子列表中找到要查找的数字，就可以返回True。

(4) find_out (test_list,25)：这是在主程序中调用find_out函数进行查找操作。可以传入测试列表test_list和要查找的数字，这里可以是列表中的任意一个数字，例如 25。程序会通过分治法在测试列表中查找该数字是否存在，并返回结果。如果数字存在于列表中，打印结果为True；如果不存在，打印结果为False。

参考程序：

#子问题算法（子问题规模为1）

def is_in_list(init_list,num):

if init_list[0] == num:

return True

else:

return False

#分治法

def find_out(init_list,num):

n = len(init_list)

if n == 1: #如果问题的规模等于1，直接解决

return is_in_list(init_list,num)

#分解（子问题规模为n/2）

left_list,right_list = init_list[:n//2],init_list[n//2:]

#递归（树），分治，合并

res=find_out(left_list,num) or find_out(right_list,num)

return res

if __name__ == "__main__":

#测试数据

test_list = [18,43,21,3,28,2,46,25,32,40,14,36]

#查找

print(find_out(test_list,25)) #True

37.参考答案：

（1）num1==0 or num2==0: 或其他等效答案；（3分）

（2）num2 -= 1 或 num2=num2 - 1或其他等效答案；（4分）

（3）value 。（3分)

解析：

（1）num1==0 or num2==0： - 当两个数中有一个为 0 时，它们的乘积为 0。所以在这个条件下，将累加值`value`加上 0。如果`num1`为 0，无论`num2`是多少，乘积都是 0；同样，如果`num2`为 0，无论`num1`是多少，乘积也都是 0。

（2）num2 -= 1 或 num2=num2 - 1： - 在每次递归调用中，需要减少`num2`的值，因为已经进行了一次加法运算，相当于少了一个被乘数。通过将`num2`减 1，实现了逐步逼近乘法运算的过程。例如，计算 3×7，可以理解为 3 + 3 + 3 + 3 + 3 + 3 + 3，每次递归调用时减少`num2`的值，直到`num2`为 0 时停止递归。

（3）value： - 在递归过程中，不断累加`value`的值，最后返回这个累加值作为两个数的乘积。每次递归调用都会更新`value`，并将其作为参数传递给下一次递归调用，直到满足结束条件。最后，返回的`value`就是`num1`和`num2`的乘积。

参考程序：

def cheng_fa(num1,num2,value):

if num1==0 or num2==0:

value += 0

else:

value += num1

num2 -= 1

value = cheng_fa(num1,num2,value)

return value

num1=int(input('输入第1个数：'))

num2=int(input('输入第2个数：'))

value=0

value = cheng_fa(num1,num2,value)

print('{} X {} = {}'.format(num1,num2,value))

程序运行结果：

输入第1个数：3

输入第2个数：7

3 X 7 = 21

38.参考答案：

(1)n>0: 或n>=0: （2分）

(2)-n（2分）

(3)my_abs(x1-x2)+my_abs(y1-y2)或sum([my_abs(x1-x2),my_abs(y1-y2)])或 sum((my_abs(x1-x2),my_abs(y1-y2))) 或其他等效答案；（4分）

(4)mht/1000/v*60 或mht/(1000*v)*60 或mht*60/1000/v 或 (mht*60)/(1000*v)或其他等效答案。（4分）

解析：

n>=0： - 在求绝对值的函数中，当输入的数大于等于 0 时，它的绝对值就是它本身。这个条件判断用于确定返回值是原数还是其相反数。
-n”： - 当输入的数小于 0 时，它的绝对值是其相反数。所以在条件不满足（即输入的数小于 0）时，返回该数的相反数。
my_abs(x1-x2)+my_abs(y1-y2)或 sum([my_abs(x1-x2),my_abs(y1-y2)])或 sum((my_abs(x1-x2),my_abs(y1-y2))) ： - 根据曼哈顿距离的定义，平面上两点 A(x1,y1)与 B(x2,y2)的曼哈顿距离为|x1 - x2| + |y1 - y2|。这里使用自定义的求绝对值函数`my_abs`分别计算两点在 x 和 y 方向上的距离差的绝对值，然后将它们相加得到曼哈顿距离。 - `sum([my_abs(x1-x2),my_abs(y1-y2)])`和`sum((my_abs(x1-x2),my_abs(y1-y2)))`是通过将两个绝对值作为列表或元组传入`sum`函数来实现相加的效果，也是等效的方法。
mht/1000/v*60 或 mht/(1000*v)*60 或 mht*60/1000/v 或 (mht*60)/(1000*v)： - 首先，速度`v`的单位是`km/h`，而距离`mht`的单位是米。为了计算骑行时间，需要将速度转换为米/分钟。1km = 1000 米，1h = 60 分钟，所以速度`v`转换为米/分钟为`v * 1000 / 60`。 - 然后，用曼哈顿距离`mht`除以转换后的速度，即`mht / (v * 1000 / 60)`，得到的结果就是以分钟为单位的骑行时间。其他几种表达式也是通过不同的运算顺序实现相同的计算目的。

试题解析：

参考程序：

#求绝对值

def my_abs(n):

if n>=0:

return n

else:

return -n

#主程序

v=30 #平均骑行速度

x1,y1=eval(input('输入A点的坐标（米），以逗号分隔：'))

x2,y2=eval(input('输入B点的坐标（米），以逗号分隔：'))