第4单元检测卷

第4单元检测卷 - 题目、答案与解析

一、单项选择题

1. 题目：在Python中，用于创建一个新字典的语法是 ( )

   • A. d = dict[]
   • B. d = {}
   • C. d = ()
   • D. d = new dict()

   答案：B
   解析：在Python中，创建字典最常用和直接的方法是使用花括号{}。例如，d = {}会创建一个空字典。d = {'key': 'value'}会创建一个包含键值对的字典。选项A的dict[]语法错误。选项C的()用于创建元组。选项D的new dict()不是Python的语法。

2. 题目：下列代码的输出结果是 ( )

   my_dict = {'a': 1, 'b': 2, 'c': 3}
   print(my_dict['b'])
   

   • A. 1
   • B. 2
   • C. 3
   • D. 'b'

   答案：B
   解析：这段代码首先创建了一个字典my_dict，其中键'b'对应的值是2。然后，通过my_dict['b']这种键查找的方式访问字典，会返回键'b'所对应的值，即2。因此，print函数会输出2。

3. 题目：要向字典 scores 中添加一个键值对 "Tom": 95，正确的代码是 ( )

   • A. scores.add("Tom", 95)
   • B. scores.append("Tom", 95)
   • C. scores["Tom"] = 95
   • D. scores.insert("Tom", 95)

   答案：C
   解析：在Python中，向字典中添加或更新键值对的标准方法是使用赋值语句字典名[键] = 值。如果键已存在，则更新其值；如果键不存在，则向字典中添加该键值对。因此，scores["Tom"] = 95是正确的。add, append, insert通常是列表或集合的方法，不适用于字典。

4. 题目：下列代码的输出结果是 ( )

   s = {1, 2, 2, 3, 3, 3}
   print(len(s))
   

   • A. 3
   • B. 4
   • C. 5
   • D. 6

   答案：A
   解析：这段代码创建了一个集合s。集合（Set）的一个重要特性是元素唯一性。当使用{1, 2, 2, 3, 3, 3}创建集合时，重复的元素2和3会被自动去除，最终集合中只包含{1, 2, 3}三个元素。len(s)返回集合中元素的数量，因此输出3。

5. 题目：下列哪个方法可以用于向集合 fruits 中添加一个元素 "apple"？ ( )

   • A. fruits.add("apple")
   • B. fruits.append("apple")
   • C. fruits.insert("apple")
   • D. fruits.update("apple")

   答案：A
   解析：向集合中添加单个元素，应使用add()方法。fruits.add("apple")会将字符串"apple"添加到fruits集合中。append和insert是列表的方法。update()方法用于向集合中添加多个元素（如另一个集合或列表中的所有元素）。

6. 题目：下列代码的输出结果是 ( )

   d = {'name': 'Alice', 'age': 25}
   d['age'] = 26
   print(d.get('age'))
   

   • A. 25
   • B. 26
   • C. None
   • D. 'age'

   答案：B
   解析：代码首先创建了一个字典d。然后，通过d['age'] = 26这行代码，将键'age'对应的值从25更新为26。最后，d.get('age')方法用于获取键'age'的当前值，此时值已变为26，所以输出26。

7. 题目：要从字典 info 中删除键 "city"，如果该键不存在则不报错，应使用 ( )

   • A. del info['city']
   • B. info.pop('city')
   • C. info.remove('city')
   • D. info.discard('city')

   答案：B
   解析：

   • A: del info['city']：如果键'city'不存在，会抛出KeyError异常。
   • B: info.pop('city')：pop()方法会移除指定的键并返回其值。如果键不存在，可以提供一个默认值来避免报错，如info.pop('city', None)。即使不提供默认值，pop()也是最接近要求的，因为它的主要功能就是删除键。
   • C: remove()是列表或集合的方法，字典没有此方法。
   • D: discard()是集合的方法，用于删除元素，字典没有此方法。
     在给定的选项中，pop()是字典中用于删除键的标准方法，并且其行为（在键不存在时报错）比del更可控，通常被认为是更安全的删除方式。因此，B是最佳答案。

8. 题目：下列代码的输出结果是 ( )

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   print(set1.union(set2))
   

   • A. {1, 2, 3}
   • B. {3, 4, 5}
   • C. {1, 2, 3, 4, 5}
   • D. {3}

   答案：C
   解析：set1.union(set2)或set1 | set2用于计算两个集合的并集。并集是指包含两个集合中所有元素的集合，重复的元素只出现一次。set1是{1, 2, 3}，set2是{3, 4, 5}，它们的并集是{1, 2, 3, 4, 5}。

9. 题目：下列哪个选项会返回 True？ ( )

   • A. 'a' in {'a': 1}
   • B. 1 in {'a': 1}
   • C. ('a', 1) in {'a': 1}
   • D. {'a': 1} in {'a': 1}

   答案：A
   解析：在Python中，使用in操作符检查字典时，默认检查的是键，而不是值或键值对。

   • A: 'a' in {'a': 1}：检查键'a'是否在字典中。'a'是键，所以返回True。
   • B: 1 in {'a': 1}：检查值1是否在字典的键中。1不是键，所以返回False。
   • C: ('a', 1) in {'a': 1}：检查键值对元组('a', 1)是否在字典的键中。字典的键是'a'，不是元组，所以返回False。
   • D: {'a': 1} in {'a': 1}：检查一个字典是否是另一个字典的键。这是不合法的，因为字典不能作为字典的键（字典是可变类型），所以返回False。

10. 题目：下列代码的输出结果是 ( )

    d = {}
    d[1] = 'a'
    d[1.0] = 'b'
    print(d)
    

    • A. {1: 'a'}
    • B. {1: 'b'}
    • C. {1: 'a', 1.0: 'b'}
    • D. {1.0: 'b'}

    答案：B
    解析：在Python中，字典的键必须是可哈希（hashable）的。整数和浮点数都是可哈希的。更重要的是，相等的数值具有相同的哈希值。在这里，整数1和浮点数1.0在数值上是相等的（1 == 1.0 为 True），因此它们被视为同一个键。

    • d[1] = 'a'：向字典中添加了键1，值为'a'。
    • d[1.0] = 'b'：由于1.0与1是同一个键，这行代码不是添加新键，而是更新了键1对应的值，将其从'a'改为'b'。
    • 最终，字典中只有一个键值对{1: 'b'}。在打印时，Python通常会使用键的原始类型，但在这里，由于1和1.0是等价的，显示哪个取决于内部实现，但结果都是指向同一个键。选项B最准确地反映了最终状态。

二、多项选择题

1. 题目：关于Python字典的描述，正确的有 ( )

   • A.字典中的键必须是唯一的
   • B.字典中的值可以是任意类型
   • C.字典是有序的（在Python 3.7+中）
   • D.字典是可变的

   答案：A, B, C, D
   解析：

   • A: 正确。字典的键必须是唯一的，如果添加一个已存在的键，会更新其值，而不是创建新的条目。
   • B: 正确。字典的值可以是任何Python对象，包括数字、字符串、列表、元组，甚至是另一个字典（嵌套字典）。
   • C: 正确。从Python 3.7版本开始，字典被正式规定为插入有序的，即元素的迭代顺序与它们被插入字典的顺序相同。在Python 3.6中这是一个实现细节，3.7+成为语言规范。
   • D: 正确。字典是可变（mutable）数据类型，创建后可以修改其内容（添加、删除、更新键值对）。

2. 题目：下列哪些方法可以用于字典的操作？ ( )

   • A. keys()
   • B. values()
   • C. append()
   • D. items()

   答案：A, B, D
   解析：

   • A: dict.keys()：返回一个包含字典所有键的视图对象。
   • B: dict.values()：返回一个包含字典所有值的视图对象。
   • C: append()：是列表的方法，用于在列表末尾添加元素。字典没有append()方法。
   • D: dict.items()：返回一个包含字典所有键值对（元组形式）的视图对象。
     因此，keys(), values(), items()都是字典的常用方法。

3. 题目：下列代码中，能正确创建集合的有 ( )

   • A. s = set([1, 2, 3])
   • B. s = {1, 2, 3}
   • C. s = set("hello")
   • D. s = {}

   答案：A, B, C
   解析：

   • A: 正确。set(iterable)是创建集合的构造函数，可以接受任何可迭代对象（如列表、元组、字符串）。set([1, 2, 3])会将列表[1, 2, 3]转换为集合{1, 2, 3}。
   • B: 正确。{element1, element2, ...}是Python 3.x中创建集合的字面量语法，非常直观。
   • C: 正确。set("hello")会将字符串"hello"（一个可迭代对象）转换为集合。字符串中的每个字符都会成为集合的一个元素，结果是{'h', 'e', 'l', 'o'}（注意'l'只出现一次）。
   • D: 错误。{}在Python中创建的是一个空字典，而不是空集合。创建空集合的唯一方法是使用set()构造函数，即s = set()。

4. 题目：关于集合的运算，下列说法正确的有 ( )

   • A. s1 & s2 计算两个集合的交集
   • B. s1 | s2 计算两个集合的并集
   • C. s1 - s2 计算两个集合的差集
   • D. s1 ^ s2 计算两个集合的对称差集

   答案：A, B, C, D
   解析：这四个选项分别对应了集合的四种主要运算：

   • A: 正确。& 或 s1.intersection(s2) 计算交集，即同时属于s1和s2的元素。
   • B: 正确。| 或 s1.union(s2) 计算并集，即属于s1或s2的所有元素。
   • C: 正确。- 或 s1.difference(s2) 计算差集，即属于s1但不属于s2的元素。
   • D: 正确。^ 或 s1.symmetric_difference(s2) 计算对称差集，即只属于s1或只属于s2的元素（并集减去交集）。

5. 题目：下列哪些方法可以用于从字典中移除元素？ ( )

   • A. pop(key)
   • B. popitem()
   • C. clear()
   • D. del dict[key]

   答案：A, B, C, D
   解析：

   • A: pop(key)：移除指定的键并返回其值。如果键不存在，会抛出KeyError（除非提供默认值）。
   • B: popitem()：随机移除并返回一个键值对（在Python 3.7+中，移除的是最后一个插入的项）。当字典为空时，会抛出KeyError。
   • C: clear()：移除字典中的所有元素，使其变为空字典{}。
   • D: del dict[key]：这是一个语句，而不是方法。它用于删除指定的键值对。如果键不存在，会抛出KeyError。
     这四种方式都可以从字典中移除元素，只是方式和场景不同。

三、是非选择题

1. 题目：字典中的键可以是列表类型。 ( )
   答案：错误
   解析：字典的键必须是可哈希（hashable）的类型。可哈希的对象在其生命周期内其哈希值是不可变的。列表（list）是可变（mutable）类型，其内容可以改变，因此列表是不可哈希的，不能用作字典的键。常见的可哈希类型包括：数字、字符串、元组（如果元组内的元素也都是可哈希的）。

2. 题目：集合中的元素是有序的。 ( )
   答案：错误
   解析：集合（Set）的核心特性之一是无序性。集合中的元素没有固定的顺序，每次迭代或打印集合时，元素的顺序可能不同（尽管在CPython中，对于整数等简单类型，顺序有时看起来是固定的，但这不是语言保证的）。这与列表和元组（有序）形成对比。

3. 题目：d.get('key') 和 d['key'] 在键 'key' 不存在时的行为完全相同。 ( )
   答案：错误
   解析：当键不存在时，它们的行为完全不同。

   • d['key']：如果键'key'不存在于字典d中，会立即抛出KeyError异常。
   • d.get('key')：如果键'key'不存在，会静默地返回 None，而不会报错。还可以提供一个默认值，如d.get('key', 'default_value')，在键不存在时返回指定的默认值。
     因此，get()方法提供了一种更安全、更温和的访问字典元素的方式。

4. 题目：s.update(t) 方法可以将集合 t 中的所有元素添加到集合 s 中。 ( )
   答案：正确
   解析：set.update(iterable) 方法的作用是，将一个可迭代对象（如列表、元组、另一个集合）中的所有元素添加到原集合中。它相当于取原集合与参数集合的并集，并更新原集合。例如，s = {1, 2}; s.update({3, 4})，执行后s会变为{1, 2, 3, 4}。

5. 题目：在Python 3.6及更早版本中，字典是无序的。 ( )
   答案：正确
   解析：在Python 3.6版本中，字典的有序性是一个实现细节（CPython解释器的一个优化），并不是语言规范的一部分。这意味着你不能依赖字典的顺序，因为其他Python实现（如PyPy）可能不保证有序。从Python 3.7开始，字典的插入顺序被正式确定为语言规范，所有符合规范的Python实现都必须保证字典的有序性。

四、综合应用题

1. 题目：阅读以下代码，并回答问题。

   # 创建一个学生字典，存储姓名和年龄
   student = {"name": "张三","age": 20,"grades": [85, 90, 78]
   }# 1. 将张三的年龄修改为21
   # 2. 在成绩列表中添加一个新的成绩92
   # 3. 打印出最终的字典
   

   请在横线处填写正确的代码，完成上述要求。

   student = {"name": "张三","age": 20,"grades": [85, 90, 78]
   }
   # 1. 将张三的年龄修改为21
   ①
   # 2. 在成绩列表中添加一个新的成绩92
   ②
   # 3. 打印出最终的字典
   ③
   

   答案：
   ① student["age"] = 21
   ② student["grades"].append(92)
   ③ print(student)

   解析：

   • ①：修改字典中已存在键的值，直接通过键进行赋值即可。student["age"] = 21将键"age"对应的值更新为21。
   • ②：student["grades"]的值是一个列表[85, 90, 78]。要向列表末尾添加元素，应使用列表的append()方法。student["grades"].append(92)访问到这个列表，并调用其append方法添加92。
   • ③：打印一个变量（这里是字典student）的内容，使用print()函数即可。

2. 题目：编写一个程序，统计一段文本中每个字符出现的次数，并将结果存储在一个字典中，最后打印出该字典。例如，文本为 "hello"，则结果应为 {'h': 1, 'e': 1, 'l': 2, 'o': 1}。
   请在横线处填写正确的代码。

   text = "hello world"
   char_count = {}  # 创建一个空字典用于存储结果for char in text:if char in char_count:①else:②print(char_count)
   

   答案：
   ① char_count[char] += 1
   ② char_count[char] = 1

   解析：

   • 程序遍历字符串text中的每一个字符char。
   • if char in char_count:：检查当前字符char是否已经作为键存在于char_count字典中。
   • ①：如果字符已经存在，说明之前已经统计过，那么只需要将其对应的计数值加1即可。char_count[char] += 1 实现了这个功能。
   • ②：如果字符不存在（else分支），说明这是第一次遇到这个字符，需要将其作为新键添加到字典中，并将其计数值初始化为1。char_count[char] = 1 实现了这个功能。
   • 循环结束后，char_count字典中就存储了每个字符及其出现的次数。

3. 题目：有两个集合 A = {1, 2, 3, 4, 5} 和 B = {4, 5, 6, 7, 8}。请编写代码，计算并打印以下结果：

   1. A 和 B 的交集
   2. A 和 B 的并集
   3. A 相对于 B 的差集（A - B）
   4. B 相对于 A 的差集（B - A）
      请在横线处填写正确的代码。

   A = {1, 2, 3, 4, 5}
   B = {4, 5, 6, 7, 8}# 1. A 和 B 的交集
   intersection = ①
   print("A和B的交集:", intersection)# 2. A 和 B 的并集
   union = ②
   print("A和B的并集:", union)# 3. A 相对于 B 的差集
   diff_A_B = ③
   print("A相对于B的差集:", diff_A_B)# 4. B 相对于 A 的差集
   diff_B_A = ④
   print("B相对于A的差集:", diff_B_A)
   

   答案：
   ① A & B 或 A.intersection(B)
   ② A | B 或 A.union(B)
   ③ A - B 或 A.difference(B)
   ④ B - A 或 B.difference(A)

   解析：

   • ①：交集（同时属于A和B的元素）可以使用运算符&或方法intersection()。A & B的结果是{4, 5}。
   • ②：并集（属于A或B的所有元素）可以使用运算符|或方法union()。A | B的结果是{1, 2, 3, 4, 5, 6, 7, 8}。
   • ③：A相对于B的差集（属于A但不属于B的元素）可以使用运算符-或方法difference()。A - B的结果是{1, 2, 3}。
   • ④：B相对于A的差集（属于B但不属于A的元素）可以使用运算符-或方法difference()。B - A的结果是{6, 7, 8}。