set总结

set 定义

列表的特性：

• 可修改
• 无序
• 不重复

列表的创建：

​ 1.直接创建; s = {‘a', 1, 'c'}

​ 2.set() 创建一个空set; s = set()

​ 3.set(iterable)创建一个包含可迭代对象元素的set; set = {'abc'}

#直接创建
>>> s = {'a', 1, 2, 'b'}
>>> s
{1, 2, 'b', 'a'}
#使用set()创建一个空set
>>> s = set()
>>> s
set()
#创建一个包含可迭代对象元素的set
>>> s = set('abc')
>>> s
{'c', 'b', 'a'}

set的方法：

方法	说明
set.add(elem)	本地修改，增加一个元素
set.update(iterable)	本地修改，增加可迭代对象的元素
set.remove(elem)	本地修改，删除一个元素， 返回None,元素不存在则报错
set.discart(elem)	本地修改，删除一个元素，不论是否存在，返回None
set.pop()	本地修改，随机弹出一个元素，返回弹出的元素
set.clear()	本地修改
set.copy()	返回一个复制的新set

>>> s = set('abc')
>>> s
{'c', 'b', 'a'}
#增加一个元素
>>> s.add('de')
>>> s
{'c', 'de', 'b', 'a'}
#将可迭代对象的元素增加到元组中 与union效果相同
>>> s.update('def')
>>> s
{'e', 'f', 'b', 'd', 'de', 'a', 'c'}

#remove删除一个元素
>>> s.remove('a')
>>> s
{'e', 'f', 'b', 'd', 'de', 'c'}
#remove删除一个不存在的元素
>>> s.remove('ab')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'ab'

#remove删除一个元素
>>> s.discard('e')
>>> s
{'f', 'b', 'd', 'de', 'c'}

#remove删除一个不存在的元素
>>> s.discard('ab')
>>> s
{'f', 'b', 'd', 'de', 'c'}

#pop随机弹出一个元素，并返回该元素
>>> s.pop()
'f'


>>> s2= s.copy()
>>> s2
{'d', 'de', 'b', 'c'}
>>> s2.clear()
>>> s2
set()

set集合的判断

角色	说明	判断
元素存在	集合中是否有或者没有这个元素	x in set ； x not in set
子集	A是B的子集，说明A的所有元素在B中都存在	A.issubset (B)或者 A <= B
真子集	A是B的真子集，说明A的所有元素都在B中且B的元素个数比A多。	A < B
超集	A是B的超集，说明A中有B的所有元素	A.issuper(B)或者A >= B
真超集	A是B的真超集，说明A中有B的所有元素，且A的元素个数比B多	A > B
isdisjoin	A中所有的元素都不在B中	A.isdisjoint(B)

#几个范例
>>> A = {1, 2, 3}
>>> 1 in A
True
>>> 4 in A
False
>>> 4 not in A
True


>>> A = {1,2,3,4}
>>> B = {1,2,3,4,5}
>>> A.issubset(B)
True
>>> A<B
True

>>> A = {1,2,3,4}
>>> B = {1,2,3,4}
>>> A.issubset(B)
True
>>> A<B
False
>>> A<=B
True

>>> A = {1 ,2, 3}
>>> B = {4, 5, 6}
>>> A.isdisjoint(B)
True

set运算

操作	说明	方法	运算符重载
并集-->返回新集合	A与B的并集，返回包含A与B所有元素的集合，是A和B的super集合	A.union(*others)	A | B
并集-->本地修改	本地修改集合A为A与B的并集	A.update(*others)	A |= B
交集-->返回新集合	返回A与B的共同元素的集合	A.intersection(others)	A & B
交集-->本地修改	本地修改A集合为A与B交集，	A.intersection_update(*others)	A &= B
差集-->返回新集合	A的B差集，返回集合A中减去B的元素的集合	A.difference(*others)	A - B
差集-->本地修改	本地修改A集合为A与B的差集	A.difference_update(*others)	A -= B
对称差集-->返回新集合	返回一个包含只在A中和只在B中的元素的集合,又被称为补集	A.symmetric_difference(B)	A ^ B
对称差集-->本地修改	本地修改A为A与B的相对差集	A.symmetric_difference(B)	A ^= B

并集

>>> A = {1, 2, 3}
>>> B = {3, 4, 5}
>>> A.union(B)
set([1, 2, 3, 4, 5])

>>> A | B
set([1, 2, 3, 4, 5])

并集的运算符重载，必须为set，union是个迭代对象就可以

>>> C = (5,6)

>>> A | B | C
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'set' and 'tuple'
        
>>> A.union(B,C)
set([1, 2, 3, 4, 5, 6])

并集的本地修改

>>> C = (5,6)
>>> A
set([1, 2, 3])
>>> A.update(B)
>>> A
set([1, 2, 3, 4, 5])

>>> A |= set(C)
>>> A
set([1, 2, 3, 4, 5, 6])

交集运算

>>> A = {1, 2, 3}
>>> B = {3, 4, 5}
>>> C = (5,6)
>>> A.intersection(B)
set([3])
>>> A.intersection(B,C)
set([])
>>> A & B
set([3])
>>> A & B & C
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for &: 'set' and 'tuple'
>>> A & B & set(C)
set([])
>>> A.intersection_update(B)
>>> A
set([3])
>>> A &= set(C)
>>> A
set([])

差集运算

>>> A = {1, 2, 3}
>>> B = {3, 4, 5}
>>> C = (5,6)
>>> A.difference(B)
set([1, 2])
>>> A.difference(B,C)
set([1, 2])
>>> A -B -C
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'set' and 'tuple'
>>> A - B - set(C)
set([1, 2])
>>> A.difference_update(B)
>>> A
set([1, 2])
>>> A -= set(C)
>>> A
set([1, 2])

相对差集（补集）

>>> A = {1, 2, 3}
>>> B = {3, 4, 5}
>>> C = (5,6)
>>> A.symmetric_difference(B)
set([1, 2, 4, 5])

>>> A ^ B
set([1, 2, 4, 5])
>>> A.symmetric_difference(C)
set([1, 2, 3, 5, 6])

>>> A.symmetric_difference_update(B)
>>> A
set([1, 2, 4, 5])
>>> A ^= set(C)
set([1, 2, 3, 5, 6])

转载于:https://www.cnblogs.com/dingtianwei/p/9472635.html