Python集合
集合(set)是一个无序的不重复元素序列。
-
定义:是一个无序的不重复元素序列。
-
创建:可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
-
特点:无序:输入顺序和输出顺序比一至 不重复
-
注:s = { }#这是字典
集合应用场景:
去重:如列表 去重。
- 关系测试:判断数据是否存在 交集,并集,差集 等关系。
- 集合的类型: 可变集合 —— set 不可变集合 —— frozenset
python set类是在python的sets模块中,新的python版本可以直接创建集合,不需要导入sets模块。
具体用法:
set('old')
set(‘o’,’l’,’d’)
集合内置方法完整列表
序号 | 方法 | 描述 |
---|---|---|
1 | add() | 为集合添加元素 |
2 | clear() | 移除集合中的所有元素 |
3 | copy() | 拷贝一个集合 |
4 | difference() | 返回多个集合的差集 |
5 | difference_update() | 移除集合中的元素,该元素在指定的集合也存在。 |
6 | discard() | 删除集合中指定的元素 |
7 | intersection() | 返回集合的交集 |
8 | intersection_update() | 返回集合的交集。 |
9 | isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
10 | issubset() | 判断指定集合是否为该方法参数集合的子集。 |
11 | issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
12 | pop() | 随机移除元素 |
13 | remove() | 移除指定元素 |
14 | symmetric_difference() | 返回两个集合中不重复的元素集合。 |
15 | symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
16 | union() | 返回两个集合的并集 |
17 | update() | 给集合添加元素 |
1.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()
{'的', '厉', ',', '了', '我', '国', '害'}
{1.23, 'a'}
{1, 2}
{'b', 1, 2}
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)
程序运行结果:
{1, 2, 'z', 'a', 'ab'}
3.clear()函数
描述:删除集合s中的所有元素。
语法:s.clear()
示例:
s = {1,2,3,"a","bn"}
s.clear() #删除集合s所有元素
print(s)
程序运行结果:
set()
4.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, 'opq', 'bc', 'a'}
5.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, 'h', 'a'}
6. 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)
<ipython-input-51-aa7ff641e07c> in <module>()
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)
<ipython-input-58-4637751b63f2> in <module>()
4
5 s2 = set() #创建一个空集合
----> 6 print(s2.pop()) #s2为空集合,程序会报错。
KeyError: 'pop from an empty set'
8.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'}
{'h', '78'}
{1, 2, 3, 'a', 'b', 'c'} {1, 2, 'a', 'b', 'h', '78'}
9. 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'}
注意difference()函数和difference_update()函数的区别:
difference()函数不改变集合的元素。
difference_update()函数改变集合a元素。
10.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.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}
12.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. 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}
14.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.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'}
16.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. 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.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()函数的用法相似,注意两者区别。