Python3 解释器执行 {1, 2, 'a'} | {2, 3, 4} 的结果 - 常规

Python3 解释器执行 {1, 2, 'a'} | {2, 3, 4} 的结果为()

在 Python 中，集合运算使用符号 | 表示并集运算。因此，{1, 2, 'a'} | {2, 3, 4} 的结果为 {1, 2, 3, 4, 'a'}。

正确答案：B. {1, 2, 3, 4, 'a'}

Python 集合的特性

集合是无序的，元素没有特定的顺序。
集合中的元素是唯一的，不能重复。
集合支持多种操作，包括并集、交集、差集、子集等。

Python 集合的操作

并集： 使用符号 | 或 union() 方法。
交集： 使用符号 & 或 intersection() 方法。
差集： 使用符号 - 或 difference() 方法。
子集： 使用符号 < 或 issubset() 方法。

示例代码

# 创建两个集合
s1 = {1, 2, 'a'}
s2 = {2, 3, 4}

# 并集
print(s1 | s2)  # 输出：{1, 2, 3, 4, 'a'}

# 交集
print(s1 & s2)  # 输出：{2}

# 差集
print(s1 - s2)  # 输出：{1, 'a'}

# 子集
print(s1 < s2)  # 输出：False

总结

Python 集合是一种强大的数据结构，可以用于存储无序且唯一的元素。通过使用集合运算，我们可以方便地对集合进行操作，例如求并集、交集、差集和子集等。

以下选项中，a不是集合对象的是（）。

A. a={}

B. a=set()

C. a=set(list('Python'))

D. a={10,'aaa',True}

正确答案：A. a={}

解释：

A. a={} 创建的是一个空字典，而不是集合。
B. a=set() 创建的是一个空集合。
C. a=set(list('Python')) 创建的是一个包含字符 'P', 'y', 't', 'h', 'o', 'n' 的集合。
D. a={10,'aaa',True} 创建的是一个包含元素 10, 'aaa', True 的集合。

Python集合中的元素不可以是（）。

A. 数字

B. 字符串

C. 元组

D. 列表

正确答案：D. 列表

解释：

Python 集合中的元素必须是可哈希的。可哈希的元素意味着它们是不可变的。列表是可变的，因此不能作为集合元素。

以下哪一条语句会得到一个对象，等同于{'1','2','3'}。

A. list('123')

B. tuple('123')

C. set('123')

D. 以上都不是

正确答案：C. set('123')

解释：

A. list('123') 创建的是一个包含字符 '1', '2', '3' 的列表。
B. tuple('123') 创建的是一个包含字符 '1', '2', '3' 的元组。
C. set('123') 创建的是一个包含字符 '1', '2', '3' 的集合。

对于两个集合s1和s2，s1 < s2的意思是？

A. s1的大小小于s2的大小

B. s1的元素比s2的小

C. s1是s2的真子集

D. s2是s1的真子集

正确答案：C. s1是s2的真子集

解释：

在 Python 中，s1 < s2 表示 s1 是 s2 的真子集，即 s1 包含于 s2，且 s1 不等于 s2。

下列程序运行输出结果为_______。

m={1:'A','2':'B'} print(m.get(2,-1))

A. 'B'

B. 'A'

C. None

D. -1

正确答案：A. 'B'

解释：

m.get(2, -1) 用于获取字典 m 中键为 '2' 的值，如果键不存在，则返回 -1。在本例中，键 '2' 存在，其值为 'B'，因此输出结果为 'B'。

如下程序代码输出的结果是：（）。

dct={'name':'KKKK','age':65} for k in dct: print(k)

A. 'name':'KKKK' 'age': 65

B. KKKK 65

C. ('name', 'KKKK') ('age', 65)

D. name age

正确答案：D. name age

解释：

for k in dct: 语句会遍历字典 dct 的键，因此输出的结果是字典的键 name 和 age。

字典对象的( )方法可以获取指定“键”对应的“值”，并且可以在指定“键”不存在的时候返回指定的默认值，如果不指定则返回None。

A. key()

B. get()

C. items()

D. values()

正确答案：B. get()

解释：

get() 方法可以获取指定键对应的值，并在键不存在时返回指定的默认值。如果没有指定默认值，则返回 None。

对字典对象直接进行迭代或者遍历时默认是遍历字典的：（）。

A. 值集合

B. 键集合

C. 键-值对集合

D. 对象

正确答案：B. 键集合

解释：

直接对字典对象进行迭代或遍历时，默认遍历的是字典的键集合。

以下对字典的说法错误的是（）。

A. 字典可以为空

B. 字典的键不能相同

C. 字典的键不可变

D. 字典的键对应的值不可变

正确答案：D. 字典的键对应的值不可变

解释：

字典的键必须是不可变的，而值可以是可变的。

对于for i in s:......语句，以下说法不正确的是（）。

A. 如果s为字符串，则该循环执行时，i取值会对字符串中的每个字符进行遍历

B. 如果s为列表，则该循环执行时，i取值会对列表中的每个元素进行遍历

C. 如果s为字典，则该循环执行时，i取值会对字典中的每个键值对进行遍历

D. 如果s为集合，则该循环执行时，i取值会对集合中的每个元素进行遍历

正确答案：C. 如果s为字典，则该循环执行时，i取值会对字典中的每个键值对进行遍历

解释：

对字典进行迭代时，i 取值会对字典的键进行遍历，而不是键值对。

对于正确的表达式a[2]，a不可能是以下哪个类型？

A. 列表

B. 元组

C. 集合

D. 字符串

正确答案：C. 集合

解释：

集合是无序的，没有索引，因此不能使用 a[2] 这种方式访问元素。

使用( )运算符来确定一个键是否在字典中。

A. &

B. in

C. ^

D. ?

正确答案：B. in

解释：

使用 in 运算符可以判断一个键是否在字典中。

把字典对象直接转换成列表（集合）时，默认是把( ) 转换成列表（集合）？

A. 键

B. 值

C. 键和值

D. 无内容

正确答案：A. 键

解释：

把字典对象直接转换成列表（集合）时，默认是把字典的键转换成列表（集合）。

下列程序运行输出结果为_______。

a=[1,2,3] b=[4,5,6] print(list(zip(a,b)))

A. [(1, 4), (2, 5), (3, 6)]

B. [(4, 1), (5, 2), (6, 3)]

C. [1, 2, 3, 4, 5, 6]

D. [(1, 2, 3), (4, 5, 6)]

正确答案：A. [(1, 4), (2, 5), (3, 6)]

解释：

zip(a, b) 函数将两个列表 a 和 b 对应位置的元素组合成元组，并返回一个元组的迭代器。list(zip(a, b)) 将迭代器转换为列表，输出结果为 [(1, 4), (2, 5), (3, 6)]。

下列程序运行输出结果为_______。

a=[1,2,3] b=[4,5,6] c=[7,8,9] print(list(zip(a,b,c)))

A. [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

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

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

D. [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

正确答案：A. [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

解释：

zip(a, b, c) 函数将三个列表 a, b, c 对应位置的元素组合成元组，并返回一个元组的迭代器。list(zip(a, b, c)) 将迭代器转换为列表，输出结果为 [(1, 4, 7), (2, 5, 8), (3, 6, 9)]。

以下哪个函数返回的是一个生成器对象？

A. range()函数

B. zip()函数

C. map()函数

D. filter()函数

正确答案：A. range()函数

解释：

range() 函数返回的是一个生成器对象，而不是一个列表。

对于下面的代码：

a = [1, 2, 3, 4, 5] b = [i * 2 for i in a]

b的值是（）

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

B. [2, 4, 6, 8, 10]

C. [1, 4, 9, 16, 25]

D. [2, 4, 6, 8, 10, 12]

正确答案：B. [2, 4, 6, 8, 10]

解释：

b = [i * 2 for i in a] 使用列表推导，将列表 a 中的每个元素 i 乘以 2，并将结果存入新的列表 b 中，因此 b 的值为 [2, 4, 6, 8, 10]。

下列程序运行输出结果为_______。

a = [1, 2, 3] b = [4, 5, 6] c = [7, 8, 9] d = [a, b, c] print(list(zip(*d)))

A. [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

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

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

D. [(1, 2, 3, 4, 5, 6, 7, 8, 9)]

正确答案：A. [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

解释：

*d 将列表 d 解包成多个参数，传递给 zip() 函数。zip(*d) 将 d 中每个子列表的对应位置元素组合成元组，并返回一个元组的迭代器。list(zip(*d)) 将迭代器转换为列表，输出结果为 [(1, 4, 7), (2, 5, 8), (3, 6, 9)]。

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

a = [1, 2, 3, 4, 5] b = map(lambda x: x * 2, a) print(list(b))

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

B. [2, 4, 6, 8, 10]

C. [1, 4, 9, 16, 25]

D. [2, 4, 6, 8, 10, 12]

正确答案：B. [2, 4, 6, 8, 10]

解释：

map(lambda x: x * 2, a) 使用 map() 函数将匿名函数 lambda x: x * 2 应用于列表 a 的每个元素，并返回一个新的迭代器。list(b) 将迭代器转换为列表，输出结果为 [2, 4, 6, 8, 10]。

下列程序运行输出结果为_______。

a = [1, 2, 3] b = [4, 5, 6] c = [7, 8, 9] d = [a, b, c] e = list(map(list, zip(*d))) print(e)

A. [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

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

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

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

正确答案：C. [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

解释：

zip(*d) 解包列表 d，将子列表的对应元素组合成元组，形成迭代器。
map(list, zip(*d)) 将 zip(*d) 生成的每个元组应用 list 函数，将元组转换为列表。
list(map(list, zip(*d))) 将 map() 函数生成的迭代器转换为列表，最终输出结果为 [[1, 4, 7], [2, 5, 8], [3, 6, 9]]。