Python 简明教程 --- 13，Python 集合

微信公众号：码农充电站pro
我的主页：https://codeshellme.github.io

若是代码和注释不一致，那极可能二者都错了。
—— Norm Schryer

目录

前几节咱们已经介绍了Python 中的列表list，元组tuple 和 字典dict，本节来介绍Python 中的最后一种数据结构——集合set。

>>> set
<type 'set'>

1，Python 集合

Python 中的set 与 dict 很像，惟一的不一样是，dict 中保存的是键值对，而set 中只保存键，没有值。

Python 集合有以下特色：

• 集合中的元素是惟一的，不重复的
• 集合中的元素是无序的
• 集合中的元素能够是任意一种不可变类型，好比字符串，数字，元组
• 集合中的元素能够动态的增长/删除
• Python 会在须要的时候自动的扩容和缩容集合，方便开发者使用

2，声明集合

Python 集合的声明有两种方式：

• 使用set() 建立集合，() 中可为空，也能够是任意的可迭代类型，好比列表，元组，字典
• 使用大括号{}建立集合，从该建立方式上也能看出集合与字典很像

建立空集合时，只能用set()，而不能用{}：

>>> s = set()  # 空集合
>>> s
set()
>>> s = {}     # 空的 {} 会被解析成字典
>>> s
{}

建立非空集合时，能够用set()，也能够用{}：

>>> s = {1, 'abc', 1.5}       # 用 {} 建立集合
>>> s
{1, 'abc', 1.5}
>>> s = set([1, 'abc', 1.5])  # 用列表建立集合
>>> s
{1, 'abc', 1.5}
>>> s = set((1, 'abc', 1.5))  # 用元组建立集合 
>>> s
{1, 'abc', 1.5}
>>> s = set({'a':1, 'b':2, 'c':3}) # 用字典建立集合
>>> s                              # 只会包含字典中的键
{'c', 'b', 'a'}

因为集合中的元素是惟一的，若是初始化时的可迭代数据中有重复的元素，则会自动删去重复的元素：

>>> s = set([1, 2, 2, 3])  # 列表中有两个 2
>>> s                      # 集合中只有一个 2
{1, 2, 3}

3，集合元素个数

使用len() 函数能够查看集合中元素的个数：

>>> s = set([1, 'abc', 1.5])
>>> s
{1, 'abc', 1.5}
>>> len(s)   # 元素个数
3

4，访问集合元素

因为Python 集合中的元素的是无序的，因此可不能使用下标 的方式来访问集合中的单个元素。

咱们可使用for 循环 来遍历集合中的全部元素：

>>> s = set([1, 'abc', 1.5])
>>> for i in s:
...     print(i)
... 
1
abc
1.5

5，集合运算

咱们能够对两个集合进行以下运算：

• & 运算：计算集合的交集
• | 运算：计算集合的并集
• in 运算：判断某个元素是否在集合中

交集与并集

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2   # 交集
{2, 3}
>>> s1 | s2   # 并集
{1, 2, 3, 4}

in 运算

>>> s = set([1 , 2, 3])
>>> 1 in s
True
>>> 2 not in s
False

6，集合函数

使用dir(set) 查看集合支持的全部方法：

>>> dir(set)
['__and__', '__class__', '__contains__', 
'__delattr__', '__dir__', '__doc__', 
'__eq__', '__format__', '__ge__', 
'__getattribute__', '__gt__', '__hash__', 
'__iand__', '__init__', 
'__init_subclass__', '__ior__', 
'__isub__', '__iter__', '__ixor__', 
'__le__', '__len__', '__lt__', '__ne__', 
'__new__', '__or__', '__rand__', 
'__reduce__', '__reduce_ex__', 
'__repr__', '__ror__', '__rsub__', 
'__rxor__', '__setattr__', '__sizeof__', 
'__str__', '__sub__', '__subclasshook__', 
'__xor__', 
'add', 'clear', 'copy', 'difference', 
'difference_update', 'discard', 
'intersection', 'intersection_update', 
'isdisjoint', 'issubset', 'issuperset', 
'pop', 'remove', 'symmetric_difference', 
'symmetric_difference_update', 'union', 
'update']

下面一一介绍这些非魔法方法，共17 个。

1.add 方法

做用：向集合S 中添加元素
原型：S.add(...) -> None
参数：任意不可变类型数据
返回值： 老是返回 None

因为集合中的元素是惟一的，向集合中添加元素时有两种状况：

• 添加的元素集合中不存在：只要元素类型合法，就会成功添加进去
• 添加的元素集合中已存在：不会对集合进行任何操做

示例：

>>> s = set([1, 3, 5]) # 初始化一个集合
>>> s
{1, 3, 5}
>>> s.add(7)  # 向集合中添加一个不存在的元素
>>> s
{1, 3, 5, 7}
>>> s.add(5)  # 向集合中添加一个已存在的元素
>>> s
{1, 3, 5, 7}

2.remove 方法

做用：删除集合S 中的元素
原型：S.remove(...) -> None
参数：任意不可变类型数据
返回值：当要删除的元素存在时，返回None，不然，抛出异常

示例：

>>> s = set([1, 3, 5])
>>> s
{1, 3, 5}
>>> s.remove(3)   # 元素 3 存在
>>> s             # 成功删除
{1, 5}
>>> s.remove(3)   # 元素 3，已不存在
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3       # 抛出异常

3.discard 方法

做用：用于删除集合S 中的元素，与remove 方法的不一样是，若是元素不存在，不会抛出异常
原型：S.discard(...) -> None
参数：任意不可变类型数据
返回值：老是返回None

示例：

>>> s = set([1, 3, 5, 6])
>>> s.discard(3)  # 删除一个已存在的元素
>>> s
{1, 5, 6}
>>> s.discard(7)  # 删除一个不存在的元素
>>> s
{1, 5, 6}

4.pop 方法

做用：随机删除并返回集合S 中的一个元素
原型：S.pop() -> item
参数：无
返回值：被删除的元素，若是集合为空，抛出异常

示例：

>>> s = set([3, 5, 1])
>>> s.pop()  # 删除并返回 1
1
>>> s.pop()  # 删除并返回 3
3
>>> s.pop()  # 删除并返回 5
5
>>> s        # 集合为空
set()
>>> s.pop()  # 抛出异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'pop from an empty set'

5.union 方法

做用：用于合并多个集合，至关于多个集合作并集运算
原型：set.union(...) -> set
参数：任意多个可迭代类型数据
返回值： 返回新的集合

示例：

>>> # 参数中有集合，元组，列表
>>> set.union({2, 3}, (3, 5), [5, 6])
{2, 3, 5, 6}

6.update 方法

做用：向集合S 中添加元素
原型：S.update(...) -> None
参数：任意多个可迭代类型数据
返回值：老是返回 None

示例：

>>> s = set({2})
>>> s
{2}
>>> s.update({3, 5}, {5, 6}, [7, 8])
>>> s
{2, 3, 5, 6, 7, 8}

7.clear 方法

做用：清空集合S
原型：S.clear() -> None
参数：无
返回值：老是返回None

示例：

>>> s = set([1, 3, 5])
>>> s
{1, 3, 5}
>>> s.clear()
>>> s         # 集合为空
set()

8.copy 方法

做用：浅拷贝集合S
原型：S.copy( ) -> set
参数：无
返回值：一个集合

示例：

>>> s = set([1, 3, 5])
>>> s
{1, 3, 5}
>>> s1 = s.copy()
>>> s1
{1, 3, 5}

9.difference 方法

做用：集合的差集
原型：S.difference(...) -> set
参数：任意多个可迭代类型数据
返回值：一个集合

示例：

>>> s = set([1, 3, 5, 6])
>>> # 参数能够是任意的可迭代类型
>>> s.difference({1}, [3], (4, 5)) 
{6}

10.difference_update 方法

做用：集合的差集，与difference 方法的不一样是，difference_update 直接在集合S 上作修改
原型：S.difference_update(...) -> None
参数：任意多个可迭代类型数据
返回值：老是返回None

示例：

>>> s = set([1, 3, 5, 6])
>>> s.difference_update({1}, [3], (4, 5))
>>> s
{6}

11.intersection 方法

做用：集合的交集
原型：S.intersection(...) -> set
参数：任意多个可迭代类型数据
返回值：一个集合

示例：

>>> s = set([1, 3, 5, 6])
>>> s.intersection({1}, [3], (4, 5)) # 至关于 s & {1} & [3] & (4, 5)
set()
>>> s.intersection({1, 3}, [3, 4], (3, 4, 5)) # 至关于 s & {1, 3} & [3,4] & (3, 4, 5)
{3}

12.intersection_update 方法

做用：集合的交集，与intersection 方法的不一样是，intersection_update 直接在集合S 上作修改
原型：S.difference_update(...) -> None
参数：任意多个可迭代类型数据
返回值：老是返回None

示例：

>>> s = set([1, 3, 5, 6])
>>> s.intersection_update({1, 3}, [3,4], (3, 4, 5))  
>>> s
{3}

13.isdisjoint 方法

做用：用于判断两个集合中是否有相同的元素
原型：S.isdisjoint(...) -> bool
参数：任意可迭代类型数据
返回值：若是有相同的元素，返回False，不然，返回True

示例：

>>> s1 = set([1, 2, 3])
>>> s2 = set([3, 4, 5])
>>> s3 = set([5, 6])
>>> s1.isdisjoint(s2) # s1, s2 中有相同的元素
False
>>> s1.isdisjoint(s3) # s1, s3 中没有相同的元素
True
>>> s1.isdisjoint((4, 5)) # 参数是元组
True

14.issubset 方法

做用：判断集合S 是不是另外一个集合的子集
原型：S.issubset(...) -> bool
参数：任意可迭代类型数据
返回值：bool 类型

示例：

>>> s = set([1, 3, 5])
>>> s.issubset({1, 3, 5, 7}) # 参数是字典
True
>>> s.issubset([1, 3, 5, 7]) # 参数是数组
True
>>> s.issubset([1, 3, 7])
False

15.issuperset 方法

做用：判断一个集合是不是另外一个集合S 的子集，是issubset方法的反义
原型：S.issuperset(...) -> bool
参数：任意可迭代类型数据
返回值：bool 类型

示例：

>>> s.issuperset({1, 3, 5, 7})
False
>>> s.issuperset({1, 3})
True

16.symmetric_difference 方法

做用：返回两个集合中不重复的元素集合
原型：S.symmetric_difference(...) -> set
参数：任意可迭代类型数据
返回值：一个集合

示例：

>>> s = set([1, 3, 5])
>>> s
{1, 3, 5}
>>> s.symmetric_difference([8, 9])
{1, 3, 5, 8, 9}
>>> s.symmetric_difference([8, 3])
{8, 1, 5}

17.symmetric_difference_update 方法

做用：求两个集合中不重复的元素集合，与symmetric_difference方法的不一样是，symmetric_difference_update 方法，直接在S 修改
原型：S.symmetric_difference_update(...) -> None
参数：任意可迭代类型数据
返回值：老是返回None

示例：

>>> s = set([1, 3, 5])
>>> s.symmetric_difference_update({6, 8})
>>> s
{1, 3, 5, 6, 8}
>>> s.symmetric_difference_update({6, 8})
>>> s
{1, 3, 5}

（完。）

---

推荐阅读：

Python 简明教程 --- 8，Python 字符串函数

Python 简明教程 --- 9，Python 编码

Python 简明教程 --- 10，Python 列表

Python 简明教程 --- 11，Python 元组

Python 简明教程 --- 12，Python 字典

---

欢迎关注做者公众号，获取更多技术干货。