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 +=i
i+=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 1
return 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 n
return 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 x
x +=5
return x
def bar():
x = 5
return 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 1
return 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 1
return 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:
break
count += 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:
continue
print(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:
break
print(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。