大学计算机基础选择题详解(四)

文档下载: 大学计算机基础选择题详解(四).pdf

1. 对于序列 s，能够返回序列 s 中第 i 到 j（不包括 j）以 k 为步长的元素子序列的表达是（ D ）。

• A. s[i;j;k]
• B. s(i,j,k)
• C. s[i,j,k]
• D. s[i:j:k]

Python 的切片使用的是冒号：
s[i:j:k] i 是切片的起始索引（包含），j 是切片的结束索引（不包含），k 是步长。

2. 下面代码的输出结果是（ A ）

list1 = []
for i in range(1,11):
    list1.append(i**2)
print(list1)

• A. [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
• B. [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
• C. 错误
• D. [1,2,3,4,5,6,7,8,9,10]

for i in range(1,11): #循环从 1 到 10, 赋值给 i
list1.append(i**2) #把 i 的平方放入 list1 也就是 list1 中放入的是 1 到 10 的平方

3. 下面代码的输出结果是（ A ）

a=[9,6,4,5]
N=len(a)
for i in range(int(len(a)/2)):
    a[i],a[N-1-i]=a[N-1-i],a[i]
print(a)

• A. [5,4,6,9]
• B. [9,4,6,5]
• C. [5,6,9,4]
• D. [9,6,5,4]

a=[9,6,4,5] #初始化列表, 也就是 C 语言的数组
N=len(a) # 变量 N 被赋值为列表的长度,也就是 4 int(len(a)/2) 即: int(4/2) 即: for i in range(2) 即 i 赋值为 0、1
for i in range(int(len(a)/2)):
    a[i],a[N-1-i]=a[N-1-i],a[i]
print(a)
当 i = 0 时：
a[0], a[N - 1 - 0] = a[N - 1 - 0], a[0]
即 a[0], a[3] = a[3], a[0]
执行后，a = [5, 6, 4, 9]
当 i = 1 时：
a[1], a[N - 1 - 1] = a[N - 1 - 1], a[1]
即 a[1], a[2] = a[2], a[1]
执行后，a = [5, 4, 6, 9]

4. 给定字典 d,以下选项中对 x in d 的描述正确的是（ C ）。

• A. x 是一个二元元组,判断 x 是否是字典 d 中的键值对
• B. 判断 x 是否是在字典 d 中以键或值方式存在
• C. 判断 x 是否是字典 d 中的键
• D. 判断 x 是否是字典 d 中的值

字典是以键值对(key : value)为元素构成的集合,例如:
person = {‘name’: ‘张三’, ‘age’: 20}
x in person , 是判断字典中是否有指定的 key

5. 下面代码的输出结果是（ A ）。

list1 = [(m,n) for m in 'AB' for n in 'CD']
print(list1)

• A. [(‘A’, ‘C’), (‘A’, ‘D’), (‘B’, ‘C’), (‘B’, ‘D’)]
• B. [‘A’,’B’,’C’,’D’]
• C. 错误
• D. *[‘AC’, ‘AD’, ‘BC’, ‘BD’]

下面代码的输出结果分析如下：
list1 = [(m,n) for m in ‘AB’ for n in ‘CD’]
print(list1)
这段代码使用了列表推导式来生成一个列表。对于字符>串 ‘AB’ 中的每个字符 m，以及字符串 ‘CD’ 中的每个字
符 n，它都会生成一个元组 (m, n) 并将其添加到列表中。
让我们逐步分析：
当 m = ‘A’ 时：
n = ‘C’ 生成元组 (‘A’, ‘C’)
n = ‘D’ 生成元组 (‘A’, ‘D’)
当 m = ‘B’ 时：
n = ‘C’ 生成元组 (‘B’, ‘C’)
n = ‘D’ 生成元组 (‘B’, ‘D’)
因此，最终生成的列表是：
[(‘A’, ‘C’), (‘A’, ‘D’), (‘B’, ‘C’),(‘B’, ‘D’)]
现在，我们对比选项：
A. [(‘A’, ‘C’), (‘A’, ‘D’), (‘B’, ‘C’), (‘B’, ‘D’)] 正确
B. [‘A’,‘B’,‘C’,‘D’] - 错误，这不是元组列表，且缺少组合。
C. 错误 - 代码没有语法错误，因此这个选项不正确。
D. *[‘AC’, ‘AD’, ‘BC’, ‘BD’] - 错误，这看起来像是尝试解包列表，但列表中的元素是字符串而不是元组，且原代码
生成的是元组。
所以，正确答案是：
A. [(‘A’, ‘C’), (‘A’, ‘D’), (‘B’, ‘C’), (‘B’, ‘D’)]

6. 在下列选项中，（ ACD）为空列表。

• A. [ ]
• B. list(“AB”)
• C. list(( ))
• D. list()

A. [ ] – 直接定义空列表√
B. list(“AB”) – list 函数把字符串"AB"转换为字符列表,即 [‘A’,‘B’], 非空∴×
C. list(( )) – 将一个空元组 () 转换为一个列表
D. list() – 函数调用没有参数，根据 Python 的 list构造函数，它会返回一个空列表 []。

7. 在下列选项中，（ ABC）与集合{1,2}相等。

• A. {2,1} – 集合无序, 完全等价于{1,2}
• B. {2,1,1} – 集合非重，虽然里面放了两个 1，实际上只存一个
• C. {1,2,1} – 集合非重无序，同 B
• D. {2,0}

• A. {2,1} – 集合无序, 完全等价于{1,2}
• B. {2,1,1} – 集合非重，虽然里面放了两个 1，实际上只存一个
• C. {1,2,1} – 集合非重无序，同 B
• D. {2,0}

Python中数据类型总结:

数据类型	示例	是否可重	是否可增删改	是否有序
列表[ ]	list =[1,2,3]	元素可重	可增删改	有序
字典{xx :yy}	person ={name:’张三’,age:20}	key 非重	可增删改	无序
元祖( )	tuple =(1,2,3)	可重，即不可变的列表	不可增删改	有序
集合{1,2,3}	set = {1,2,3}	非重	可增删改	无序

8. 下列关于 Python 语言中列表的说法中，正确的是（ ABC）。

• A. 同一列表中的元素可以重复
• B. 列表中的元素的下标可以是负数
• C. 列表的元素在一对方括号之间，用逗号分隔开
• D. 同一列表中的类型是相同的

• A. 同一列表中的元素可以重复√
  Python 列表允许包含重复的元素。例如：[1, 2, 3, 2] 是一个有效的列表，其中元素 2 重复了。
• B. 列表中的元素的下标可以是负数√
  在 Python 中，负数索引用于从列表的末尾开始计数。例如，
  索引 -1 表示列表的最后一个元素，索引 -2 表示倒数第二个元素，依此类推。
• C. 列表的元素在一对方括号之间，用逗号分隔开√
  列表的定义就是使用方括号 [] 来包含元素，元素之间用逗号, 分隔。例如：[1, 2, 3] 是一个列表。
• D. 同一列表中的类型是相同的×
  Python 列表是动态类型的，即列表中的元素可以是不同类型的。
  例如：[1, “hello”, 3.14] 是一个有效的列表，它包含了整数、字符串和浮点数。

9. 若

alist1=[“apple”,“banana”,“orange”],
alist2=[“pear”,“peach”,“watermelon”]，想要合并为一个列表
[“apple”,“banana”,“orange”,“pear”,“peach”,“watermelon”]，
下列正确的是（ CD ）。

• A. alist1.append(alist2)
• B. alist1.pop(alist2)
• C. print(alist1+alist2)
• D. alist1.extend(alist2)

• A. alist1.append(alist2)
  这个方法会将 alist2 作为单个元素添加到 alist1 的末尾，而不是将alist2 中的元素逐个添加到 alist1 中。
  因此，结果会是
  [“apple”, “banana”,“orange”,[“pear”,“peach”,“watermelon”]]。
• B. alist1.pop(alist2)
  pop 方法用于移除列表中的元素，并返回该元素的值。它接受一个索引作为参数，而不是另一个列表。
  因此，这个选项会导致一个类型错误，因为 alist2 不是一个有效的索引。
• C. print(alist1+alist2)
  这个表达式会正确地合并两个列表，并打印出结果 [“apple”,“banana”, “orange”, “pear”, “peach”, “watermelon”]。>但是，它不会修改 alist1 或 alist2，而是创建一个新的合并后的列表并打印出来。
  如果你想要合并后的结果保存在一个变量中，你需要显式地赋值，
  如 merged_list = alist1 + alist2。
• D. alist1.extend(alist2)
  这个方法会将 alist2 中的所有元素添加到 alist1 的末尾，这正是你想要的结果。
  alist1 会被修改为 [“apple”, “banana”,“orange”, “pear”, “peach”, “watermelon”]。

10. 针对以下代码，说法正确的是（ BCD）。

a={‘name’:‘Alice’,‘detail’:[{‘age’: 18, ‘job’: ‘tester’}, ‘man’]}
b=[‘name’, ‘detail’, 18]
c=([‘name’, ‘detail’], [{‘age’: 18, ‘job’: ‘tester’}, ‘man’])
if a[‘name’]:
for i in b:
print(len( c ), i, c[-1])

• A. 列表 b 定义错误
• B. 程序打印结果中存在二个固定值
• C. 程序会打印三行数据
• D. 元组 c 中的’tester’可以被修改

• A. ‌列表 b 定义错误‌
  列表 b 的定义是合法的，它包含了三个元素：两个字符串 ‘name’ 和 ‘detail’，以及一个整数 18。
  因此，A 选项是错误的。
• B. ‌程序打印结果中存在二个固定值‌
  在循环中，len© 和 c[-1] 的值是固定的。
  len© 计算的是元组 c 的长度，它始终为 2（因为 c 包含两个元素）。
  c[-1] 指的是元组 c 的最后一个元素，它始终为 [{‘age’: 18, ‘job’: ‘tester’}, ‘man’]。
  因此，B 选项是正确的。
• C. ‌程序会打印三行数据‌
  列表 b 有三个元素，for 循环会遍历这三个元素，并且每次循环都会执行 print 语句。
  因此，程序会打印三行数据。
  所以，C 选项是正确的。
• D. ‌元组 c 中的’tester’可以被修改‌
  虽然元组 c 本身是不可变的，但是元组中包含的列表是可变的。
  列表中的字典有一个键 ‘job’，其对应的值是 ‘tester’。
  这个字典值是可以被修改的（例如，通过 c[‘job’] = ‘new_job’）。
  因此，尽管元组 c 本身不能修改，但它包含的列表中的字典值是可以修改的。
  所以，D 选项也是正确的。
  综上所述，正确的选项是 B、C 和 D。

11. Python 集合不支持使用下标访问其中的元素。（ B ）

• A. 错
• B. 对

这里说的 Python 集合，指的是 set，也就是类似于｛1,2,3｝这样的结构，其特点是①无序②唯一（非重）
因为无序，也就无法用下标访问

12. 假设 x 是含有 5 个元素的列表，那么切片操作 x[10:]是无法执行的，会抛出异常。（ B ）

• A. 对
• B. 错

列表切片操作允许我们获取列表的一个子列表。
切片的基本形式是 list[start:stop:step]，其中
start 是起始索引（包含），
stop 是结束索引（不包含），
step 是步长（可选）
x 是一个含有 5 个元素的列表，其索引范围是 0 到 4（包含）。
切片操作 x[10:] 尝试从索引 10 开始获取子列表，实际操作的结果输出的是空列表

x=[1,2,3,4,5];print(x[10:])
[]

13. 已知 A 和 B 是两个集合，并且表达式 A<B 的值为 False，那么表达式 A>B 的值一定为 True。（ B ）

• A. 对
• B. 错

如果集合 A 是集合 B 的子集（即 A 中的每一个元素都是 B 中的元素），
那么 A <=B。
如果 A <= B 且 A != B（即 A 是 B 的子集但 A 不等于 B），那么 A < B。
题目中 A < B 为 False，则 A > B 或者 A = B

14. 一个列表可以作为字典的键。（ A ）A. 错 B. 对

在 Python 中，任何不可变的类型都可以作为字典的键。
这包括整数、浮点数、字符串和元组等。
4.7 题解析中列表，元祖不可修改

15. Python 中的列表是不可变的。（ B ）

• A. 对
• B. 错

参考 4.7 题解析。

文档下载: 大学计算机基础选择题详解(四).pdf