GESP Python 5级 2025.06
有关下列 Python 代码的说法，错误的是（ ）。
# 自定义函数SORTED()仿Python的sorted()功能
def SORTED(for_in_data, fx = None, Reverse = False):
lst = list(for_in_data)
if fx == None:
lst.sort(reverse = Reverse)
else:
lst.sort(key = lambda x:fx(x), reverse = Reverse)
return lst
执行 SORTED({1:1,2:4,3:9}) 不会报错。
执行 SORTED(range(10)) 不会报错。
执行 SORTED([1,20,3], Reverse = True)[::-1] 不会报错。
执行 SORTED([1,None,'123']) 不会报错。
下列 Python 代码用于判断一个正整数是否是质数（素数），相关说法中正确的是（ ）。
def is_prime(N):
if N <= 1:
return False # 处理所有非正整数
if N == 2 or N == 3 or N == 5:
return True
if N % 2 == 0 or N % 3 == 0 or N % 5 == 0:
return False
i = 7
step = 4
finish_number = int(N ** 0.5) + 1
while i <= finish_number:
if N % i == 0:
return False
i += step
step = 6 - step
return True
# 列出 1-N 之间所有质数
N = int(input())
print([n for n in range(1,N+1) if is_prime(n)])
代码存在错误，比如 5 是质数，但因为 5 % 5 余数是 0 返回了 False
finish_number 的值应该是 N//2，当前写法将导致错误
当前 while 循环正确的前提是：所有大于 3 的质数都符合 形式
while 循环修改如下，其执行效果与执行时间相同
for i in range(2, finish_number):
if N % i == 0:
return False
return True
下列 Python 代码用于求解两个正整数的最大公约数，相关说法中错误的是（ ）。
def gcd0(big, small):
if big < small:
big, small = small, big
if big % small == 0:
return small
return gcd0(small, big % small)
def gcd1(big,small):
if big < small:
big, small = small, big
for i in range(small, 0, -1):
if big % i == 0 and small % i == 0:
return i
print(gcd0(48,24))
print(gcd1(36,24))
函数的时间复杂度为
函数的时间复杂度为
一般说来， 的效率高于
中的代码 range(small, 0, -1) 应该修改为 range(small, 1, -1)
在 Python 中，可以用字典模拟单向或双向链表的实现。下面的代码模拟单向链表，和链表对象相比，有关其缺点的说法，错误的是（ ）。
node1 = {'data': 1, 'next': None}
node2 = {'data': 2, 'next': None}
node1['next'] = node2 # node1 的下一个节点是 node2
类型安全差，易出错。例如：node1["NEXT"] = node2 不会报错，导致逻辑错误。
内存开销大。字典需要保存键名称以及哈希表。
无法封装方法，如 insert() 插入函数较为常用，但其代码需要分散在外部。
重复存储，难以保证一致性。如在 node1['next'] = node2 代码中，node1['next'] 的值为 node2，而 node2 自身也将保存一份。
基于上题代码，模拟单向链表实现插入新节点函数 insertNode() 的代码如下，横线处应填入的代码是（ ）。
def insertNode(linkNode, newNodeData):
newNode = ___________________
______________________
{'data': newNodeData, 'next': linkNode['next']}
linkNode['next'] = newNode
{'data': newNodeData, 'next': None}
linkNode['next'] = newNode
{'data': newNodeData, 'next': newNode}
linkNode['next'] = newNode
{'data': newNodeData, 'next': linkNode['next']}
linkNode = newNode
下面的 Python 代码用于实现双向链表。is_empty() 函数用于判断链表是否为空，如为空返回 True，否则 False。横线处不能填入的代码是（ ）。
class double_link:
class Node:
def __init__(self, data):
self.data = data
self.prev = None # 指向前一个节点
self.next = None # 指向下一个节点
def __init__(self):
self.head = None
self.tail = None
self._size = 0
def is_empty(self):
return ________
self.tail is None
self._size == 0
self == None
self.head is None
基于上题代码正确的前提下，填入相应代码完善 append() 函数，用于在尾部增加新节点（ ）。
def append(self, data):
new_node = self.Node(data)
if self.is_empty():
self.head = new_node
self.tail = new_node
else:
_______________
_______________
_______________
self._size += 1
return new_node
self.tail.next = new_node
new_node.prev = self.tail
self.tail.next = new_node
self.tail = new_node
new_node.prev = self.tail
self.tail.next = new_node
new_node.prev = self.tail
self.tail.next = new_node
self.tail = new_node
下面的 Python 代码，用于求一系列数据中的最大值。有关其算法说法错误的是（ ）。
def find_max(nums):
if not nums:
raise ValueError("输入数组不能为空")
def _find_max(left, right):
if left == right:
return nums[left]
mid = (left + right) // 2
return max(
_find_max(left, mid),
_find_max(mid + 1, right)
)
return _find_max(0, len(nums) - 1)
print(find_max([3,39,1,31,1,2,3,12,2]))
该算法采用分治算法。
该算法是递归实现。
该算法采用贪心算法。
该算法不是递推算法。
基于上题的 find_max() 实现，下面的说法错误的是（ ）。
find_max() 适用于 str。
find_max() 适用于 list。
find_max() 适用于 tuple。
find_max() 适用于 dict。
下面的 Python 代码，用于求一系列数据中的最大值。有关其算法说法错误的是（ ）。
def find_max(nums):
if not nums:
raise ValueError("输入数组不能为空")
if len(nums) == 1:
return nums[0]
mid = len(nums) // 2
return max(
find_max(nums[:mid]),
find_max(nums[mid:])
)
print(find_max([1,2,2,11,21,1,2,3]))
本题的 find_max() 函数采用分治算法
和上上题的 find_max() 函数相比，本题 find_max() 运行效率相对较低，因为需要分配额外的内存空间，用以存储 nums 的切片结果
和上上题的 find_max() 函数相比，本题 find_max() 的空间复杂度与之相同，不需要额外的存储资源
本题的 find_max() 的时间复杂度为