[Python]以下哪个方式可以创建一个空的集合？A.set()B.{}C.[]D.() 已知：s=set(‘abcd‘)，向集合对象s中增加新元素，不可以采用哪些形式（ ）。A.s.add(‘ef‘_以下哪个指令能建立一个集合( )。

1.以下哪个方式可以创建一个空的集合？

A.set()

B.{}

C.[]

D.()

答案:A

解析：

在Python中，要创建一个空的集合，应该使用set()构造函数。其他选项表示不同类型的数据结构：

• B. {} 创建一个空的字典（dictionary）。
• C. [] 创建一个空的列表（list）。
• D. () 创建一个空的元组（tuple）。

所以，正确答案是A. set()。

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

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

B.s1的元素比s2的小

C.s1是s2的真子集

D.s2是s1的真子集

答案:C

解析：在Python中，集合之间的关系可以通过包含关系来比较，使用“<”运算符表示真子集关系。如果s1是s2的真子集，则表示s1中的元素都包含在s2中，并且s1和s2不相等。因此，选项C是正确的解释。

3.返回集合中元素个数的函数是______。

A.size()

B.len()

C.elements()

D.count()

答案:B

解析：Python中返回集合中元素个数的函数是len()。因此，选项B是正确的。选项A、C、D都不是Python中用来返回集合元素个数的函数。

4.已知：s=set('abcd')，向集合对象s中增加新元素，不可以采用哪些形式（ ）。

A.s.add('ef')

B.s.update('gh')

C.s=s|set('123')

D.s=s and set('123')

答案:D

解析：

选项C中的 | 是求s和set('123')的并

s=set('abcd')
s=s|set('123')
print(s)
'
运行
运行

选项D是不能用来向集合对象s中增加新元素的形式。

这是因为选项D中的表达式 s=s and set('123') 不会将元素添加到原始集合s中，而是会创建一个新的集合。这里的 and 运算符实际上会首先计算 s（如果 s 为空则返回 s，否则返回 set('123')），然后将其赋值给 s，从而丢失了原始集合 s 中的所有元素。

所以，如果我们运行以下代码：

s = set('abcd')  
s = s and set('123')  
print(s)
'
运行
运行

我们会发现，打印出来的结果是 set(['1', '2', '3'])，原始的 s 集合中的元素 'a', 'b', 'c', 'd' 都不见了。

因此，选项D不符合向集合对象s中添加新元素的要求。而选项A、B和C都是可以用来添加新元素到集合s中的正确方法。

5.集合的元素可以是：

A.集合

B.字符串

C.字典

D.列表

答案:B

解析：在Python中，集合（set）是一个无序的不重复元素序列。它的主要功能是检查元素的成员关系，以及消除重复元素。集合中的元素可以是任何不可变类型，包括整数、浮点数、字符串、元组等。因此，选项B（字符串）是正确的。但是，选项A（集合）、选项C（字典）和选项D（列表）都是可变的，所以不能作为集合的元素。

6.以下代码的执行结果是( ) 。

a={i for i in range(1,10)}
b={i for i in range(12) if i%2==1 }
print(a|b)
'
运行
运行

A.{2, 4, 6, 8, 11}

B.{1, 2, 3, 4, 5, 6, 7, 8, 9, 11}

C.{1, 3, 5, 7, 9}

D.{2, 4, 6, 8}

答案:B

解析：

首先，我们需要理解这段代码的含义。这里我们有两个集合，集合a包含1到9的所有整数，集合b包含1到11的所有奇数。

然后，代码中使用了“|”操作符，这个操作符在Python中用于取两个集合的并集。

接下来，我们分析一下两个集合的内容。集合a的内容为{1, 2, 3, 4, 5, 6, 7, 8, 9}，集合b的内容为{1, 3, 5, 7, 9, 11}。

因此，这两个集合的并集为{1, 2, 3, 4, 5, 6, 7, 8, 9, 11}，所以选项B {1, 2, 3, 4, 5, 6, 7, 8, 9, 11}是正确的。

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

A.列表

B.元组

C.集合

D.字符串

答案:C

解析：Python中的集合类型不支持索引操作，它们是无序的集合，不能像列表、元组和字符串那样通过索引访问元素。因此，选项C“集合”是不可能的类型。

8.以下代码段的执行结果为( )。

d={"A":[9,10],"B":[7,8],"C":[5,6]}
d["C"]=[3,4]
a=[]
for i in d:
    a.append(d[i])
print(a)
'
运行
运行

A.[[9, 10], [7, 8], [3, 4]]

B.[[9, 10], [7, 8], [5, 6]]

C.[[3, 4]]

D.语句出错

答案:A

解析：

首先，我们分析代码段：

1. 一个字典d被初始化，其包含三个键值对，其中键为"A", "B", "C"，对应的值分别是列表[9, 10], [7, 8], [5, 6]。
2. 然后，字典d中的键"C"对应的值被更改为[3, 4]。
3. 创建一个空列表a。
4. 循环遍历字典d的键，并追加每个键对应的值（列表）到列表a中。
5. 打印列表a。

根据以上分析，列表a将包含以下列表：[9, 10]（来自键"A"），[7, 8]（来自键"B"），[3, 4]（来自键"C"）。

所以，最终的输出将是：[[9, 10], [7, 8], [3, 4]]。

因此，答案是：A. [[9, 10], [7, 8], [3, 4]]。

9.以下代码段的执行结果为( )。

d={"A":[9,10],"B":[7,8],"C":[5,6]}
d["D"]=[3,4]
a=[]
for i in d:
    a.append(d[i])
print(a)
'
运行
运行

A.[[9, 10], [7, 8], [5,6]]

B.[[9, 10], [7, 8], [5, 6], [3, 4]]

C.[[9, 10], [7, 8], [3, 4]]

D.语句出错

答案:B

解析：这段Python代码首先定义了一个字典d，然后向这个字典里添加了一个新的键值对"D":[3,4]。然后定义了一个空列表a，遍历字典d，将字典d中每个键对应的值添加到列表a中。

因此，最后打印出的列表a应该包含所有的键值对的值，即：[[9, 10], [7, 8], [5, 6], [3, 4]]。

所以，正确答案是选项B：[[9, 10], [7, 8], [5, 6], [3, 4]]。

10.执行下面语句的结果是（）

dict={'Name':'Zara','Age':7,'Name':'Manni'}
dict.pop('Name')
dict['Add']='Shanghai'
dict.popitem()
print(dict)
'
运行
运行

A.{}

B.{'Age': 7}

C.{'Name': 'Zara', 'Age': 7}

D.{'Age': 7, 'Name': 'Manni'}

答案:B

解析：

首先，我们来看这段Python代码。

在第一行，创建一个字典dict，但它包含两个相同的键'Name'，在字典中，键是唯一的，所以这里的'Name':'Manni'会覆盖'Name':'Zara'，因此实际上字典是{'Name': 'Manni', 'Age': 7}。

第二行，使用pop方法删除了键为'Name'的项，此时字典变为{'Age': 7}。

第三行，向字典中添加了一个新的键值对'Add':'Shanghai'，此时字典变为{'Age': 7, 'Add': 'Shanghai'}。

第四行，使用了popitem()方法，这个方法会删除并返回字典中的最后一对键值，即'Add': 'Shanghai'，所以此时的字典又回到了{'Age': 7}。

因此，执行print(dict)语句后，结果为{'Age': 7}，所以正确答案是B. {'Age': 7}。