首页 › 试卷 › GESP编程能力等级认证 › GESP-Python四级 › 2024年9月CCF-GESP编程能力等级认证Python编程四级真题

2024年9月CCF-GESP编程能力等级认证Python编程四级真题 VIP

GESP-Python四级 共 27 题 2024 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

据有关资料,山东大学于1972年研制成功DJL-1计算机,并于1973年投入运行,其综合性能居当时全国第三位。DJL-1计算机运算控制部分所使用的磁心存储元件由磁心颗粒组成,设计存贮周期为2μs(微秒)。那么该磁心存储元件相当于现代计算机的(2024.9-4)( )。

  • A 内存
  • B 磁盘
  • C CPU
  • D 显示器
查看答案与解析
答案:A
解析:

DJL-1计算机使用的磁心存储元件是一种快速的存储设备,设计存储周期为2微秒,这与现代计算机的内存(RAM)功能相似。内存用于临时存储正在处理的数据和指令,因此是计算机系统中重要的组件。而磁盘主要用于长期存储数据,CPU则负责执行指令,显示器则用于输出信息。

2. 单选题

IPv4版本的因特网总共有( )个A类地址网络。

  • A 65000
  • B 200万
  • C 126
  • D 128
查看答案与解析
答案:C
解析:

在IPv4中,A类地址的网络范围是从1.0.0.0到126.0.0.0,共有126个可用的A类网络

3. 单选题

执行下面Python代码后,输出的结果是?( )

my_list = [1, 2, [3, 4]]
my_list[2].extend([5, 6])
print(my_list)
  • A [1, 2, 5, 6]
  • B [1, 2, [3, 4]]
  • C [1, 2, [3, 4, 5, 6]]
  • D [1, 2, [3, 4, [5, 6]]]
查看答案与解析
答案:C
解析:

代码中的my_list[2] 是对列表[3, 4] 的引用。使用extend([5, 6]) 方法后,会将[5, 6] 中的元素添加到这个子列表中,因此最终my_list 的内容变为[1, 2, [3, 4, 5, 6]]

4. 单选题

执行下面Python代码后,会发生什么?( )

my_tuple = (1, 2, (3, 4))
my_tuple[2] = (5, 6)


  • A my_tuple变为(1, 2, (5, 6))
  • B 代码正常执行,没有变化
  • C 抛出ValueError异常
  • D 抛出TypeError异常
查看答案与解析
答案:D
解析:

元组是不可变的,因此不能修改元组中的元素。当尝试通过my_tuple[2] = (5, 6)来更改元组中索引为2的元素时,会抛出TypeError 异常

5. 单选题

执行下面Python代码后,输出的结果是?( )

try:
	result = 10 / int('a')
except ValueError:
	print("10", end="#")
else:
	print("20", end="#")
finally:
	print("30", end="#")


  • A 10#30#
  • B 10#
  • C 20#
  • D 30#
查看答案与解析
答案:A
解析:

int(‘a’)会引发ValueError 异常,程序会跳转到except 块,并打印"10#“。由于发生了异常,else块不会执行。最后,finally块总是会执行,打印"30#”。所以输出结果是10#30#

6. 单选题

执行下面Python代码后,输出的结果是?( )

def func(n):
	return len([num for num in range(n) if num % 2 == 0])
print(func(20))


  • A 8
  • B 10
  • C 11
  • D 15
查看答案与解析
答案:B
解析:

代码中的列表推导式[num for num in range(n) if num % 2 == 0] 用于生成从0 到n-1 中所有偶数的列表。当n 为20 时,生成的偶数有0, 2, 4, 6, 8, 10, 12, 14, 16, 18,总共有10 个偶数。因此,func(20)的输出结果是10

7. 单选题

执行下面Python代码后,输出的结果是?( )

def func(*args):
	return ''.join(args)
print(func('Hello', 'World'))


  • A HelloWorld
  • B Hello World
  • C “Hello” “World”
  • D 抛出异常
查看答案与解析
答案:A
解析:

func接受可变数量的参数*args,并将这些参数连接成一个字符串。‘’.join(args)会将所有传入的字符串连接在一起,因此func(‘Hello’, ‘World’) 的输出结果是HelloWorld

8. 单选题

执行下面Python代码后,输出的结果是?( )

def func(lst):
	lst.append(10)
	return lst
	
lstA = [1,2,3]

func(lstA)
print(lstA,func(lstA))


  • A [1, 2, 3, 10, 10] [1, 2, 3, 10, 10]
  • B [1, 2, 3] [1, 2, 3, 10]
  • C [1, 2, 3, 10] [1, 2, 3, 10]
  • D [1, 2, 3, 10] [1, 2, 3, 10, 10]
查看答案与解析
答案:A
解析:

第一次调用func(lstA) 后,lstA变为[1, 2, 3, 10]。然后在print 语句中再次调用func(lstA),又会在lstA 末尾添加一个10,最终变为[1, 2, 3, 10, 10]。因此,输出为[1, 2, 3, 10, 10] [1, 2, 3, 10, 10]。注意:lst参数是可变参数类型。

9. 单选题

执行下面Python代码后,输出的结果是?( )

def tpADD(tpl):
	tpl = tpl +(5,6)
	return tpl
	
tp = (1,2,3)
tpADD(tp)
print(tp,tpADD(tp))


  • A (1, 2, 3, 5, 6, 5, 6) (1, 2, 3, 5, 6, 5, 6)
  • B (1, 2, 3, 5, 6) (1, 2, 3, 5, 6)
  • C (1, 2, 3) (1, 2, 3, 5, 6)
  • D (1, 2, 3) (1, 2, 3)
查看答案与解析
答案:C
解析:

在函数tpADD(tpl) 中,tpl作为参数被传入,原始的元组tp 不会被修改。【不可变参数类型】调用tpl = tpl + (5, 6) 创建了一个新的元组(1, 2, 3, 5, 6),但这个新元组并没有赋值回tp。所以第一次打印tp 时,输出仍然是原始元组(1, 2, 3)。第二次调用tpADD(tp) 返回的是新元组(1, 2, 3, 5, 6),因此输出结果为(1, 2, 3) (1, 2, 3, 5, 6)

10. 单选题

执行下面Python代码后,输出的结果是?( )

x = 5

def foo():
	def bar():
		global x
		x = 10
		
	bar()
	print(x, end="#")
	
foo()
print(x, end="#")
  • A 5#5#
  • B 10#5#
  • C 5#10#
  • D 10#10#
查看答案与解析
答案:D
解析:

当调用bar() 时,它会将全局变量x 设置为10。因此,在foo() 内部的print(x, end=“#”)输出10,然后当foo() 完成后,再次输出print(x, end=“#”)时,x仍然是10。所以最终的输出是10#10#

11. 单选题

执行下面Python代码后,输出的结果是?( )

def func(d):
	d['a'] = 5
	
c = {'a': 1, 'b': 2}
func(c)
print(c)
  • A {‘a’: 1, ‘b’: 2}
  • B {‘b’: 2}
  • C {‘a’: 5, ‘b’: 2}
  • D 抛出异常
查看答案与解析
答案:C
解析:

在函数func(d) 中,d[‘a’] = 5 将字典d 中的键’a’ 的值修改为5。在func© 调用时,c是一个字典{‘a’: 1, ‘b’: 2}。调用后,c的内容变为{‘a’: 5, ‘b’: 2}。因此,最终输出结果为{‘a’: 5, ‘b’: 2}

12. 单选题

以下Python代码实现的排序算法的时间复杂度是?( )

def func_sort(arr):
	n = len(arr)
	for i in range(n - 1):
		min_idx = i
		for j in range(i+1, n):
			if arr[j] < arr[min_idx]:
				min_idx = j
		arr[i], arr[min_idx] = arr[min_idx], arr[i]


  • A O(n)
  • B O(2n)
  • C O(n2)
  • D O(n3)
查看答案与解析
答案:C
解析:

这段代码实现的是选择排序算法。外层循环运行n-1 次,内层循环在最坏情况下运行n-i 次,总体的时间复杂度为O(n)+O(n−1)+O(n−2)+…+O(1)即O(n2)

13. 单选题

执行下面Python代码后,输出的结果是?( )

tuples = [(1, 'apple'), (2, 'banana'), (0, 'cherry')]
sorted_tuples = sorted(tuples, key=lambda x: x[1])
print(sorted_tuples)
  • A [(1, ‘apple’), (0, ‘cherry’), (2, ‘banana’)]
  • B [(2, ‘banana’), (1, ‘apple’), (0, ‘cherry’)]
  • C [(0, ‘cherry’), (1, ‘apple’), (2, ‘banana’)]
  • D [(1, ‘apple’), (2, ‘banana’), (0, ‘cherry’)]
查看答案与解析
答案:D
解析:

sorted()函数根据元组的第二个元素进行排序。对于’apple’, ‘banana’, 和’cherry’,它们的排序顺序是’apple’, ‘banana’, ‘cherry’,所以输出结果是[(1, ‘apple’), (2, ‘banana’), (0, ‘cherry’)]

14. 单选题

假设你正在爬楼梯,每次可以爬1阶或2阶。给定楼梯的阶数 n ,计算有多少种不同的方法可以爬到楼顶。以下Python代码的横线处应该填写?( )

def climbStairs(n):
	if n == 1:
		return 1
	if n == 2:
		return 2
		
	# 初始化前两阶楼梯的数据
	dp = [0] * (n + 1)
	dp[1] = 1
	dp[2] = 2
	
	# 从第3阶楼梯开始,计算每一阶楼梯的爬法数量
	for i in range(3, n + 1):
		__________
	return dp[n]
  • A dp[i] = 2 * dp[i - 1] + dp[i - 2]
  • B dp[i] = dp[i - 1] + dp[i - 2]
  • C dp[i] = 2 * dp[i - 2]
  • D dp[i] = dp[i - 1] + 2 * dp[i - 2]
查看答案与解析
答案:B
解析:

为了到达第i 阶楼梯,你可以从第i-1 阶爬上来(方式为dp[i-1]),或者从第i-2 阶爬上来(方式为dp[i-2])。因此,总的方法数是这两者之和,即dp[i] = dp[i - 1] + dp[i - 2]

15. 单选题

文件numbers.txt的内容如下:

5
12
7
15
3
20
8

执行下面Python代码后,输出的结果是?( )

def func(file_path, threshold):
	lst = []
	with open(file_path) as file:
		for line in file:
			number = int(line.strip())
			if number > threshold:
				lst.append(number)
	return lst
	
file_path = 'numbers.txt'
threshold = 12
selected_numbers = func(file_path, threshold)
print(selected_numbers)
  • A [15, 20]
  • B [12, 15, 20, 8]
  • C [5, 12, 7, 15, 20, 8]
  • D [12, 15, 20]
查看答案与解析
答案:A
解析:

代码读取numbers.txt文件中的每一行,将其转换为整数。它只会将大于threshold(即12)的数字添加到列表lst 中。在文件内容中,数字15

二、判断题

16. 判断题

小杨最近开始学习C++编程,老师说C++是一门面向对象的编程语言,也是一门高级语言。(2024.9-4)( )

  • A对
  • B错
查看答案与解析
答案:对
解析:

C++是一门面向对象的编程语言,也是一门高级语言

17. 判断题

在Python程序中,自定义函数可以定义在主程序代码的前面,也可以定义在主程序代码的后面,都不会发生错误。( )

  • A对
  • B错
查看答案与解析
答案:错
解析:

在Python中,函数必须在调用之前定义。如果你在调用一个函数之前没有定义它,程序会抛出NameError异常。因此,自定义函数必须在主程序代码中被调用之前进行定义,否则会发生错误

18. 判断题

在Python程序中,如果自定义函数内没有return语句或者return语句不带任何返回值,那么该函数的返回值为False。

  • A对
  • B错
查看答案与解析
答案:错
解析:

在Python中,如果自定义函数没有return 语句或者return 语句不带任何返回值,函数的返回值是None,而不是False。None是一个特殊的值,表示“无值”或“空”。只有在函数中显式返回False 时,返回值才会是False

19. 判断题

try-except-else-finally异常处理结构中,只有try程序段中的语句没有异常,else程序段中的语句才会得到执行。

  • A对
  • B错
查看答案与解析
答案:对
解析:

在try-except-else-finally结构中,try块中的代码如果没有发生异常,则会执行else 块中的代码。若try 块中发生了异常,则会跳过else 块,直接执行except 块。因此,只有当try 中的代码正常执行,没有抛出异常时,else中的语句才会被执行

20. 判断题

Python中避免使用反斜线 \ 指定文件路径时出错,如 C:\test\numbers.txt ;常常使用正斜线 / 或者双反斜线 \ 。

  • A对
  • B错
查看答案与解析
答案:对
解析:

在Python中,反斜线\ 是转义字符,因此在文件路径中使用时可能会导致错误。

21. 判断题

'w’可以作为open()函数的参数,表示以写的方式打开文件,若文件不存在,则会抛出异常。

  • A对
  • B错
查看答案与解析
答案:错
解析:

在Python中,使用’w’ 作为open()函数的参数表示以写的方式打开文件。如果指定的文件不存在,open()不会抛出异常,而是会创建一个新文件。因此,使用’w’ 模式打开文件时,如果文件不存在,它会自动创建该文件

22. 判断题

下面这段程序的时间复杂度为线性阶O(n)。( )

def func(n):
	i = 0
	while i ** 2 < n:
		i += 1
  • A对
  • B错
查看答案与解析
答案:错
解析:

在while 循环中,条件是i^2 < n。这意味着循环会继续,直到i 的平方达到或超过n。因此,循环的次数是O(√n)而不是O(n)

23. 判断题

对一组数据 [5, 2, 6, 4, 8, 1, 7, 3]使用冒泡的方法按从大到小的顺序进行排序,则第2轮排序过后的结果是[6, 5,8, 4, 7, 3, 2, 1]。

  • A对
  • B错
查看答案与解析
答案:对
解析:

对于数据[5, 2, 6, 4, 8, 1, 7, 3],在进行冒泡排序以从大到小的顺序排列时,第一轮排序结果为[5, 6, 4, 8, 2, 7, 3, 1],第二轮排序结果为[6, 5, 8, 4, 7, 3, 2, 1]

24. 判断题

执行下面Python代码后,输出的结果为(0, 0)。

lst = [(x, x**2) for x in range(-5, 6)]
a = min(lst, key=lambda x: abs(x[1]))
print(a)


  • A对
  • B错
查看答案与解析
答案:对
解析:

第一行生成一个包含元组的列表,min函数会比较元组的第二个元素(即x**2)的绝对值。由于平方值都是非负的,最小值就是0,对应的元组是(0, 0)

25. 判断题

在Python中表达式 {1, 3, 5} & {2, 4, 6} == {} 的值为True。

  • A对
  • B错
查看答案与解析
答案:错
解析:

{1, 3, 5} & {2, 4, 6} == {} 的结果是False,由于空集 {} 与任何集合比较都返回 False,因此整个表达式的结果为 False。{1, 3, 5} & {2, 4, 6}将得到空的集合,而{}是字典

三、简答题

26. 简答题

黑白方块

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有一个n行m列的网格图,其中每个格子要么是白色,要么是黑色。

小杨想知道网格图中是否存在一个满足如下条件的子矩形:

子矩形由 4 行 4 列组成;

子矩形的第 1 行 和第 4 行只包含白色格子;

对于子矩形的第 2 行 和第 3 行,只有第 1 个和第 4 个格子是白色的,其余格子都是黑色的;

请你编写程序帮助小杨判断。

输入格式

第一行包含一个正整数t,代表测试用例组数。

接下来是t组测试用例。对于每组测试用例,一共n+1 行。

第一行包含两个正整数n,m,含义如题面所示。

之后n行,每行一个长度为m的01串,代表网格图第i行格子的颜色,如果为0,则对应格子为白色,否则为黑色。

输出格式

对于每组测试用例,如果存在,输出 Yes,否则输出 No。


输入样例

3
1 4
0110
5 5
00000
01100
01100
00001
01100
5 5
00000
01100
01110
00001
01100

输出样例

No
Yes
No

满足条件的子矩形形如:

0000
0110
0110
0000

对于全部数据,保证有1≤t≤10,1≤n,m≤100。

查看答案与解析
答案:<pre class="brush:python;toolbar:false">N = 110 w = [[0] * N for _ in range(N)] match = [[0] * 4 for _ in range(4)] n, m = 0, 0 def check(xa, ya): for i in range(4): for j in range(4): if w[xa + i][ya + j] != match[i][j]: return False return True def main(): for i in range(1, 3): match[1][i] = match[2][i] = 1 t = int(input()) for _ in range(t): global n, m n, m = map(int, input().split()) for i in range(1, n + 1): s = input() for j in range(1, m + 1): w[i][j] = int(s[j - 1]) fl = False for i in range(1, n - 2): for j in range(1, m - 2): if check(i, j): fl = True break if fl: break if fl: print("Yes") else: print("No") if __name__ == "__main__": main()</pre>
解析:

定义二维列表,存储将要输入的网格数据;

将要匹配的模版矩形初始化,4X4的二维列表;

使用循环遍历网格数据中每一个可能的4X4子矩形,检查从位置(i,j)开始的子矩形是否与之前定义好的模版匹配

进行判断,输出结果

27. 简答题

区间排序

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有一个包含n个正整数的序列a。

小杨计划对序列进行多次升序排序,每次升序排序小杨会选择一个区间[l,r](l≤r) 并对区间内所有数字,即al,al+1,...,ar进行升序排序。每次升序排序会在上一次升序排序的结果上进行。

小杨想请你计算出多次升序排序后的序列。

输入格式

第一行包含一个正整数n,含义如题面所示。

第二行包含n个正整数a1,a2,...,an,代表序列。

第三行包含一个正整数q,代表排序次数。

之后q行,每行包含两个正整数li,ri,代表将区间[li,ri] 内所有数字进行升序排序。

输出格式

输出一行包含n个正整数,代表多次升序排序后的序列。


输入样例

5
3 4 5 2 1
3
4 5
3 4
1 3

输出样例

1 3 4 5 2

第一次升序排序后,序列为[3,4,5,1,2];

第二次升序排序后,序列为[3,4,1,5,2];

第三次升序排序后,序列为[1,3,4,5,2];

对于全部数据,保证有1≤n≤100,1≤ai≤100,1≤q≤100,1≤li≤ri≤n。

查看答案与解析
答案:<pre class="brush:python;toolbar:false">N = 1010 a = [0] * N n = 0 def bubbleSort(l, r): flag = True while flag: flag = False for i in range(l, r): if a[i] &gt; a[i + 1]: flag = True a[i], a[i + 1] = a[i + 1], a[i] n = int(input()) s = input().split() for i in range(1, n + 1): a[i] = int(s[i-1]) q = int(input()) while q: q -= 1 l, r = map(int, input().split()) bubbleSort(l, r) for i in range(1, n + 1): print(a[i], end=" " if i != n else "\n")</pre>
解析:

将要排序的数据存储在列表中,初始化定义一个长度为1010的列表,尽可能大的数据,确保在输入规模较大的情况下不会越界

定义排序方法对数据进行排序

处理部分:

存储输入数据

处理需要进行排序的区间操作数q

对选定的l,r区间范围内数据进行排序操作,调用之前定义好的排序方法

输出结果(注意每个元素用空格分割,且最后一个元素没有空格)