当前位置：首页 > news >正文

Python中元组，字典，集合的易错题（含解析)

news 2025/8/3 10:54:15

1、以上代码的输出结果为？

def intersect(list1,list2):
common =[] #创建一个空列表common
for item in list1: #循环遍历list1
if item in list2 and item not in common: #进行判断item（list1）是否在list2中，并且item（list1）还未添加到common中
common.append(item) #将item添加到comment的末尾
return common #返回以上满足条件的值

a = [1,2,2,3,4]
b = [2,3,3,4,5]
print(sum(intersect(a,b))) #将满足条件的值相加可得2+3+4=9
答输出为9

2、以上代码的输出结果为？
def reverse_words(s):
words = s.split() #将words分割成单词列表
reversed_words = [] #创建一个空列表
for word in words: #循环遍历words中的每个单词
reversed_words.insert(0,word) #使用insert(0,word)reversed_words中实现顺序反转
return' '.join(reversed_words) #使用join将reversed_words连成字符串
print(reverse_words("Python is fun to learn"))
答：learn to fun is Python

3、以上代码的输出结果为？
def count_vowels(sentence):
vowels = {'a','e','i','o','u','A','E','I','O','U'} #创建集合vowels，包含所有大小写元音字母
counts = {} #创建空字典，用于存储元音字母出现的次数
for char in sentence: #循环遍历sentence中的字母
if char in vowels: #判断char是否为元音字母
lower_char = char.lower() #为元音字母的话将其转化为小写字母（若是小写字母则不需要改变）
if lower_char in counts: #检查lower_char是否已经存在counts字典中
counts[lower_char] +=1 #如果存在，则元音字母计数加一
else: #否则计为一
counts[lower_char] = 1
return counts

result = count_vowels("Hello World, this is s test sentence.")
print(result.get('e',0) + result.get('o', 0)) #从字典中获取’e‘和’o‘的次数

答；输出结果为7

4、以上代码输出结果为？
def transform_text(text):
words = text.split() #使用split（）方式分割成单词列表
result = [] #创建空列表用于或许存储处理单词
for i,word in enumerate(words): #循环遍历获取每个单词的索引与word
if i % 2 == 0: #判断单词索引是否为偶数
reversed_word = word[::-1] #对偶数索引进行反转操作
processed = reversed_word.capitalize() #对反转后的单词进行首字母大写，其余字母小写
else:
processed = word.lower() #对奇数索引单词进行全小写处理
result.append(processed) #将处理后的单词添加到result列表中
return ' '.join(result) #使用join（）将单词列表用空格连接成字符串并返回

text = "Hello WORLD this is a TEST"
print(transform_text(text))

答输出结果为Olleh world Siht is A test

5、以上代码输出结果为？
def manage_stack(operations):
stack =[] #初始化stack，用于模拟栈（栈遵循先进后出原则）
for op in operations: #循环遍历op中的每个元组
if op[0] =='push': #如果op索引0为push，则将元素放入栈尾
stack.append(op[1])
elif op[0]=='pop' and stack: #如果op索引0为pop，则进行出栈并移除stack最后一个元素
stack.pop()
elif op[0] == 'peek' and stack: #如果op索引为peek，则查看栈顶，打印stack最后一个元素，并以空格结尾
print(stack[-1],end=' ')
return stack

ops = [('push',1),('push',2),('peek',),('push',3),('pop',),('peek',),('push',4),('peek',)]

final_stack = manage_stack(ops) #调用ops，将返回2，2，4输出并赋值final_stack
print(sum(final_stack)) #计算final_stack中所有元素的和并打印，输出为7

答输出结果为2，2，4，7

6、以上代码输出结果为？
def count_occurrences(lst,target):
count = 0 #初始化计算器，用于累计target出现的次数
for item in lst: #循环遍历lst中的每一个item
if isinstance(item,list): #判断当前元素是否为一个列表
count +=count_occurrences(item,target) #如果是列表则返回子列表target出现的次数并累加到count中
else: #如果不是列表则检查当前普通元素item是否等于target，若是则count加一
if item == target:
count += 1
return count

nested = [1,[2,3,[2,4]],2,[5,[2]]]
print(count_occurrences(nested,2))

答输出结果为4

7、以上代码输出结果为？
def merge_dicts(d1,d2):
result = d1.copy() #复制字典d1到result中，避免直接修改原字典中的d1
for key,value in d2.items(): #遍历d2中的每一对键值对（key为键，value为值）
if key in result: #判断d2中的key是否在result中
result[key] +=value #若在则执行这一步
else: #若不是则将d2中的键值对直接添加到result中
result[key] = value
return result

d1 = {'a': 1,'b': 2} #d1，d2 是字典
d2 = {'b': 3,'c': 4}
merged = merge_dicts(d1,d2)
print(merged['a']+ merged['b']+merged['c']) #计算值的总和（1+5+4），并打印输出

答输出结果为10

8、以上代码输出结果为？
def check_sequence(s):
if len(s) <2: #如果s长度小于2，则输出False
return False
for i in range(len(s) -1): #循环遍历s，len（s）-1是为了避免索引越界
if s[i+1] - s[i]!= 1: #判断s[i+1] - s[i]是否等于1，不等于则输出False，否则True
return False
return True
print(check_sequence([5,6,7,8]),check_sequence([1,3,5])) #注意这里调用了两次check_sequence

答输出结果为True False

9、以上代码输出结果为？def cumulative_sum(numbers):
total = 0 #初始化total，用于累加计算总和
sums = [] #创建空列表，用于存储累加结果
for num in numbers: #循环遍历numbers中的每一个num元素
total += num #展开total=total+num
sums.append(total) #将更新的total添加到sums列表中
return sums
sums = cumulative_sum([3,1,4,1,5])
print(sums) #输出为[3,4,8,9,14]

答输出结果为[3,4,8,9,14]

10、以上代码输出结果为？
def count_chars(s):
counts = {} #创建空字典counts，用于存储字符出现的次数
for char in s: #遍历字符串中s的每一个char
counts[char] = counts.get(char,0) + 1 #counts.get(char,0)为字典char对应出现的次数，若存在相同则加1
return counts
result = count_chars("abracadabra")
print(result.get('a',0) + result.get('z',0)) #从result中获取'a'的次数（5），若不存在则返回 0。从result中获取'z'的次数（0，因'z'未出现）所有两者之和为（5+0）=5

答输出结果为5

11、下面关于模块说法错误的的是
A、Python3中sys是系统的内置模块
B、Python3中math是系统内置提供用于数学运算的模块，其中math.round（）方法是四舍五入的方法
C、Python3中os模块是内置模块，同时os.path模块也包含在os模块中
D、Python3中我们可以使用“pip install模块名称“命令在线安装对应的模块

答：答案为B。原因为：math.round（）确实是四舍五入，但Python中math.round会向最接近的偶数取整

12、关于迭代器和可迭代对象，描述错误的是？
A、迭代器和可迭代对象，都可以被for循环遍历
B、迭代器可以被内建函数next（）操作获取下一个数据
C、可迭代对象可以被内建函数next（）操作获取下一个数据
D、可迭代对象内部肯定会包含一个迭代器对象

答案为C。原因：可迭代对象本身不能直接用next（）操作，需要通过iter（）函数先转换为迭代器后才能用next（）获取下一个数据

13、以上代码输出结果为？
a = {1:'a',2:'b',3:'c'} #a为字典，字典中村的是键值对
b = a.copy() #浅层拷贝a给b
b[1] = 'd' #修改字典b中键为1对应的值
print(a[1]) #由于修改b，a不会被影响，所以print(a[1]) 输出为‘a’

答输出结果为a

14、以上代码输出结果为？
s = {1,2,3} #字典
s.discard(s.remove(2)) #删除s中指定的元素2，且不会报错
print(s)

答输出结果为{1，3}

15、以上代码输出结果为？
d = {} #创建一个空字典
d[1] = 'a' #键1存值‘a’
d[1.0] ='b' #d[1.0] = 'b'因为哈希冲突+值相等，视为通一键，覆盖为‘b'
print(d[1] + d[1.0]) #实际上取的是通一个键，拼接’bb‘

答输出结果为bb

16、以上代码输出结果为？
lst = [1,2,3] #定义一个列表，初始值为[1,2,3]
lst[1:2] = [4,5,6] #lst[1:2]列表切片，从索引1（包含1）到2（不包含2）将[4，5，6]赋值给原列表[2]
print(lst) #输出为[1,4.5.6.3]

答输出结果为1,4.5.6.3]

17、以上代码输出结果为？
s = "hello"
print(s[::-1][::-1] is s) #第一个[::-1]反转”hello“生成一个新的字符”olleh“，第二个[::-1]又将”olleh“反转成”Hello“，is是判断变量内存地址是否相同

答输出结果为False

18、以上代码输出结果为？
a = [1,2,3] #创建一个列表a
b = a #将a赋值给b，引用同一个列表对象（内存地址）
b += [4] #直接在原列表上修改添加元素4
print(a is b ,a ==b) #is判断是否引用同一个对象，“==”判断两个对象的值是否相等

答输出结果为True True

19、以上代码输出结果为？
t = (1,[2,3])
t[1] += [4]
print(t)

答输出结果为报错

20、以上代码输出结果为？
d = {1:'a',True:'b'} #字典
print(len(d),d[1]) #输出d的键长度，注意这里键的长度为一，因为1和True在Python中是同一个键。d[1]是访问键为一的值

答输出结果为1 b

21、以上代码输出结果为？
lst = [1,2,3] #列表lst可修改
lst += (4,) #在列表lst中添加元组4
print(lst) #输出lst

答输出结果为[1, 2, 3, 4]

22、以上代码输出结果为？
a = [[]] * 3 #创建一个列表复制3次，注意三个子列表其实是同一个
a[0].append(1) #访问a的第一个元素添加原素1，由于三个子列表是同一个所以修改会同时反应在子列表中
print(a)

答输出结果为[[1], [1], [1]]

23、以下是字符转换成字节的方法是？
A、decode（）
B、encode（）
C、upper（）
D、rstrip（）

答：B，解释encode() 方法用于将字符串按指定编码转换为字节序列；decode() 是字节转字符串；upper() 是字符串转大写；rstrip() 是去除字符串右侧空白，只有 encode() 实现字符转字节

24、以下不能创建一个字典的语句是？
A、dict1 = {}
B、dict2 = {3：5}
C、dict3 = {（1，2，3）：“uestc”}
D、dict4 = {[1,2,3]:"uestc"}

答为D，[1,2,3]键是列表（可变类型），字典的键必须是不可变的类型，所以D不能创建

25、以下哪个语句在Python中是非法的？
A、x = y = z =1
B、x = (y = z + 1)
C、x,y = y,x
D、x +=y

答：答案为B。Python 中赋值语句（如 y = z + 1 ）不能直接作为表达式嵌套在其他赋值里，x = (y = z + 1) 语法非法；A 是多变量赋值，C 是交换变量，D 是增量赋值，均合法，选 B 。

26、以下哪种操作的时间复杂度不是O（1）？
A、dict[key]
B、set.add(item)
C、list.append(item)
D、list.insert(0,item)

答 A 选项dict[key]：字典通过键查找值，时间复杂度是 O (1)。
B 选项set.add(item)：集合添加元素，时间复杂度是 O (1)。
C 选项list.append(item)：列表末尾添加元素，时间复杂度是 O (1)。
D 选项list.insert(0, item)：列表在开头插入元素，需要移动后续所有元素，时间复杂度是 O (n)（n 为列表长度），不是 O (1)，选 D

27、以上代码输出结果为？
s = "programming" #字符串
print(s[s.find('g'):s.rfind('g')]) #find('g')找字符串中g第一次出现的索引，rfind('g')找g在字符串中出现的最后一次索引

答输出结果为grammin

28、以上代码输出结果为？
values = [0,1,False,True,'','a']
print(sum(filter(None,values))) #filter（）用于过滤，条件为None时保留所有非空/非假。对 values 过滤后，保留的元素是：1（非零整数）、True（布尔真）、'a'（非空字符串）sum() 函数用于计算可迭代对象中所有元素的和，但要求元素必须是数值类型（int、float 等），由于‘a’非数值类型，无法参与求和，所有会报错。

答输出结果为：报错

29、以下代码的输出结果是什么？
data = ['Python','Java','C++']
print(max(data,key = len) + min(data)) #将最大长度与最小长度进行拼接

答：PythonC++

30以下代码的输出结果是什么？
nums = [1.5,2.3,3.7,4.1]
print(sum(map(round,nums)) // len(nums)) #round四舍五入取靠近偶数的值，得2，2，4，4，，相加除以列表长度即可

答：3

31、以下代码的输出结果是什么？

numbers = [10,5,20,15]
print (all(x >sum(numbers)/len(numbers) for x in numbers)) #sum(numbers)/len(numbers所有元素相加除以其长度，后进行判断每个列表得值是否大于它

答：False

32、以下代码的输出结果是什么？
data = [1,2,3,4,5]
result = map(lambda x: x**2,filter(lambda x : x%2 == 0,data)) #filter(lambda x : x%2 == 0,data)找偶数，过滤得到[2,4],后计算其偶数平方
print(list(result)[1]) #输出索引为1得值，也就是16

答16

33、以下代码的输出结果是什么？
s = "abcd"
d = {c: i for i,c in enumerate(s)} #enumerate(s)生成索引，字典d以字符为键，索引为值
lst =[d[c] for c in s if c in d and d[c] % 2 ==1] #c in d （c在字典d中恒成立）， d[c] % 2 ==1找到对应索引奇数
print(sum(lst) if lst else 0) #lst 非空，计算1+3=4，否则为0

答4

34、以下代码的输出结果是什么？
t = (1,[2,3]) #t为元组，不可修改
try: #尝试修改索引0的元素，便会输出异常，进入下一步
t[0] = 4
except TypeError: #将t中[1][0]的元素2改为4，由于其为列表可以被修改所以(1,[4,3])
t[1][0] = 4
print(t[0] + t[1][0]) #索引0的元素加索引1中0的元素可得5

答5

35、以下代码的输出结果是什么？
keys = ['a','b','c']
values = [1,2]
d = dict(zip(keys,values * 2)) #values * 2 对列表 values 进行重复操作，结果为 [1, 2, 1, 2], 将 keys 和重复后的 values 按位置配对
print(d.get('c',len(d))) #若键 'c' 存在，返回对应值（此处 'c' 存在，值为 1）.若键不存在，返回默认值 len(d)（字典长度，此处不触发）

答1

36、以下代码的输出结果是什么？

s1 = {1,2,3}
s2 = {3,4,5}
s3 = {5,6,7}
result = s1 & s2 | s2 & s3 #s1 & s2 找其内相同的值并去重并上s2 & s3其内相同的值
print(len(result)) #输出其长度为2

答：2

37、以下代码的输出结果是什么？
def func(d,k,v): #[].append(v) 会创建一个新空列表并添加 v，但该操作返回 None（append 方法无返回值），且不会会修改原字典 d
d.get(k,[].append(v))
d = {} #定义一个空字典
func(d,'a',1) #调用两次func，但函数不会修改d，所以d为空
func(d,'a',2)
print(d.get('a',[0])[0]) #：在空字典 d 中获取键 'a' 的值，因键不存在，返回默认值 [0]。

答：0

38、以下代码的输出结果是什么？

s = "abcde"
lst =[1,2,3,4,5]
print([(x,y) for x,y in zip(s,lst) if x > 'b' and y % 2 ==0][1][0])
答报错

39、以下代码的输出结果是什么？
d = {'a':1,'b':2,'c':3}
print([k for k,v in d.items() if v % 2][0]+str(len(d)))

答：3

40、以下代码的输出结果是什么？
data = ['a','b','c']
mapping = {k:v for v,k in enumerate(data)} #用字典推导式创建字典 mapping。enumerate(data) 生成索引
result = [mapping[x] for x in data if x in mapping] #取其在 mapping 中对应的值（即原索引），因此 result 为 [0, 1, 2]
print(sum(result)) #计算 result 中所有元素的和：0 + 1 + 2 = 3

答：3

41、以下代码的输出结果是什么？
s1 = {1,2,3}
s2 = {3,4,5}
result = s1 -s2 |s2 -s1 #s1-s2得{1，2}|s2 -s1得{4，5}
print(len(result)) #输出其长度为4

答4

42、关于以下操作得时间复杂度，说法正确得是？
s = "hello world"
lst = [1,2,3,4,5]
d = {'a':1,'b':2}
A、s[::-1]是O（1）
B、3 in lst是O（n）
C、d['a']是O（n）
D ’world' in s 是O（1）

答B

43、以下那种方式不能用于从列表[1,2,3,2,1]中删除所有值为2的元素？
A、[x for x in lst if x != 2]
B、while 2 in lst:
lst.remove(2)
C、list(filter(lambda x: x != 2, lst))
D、del lst[lst.index(2)]

答D

44、以下代码的输出结果是什么？
lst = [1,2,3]
tp1 = (lst,4) #在列表lst中添加元素4，
lst.append(5) #在lst末尾添加元素5
print(len(tp1) + len(tp1[0])) #lst的长度加上tp1中下标0的元素

答6

45、（单选题，分值1.5）关于容器操作的时间复杂度，以下说法正确的是？
A 列表的in操作是O(1)
B 字典的keys()操作是O(n)
C 字符串拼接是O(1)
D 集合的交集操作是O(1)

答：B

46、（单选题，分值1.5）关于Python容器的可变性，以下说法正确的是？
A 字符串可以通过索引修改单个字符
B 元组一旦创建就不能以任何方式修改
C 集合中的元素必须是不可变类型
D 字典的值可以是任意类型，但键必须是字符串

答：C

47、（单选题，分值1.5）以下哪种方法不能用于删除字典d中键为'key'的项？
A del d['key']
B d.pop('key')
C d.remove('key')
D d.clear() if 'key' in d

答：C

48、（单选题，分值1.5）关于Python容器的内存分配策略，以下说法错误的是？
A list采用过度分配策略减少resize次数
B dict在删除元素后会自动收缩内存
C set的存储结构与dict类似
D tuple的内存分配是一次性的

答：B

49、（单选题，分值1.5）关于Python容器的内存管理，以下说法错误的是？
A 列表的resize操作可能会导致内存重新分配
B 字典的键必须是可哈希的对象
C 集合的元素必须是不可变类型
D 列表比元组更节省内存