2025年12月 GESP CCF编程能力等级认证Python六级真题

========================================================================

答案和更多内容请查看网站：【试卷中心 -----> CCF GESP ----> Python ----> 六级】

网站链接

青少年软件编程历年真题模拟题实时更新

========================================================================

2025年12月 GESP CCF编程能力等级认证Python六级真题

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

第 1 题在Python的面向对象编程中，下列关于"动态绑定（等效于虚函数）"的描述中，错误的是（）。

A. 动态绑定用于支持运行时多态。

B. 通过基类变量调用方法时，会根据对象实际类型决定调用版本。

C. 构造函数（ init ）可以通过动态绑定实现多态以支持灵活初始化。

D. 基类析构函数（ del ）常保证子类调用其实现，以避免资源泄漏析构函数常声明为虚函数以避免资源泄漏。

第 2 题执行如下代码，将输出钢琴：叮咚叮咚和吉他：咚咚当当而不是两行乐器在演奏声音，这体现了面向对象编程的（）特性。

复制代码

class Instrument: ""
"基类：乐器"
""
def play(self): print("乐器在演奏声音")
def __del__(self): pass
class Piano(Instrument): ""
"子类：钢琴"
""
def play(self): print("钢琴：叮咚叮咚")
class Guitar(Instrument): def play(self): print("吉他：咚咚当当")
if __name__ == "__main__": instruments = [Piano(), Guitar()]
for inst in instruments: inst.play()

A. 继承

B. 封装

C. 多态

D. 链接

第 3 题执行下面代码，将输出（）。

复制代码

class Instrument: def play(self): print("乐器在演奏声音")
def __del__(self): pass
class Piano(Instrument): def play(self): print("钢琴：叮咚叮咚")
class Guitar(Instrument): def play(self): print("吉他：咚咚当当")
if __name__ == "__main__": instruments = [Piano(), Guitar()]
for inst in instruments: Instrument.play(inst)

钢琴：叮咚叮咚

吉他：咚咚当当

乐器在演奏声音

C. 编译错误

D. 运行错误

第 4 题某文本编辑器把用户输入的字符依次压入栈 S。用户依次输入 A , B , C , D 后，用户按了两次撤销（每次撤销，弹出栈顶一个字符）。此时栈从栈底到栈顶的内容是：（）。

A. A B

B. A B C

C. A B D

D. B C

第 5 题假设循环队列数组长度为 N ，其中队空判断条件为： front == rear ，队满判断条件为： (rear + 1) %N == front ，出队对应的操作为： front = (front + 1) % N ，入队对于的操作为： rear = (rear + 1) %N 。循环队列长度 N = 6 ，初始 front = 1 , rear = 1 ，执行操作序列为：入队, 入队, 入队, 出队, 入队, 入队，则最终 (front, rear) 的值是（）。

A. (2, 5)

B. (2, 0)

C. (3, 5)

D. (3, 0)

第 6 题以下函数 check() 用于判断一棵二叉树是否为（）。

复制代码

class TreeNode:
    def __init__(self, val = 0, left = None, right = None):
    self.val = val
self.left = left
self.right = right
from collections
import deque
def check(root):
    if not root:
    return True
q = deque()
q.append(root)
has_null = False
while q:
    cur = q.popleft()
if not cur:
    has_null = True
else :
    if has_null:
    return False
q.append(cur.left)
q.append(cur.right)
return True

A. 满二叉树

B. 完全二叉树

C. 二叉搜索树

D. 平衡二叉树

第 7 题以下代码实现了二叉树的（）。

复制代码

class TreeNode:
    def __init__(self, val = 0, left = None, right = None):
    self.val = val
self.left = left
self.right = right
def traverse(root):
    if not root:
    return
traverse(root.left)
traverse(root.right)
print(root.val, end = " ")
if __name__ == "__main__":
    root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
print("后序遍历结果：", end = "")
traverse(root)

A. 前序遍历

B. 中序遍历

C. 后序遍历

D. 层序遍历

第 8 题下面代码实现了哈夫曼编码，则横线处应填写的代码是（）。

复制代码

class Symbol:
    def __init__(self, ch = '', freq = 0, code = ''):
    self.ch = ch
self.freq = freq
self.code = code
class Node:
    def __init__(self, w = 0, l = -1, r = -1, sym = -1):
    self.w = w
self.l = l
self.r = r
self.sym = sym
def pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB):
    if pA[0] < n and(pB[0] >= len(internal_idx) or nodes[leaf_idx[pA[0]]].w <=
        nodes[internal_idx[pB[0]]].w):
    res = leaf_idx[pA[0]]
pA[0] += 1
return res
else :
    res = internal_idx[pB[0]]
pB[0] += 1
return res
def dfs_build_codes(u, nodes, sym_list, path):
    if u == -1:
    return
if nodes[u].sym != -1:
    sym_list[nodes[u].sym].code = ''.join(path)
return
path.append('0')
dfs_build_codes(nodes[u].l, nodes, sym_list, path)
path.pop()
path.append('1')
dfs_build_codes(nodes[u].r, nodes, sym_list, path)
path.pop()
def build_huffman_codes(sym_list):
    n = len(sym_list)
for sym in sym_list:
    sym.code = ''
if n <= 0:
    return -1
if n == 1:
    sym_list[0].code = '0'
return 0
nodes = []
leaf_idx = []
for i in range(n):
    leaf_idx.append(len(nodes))
nodes.append(Node(sym_list[i].freq, -1, -1, i))
leaf_idx.sort(key = lambda x: (nodes[x].w, nodes[x].sym))
internal_idx = []
pA = [0]
pB = [0]
for k in range(1, n):
    x = pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB)
y = pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB)
z = len(nodes)
______________________________
root = internal_idx[-1]
if internal_idx
else -1
path = []
dfs_build_codes(root, nodes, sym_list, path)
return root
if __name__ == "__main__":
    syms = [
Symbol('A', 5)
, Symbol('B', 9)
, Symbol('C', 12)
, Symbol('D', 13)
, Symbol('E', 16)
, Symbol('F', 45)
]
root = build_huffman_codes(syms)
print(f "哈夫曼树根节点下标：{root}")
for sym in syms:
    print(f "字符 '{sym.ch}' (频率 {sym.freq})：编码 {sym.code}")

nodes.append(Node(nodes[x].w + nodes[y].w, x, y, -1))

internal_idx.append(z)

nodes.append(Node(nodes[x].w + nodes[y].w, x, y, 1))

internal_idx.append(z)

nodes.append(Node(nodes[x-1].w + nodes[y].w, x, y, 1))

internal_idx.append(z)

nodes.append(Node(nodes[x+1].w + nodes[y].w, x, y, 1))

internal_idx.append(z)

第 9 题以下关于哈夫曼编码的说法，正确的是（）。

A. 哈夫曼编码是定长编码

B. 哈夫曼编码中，没有任何一个字符的编码是另一个字符编码的前缀

C. 哈夫曼编码一定唯一

D. 哈夫曼编码不能用于数据压缩

第 10 题以下函数实现了二叉排序树（BST）的（）操作。

复制代码

class TreeNode:
    def __init__(self, val = 0, left = None, right = None):
    self.val = val
self.left = left
self.right = right
def op(root, x):
    if not root:
    return TreeNode(x)
if x < root.val:
    root.left = op(root.left, x)
else :
    root.right = op(root.right, x)
return root

A. 查找

B. 插入

C. 删除

D. 遍历

========================================================================

答案和更多内容请查看网站：【试卷中心 -----> CCF GESP ----> Python ----> 六级】

网站链接

青少年软件编程历年真题模拟题实时更新

========================================================================