集合定义
set对象,也就是集合对象，是不同哈希对象的无序集合。构成集合的事物或对象称作元素或是成员。常见的用途包括成员资格测试、从序列中删除重复项以及计算数学运算，如交集、并集、差分和对称差分。
集合对象可以用多种方式构建:
- 使用大括号，用逗号分隔项目: {a}, {a, b, c}
- 使用类型构造函数set(iterable)。其中iterable参数是序列类型。省略iterable参数，构建空集合对象set()
例如：
1
2
3
4
5
6
7
|
s1 = {1,2,3,4} # 集合L1有四个元素，分别是数字1，数字2，数字3和数字4
s2 = set() # L2是空集合。构造函数生成空列表
s3 = set(a) # 根据字符串，转换成集合
print(s1)
print(s2)
print(s3)
|
执行以上程序会输出如下结果：
1
2
3
|
{1, 2, 3, 4}
set()
{'e', 'o', 'h', 'l'}
|
其中，用逗号分割的集合，最后一个逗号是可选的。
{1,2,3,4} 和 {1,2,3,4,} 都是合法的集合。
集合成员之间用逗号隔开。成员的类型可以不相同，它支持数字，字符串等可哈希的对象。
1
|
s = {"apple", "banana", 1,1.5} #集合s，有4个成员。类型分别是str，str，int，float。
|
集合成员必须是可哈希的对象(常见的不可变对象是可哈希的，如数字类型，字符串类型，字节类型。可变对象是不可哈希的，如列表类型，集合类型，字典类型等)。
1
|
s = {"apple", "banana",['a','b']}
|
执行以上程序会输出如下结果：
1
2
3
4
|
Traceback (most recent call last):
File "main.py", line 1, in <module>
s = {"apple", "banana",['a','b']}
TypeError: unhashable type: 'list'
|
创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。
例如：
1
2
3
4
5
|
s1 = set() # 空集合
d = {} # 空字典
print(type(s1))
print(type(d))
|
执行以上程序会输出如下结果：
1
2
|
<class 'set'>
<class 'dict'>
|
集合推导
除了上面介绍的方法生成集合外，还可以使用集合推导来生成集合。推导comprehensions（又称解析式），是Python的一种独有特性。推导是可以从一个数据序列构建另一个新的数据序列的结构体。 集合推导就是利用其他数据序列构建集合。
集合推导语法：
{ x for x in iterable if 条件 }
其中if语句是可以省略的。
例如：
1
2
3
4
|
a = "hello"
s = {x for x in a} # 集合推导生成集合
print(s)
|
执行以上程序会输出如下结果：
集合成员是不可重复的。
例如：
1
2
3
|
s = set([1, 1, 2, 2, 3, 3]) # 结果为{1, 2, 3}
a = "hello"
s3 = {x for x in a} # 结果为{'e', 'o', 'h', 'l'}
|
集合可用于成员测试
操作符in
例如，x in s 测试成员x是集合s的成员。
操作符not in
例如，x not in s 测试成员x不是集合s的成员。
例如：
1
2
3
4
5
6
|
s = {"apple", "banana", 1,1.5}
if 'apple' in s :
print('apple 在集合中')
else :
print('apple 不在集合中')
|
执行以上程序会输出如下结果：
set计算操作
集合可以看成数学意义上的无序和无重复元素的集合，因此，两个集合可以做数学意义上的交集、并集等操作。集合对象的支持的运算符操作。
交集 &
并集 |
差集 -
对称差集 ^
例如：
1
2
3
4
5
6
7
|
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2) # 交集 结果为{2, 3}
print(s1 | s2) # 并集 结果为{1, 2, 3, 4}
print(s1 - s2) # 差集 结果为{1}
print(s1 ^ s2) # 对称差集 结果为{1, 4}
|
执行以上程序会输出如下结果：
1
2
3
4
|
{2, 3}
{1, 2, 3, 4}
{1}
{1, 4}
|
实际上集合运算符操作(交集，并集，差集，对称差集)，调用的是以下方法。效果是一样的。
交集 intersection()
并集 union()
差集 difference()
对称差集 symmetric_difference()
例如：
1
2
3
4
5
6
7
|
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1.intersection(s2)) # 交集 相当于s1 & s2
print(s1.union(s2)) # 并集 相当于s1 | s2
print(s1.difference(s2)) # 差集 相当于s1 - s2
print(s1.symmetric_difference(s2)) # 对称差集 相当于s1 ^ s2
|
执行以上程序会输出如下结果：
1
2
3
4
|
{2, 3}
{1, 2, 3, 4}
{1}
{1, 4}
|
其中，s1 - s2 与s2 - s1的结果是不一样的。
例如：
1
2
3
4
|
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 - s2) #差集 结果为{1}
print(s2 - s1) #差集 结果为{4}
|
集合是可变对象，本身的值是可以改变的。由于集合是无序的，改变后的成员顺序可能会发生改变。
例如：
1
2
3
|
s = {"apple", "banana"}
s.add("cherry") # 使用add方法添加成员cherry，
print(s) # 打印添加成员后的s。
|
执行以上程序会输出如下结果：
1
|
{'banana', 'cherry', 'apple'}
|
集合不支持索引取值和切片取值
集合是无序的，不记录成员位置或插入顺序。因此，集合不支持索引、切片等行为。
例如：
1
2
|
s = {"apple", "banana",'cherry',}
print(s[1]) # 集合不支持索引操作，会报错
|
集合不支持索引操作，报错如下。
1
2
3
4
|
Traceback (most recent call last):
File "main.py", line 2, in <module>
print(s[1]) # 集合不支持索引操作，会报错
TypeError: 'set' object does not support indexing
|
例如：
1
2
|
s = {"apple", "banana",'cherry',}
print(s[0:2]) # set不支持切片操作，会报错
|
set不支持切片操作，报错如下。
1
2
3
4
|
Traceback (most recent call last):
File "main.py", line 2, in <module>
print(s[0:2]) # set不支持切片操作，会报错
TypeError: 'set' object is not subscriptable
|
集合常用方法
add(elem)
将elem成员添加到集合中，返回值None。
例如：
1
2
3
4
|
s = {"apple", "banana"}
s1 = s.add("cherry")
print(s1) # s1的值是None
print(s) # 添加后的s的值是{"apple","cherry","banana"}
|
update(*others)
将others里面的所有成员添加到集合中，返回值None。
例如：
1
2
3
4
5
|
s = {"apple", "banana"}
a = "hello"
s1 = s.update(a)
print(s1) # s1的值是None
print(s) # 添加后的s的值是{'h', 'e', 'apple', 'l', 'o', 'banana'}
|
remove(elem)
从集合中移除成员elem,返回值None。如果集合中不包含elem，则引发KeyError。
例如：
1
2
3
4
|
s = {"apple", "banana","cherry"}
s1 = s.remove("cherry")
print(s1) #s1的值是None
print(s) #s的值是{'banana', 'apple'}
|
1
2
|
s = {"apple", "banana","cherry"}
s1 = s.remove("orange")
|
报错，抛出以下异常。
1
2
3
4
|
Traceback (most recent call last):
File "main.py", line 2, in <module>
s1 = s.remove("orange")
KeyError: 'orange'
|
discard(elem)
如果存在成员elem，则将其从集合中移除，返回值None。与remove方法不同，集合中不包含elem时，不引发KeyError。
例如：
1
2
3
4
|
s = {"apple", "banana", "cherry"}
s1 = s.discard("cherry")
print(s1) # s1的值是None
print(s) # s的值是{'banana', 'apple'}
|
1
2
3
4
|
s = {"apple", "banana", "cherry"}
s1 = s.discard("orange")
print(s1) # s1的值是None
print(s) # s的值是{'apple', 'banana', 'cherry'}
|
pop()
从集合中移除任意成员，并返回被删除的那个成员。
例如：
1
2
3
4
|
s = {"apple", "banana","cherry"}
s1 = s.pop()
print(s1) # s1的值是cherry
print(s) # s的值是{'banana', 'apple'}
|
如果集合为空，则引发keyError。
例如：
1
2
|
s = set()
s1 = s.pop()
|
报错，抛出以下异常。
1
2
3
4
|
Traceback (most recent call last):
File "main.py", line 2, in <module>
s1 = s.pop()
KeyError: 'pop from an empty set'
|
clear()
从集合中移除所有成员，返回值None。
例如：
1
2
3
4
|
s = {"apple", "banana","cherry"}
s1 = s.clear()
print(s1) # s1的值是None
print(s) # s的值是空
|
转载请注明本网址。