Python 第一阶段测试题 答案及解析

Python 第一阶段测试题

1.（多选题，分值 2）以下能实现 1-100 偶数求和的有？（ABD）

A

sum=0
for i in range(2,101,2): sum+=i

B

sum=0
i=1
while i<=100:if i%2==0: sum +=ii+=1

Csum(range(1,101,2))
Dsum(i for i in range(1,101) if i%2==0)
解析：

• A：range(2,101,2)直接生成 2-100 的偶数，累加正确。
• B：while循环中，若i为偶数则累加，每次循环i递增1，逻辑正确。
• C：range(1,101,2)生成奇数，求和结果为奇数和，错误。
• D：生成器表达式筛选偶数后求和，正确。

2.（单选题，分值 1.5）print("Py"+"thon"[1:3])的输出是？(D)

A “Pyth”

B “Python”

C “Pyt”

D “Pyho”
解析：
thon对应的索引分别是0123，[1:3]表示从1开始到3结束（不包括3），所以最后是ho,再加上前面的Py，最后答案为Pyho，选D

3.（单选题分值1.5)列表a=[5,2,8,1]，执行a.sort(reverse=True)后，a的值是？(B)

A [1,2,5,8]

B [8,5,2,1]

C [5,2,8,1]

D [1,8,2,5]
解析：
a.sort(reverse=True)对列表原地降序排序，[5,2,8,1]降序后为[8,5,2,1]。

4.（判断题，分值 1）函数内部定义的局部变量，在函数调用结束后就会被销毁。(✔)
解析：
函数内局部变量仅在函数调用时存在，调用结束后被销毁。

5.（单选题，分值 1.5）以下代码的输出结果是？（C）

def recursive(n):if n==0:return 1return n * recursive(n -1)//2
print(recursive(5))

A 120
B 60
C 0
D 报错
解析：
若假设代码缩进正确（return n * recursive(n -1)//2与if语句对齐），计算过程为：
recursive(5) = 5 * recursive(4) // 2
recursive(4) = 4 * recursive(3) // 2
recursive(3) = 3 * recursive(2) // 2
recursive(2) = 2 * recursive(1) // 2
recursive(1) = 1 * recursive(0) // 2 = 1 * 1 // 2 = 0
逐步回溯可得结果为0，因此正确答案为 C。

6.（多选题，分值 2）以下哪些代码可以正确地创建一个包含 1 到 5 的列表？(ABD)
A list(range(1,6))
B [x for x in range(1,6)]
C list(12345)
D [int(x) for x in "12345"]
解析：

• A：range(1,6)生成 1-5，转为列表正确。
• B：列表推导式遍历 1-5，正确。
• C：list(12345)报错（整数不可迭代），错误。
• D：将字符串 "12345"每个字符转为整数，正确。

7.（多选题，分值 2）以下哪些代码会产生异常？(ABCD)

A print([1,2,3][3])

B print(1/0)

C print(int('abc',11))

D print(len(None))
解析：

• A：[1,2,3][3]访问索引 3（列表最大索引为 2），触发IndexError，产生异常。
• B：1/0除数为0，触发ZeroDivisionError，产生异常。
• C：int(‘abc’, 11)中，11 进制的有效字符范围是 0-10（对应 ‘a’），而’b’在 11 进制中代表 11，超出基数范围（基数为 11 时，最大数字为 10），实际会触发ValueError: invalid literal for int() with base 11: ‘abc’，产生异常。
• D：len(None)中，None不是可迭代对象，无__len__方法，触发TypeError，产生异常。

8.（单选题，分值 1.5）以下代码的输出结果是什么？（A）

list1 = [1,2,3]
list2 = [4,5,6]
print([x * y for x in list1 for y in list2])

A [4,5,6,8,10,12,12,15,18]

B [[4,5,6],[8,10,12],[12,15,18]]

C [4,8,12,5,10,15,6,12,18]

D [1,2,3,4,5,6]
解析：
列表推导式 [x * y for x in list1 for y in list2] 逻辑是：
遍历 list1 中每个 x ，再遍历 list2 中每个 y ，计算 x * y 。
list1 = [1,2,3]，list2 = [4,5,6] 。
当 x=1 时，y 取 4、5、6 → 14=4，15=5，16=6 。
当 x=2 时，y 取 4、5、6 → 24=8，25=10，26=12 。
当 x=3 时，y 取 4、5、6 → 34=12，35=15，3*6=18 。
结果列表为 [4,5,6,8,10,12,12,15,18] ，对应选项 A 。

9.（单选题，分值 1.5）以下代码的输出结果是什么？(B)

def func(n):if n <= 1:return nreturn func(n-1)+func(n-2)
print(func(4))

A 2

B 3

C 4

D 5
解析：
func(n)计算斐波那契数列第 n 项
func(4) = func(3) + func(2) = (func(2)+func(1)) + (func(1)+func(0)) = (1+1)+(1+0) = 3。

10.（单选题，分值 1.5）以下代码的输出结果是什么？ ( C )

x = 10
def foo():global xx +=5return x
def bar():x = 5return foo()
print(bar())

A 5

B 10

C 15

D 报错
解析：
foo()中用global声明x为全局变量，调用foo()时x从 10 变为 15；bar()中局部变量x=5不影响全局，最终输出 15。

11.（判断题，分值 1）if x:中的x可以是任意 Python 对象。(✔)
解析：
Python 中任何对象都可作为if条件，非零 / 非空对象为True，否则为False。

12（判断题，分值 1）a = [1,2]和b = [1,2]使a和b指向同一对象。(✖)
解析：
a = [1,2]和b = [1,2]创建两个独立列表对象，a is b结果为False。

13.（判断题，分值 1）列表的remove()方法通过索引删除元素。(✖)
解析：
remove()通过值删除第一个匹配元素，pop()通过索引删除。

14.（多选题，分值 2）关于列表切片a = [1,2,3,4,5]，正确的有？(ABCD)

A a[1:3] → [2,3]

B a[ : 3]→[1,2,3]

C a[-1] → 5

D a[::2] → [1,3,5]
解析：

• A：a[1:3]取索引 1-2，结果[2,3]。
• B：a[:3]取开头到索引 2，结果[1,2,3]。
• C：a[-1]取最后一个元素 5。
• D：a[::2]步长为 2，取[1,3,5]。

15.（多选题，分值 2）if-elif-else结构的特点有？(ABD)

A 可以有多个elif

B else必须放在最后

C 所有分支都会被执行

D 只能有一个分支被执行
解析：

• A：可包含多个elif分支。
• B：else必须在最后（可选）。
• C：仅第一个满足条件的分支执行，错误。
• D：分支互斥，仅一个执行。

16.（多选题，分值 2）以下输入转换正确的有？(ABC)

A int("12") → 12

B float("3.14") → 3.14

C str(100) → "100"

D list(123) → [1,2,3]
解析：
D：list(123)报错（整数不可迭代），错误。

17.（多选题，分值 2）以下递归函数可能陷入无限递归的有？(AC)

A

 def f(n): return n*f(n-1)

B

 def f(n): if n ==0: return 1return n*f(n-1)

C

 def f(n): return f(n)

D

def f(n):if n>0: return f(n-1)

解析：

• A：无终止条件，递归调用f(n-1)会无限进行（直到栈溢出）。
• B：有n==0的终止条件，正确递归。
• C：直接调用f(n)，无终止，无限递归。
• D：当n<=0时无返回，但不会无限递归（仅对n>0递归）。

18.（多选题，分值 2）以下能跳出循环的语句有？(AC)

A break

B continue

C return

D pass
解析：

• A：break直接终止循环。
• B：continue跳过当前循环，进入下一次。
• C：return在函数中直接返回，终止循环。
• D：pass仅占位，不影响循环。

19.（判断题，分值 1）Python 中的列表切片操作list[1:]会返回索引为 1 和 3 的元素。(✖)
解析：
list[1:]返回从索引 1 到末尾的所有元素，而非仅索引 1 和 3。

20.（判断题，分值 1）在 Python 中，函数内部定义的变量默认是全局变量。(✖)
解析：
函数内变量默认是局部变量，需用global声明为全局变量。

21.（判断题，分值 1）Python 中的列表可以包含不同类型的元素。(✔)
解析：
Python 列表可包含不同类型元素（如[1, “a”, True]）。

22.（判断题，分值 1）在 Python 中，a is b和a == b的含义完全相同。(✖)
解析：
a is b判断是否为同一对象（内存地址），a == b判断值是否相等。

23.（判断题，分值 1）Python 中的字符串是不可变类型，一旦创建就不能修改。(✔)
解析：
字符串创建后不能修改单个字符（如s[0] = 'a’报错）。

24.（判断题，分值 1）Python 中的变量不需要声明类型，可以直接赋值使用。(✔)
解析：
Python 是动态类型语言，变量无需声明类型，直接赋值即可。

25.（多选题，分值 2）在 Python 中，以下哪些方法可以用于获取列表的元素？(ACD)

A list[index]

B list.get(index)

C list.pop(index)

D list[start:end]
解析：

• A：list[index]通过索引访问，正确。
• B：列表无get()方法（字典有），错误。
• C：pop(index)删除并返回指定索引元素，正确。
• D：切片list[start:end]返回子列表，正确。

26.（多选题，分值 2）在 Python 中，以下哪些是列表的合法操作？(ABD)

A [1,2] + [3,4]

B [1,2] * 2

C [1,2] - [1]

D [1,2,3][1:]
解析：

• A：+用于列表拼接，正确。
• B：*用于重复列表，正确。
• C：列表不支持-操作，错误。
• D：切片操作合法，正确。

27.（多选题，分值 2）以下哪些是 Python 中的基本数据类型？(ABD)

A 整数（int）

B 浮点数（float）

C 数组（array）

D 字符串（str）
解析：

• A：整数（int）是基本类型。
• B：浮点数（float）是基本类型。
• C：数组（array）需导入模块，非基本类型。
• D：字符串（str）是基本类型。

28.（多选题，分值 2）关于 Python 变量，以下说法正确的是？(ABCD)

A 变量无需声明类型

B 变量存储的是对象的引用

C 不可变对象无法修改

D 可变对象的修改会影响所有引用
解析：

• A：变量无需声明类型，正确。
• B：变量存储对象引用，正确。
• C：不可变对象（如字符串）本身不可修改,正确。
• D：可变对象（如列表）修改后，所有引用该对象的变量都会受影响，正确。

29.（单选题，分值 1.5）以下代码的输出结果是？（B）

def func(n):if n == 0:return []else:return func(n-1) + \[n]
print(func(3))

A [3,2,1]

B [1,2,3]

C [0,1,2,3]

D 抛出异常
解析：
func(3) = func(2) + [3]，func(2) = func(1) + [2]，func(1) = func(0) + [1]，func(0) = []，最终结果[1,2,3]。

30.（多选题，分值 2）关于递归函数，以下说法正确的是？(ACD)

A 递归函数必须有终止条件

B 递归函数效率一定高于循环

C 递归过深可能导致栈溢出

D 所有递归函数都可以转化为循环
解析：

• A：递归必须有终止条件，否则无限递归，正确。
• B：递归效率通常低于循环（有栈开销），错误。
• C：递归过深会导致栈溢出（如RecursionError），正确。
• D：所有递归都可转为循环，正确。

31.（多选题，分值 2）关于变量作用域，以下说法正确的是？(ACD)

A 全局变量可以在函数内部直接访问

B 局部变量可以在函数外部访问

C global关键字用于在函数内部修改全局变量

D 函数内部定义的变量默认是局部变量
解析：

• A：全局变量可在函数内直接访问（除非被局部变量遮蔽），正确。
• B：局部变量仅在函数内有效，错误。
• C：global用于在函数内修改全局变量，正确。
• D：函数内变量默认是局部变量，正确。

32.（多选题，分值 2）以下代码中，哪些会修改原列表？(ACD)

A lst.append(1)

B lst = lst + [1]

C lst.extend([1])

D lst.insert(8, 1)
解析：

• A：append()原地添加元素，修改原列表。
• B：lst = lst + [1]创建新列表赋值给lst，原列表不变。
• C：extend()原地扩展列表，修改原列表。
• D：insert()原地插入元素，修改原列表。

33.（单选题，分值 1.5）运行以下代码，输出结果是？(B)

x = [1,2]
def func():x = [3,4]x.append(5)print(x)
func()
print(x)

A [3,4,5][3,4,5]

B [3,4,5][1,2]

C [1,2,5][1,2,5]

D [1,2][1,2]
解析：
func()中x = [3,4]是局部变量，修改后打印[3,4,5]；全局变量x仍为[1,2]。

34.（单选题，分值 1.5）运行以下代码，输出结果是？(D)

x = 10
def func():print(x)x=20
func()
print(x)

A 10 20

B 20 20

C 10 10

D 抛出异常
解析：
函数内先打印x再赋值x=20，Python 认为x是局部变量，但打印时未定义，触发UnboundLocalError。

35.（单选题，分值 1.5）运行以下代码，输出结果为？(D)

a, b, c, d = 1, 2, 3, 4
c, d, a, b = d, b, a, c
print(a, b, c, d)

A 1 3 2 4

B 1 2 4 3

C 1 4 2 3

D 1 3 4 2
解析：
初始a=1, b=2, c=3, d=4，赋值后：
c = d=4，d = b=2，a = a=1，b = c=3，最终a=1, b=3, c=4, d=2。

36.（单选题，分值 1.5）以下代码的输出结果是？(B)

def flatten(lst):result = []for sub in lst:for num in sub:result.append(num)return result
nested = [[1,2], [3,4]]
print(flatten(nested))

A [[1, 2, 3, 4]]
B [1,2,3,4]
C [1, 2, [3,4]]
D 抛出异常
解析：
lst 是传入的 nested = [[1,2], [3,4]]，第一次取 sub = [1,2]，第二次取 sub = [3,4] 。
当 sub = [1,2] 时，内层循环取 num = 1 → result.append(1)；取 num = 2 → result.append(2) ，此时 result = [1,2] 。
当 sub = [3,4] 时，内层循环取 num = 3 → result.append(3)；取 num = 4 → result.append(4) ，此时 result = [1,2,3,4] 。
循环结束后，return result 返回 [1,2,3,4] ，print(flatten(nested)) 输出该列表。

37.（单选题，分值 1.5）以下代码的输出结果是？( C )

def process(lst):lst = lst + [4]return lst
original = [1,2,3]
modified = process(original)
print(original, modified)

A [1,2,3] [1,2,3]

B [1,2,3,4] [1,2,3,4]

C [1,2,3,] [1,2,3,4]

D 抛出异常
解析：

函数 process(lst) 接收参数 lst 后，执行 lst = lst + [4]。这里的 + 运算符用于列表拼接，会创建一个新的列表对象（原列表 lst 与 [4] 拼接的结果），并将新列表赋值给局部变量 lst。
原列表 original = [1,2,3] 并未被修改，因为拼接操作不会影响原始对象，只是创建了新对象。
函数返回新列表 [1,2,3,4]，赋值给 modified。因此，print(original, modified) 输出
[1,2,3] [1,2,3,4]。

38.（单选题，分值 1.5）以下代码的输出结果是？()

def double(lst):new_lst = []for num in lst:new_lst.append(num * 2)return new_lst
nums = [1,2,3]
result = double(nums)
print(nums, result)

A [1,2,3] [1,2,3]

B [1,2,3] [2,4,6]

C [2,4,6] [2,4,6]

D 抛出异常
解析：
double()返回新列表[2,4,6]，原列表nums不变。

39.（单选题，分值 1.5）以下代码的输出结果是？( C )

lst = [1,2,3]
new_lst = []
for num in lst:new_lst.insert(0, num * 2)
print(new_lst)

A [2,4,6]

B [2,6,12]

C [6,4,2]

D [12,6,2]
解析：
insert(0, num2)在列表头部插入元素：插入12=2 → [2]；插入22=4 → [4,2]；插入32=6 → [6,4,2]。

40.（单选题，分值 1.5）运行以下代码，输出结果是？(A)

lst = [1,2,3]
for i in range(1,len(lst)):lst[i] = lst[i-1] + lst[i]
print(lst)

A [1,3,6]

B [1,3,5]

C[1,2,6]

D[1,2,5]
解析：
初始 lst = [1,2,3]，len(lst)=3，range(1, 3) 得到 i = 1 和 i = 2。
当 i = 1 时：lst[1] = lst[0]+lst[1] = 1 + 2 = 3，此时 lst = [1, 3, 3]。
当 i = 2 时：lst[2] = lst[1]+lst[2] = 3 + 3 = 6，此时 lst = [1, 3, 6]。

41.（单选题，分值 1.5）以下代码的输出结果是？(D)

lst = [1,2,3]
for i in lst:lst.pop(0)
print(lst)

A []
B [1, 2, 3]
C [2,3]
D [3]
解析：
列表 lst = [1,2,3]，for 循环会迭代列表中的元素，共计划迭代 3 次（因初始长度为 3 ）。
第一次循环:迭代变量 i 取列表第一个元素1。执行 lst.pop(0) ，移除列表第一个元素 1 ，列表变为 [2,3] 。
第二次循环:迭代器按初始长度继续取第二个元素，此时列表已改变，实际取到的是 2（原列表第二个元素，现列表第一个元素 ）。执行 lst.pop(0) ，移除列表第一个元素 2 ，列表变为 [3] 。
第三次循环:迭代器本应取第三个元素，但此时列表长度已变为 1 ，迭代终止 。
42.（单选题，分值 1.5）运行以下代码，输出结果是？( C )

lst = [1,2,3]
result = []
for num in lst:if num > 1:result.append(num * 2)
print(result)

A [ ]

B [2]

C [4，6]

D [2,4,6]
解析：
筛选num>1的元素（2,3），翻倍后为[4,6]。

43.（单选题，分值 1.5）以下代码的输出结果是？(B)

lst = [1,2,3]
for num in lst:num *= 2
print(lst)

A [2,4,6]

B [1,2,3]

C [4,8,12]

D 抛出异常
解析：
num *= 2仅修改循环变量，不影响原列表lst，仍为[1,2,3]。

44.（单选题，分值 1.5）以下代码的输出结果是？(D)

lst = [1,2,3]
lst.append([4,5])
lst.extend([6,7])
lst.insert(8,9)
print(lst)

A [1,2,3,4,5,6,7,9]

B [1,2,3,[4,5,8,9],6,7]

C [1,2,3,6,7,[4,5],9]

D [1,2,3,[4,5],6,7,9]
解析：
append([4,5])添加子列表 → [1,2,3,[4,5]]；extend([6,7])添加元素 → [1,2,3,[4,5],6,7]；insert(8,9)在索引 8 插入 9（当前长度为 6，索引 8 等价于末尾）→ [1,2,3,[4,5],6,7,9]。

45.（单选题，分值 1.5）运行以下代码，输出结果是？(B)

matrix = [[0] * 2] * 3
matrix[0][0] = 1
print(matrix)

A [[1,0], [0,0], [0,0]]

B [[1,0], [1,0], [1,0]]

C [[1,1], [1,1], [1,1]]

D 抛出异常
解析：
[[0]*2]*3创建 3 个引用同一子列表的列表，修改matrix[0][0]会影响所有子列表，结果[[1,0],[1,0],[1,0]]。

46.（单选题，分值 1.5）以下代码的输出结果是？（ C ）

def func(a, b):return a + b, a * b
sum, product = func(3, 4)
print(sum, product)

A 12 7

B 3 4

C 7 12

D 抛出异常
解析：
func(3,4)返回(7, 12)，分别赋值给sum和product，输出7 12。

47.（单选题，分值 1.5）以下关于 Python 函数的说法，错误的是？(B)

A 函数可以返回多个值

B 函数必须有参数

C 函数可以作为参数传递给其他函数

D 函数可以嵌套定义
解析：
函数可以没有参数（如def func(): pass），B 错误。

48.（单选题，分值 1.5）运行以下递归函数，输出结果是？(B)

def factorial(n):if n == 0:return 1return n * factorial(n - 1)
print(factorial(3))

A 3

B 6

C 9

D 抛出 RecursionError
解析：
factorial(3) = 3*2*1 = 6。

49.（单选题，分值 1.5）运行以下代码，输出结果是？(B)

def modify_list(lst):lst.append(4)my_list = [1,2,3]
modify_list(my_list)
print(my_list)

A [1,2,3]

B [1,2,3,4]

C [4]

D 抛出异常
解析：
modify_list()通过引用修改原列表，添加 4 后my_list变为[1,2,3,4]。

50.（单选题，分值 1.5）运行以下代码，输出结果是？(B)

result = []
for i in range(3):inner_list = []for j in range(2):inner_list.append(i + j)result.append(inner_list)
print(result)

A [[0,1,2], [1,2,3], [2,3,4]]

B [[0,1], [1,2], [2,3]]

C [[0,1], [2,3], [4,5]]

D [[0,1,2], [0,1,2], [0,1,2]]
解析：
外层循环i=0,1,2，内层循环j=0,1，i+j分别为0+0=0,0+1=1；1+0=1,1+1=2 2+0=2,2+1=3，结果[[0,1],[1,2],[2,3]]。

51.（单选题，分值 1.5）运行以下代码，输出结果是？(D)

nums = [1,2,3,4,5]
i = 0
while i < len(nums):if nums[i] % 2 == 0:nums.pop(i)else:i += 1
print(nums)

A [3,4,5]

B [2,3,5]

C [1,3,4]

D [1,3,5]
解析：

遍历列表，删除偶数：
i=0（1 是奇数，i=1）；i=1（2 是偶数，删除后列表为[1,3,4,5]，i不变）；i=1（4 是偶数，删除后列表为[1,3,5]，i不变）；最终[1,3,5]。

52.（单选题，分值 1.5）运行以下代码，输出结果是？（C）

count = 0
for i in range(5):for j in range(3):if i == 2 and j == 1:breakcount += 1
print(count)

A 15

B 14

C 13

D 12
解析：
先看循环结构：外层 for i in range(5) 会让 i 取 0、1、2、3、4 ，共 5 轮；内层 for j in range(3) 让 j 取 0、1、2 ，每轮外层循环对应 3 次内层循环尝试。
再看特殊情况：当 i = 2 且 j = 1 时，触发 break ，会提前终止当前 i=2 时的内层循环。
接着统计 count += 1 执行次数：
i = 0 时，内层 j 正常走 0、1、2 ，count 加 3 次。
i = 1 时，同理，count 加 3 次。
i = 2 时，j = 0 执行 count += 1；j = 1 触发 break，j = 2 不执行，仅加 1 次。
i = 3 时，内层正常，count 加 3 次。
i = 4 时，内层正常，count 加 3 次。
最后计算总和：3 + 3 + 1 + 3 + 3 = 13 ，所以输出 count 为 13 ，选 C 。

53.（单选题，分值 1.5）有如下代码，要使程序输出 1 到 100（包含 100）中所有能被 3 整除的数的和，空白处应填写？(A)

sum_num = 0
for i in range(1, 101):_______sum_num += i
print(sum_num)

A if i % 3 == 0:

B if i % 3 != 0:

C while i % 3 == 0:

D while i % 3 != 0:
解析：
需累加能被 3 整除的数，条件为i % 3 == 0。

54.（单选题，分值 1.5）以下代码的输出结果是？(D)

for i in range(1,6,2):print(i,end=' ')if i == 3:continueprint(i + 1, end='')

A 1 2 3 4 5

B 1 2 3 4

C 1 2 4 5 6

D 1 2 3 5 6
解析：
range(1,6,2) 生成序列 1,3,5 ，循环三次，i 依次为 1、3、5 。
i=1：先 print(1,end=' ') 输出 1 ，再 print(1 + 1, end='') 输出 2 。
i=3：先 print(3,end=' ') 输出 3 ，因 if i == 3 触发 continue ，跳过 print(i + 1...) 。
i=5：先 print(5,end=' ') 输出 5 ，再 print(5 + 1, end='') 输出 6 。
最终输出拼接为 1 2 3 5 6 ，选 D 。

55.（单选题，分值 1.5）以下关于 Python 中 for 循环和 while 循环的说法，错误的是？( C )

A for 循环通常用于遍历序列（如列表、元组、字符串等），while 循环通常用于条件判断循环
B for 循环的循环次数在循环开始前通常是确定的，而 while 循环的循环次数可能在循环开始时不确定
C for 循环不能实现无限循环，而 while 循环可以通过设置合适的条件实现无限循环
D for 循环和 while 循环都可以使用 break 和 continue 语句来控制循环流程
解析：
for循环可通过while True实现无限循环（如for _ in iter(int, 1):)，C 错误。

56.（单选题，分值 1.5）以下代码的输出结果是？(B)

for i in range(5):if i == 3:breakprint(i, end='')
else:print("else")

A 012else

B 012

C 01234

D 01234else
解析：
i=3时break，循环提前终止，else不执行，仅打印012。

57.（单选题，分值 1.5）以下表达式结果为 0 的是？(D)

A 5 & 3

B 5 | 3

C 5 << 3

D 5 >> 3
解析：

• A：5 & 3 = 1（二进制101 & 011 = 001）
• B：5 | 3 = 7（101 | 011 = 111）
• C：5 << 3= 40（左移 3 位）
• D：5 >> 3 = 0（右移 3 位，101 → 000）

58.（单选题，分值 1.5）运行以下代码，输出结果是？(A)

a = 5
b = 3
print(a & b, a | b, a ^ b)

A 1 7 6

B 0 7 6

C 1 6 7

D 0 6 7
解析：
5&3=1，5|3=7，5^3=6。

59.（单选题，分值 1.5）运行以下代码，输出结果是？（A）

a = False
b = True
print(a and b or not a and not b)

A True

B False

C 抛出异常

D 无法确定
解析：
a=False, b=True，计算：a and b = False；not a and not b = True and False = False；False or False = False。

60.（单选题，分值 1.5）运行以下代码，输出结果是？( C )

a = [1,2]
b = [1,2]
print(a is b, a == b)

A True True

B True False

C False True

D False False
解析：
a和b是不同对象（a is b → False），但值相等（a == b → True）。

61.（单选题，分值 1.5）运行以下代码，输出结果是？(B)

a = 5 // 2
b = 5 / 2
c = 5 % 2
print(a + b + c)

A 5.0

B 5.5

C 6.0

D 6.5
解析：
a=5//2=2，b=5/2=2.5，c=5%2=1，总和2+2.5+1=5.5

62.（单选题，分值 1.5）以下代码输出结果是？(B)

b = 0.3
a = 0.1 + 0.2
print(a == b)

A True

B False

C 抛出 TypeError

D 随机结果
解析：
0.1 + 0.2 = 0.30000000000000004，与0.3不相等。

63.（单选题，分值 1.5）运行以下代码，输出结果是？(D)

a = [1,2,3]
b = a
c = a[:]
d = [1,2,3]
a.append(4)
c[0] = 0
d[1] = 9
print(a, b, c, d)

A [1,2,3] [1,2,3,4] [0,2,3] [1,2,3]

B [1,2,3,4] [1,2,3,4] [0,2,3] [1,2,3]

C [1,2,3] [1,2,3,4] [0,2,3] [1,9,3]

D [1,2,3,4] [1,2,3,4] [0,2,3] [1,9,3]
解析：
b = a ，b 和 a 指向同一列表对象，a.append(4) 会同时改变 a 和 b ，所以 a 和 b 最终为 [1,2,3,4] 。
c = a[:] ，c 是 a 的浅拷贝，独立于 a ，c[0] = 0 只改变 c ，c 变为 [0,2,3] 。
d = [1,2,3] 是独立列表，d[1] = 9 使其变为 [1,9,3] 。

64.（单选题，分值 1.5）执行以下代码后，b 的值是什么？（B）

a = [1,2,[3,4]]
b = a
a[2][0] = 999
print(b)

A [1,2,[3,4]]

B [1,2,[999,4]]

C [1,2,999]

D 代码报错
解析：
b与a引用同一列表，修改a[2][0]（子列表元素），b同步变化为[1,2,[999,4]]。

65.（单选题，分值 1.5）以下代码的输出是什么？( C )

s = "Python"
s[0] = "j"
print(s)

A Python
B Jython
C 代码抛出 TypeError
D 代码抛出 SyntaxError
解析：
字符串是不可变类型，修改单个字符触发TypeError。