集合2：方法和运算符—适用set/frozenset（上）

目录

1. s.copy()

2. s.isdisjoint(other)

3. 子集

3.1 s.issubset(other)

3.2 set <= other

3.3 set < other

4. 超集

4.1 s.issuperset(other)

4.2 set >= other

4.3 set > other

---

不改变原集合的方法，同时适用于set、frozenset对象，包括如下方法以及等价运算符：

1. s.copy()

返回 s 集合的一个浅拷贝

s = {1.1, 257, ('a',), 4, 5}
s = {1.1, 257, ('a','b','c')}
s1 = s.copy()
for x in s:
...     for x1 in s1:
...         if x == x1:
...             print(x)
...             if x is x1:
...                 print('x和x1是同一元素')
...                 
1.1
x和x1是同一元素
('a', 'b', 'c')
x和x1是同一元素
257
x和x1是同一元素

2. s.isdisjoint(other)

如果 s 集合中没有与 other 容器存在共同的元素，那么返回 True，否则返回 False；

当且仅当两个集合的交集为空集合时，两者为不相交集合；

other可以不是集合，还可以是列表、元组、字典、字符串；

列表、元组元素的子元素与集合中元素相同，仍不相交；

字典则判断其键是否与集合元素相交。

s1 = {1,'2',3.4,5j}

#如果 s 集合中没有与 other 容器存在共同的元素，那么返回 True，否则返回 False
s8 = {5j,6j,7j}
s1.isdisjoint(s8)
False
s9 = {'1',2}
s1.isdisjoint(s9)
True

#other可以是字典，判断其键是否与集合元素相交
s2 = {1:'x'}
s1.isdisjoint(s2)
False
s3 = {'x':1}
s1.isdisjoint(s3)
True

#other可以是列表
s4 = ['a','2','b']
s1.isdisjoint(s4)
False

#other可以是元组
s5 = (3.4,'c','d')
s1.isdisjoint(s5)
False

#列表、元组元素的子元素与集合中元素相同，仍不想交；
s6 = [(0,1),4,5]
s1.isdisjoint(s6)
True

#other可以是字符串
s7 = '123'
s1.isdisjoint(s7)
False

3. 子集

3.1 s.issubset(other)

如果 s 集合是 other 容器的子集，那么返回 True，否则返回 False；

对于两个集合 A、B，如果集合 A 中任意一个元素都是集合 B 中的元素，我们就说这两个集合有包含关系，称集合 A 为集合 B 的子集（Subset）；

other可以是列表、元组、字典、字符串等，字典是判断s集合是否是字典键的子集；

集合A==集合B，A是B的子集，但不是B的真子集。

s1 = {1,2,3,4}

#s 集合是 other 容器的子集，返回 True
s2 = {1,2,3,4}
s1.issubset(s2)
True
s3 = {1,2,3,4,5}
s1.issubset(s3)
True

#s 集合不是 other 容器的子集，返回 False
s4 = {2,3,4}
s1.issubset(s4)
False

#other 可以是元组、列表、字典、字符串等
s5 = [1,2,3,4,5]
s1.issubset(s5)
True
s6 = (1,2,3,4)
s1.issubset(s6)
True
s7 = {1:'a',2:'b',3:'c',4:'d'}
s1.issubset(s7)
True
s8 = {'1','2','3'}
s9 = '1234'
s8.issubset(s9)
True

3.2 set <= other

检测是否集合中的每个元素都在 other 之中，集合之间对比时，等价于s.issubset()；

运算符比较，other必须为集合，不支持列表、元组、字典、字符串等可迭代对象。

s1 = {1,2,3,4}

#集合中的每个元素都在 other 之中，返回True
s2 = {1,2,3,4,5}
s1 <= s2
True
s3 = {1,2,3,4}
s1 <= s3
True

#集合中有元素不在other之中，返回False
s4 = {1,2,3}
s1 <= s4
False

#运算符比较，other必须为集合，不支持列表、元组、字典、字符串等可迭代对象
s5 = [1,2,3,4,5]
s1 <= s5
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: '<=' not supported between instances of 'set' and 'list'

3.3 set < other

检测集合是否为 other 的真子集，即 set <= other and set != other。

s1 = {1,2,3,4}

#集合中的每个元素都在 other 之中，且set != other，返回True
s2 = {1,2,3,4,5}
s1 < s2
True

#set == other，返回False
s3 = {1,2,3,4}
s1 < s3
False

#集合中有元素不在other之中，返回False
s4 = {1,2,3}
s1 < s4
False

4. 超集

4.1 s.issuperset(other)

如果 s 集合是 other 容器的超集，那么返回 True，否则返回 False；

对于两个集合 A、B，如果集合 B 中任意一个元素都是集合 A 中的元素，我们就说这两个集合有包含关系，称集合 A 为集合 B 的超集（Superset）；

other可以是列表、元组、字典、字符串等，字典是判断s集合是否是字典键的子集；

集合A==集合B，A是B的超集，但不是B的真超集。

s1 = {1,2,3,4}

# s 集合不是 other 容器的超集，返回 False
s2 = {1,2,3,4,5}
s1.issuperset(s2)
False

# s 集合是 other 容器的超集，返回 True
s3 = {1,2,3,4}
s1.issuperset(s3)
True
s4 = {1,2,3}
s1.issuperset(s4)
True

#other 可以是元组、列表、字典、字符串等
s5 = [1,2,3,4]
s1.issuperset(s5)
True
s6 = (1,2,3)
s1.issuperset(s6)
True
s7 = {1:'a',2:'b',3:'c',4:'d'}
s1.issuperset(s7)
True
s8 = {'1','2','3','4'}
s9 = '123'
s8.issuperset(s9)
True

4.2 set >= other

检测是否 other 中的每个元素都在集合之中，集合之间对比时，等价于s.issuperset()

运算符比较，other必须为集合，不支持列表、元组、字典、字符串等可迭代对象。

s1 = {1,2,3,4}

# other 中存在不在集合中的元素，返回 True
s2 = {1,2,3,4,5}
s1 >= s2
False

# other 中的每个元素都在集合之中，返回 True
s3 = {1,2,3,4}
s1 >= s3
True
s4 = {1,2,3}
s1 >= s4
True

#运算符比较，other必须为集合，不支持列表、元组、字典、字符串等可迭代对象
s5 = [1,2,3,4]
s1 >= s5
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: '>=' not supported between instances of 'set' and 'list'

4.3 set > other

检测集合是否为 other 的真超集，即 set >= other and set != other。

s1 = {1,2,3,4}

# other 中存在不在集合中的元素，返回 False
s2 = {1,2,3,4,5}
s1 > s2
False

#set == other，返回 False
s3 = {1,2,3,4}
s1 > s3
False

# other 中的每个元素都在集合之中，且set != other，返回 True
s4 = {1,2,3}
s1 > s4
True