python基础类型set 用法

python 数据结构 set 用法

集合（set）是一个无序的不重复元素序列。

A set object is an unordered collection of distinct hashable objects.
set 是一个无序的,不重复的可hash 对象.

用来 存储 不重复元素的一个容器,并且元素直接是无序的.

可以使用大括号 { } 或者 set() 函数创建集合.
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# 创建一个set 
s = set([3,5,9,10])    
s
{9, 10, 3, 5}
t = set("Hello")         #创建一个唯一字符的集合
t
{'H', 'o', 'e', 'l'}


# 也可以这样创建一个集合
# s = {3,5,9,10}


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


# 添加元素
#如果 已经存在的元素,不会重新添加

s = {3,5,9,10}
s.add(5)
s
{9, 10, 3, 5}
s.add(66)
s
{66, 3, 5, 9, 10}



#判断一个元素是否在  集合可以用 in 
5 in s 
True
6 in s
False
66 in s 
True



# 求集合长度  
len(s)
5


# 删除元素集合中的一个元素
>>> s.remove(66)
>>> s
{3, 5, 9, 10}



# remove 删除一个不存在的元素 会报错 KeyError
s.remove('frank')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'frank'



# 也可以用来删除 元素, 如果不存在不会报错, 不会对集合做任何操作直接返回None.
#  Remove an element from a set if it is a member.
#  If the element is not a member, do nothing.

>>> s
{3, 5, 9, 10}
>>> s.discard('frank')
>>> s
{3, 5, 9, 10}


# 集合的拷贝 s.copy 这是一个浅拷贝
>>> s = set()
>>> s.add(1)
>>> s.add(10)
>>> s.add(5)
>>> s
{1, 10, 5}
>>> s.add(7)
>>> s
{1, 10, 5, 7}
>>> s.copy()
{1, 10, 5, 7}
>>> s2 = s.copy()
>>> s2
{1, 10, 5, 7}




#集合运算里面 有交 并 补  差集  运算 

>>> s={1,2,3,4}
>>> s2 = {3,4,5,6,7}
>>> s,s2
({1, 2, 3, 4}, {3, 4, 5, 6, 7})
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s& s2
{3, 4}
>>> s.intersection(s2)  # 交集
{3, 4}
>>> s
{1, 2, 3, 4}
>>> s 
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s.difference(s2)  # 差集
{1, 2}
>>> s - s2  
{1, 2}

# 集合的并集

>>> s.union(s2)
{1, 2, 3, 4, 5, 6, 7}
>>> s|s2
{1, 2, 3, 4, 5, 6, 7}

集合的交集 和差集 运算

交集 s & s2 或 s.intersection(s2) 交集运算

差集 s - s2 或 s.difference(s2) 差集运算

并集 s |s2 或 s.union(s2) 并集运算

>>> s  
{1, 2, 3, 4}
>>> s2 
{3, 4, 5, 6, 7}
>>> s.symmetric_difference(s2)
{1, 2, 5, 6, 7}
>>> s^s2  
{1, 2, 5, 6, 7}

删除 两个集合相同的元素,其他的元素构成一个集合返回. 比如上面的例子, 3,4 是公共元素,去掉两个集合的公共元素,其他的元素构成一个新的集合返回. {1,2,5,6,7}

s^s2 或 s.symmetric_difference(s2)

判断集合之间的关系

s.issubset(other) 判断 自己是不是 other 的子集.即判断 s <= other 返回 True or False

s.issuperset(other) 判断 s >= other 返回 True or False

issubset(other)
set <= other
Test whether every element in the set is in other.
# 这个方法是判断  自己是不是 另一个集合的子集 


issuperset(other)
Report whether this set contains another set.
# 这个方法 判断 自己 是否包含另一个集合. 


>>> s
{1, 2, 3, 4}
>>> s2
{1, 2, 3, 4, 5, 6}
>>> 
>>> s.issubset(s2)
True


>>> s2.issuperset(s)
True

set里面 还有很多 xxxxx_update 方法
这里 的作用 把更新的结果 直接写回到原集合里面.就相当于原地修改集合

s.difference_update(other)   # 求差集把结果更新到 s 集合里面
s.intersection_update(other) # 求交集把结果更新到 s 集合里面
s.symmetric_difference_update(other)  # 求 这个运算的结果  把结果写到s里面. 

下面 举个例子:

# 差集更新  
s = {1, 2, 3, 4}
s2 = {3, 4, 5, 6, 7}
s - s2
{1, 2}
s.difference(s2)
{1, 2}
s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}
s.difference_update(s2)


# 交集更新 
s = {1, 2, 3, 4}
s2 = {3, 4, 5, 6, 7}
s.intersection(s2)
{3, 4}
s.intersection_update(s2)
s
{3, 4}


# symmetric_difference_update  我也不知道叫什么运算,暂且叫异或运算吧, 把结果更新到 s 里面.

s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}

s.symmetric_difference(s2)
{1, 2, 5, 6, 7}

s.symmetric_difference_update(s2)
s
{1, 2, 5, 6, 7}

#  s.update(other)
# update 方法, 将一个其他的集合 更新到自己的集合里面. 相当于批量add 操作 
# 如果有相同的元素, 也只会有一个更新的到集合里面. 不会报错. (集合本身是不重复的特性)
>>> s
{1, 2, 7}
>>> s2 = {11,22,33}
>>> s.update(s2)
>>> s
{1, 2, 33, 22, 7, 11}
>>> s2
{33, 11, 22}

方法 pop()
s.pop () 随机 删除 集合中的元素 ,并且返回该元素 , 如果集合是空的,会抛异常KeyError

>>> s = {1,34,56,32,11,35,67,89,56}
>>> s
{32, 1, 34, 35, 67, 11, 56, 89}
>>> s.pop()
32
>>> s.pop()
1
>>> s.pop()
34
>>> s.pop()
35
>>> s.pop()
67
>>> s.pop()
11
>>> s.pop()
56

# 清空集合
# s.clear()   清空集合,使其变成一个空集合.
s = {1,34,56,32,11,35,67,89,56}
s.clear()
s
set()

总结

集合一般可以用来去重操作, 当需要存放不同的元素的时候,可以考虑用set来保存元素.

参考文档

set集合 https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset