序言：

集合中各元素间是无序的，相同元素在集合中唯一存在。即 集合是无序组合，它没有索引和位置的概念，但可变集合中的元素是可以动态增加或删除的。

集合应用场景：

去重：如列表  去重。

关系测试：判断数据是否存在 交集，并集，差集  等关系。

集合的类型：

可变集合 —— set

不可变集合 —— frozenset

注：本文重点讨论的是可变集合set

————————————————

python中可变集合set和不可变集合frozenset的区别链接

1.0 set()函数

描述：可以将其它的组合数据类型转化为可变集合类型(或将不可变的集合类型frozenset转变为可变的集合类型set)，返回一个无重复元素且排序任意的可变集合。

语法： set() -> new empty set object  返回一个空集合(该集合可变)

set(iterable) -> new set object  返回一个新集合(该集合可变)

iterable —— 要转换的组合数据类型。

注：s = {} 生成的是字典类型，而不是集合类型。

程序示例①：

s1 = set() #创建一个空集合。

l = [1.23,"a"] #列表类型

d = {1:"a",2:"b"} #字典类型

a = (1,2,"b") #元组类型

s = "厉害了，我的国" #字符串

#将列表，字典，元组，字符串转化为集合

s2 =set(s)

s3=set(l)

s4=set(d)

s5=set(a)print(s1)print(s2)print(s3)print(s4)print(s5)

程序运行结果：

set()

{'了', '的', '厉', '害', '国', '，', '我'}

{'a', 1.23}

{1, 2}

{1, 2, 'b'}

程序示例②：

d = {} #创建的是字典类型，空字典

s = set() #创建可变空集合

a = {1,2,3,"a"} #默认为可变集合

b = set("1,2,3") #与a语句等效

c1 = frozenset() #创建空的不可变集合，该集合不能添加任何元素。

c2 = frozenset("1,2,3") #不可变集合，集合中元素不能增加或删除。

print(type(d),type(s),type(a),type(b),type(c1),type(c2))

f= frozenset(a) #将可变集合a转换为不可变集合f

print(f,type(f))

s1= set(c2) #将不可变集合c2转换为可变集合s1

print(s1,type(s1))

程序运行结果：

frozenset({'a', 1, 2, 3}) {'2', '3', ',', '1'}

2.0 add()函数

描述：如果集合s中不存在元素x，则将元素x添加到集合s中。

语法：s.add(x)

x —— 要添加的元素。集合s已经存在元素x，也不会报错。

程序示例：

s = {1,2,"a"}

s.add("ab") #将字符串"ab"添加到集合s中

s.add(1) #集合s已存在元素 1 ，但不会报错

s.add("z") #将单字符"z"添加到集合s中

print(s)

程序运行结果：

{'a', 1, 2, 'z', 'ab'}

3.0 clear()函数

描述：删除集合s中的所有元素。

语法：s.clear()

程序示例：

s = {1,2,3,"a","bn"}

s.clear() #删除集合s所有元素

print(s)

程序运行结果：

set()

4.0 copy()函数

描述：复制生成一个新的集合。

语法 s.copy()

程序示例：

s = {1,2,3,"a","bc"}

s1 = s.copy() #复制集合s

s.add(789) #向原集合添加元素 789

s1.add("opq") #向复制集合s1添加元素 “opq”

#结果都互不干扰

print(s)

print(s1)

程序运行结果：

{1, 2, 3, 'a', 789, 'bc'}

{1, 2, 3, 'a', 'opq', 'bc'}

5.0 discard()函数

描述：移除集合s中的value元素。若value元素存在，则移除，不存在也不报错。

语法：s.discard(value)

value —— 要删除的元素

程序示例：

s = {1,2,3,4,5,"a","ab","h"}

s.discard(1) #移除元素 1

s.discard("ab") #移除元素 "ab"

s.discard("hj") #移除元素 "hj",但集合s中不存在元素"hj"

print(s)

程序运行结果：

{2, 3, 4, 5, 'a', 'h'}

6.0 remove()函数

描述：移除集合s中的value元素。若value元素存在，则移除，不存在则报错(产生KeyError异常)。

语法：s.remove(value)

value —— 要删除的元素

程序示例：

s = {1,2,3,4,5,"a","ab","h"}

s.remove(1) #移除元素 1

s.remove("ab") #移除元素 "ab"

print(s)

s.remove("hj") #移除元素 "hj",但集合s中不存在元素"hj" 程序会报错

print(s)

程序运行结果：

{2, 3, 4, 5, 'a', 'h'}

---------------------------------------------------------------------------

KeyError Traceback (most recent call last)

in ()

3 s.remove("ab") #移除元素 "ab"

4 print(s)

----> 5 s.remove("hj") #移除元素 "hj",但集合s中不存在元素"hj"

6 print(s)

KeyError: 'hj'

7.0 pop()函数

描述：随机移除集合s中的一个元素并返回该元素。若集合为空则报错(产生KeyError异常)

语法：s.pop()

程序示例：

s1 = {1,2,3,4,5,"a","b"}

print(s1.pop()) # 随机删除一个元素并返回

print(s1)

s2 = set() #创建一个空集合

print(s2.pop()) #s2为空集合，程序会报错。

程序运行结果：

1

{2, 3, 4, 5, 'b', 'a'}

---------------------------------------------------------------------------

KeyError Traceback (most recent call last)

in ()

4

5 s2 = set() #创建一个空集合

----> 6 print(s2.pop()) #s2为空集合，程序会报错。

KeyError: 'pop from an empty set'

8.0 difference()函数

描述：生成集合的差集。

差集概念：一般地，记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B(或集合A与集合B之差)，类似地，对于集合A、B，我们把集合 x|x∈A,且x∉B 叫做A与B的差集

差集

语法：a.difference(b,c,d...)  返回一个差集  等效于 a - b - d -...

a —— 集合a

b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

程序示例①：

a = {1,2,3,"a","b","c"}

b = {1,2,"a","h","78","b"}

x1 = a.difference(b) #集合a 减 集合b

x2 = b.difference(a) #集合b 减 集合a

print(x1)

print(x2)

print(a,b) #集合a和集合b的元素不改变。

程序运行结果：

{3, 'c'}

{'78', 'h'}

{1, 2, 3, 'b', 'a', 'c'} {1, 2, 'b', 'a', 'h', '78'}

程序示例②：

a = {1,2,3,"a","b","c","k"}

b = {1,2,"a","h","78","b"}

c = {1,2,0,"c","l"}

x = a.difference(b,c)

print(x)

程序运行结果：

{3, 'k'}

9.0 difference_update()函数

描述：把集合a更新为集合a与集合b的差集。集合a元素被更新改变，但集合b元素不改变。

或 从集合s中删除同时也在x中出现的所有元素。x可以是 集合，列表，元组，字典等或者支持迭代的所有对象。

语法：a.difference_update(b,c,d...)  无返回值

s.difference_update(x) 无返回值

a —— 集合a

b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

x—— 可以是 集合，序列或可以迭代的对象(括号中可以有多个对象)。

程序示例①：

a = {1,2,3,"a","b","c"}

b = {1,2,"a","h","78","b"}

a.difference_update(b) #把集合a 更新 为集合a与集合b的差集

print(a.difference_update(b)) #返回值为空。

print(a) #集合a元素被更新改变。

print(b) #集合b元素不改变

程序运行结果：

None

{3, 'c'}

{1, 2, 'b', 'a', 'h', '78'}

程序示例②：

a = {1,2,3,4,5,6,7,8,9,"a","b"}

b = {1,2,3,"a","k"}

c = {7,8,"h","o"}

a.difference_update(b,c)

print(a) #集合a元素被更新为 集合a与集合b,集合c 的差集。

print(b,c) #集合b,c元素不改变

程序运行结果：

{4, 5, 6, 9, 'b'}

{'a', 1, 2, 3, 'k'} {8, 'o', 'h', 7}

程序示例③：

a = {1,2,3,4,5,6,"a","b","c"}

b = {1,2,"h"} #集合

l = [4,"a"] #列表

t = ("c","88") #元组

d = {"k":11,5:"666"} #字典

#从集合a中删除在 集合b 列表l 元组t 字典d 中出现过的元素。

a.difference_update(b,l,t,d)

print(a)

程序运行结果：

{'b', 3, 6}

注意difference()函数和difference_update()函数的区别：

difference()函数不改变集合的元素。

difference_update()函数改变集合a元素。

10.0 union()函数

描述：生成集合的并集。即将集合a和集合b取并集，并将并集作为一个新的集合返回， 但是不改变原集合a和集合b

并集的概念：给定两个集合A，B，把他们所有的元素合并在一起组成的集合，叫做集合A与集合B的并集，记作A∪B，读作A并B。

语法：a.union(b,c,d...)  等效于 a | b | c | d...

a —— 集合a

b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

程序示例：

a = {1,2,"a","b"}

c = {3,5,"a"}

d = {"b",7,8,9}

print(a.union(c,d)) #返回集合a,集合b,集合c 的并集

print(a.union(c)) #返回集合a,集合c的并集

程序运行结果：

{1, 2, 'b', 3, 5, 7, 8, 'a', 9}

{1, 2, 'b', 3, 5, 'a'}

11.0 update()函数

描述：将集合a和集合b取并集，并将结果保存在集合a中(即更新集合a)，集合b不改变，但是没有返回值。

或  将x中的所有项添加到集合a中。x可以是 集合，列表，元组，字典等或者支持迭代的所有对象。

语法：a.update(b,c,d...)  返回值为空

a.update(x)  返回值为空

a —— 集合a

b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

x—— 可以是 集合，序列或可以迭代的对象(括号中可以有多个对象)。

注：集合中union()函数和update()函数都是将多个可迭代的集合 合并，但是返回的结果和对原集合的影响却不一样

程序示例①：

a = {1,2,3,"a","b"}

b = {7,2,9,"j"}

a.update(b)

print(a.update(b)) #返回值为空

print(a) #集合a被更新。

print(b) #集合b不改变。

程序运行结果：

None

{1, 2, 3, 7, 'b', 9, 'a', 'j'}

{9, 2, 'j', 7}

程序示例②：

a = {1,2,3,"a","b"}

b = {7,2,9,"j"}

c = {5,6,"o"}

a.update(b,c)

print(a) #集合a被更新。

print(b,c) #集合b,集合c 不改变。

程序运行结果：

{1, 2, 3, 5, 6, 7, 'o', 'b', 9, 'a', 'j'}

{9, 2, 'j', 7} {5, 6, 'o'}

程序示例③：

a = {1,2,3}

b = {7,8,9}

l = ["a","b",55] #列表

t = ("c","88") #元组

d = {"k":11,"l":"666"} #字典

#分别将 集合b 列表l 元组t 字典d 添加到集合a中

a.update(b,l,t,d)

print(a)

注：字典类型作用的是key值

程序运行结果：

{1, 2, 3, 'a', 7, 8, 9, 'k', 'l', '88', 'c', 55, 'b'}

12.0 symmetric_difference()函数

描述：返回对称差集(反向交集)，即返回两个集合中不重复的元素集合，即移除两个集合中都存在的元素。

对称差集的概念：集合A与集合B中所有不属于A∩B的元素的集合，记为A△B,也就是A△B=(A/B)∪(B/A).

​​​​​对称差集

语法：a.symmetric_difference(b)  等效于 a ^ b

a —— 集合a

b —— 集合b

程序示例：

a = {1,2,3,"a","b"}

b = {5,6,1,"b","c"}

x1 = a.symmetric_difference(b)

print(x1)

print(a,b)

程序运行结果：

{2, 3, 5, 6, 'c', 'a'}

{1, 2, 3, 'b', 'a'} {'c', 1, 'b', 5, 6}

13.0  symmetric_difference_update()函数

函数：把集合a更新为：集合a与集合b的对称差集。集合a元素被更新改变，但集合b元素不改变。

或 计算集合s与x的对称差集，并将结果保存在集合s中。x可以是 集合，列表，元组，字典等或者支持迭代的所有对象。

对称差集的概念：集合A与集合B中所有不属于A∩B的元素的集合，记为A△B,也就是A△B=(A/B)∪(B/A).

​​​​​对称差集

语法：a.symmetric_difference_update(b)   返回值为空

s.symmetric_difference_update(x)    返回值为空

a —— 集合a

b —— 集合b

x—— 可以是 集合，序列或可以迭代的对象(括号中只有一个对象)。

程序示例①：

a = {1,2,3,"a","b"}

b = {1,5,6,"a",}

a.symmetric_difference_update(b) #取集合a和集合b的对称差集，更新集合a并保存在集合a中

print(a.symmetric_difference_update(b)) #返回值为空

print(a) #集合a被更新.

print(b) #集合b元素不变。

程序运行结果：

None

{1, 2, 3, 'b', 'a'}

{1, 'a', 5, 6}

程序示例②：

a1 = {1,2,3,4,5,6,"a","b","c"}

a2 = {1,2,3,4,5,6,"a","b","c"}

a3 = {1,2,3,4,5,6,"a","b","c"}

l = [1,2,"a"] #列表

t = (3,5,"b") #元组

d = {"a":11,5:"666"} #字典

a1.symmetric_difference_update(l) #计算集合a1与 列表l 的对称差集，并将结果保存在集合a1中

a2.symmetric_difference_update(t) #计算集合a2与 元组t 的对称差集，并将结果保存在集合a1中

a3.symmetric_difference_update(d) #计算集合a3与 字典d 的对称差集，并将结果保存在集合a1中

print(a1)

print(a2)

print(a3)

注：字典类型作用的是key值

程序运行结果：

{'b', 3, 4, 5, 6, 'c'}

{1, 2, 4, 6, 'a', 'c'}

{'b', 1, 2, 3, 4, 6, 'c'}

14.0 intersection()函数

描述：生成集合的交集。

交集的概念：设A，B是两个集合，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集(intersection)，记作A∩B。

交集

语法：a.intersection(b,c,d...)  等效于 a & b & c & d...

a —— 集合a

b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

程序示例：

a = {1,2,3,"a","b"}

c = {2,8,"b","a","c"}

b = {1,2,5,8,"a","k"}

x1 = a.intersection(b) #返回集合a 和集合b 的交集

x2 = a.intersection(b,c) #返回集合a,集合b,集合c的交集

print(x1)

print(x2)

print(a,b,c) #集合a,集合b,集合c 元素不改变

程序运行结果：

{1, 2, 'a'}

{2, 'a'}

{1, 2, 3, 'b', 'a'} {1, 2, 'k', 5, 8, 'a'} {8, 'b', 2, 'a', 'c'}

15.0 intersection_update()函数

描述：把集合a更新为：集合a与集合b(或多个集合)的交集。集合a元素被更新，但集合b(其它集合)的元素不改变。

或 计算集合s与x的交集，并将结果保存在集合s中。x可以是 集合，列表，元组，字典等或者支持迭代的所有对象。

交集的概念：设A，B是两个集合，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集(intersection)，记作A∩B。

交集

语法：a.intersection_update(b,c,d...) 返回值为空

s.intersection_update(x)  返回值为空

a —— 集合a

b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

x—— 可以是 集合，序列或可以迭代的对象(括号中可以有多个对象)。

程序示例①：

a = {1,2,3,"a","b"}

c = {2,8,"b","a","c"}

a.intersection_update(b) #取集合a和集合b的交集，更新集合a并把结果保存在集合a中

print(a.intersection_update(b)) #返回值为空

print(a) #集合a中的元素被更新

print(b) #集合b中的元素不改变

程序运行结果：

None

{1, 2, 'a'}

{1, 2, 'k', 5, 8, 'a'}

程序示例②：

a = {1,2,3,"a","b"}

c = {2,8,"b","a","c"}

b = {1,2,5,8,"a","k"}

a.intersection_update(b,c) #去集合a,集合b，集合c的交集，更新集合a并把结果保存在集合a中

print(a)

print(b,c)

程序运行结果：

{2, 'a'}

{1, 2, 'k', 5, 8, 'a'} {8, 'b', 2, 'a', 'c'}

程序示例③：

s = {1,2,3,5,"a","b"}

l = [1,2,"a"] #列表

t = (1,2,3,8,"a","b") #元组

d = {1:2,2:6,"a":5,"k":11,5:"666"} #字典

s.intersection_update(l,t,d) #计算集合s与 列表l 元组t 字典d 的交集，并将结果保存在集合s中。

print(s)

注：字典类型作用的是key值

程序运行结果：

{1, 2, 'a'}

16.0 isdisjoint()函数

描述：判断两个集合是否包含相同的元素，若没有相同元素则返回 True，否则返回 False。

语法：s.isdisjoint(b)   返回bool类型(True False)

a —— 集合a

b —— 集合b

程序示例：

a = {1,2,3,"a"}

b = {"b","c","55","66"}

c = {1,2,5,"a"}

print(a.isdisjoint(b)) #集合a与集合b无相同的元素 返回True

print(a.isdisjoint(c)) #集合a与集合c有相同的元素，返回False

程序运行结果：

True

False

17.0 issubset()函数

描述：判断两个集合是否是子集关系(A⊆B)。即判断集合a中的所有元素是否都包含在集合b中，若都包含在集合b中则返回True，否则返回False

子集

语法：a.issubset(b) 返回bool类型(True False)

a —— 集合a

b —— 集合b

程序示例：

a = {1,2,3,"a"}

b = {1,2,3,"a","b","c"}

c = {1,2,3,"b","h"}

print(a.issubset(b)) #集合a是集合b的子集

print(a.issubset(c)) #集合a不是集合b的子集

程序运行结果：

True

False

18.0 issuperset()函数

描述：判断两个集合是否是超集(父集)。即判断集合b中的所有元素是否都包含在集合a中，若都包含在集合a中则返回True，否则返回False

超集概念：如果一个集合S2中的每一个元素都在集合S1中，且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集，反过来，S2是S1的子集。 S1是S2的超集，若S1中一定有S2中没有的元素，则S1是S2的真超集，反过来S2是S1的真子集。

超集

语法：a.issuperset(b)  返回bool类型(True False)

a —— 集合a

b —— 集合b

程序示例：

a = {1,2,3,"a","b","c"}

b = {1,3,"a"}

c = {1,2,3,"b","h"}

print(a.issuperset(b)) #集合a是集合b的超集.

print(a.issuperset(c)) #集合a不是集合b的超集。

程序运行结果：

True

False

注：issubset()函数和issuperset()函数的用法相似，注意两者区别。