首页 › 题库 › GESP编程能力等级认证 › GESP-Python六级

GESP-Python六级 题库

共 243 道题 ,第 1 / 13 页 · 按题型筛选,点「查看答案」核对解析
1 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

以下关于Python 类继承的代码,执行后输出结果是?()

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "动物叫声"

class Dog(Animal):
    def speak(self):
        return f"{self.name}: 汪汪汪"

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)  # 调用父类构造方法
        self.color = color

    def speak(self):
        return f"{self.name} ({self.color}): 喵喵喵"

dog = Dog("旺财")
cat = Cat("咪宝", "橘色")
print(dog.speak(), cat.speak())


A
动物叫声动物叫声
B
旺财:汪汪汪咪宝:喵喵喵
C
旺财:汪汪汪咪宝(橘色):喵喵喵
D
动物叫声咪宝(橘色):喵喵喵
答案与解析
正确答案:C
分析类继承结构:Animal为基类,定义__init__初始化name属性和speak方法。Dog继承Animal,重写speak方法,使用父类的name属性生成字符串。Cat继承Animal,重写__init__方法,通过super()调用父类构造函数初始化name,并新增color属性,同时重写speak方法,结合name和color生成字符串。实例化Dog时传入名称,触发父类__init__赋值name。实例化Cat时传入名称和颜色,先调用父类__init__设置name,再设置color。调用speak方法时,根据实际对象类型动态绑定对应类的speak实现。
题目详情
2 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

下列代码中,s1 .draw() 和s2 .draw() 能正确运行并输出不同结果的主要原因是()。

class Shape:
    def draw(self):
        print("绘制图形")

class Circle(Shape):
    def draw(self):
        print("绘制圆形")

class Rectangle(Shape):
    def draw(self):
        print("绘制矩形")

if __name__ == "__main__":
    s1 = Circle()
    s2 = Rectangle()

    s1.draw()
    s2.draw()


A
draw() 是普通成员函数
B
Shape 中的draw() 被声明为虚函数
C
Circle 和Rectangle 中使用了公有继承
D
对象变量名不同
答案与解析
正确答案:C
分析类之间的继承关系,确认父类Shape中定义了draw方法,子类Circle和Rectangle各自重写了该方法。通过实例化不同子类得到s1和s2对象,调用draw方法时,实际执行的是各自子类中重写后的版本。此行为基于动态分派机制,根据对象的实际类型确定调用哪个类的实现。检查继承方式是否支持方法重写,确认调用语句访问的是同名但不同实现的方法。
题目详情
3 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

下面的代码在主程序if name == " main ": 中有没有一行会导致运行错误,如果有请找出错误行()

class Pet:
    def __init__(self, n, a):
        self._name = n
        self._age = a
    def get_name(self):
        return self._name
    def birthday(self):
        self._age += 1

if __name__ == "__main__":
    cat = Pet("奶茶", 2)
    print(cat.get_name())       # ①
    cat.birthday()              # ②
    cat._name = "大橘"          # ③
    print(cat.get_name())       # ④


A
第①行
B
第②行
C
第③行
D
无错误行
答案与解析
正确答案:D
分析代码结构,确认类Pet的定义是否完整,包括__init__方法是否正确初始化实例属性。检查get_name和birthday方法的逻辑是否合法。逐行审查主程序中的语句:①调用get_name方法,验证该方法是否存在且可访问;②调用birthday方法,验证其是否能正确修改_age属性;③直接访问并赋值_name属性,判断该属性是否在语法上允许被外部修改;④再次调用get_name方法,验证属性变更后是否仍可正常读取。确认Python中无访问控制关键字,下划线前缀仅表示约定的私有性,不影响实际访问。判断每一行语句在语法和运行时是否引发异常。
题目详情
4 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

游乐园的过山车每次限坐4 人,用循环队列管理排队(容量MAX=5,空一格判满)。下面代码执行后,循环队列是否已满?rear 的值是多少?

MAX = 5
queue = [None] * MAX
front = 0
rear = 0

def enqueue(x):
    global rear, queue
    queue[rear] = x
    rear = (rear + 1) % MAX

def dequeue():
    global front
    front = (front + 1) % MAX

if __name__ == "__main__":
    enqueue(1)
    enqueue(2)
    enqueue(3)
    enqueue(4)

    dequeue()
    dequeue()

    enqueue(5)
    enqueue(6)

    print("队列数组: ", queue)
    print("front下标位置: ", front)
    print("rear下标位置: ", rear)


A
已满,rear = 1
B
未满,rear = 1
C
已满,rear = 2
D
未满,rear = 4
答案与解析
正确答案:A
初始化队列容量为5,front和rear起始均为0。每执行enqueue操作,元素存入rear位置,rear按模5递增;每执行dequeue操作,front按模5递增。依次执行:入队1、2、3、4,rear移至4;两次出队,front移至2;再入队5,rear变为(4+1)%5=0;入队6,rear变为(0+1)%5=1。队列中当前元素数量由(front, rear)相对位置决定,判断是否满的条件是(rear + 1) % MAX == front。最终rear值为1,此时需根据front与rear关系判断队列状态。
题目详情
5 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 6.2 队列

在以下计算机系统应用场景中,最适合使用循环队列的是()。

A
函数调用过程中,保存局部变量和返回地址
B
表达式求值中的运算符优先级处理
C
操作系统中的进程优先级调度(高优先级先执行)
D
生产者和消费者问题中的共享缓冲区
答案与解析
正确答案:D
分析各场景的数据访问模式与存储需求。函数调用依赖后进先出的执行上下文保存,需使用栈结构管理调用帧。表达式求值中运算符的处理顺序由优先级和结合性决定,需借助栈实现延迟操作。进程调度按优先级选取下一个执行进程,高优先级任务需优先获取处理权,适合采用优先队列而非循环结构。生产者和消费者问题涉及固定大小缓冲区的并发访问,数据按到达顺序存取,前端入队、后端出队,且要求空间复用,循环队列通过模运算实现首尾相连的存储利用,满足连续存取与边界回绕的需求。
题目详情
6 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

在二叉搜索树(BST)中,若中序遍历的序列为{1, 2, 3, 4, 5},且先序遍历的第一个序列元素为3,则下列说法正确的是()。

A
该树一定是一棵完全二叉树。
B
元素4和5不可能是兄弟节点。
C
元素1所在节点的深度可能大于3(根节点深度为1)。
D
元素2一定是元素1的父节点。
答案与解析
正确答案:B
中序遍历序列{1, 2, 3, 4, 5}表明二叉搜索树的节点按升序排列,根节点为3时,左子树包含{1, 2},右子树包含{4, 5}。先序遍历首元素为3,确认根节点是3。左子树中,2可为1的父节点或1为2的左子节点;右子树中,4与5可构成不同父子关系。完全二叉树要求除最后一层外满填充,但当前结构无法确定层级填充情况。节点深度由路径长度决定,1的深度取决于其在左子树中的位置。兄弟关系取决于共同父节点,4和5可能同属一个父节点也可能不是。各节点具体位置存在多种合法构造方式,需依据BST性质和遍历顺序推导可能结构。
题目详情
7 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

某二叉树共有10个结点,记为A~J,已知它的先序遍历序列为:<strong>AB D H I E C F J G</strong>,中序遍历序列为:<strong>H DI B E A FJ C G</strong>,则该二叉树的后序遍历序列是()。

A
H I D E B J F G C A
B
H I D B E J F G C A
C
I H D E B J F G C A
D
H I D E B F J G C A
答案与解析
正确答案:A
根据先序遍历序列确定根节点,结合中序遍历序列划分左右子树。先序序列首元素为当前子树根节点,在中序序列中找到该根节点位置,其左侧为左子树结点,右侧为右子树结点。递归应用此过程,重建各子树结构。每层递归均按先序定位根、中序分左右的方式推进,直至所有结点位置确定。后序遍历顺序为左子树、右子树、根节点,依据重建的树结构进行访问即可得到后序序列。
题目详情
8 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

下列关于树的遍历的说法中,正确的一项是()。

A
对任意一棵树进行深度优先遍历,所得序列一定唯一。
B
已知一棵二叉树的先序遍历和后序遍历序列,可以唯一确定这棵二叉树。
C
若一棵二叉树的先序遍历序列与中序遍历序列相同,则该二叉树一定为只有右子树的链式结构。
D
已知一棵二叉树的先序遍历序列,即可唯一地确定该二叉树的结构。
答案与解析
正确答案:C
深度优先遍历的序列唯一性取决于访问子节点的顺序是否固定,若无明确次序则结果不唯一。仅凭先序和后序遍历无法唯一确定二叉树结构,因缺乏中序提供的根节点分割信息。先序与中序序列相同时,表明每个节点均无左子树,遍历过程中始终优先访问右子树。仅知先序遍历时,无法区分各节点在树中的具体位置,缺失分支结构信息,不能重建唯一二叉树。
题目详情
9 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.2 哈夫曼树

有6 个字符,它们出现的次数分别为:{2 , 3 , 3 , 4 , 6 , 8 },现在用哈夫曼编码为这些字符编码,最小加权路径长度WPL(每个字符的出现次数X它的编码长度,再把每个字符结果加起来)的值为()。

A
58
B
60
C
62
D
64
答案与解析
正确答案:D
将给定的6个字符出现次数作为叶节点权重,构建哈夫曼树。每次选择当前权值最小的两个节点合并为新节点,新节点的权值为两者之和,重复此过程直至只剩一个根节点。每个字符的编码长度等于其在哈夫曼树中的路径长度(从根到该叶节点的边数)。计算每个字符的权值与其路径长度的乘积,再求所有字符的乘积之和,即得最小加权路径长度WPL。
题目详情
10 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

对n个不同符号的符号进行哈夫曼编码。若生成的哈夫曼树共有115个结点,则n的值是()。

A
60
B
58
C
57
D
56
答案与解析
正确答案:B
哈夫曼树由n个叶子结点构成,每个非叶子结点由两个子结点合并生成。设非叶子结点数为k,则树中总共有n + k个结点。每次合并减少一个符号,从n个符号合并到1个根结点需进行n - 1次合并,故非叶子结点数为n - 1。因此,总结点数为n + (n - 1) = 2n - 1。给定总结点数为115,代入公式得2n - 1 = 115,解此方程可求n的值。
题目详情
11 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 2.1 格雷编码

关于格雷编码(Gray Code),下列说法正确的是()。

A
格雷编码中,编码位数越多,相邻编码之间变化的位数也越多
B
格雷编码中,相邻两个编码的二进制位恰好有一位不同
C
格雷编码就是把普通二进制编码按位取反后得到的结果
D
格雷编码不能用于数字电路和状态转换的设计中
答案与解析
正确答案:B
格雷编码是一种二进制编码方式,其特点是任意两个相邻编码之间仅有一位二进制位不同。该特性由编码的构造规则决定,与编码位数无关。生成格雷码可通过反射法或通过二进制码转换:将二进制码的每一位与其高位进行异或运算得到对应格雷码位。相邻编码间单一比特变化的性质使其在状态机设计中可减少误触发,适用于数字电路中的状态编码。按位取反操作不产生格雷码,也不改变其相邻性特征。编码位数增加不影响相邻编码间变化位数,始终保持一位差异。
题目详情
12 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

给定一棵二叉树,采用广度优先搜索(BFS) 算法,返回右视图所有节点的值。其中右视图定义为:二叉树的右视图是从树的右侧看过去时可见的节点集合,即右视图中的每个节点都是某一层中最右侧的节点。

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def rightSideView(root):
    rightmost_value_at_depth = {}
    max_depth = -1

    node_queue = []
    depth_queue = []
    node_queue.append(root)
    depth_queue.append(0)

    while node_queue:
        node = node_queue.pop(0)
        depth = depth_queue.pop(0)

        if node is not None:
            max_depth = max(max_depth, depth)
            rightmost_value_at_depth[depth] = node.val

            node_queue.append(node.left)
            node_queue.append(node.right)

            # (1) 填空处
            depth_queue.append(depth + 1)
            depth_queue.append(depth + 1)

    right_view = []
    # (2) 填空处
    for depth in range(max_depth + 1):
        right_view.append(rightmost_value_at_depth[depth])

    return right_view

if __name__ == "__main__":
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.right = TreeNode(5)
    root.right.right = TreeNode(4)

    print(rightSideView(root))


A
(1)depth , depth ;(2)0 , max_depth
B
(1)depth + 1 , depth + 1 ;(2)0 , max_depth + 1
C
(1)depth + 1 , depth + 1 ;(2)1 , max_depth + 1
D
(1)depth , depth ;(2)1 , max_depth
答案与解析
正确答案:B
使用BFS遍历二叉树,按层处理节点。每层维护一个映射记录该层最后访问的节点值,因队列中同一层节点按从左到右入队,同层后续节点会覆盖前序节点值,最终保留最右侧节点。节点入队时将其左右子节点依次加入队列,对应深度加1。初始化根节点深度为0,故遍历所有层需从0开始到max_depth(含)。遍历完成后,按深度从小到大收集每层最右节点值形成右视图结果序列。
题目详情
13 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

下列关于树的深度优先搜索(DFS)的说法中,正确的是()。

A
对树进行DFS 时,一定是按层从上到下依次访问结点
B
对任意一棵树进行DFS,得到的遍历序列唯一
C
对一棵树进行DFS 时,常借助递归或栈实现
D
DFS 只能用于二叉树,不能用于普通树
答案与解析
正确答案:C
深度优先搜索通过访问起始节点后递归探索每个子树,直到无法深入为止。该过程可利用函数调用栈通过递归实现,也可显式使用栈结构模拟访问顺序。遍历过程中访问节点的次序取决于访问子节点的顺序,不同顺序会导致不同的遍历路径。树的结构不限于二叉树,DFS适用于任何树形结构。层序访问是广度优先搜索的特征,而非深度优先搜索。遍历序列是否唯一由树的结构和子节点访问顺序共同决定。
题目详情
14 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 4.1 一维动态规划

小朋友们去邻里拜年,每个家里有不同数量的糖果。规则是:不能连续进入两个相邻的房子(即不能同时取相邻两家的糖果)。目标是拿到最多糖果。以下是代码实现,请补全横线。

def visit(nums):
    if not nums:
        return 0

    size = len(nums)
    if size == 1:
        return nums[0]

    dp = [0] * size
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])

    for i in range(2, size):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])  # 填空处

    return dp[size - 1]

if __name__ == "__main__":
    nums1 = [1, 2, 3, 1]
    print(visit(nums1))

    nums2 = [2, 7, 9, 3, 1]
    print(visit(nums2))

    nums3 = [5]
    print(visit(nums3))

    nums4 = []
    print(visit(nums4))


A
dp [i] = dp [i - 1] + nums [i]
B
dp [i] = max (dp [i - 1], dp [i - 2] * nums [i])
C
dp [i] = max (dp [i - 1], dp [i - 2] + nums [i])
D
dp [i] = dp [i - 2] + nums [i]
答案与解析
正确答案:C
定义状态 dp[i] 表示前 i+1 间房子可获得的最大糖果数。初始化处理空数组和单个元素情况。dp[0] 为第一间房子的糖果数,dp[1] 为前两间中较大值。从第三间开始,每间房子有两种选择:不进入则继承 dp[i-1];进入则加上当前糖果数 nums[i] 并加上 dp[i-2]。状态转移需取两者最大值。遍历完成后,最后位置的 dp 值即为全局最优解。
题目详情
15 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 4.1 一维动态规划

元宵节晚上,小朋友沿着一条发光石板路前进,每次可以向前走1 块或2 块石板。若dp[i] = dp[i - 1]+ dp[i - 2],下面关于dp[i] 的含义最合适的是()。

A
走到第i 块石板的不同走法数量
B
走到第i 块石板时,已经走过的石板总数
C
从第i 块石板走回起点的最少步数
D
从第i 块石板走回起点的最大步数
答案与解析
正确答案:A
分析递推关系 dp[i] = dp[i-1] + dp[i-2] 的构成机制。当前状态的值由前两个状态的值相加得到,表明每一步的结果依赖于前两步结果的累积。考虑行走过程中的选择:到达第 i 块石板的方式可以从第 i-1 块走1步,或从第 i-2 块走2步。因此,到达第 i 块的路径数等于到达前两块石板路径数之和。该递推形式与路径计数问题中的状态转移一致,反映的是不同决策路径的叠加方式。
题目详情
16 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

在Python的面向对象编程中,下列关于“动态绑定(等效于虚函数)”的描述中,错误的是( )。

A

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

B

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

C

构造函数( __init__ )可以通过动态绑定实现多态以支持灵活初始化。

D

基类析构函数( __del__ )常保证子类调用其实现,以避免资源泄漏析构函数常声明为虚函数以避免资源泄漏。

答案与解析
正确答案:C
分析动态绑定在Python中的实现机制,重点考察方法调用时的运行时类型识别。理解基类引用指向子类实例时,方法查找遵循MRO规则,自动选择对应类中定义的方法版本。构造函数__init__在实例创建时由系统直接调用,不参与常规的方法解析流程。析构函数__del__在对象生命周期结束时由垃圾回收器触发,其调用链条依赖于Python的清理机制,不会强制要求基类显式声明为虚函数以确保派生类的清理代码执行。多态性体现在方法调用阶段,而非对象构造与销毁的隐式过程。
题目详情
17 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

执行如下代码,将输出 钢琴:叮咚叮咚 和 吉他:咚咚当当 而不是两行 乐器在演奏声音 ,这体现了面向对象编程的( )特性。

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

链接

答案与解析
正确答案:C
分析类之间的关系,观察基类定义的通用方法在子类中被重新实现的方式。确认对象调用同一方法时,根据实际类型执行不同行为的过程。关注程序运行时方法调用的动态绑定机制,即相同接口在不同实例上产生不同响应的现象。识别这种通过继承实现但体现为运行时行为差异的特征。
题目详情
18 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

执行下面代码,将输出( )。

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)
A
钢琴:叮咚叮咚 吉他:咚咚当当
B
乐器在演奏声音 乐器在演奏声音
C

编译错误

D

运行错误

答案与解析
正确答案:B
分析类的继承关系和方法重写机制。确定Instrument类中play方法被Piano和Guitar类各自重写。观察列表instruments中存储的是子类实例。遍历该列表时,通过inst获取每个对象,但调用的是父类Instrument的play方法,并将inst作为参数传入。该调用方式绕过子类的play方法,直接执行父类版本。需理解显式使用类名调用实例方法时,不会触发动态绑定,而是执行指定类中的方法实现。
题目详情
19 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 6.1 栈

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

A

A B

B

A B C

C

A B D

D

B C

答案与解析
正确答案:A
字符按输入顺序依次压入栈,每压入一个字符,栈顶元素更新为当前输入字符。当执行撤销操作时,每次弹出当前栈顶的一个字符,栈的大小减一,栈顶位置下移至前一个元素。连续两次撤销操作会连续移除最后两个入栈的字符。原输入序列为 A、B、C、D,表示这四个字符已按顺序完成入栈。在未发生任何弹出操作前,栈中自栈底到栈顶的元素依次为 A、B、C、D。每次弹出操作从栈顶移除一个元素,不改变剩余元素的相对顺序。连续执行两次弹出后,需确定此时栈中剩余的元素及其从栈底到栈顶的排列。
题目详情
20 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 6.2 队列

假设循环队列数组长度为 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)

答案与解析
正确答案:B
初始化时,front 和 rear 均为 1。每次入队操作执行 rear = (rear + 1) % N,每次出队操作执行 front = (front + 1) % N。根据给定的判断条件,队空为 front == rear,队满为 (rear + 1) % N == front。操作序列依次为:三次入队,一次出队,两次入队。每一步均依据当前 front 和 rear 的值,按对应公式更新其位置。所有计算在模 N 下进行,N 为数组长度 6。更新过程中需严格遵循操作顺序和取模规则。
题目详情