python之集合及其方法---整理集

集合的定义：

由不同元素组成、一组无序排列的可hash值、集合中元素必须是不可变类型

　　集合的定义方式：
　　由大括号组成；
　　每个元素用逗号分隔；
　　元素书写不是key-value形式；

集合是由不同元素组成，如果在集合中使用相同元素，会自动处理
例如：

s={1,2,3,3,44,33,33,4,4,5,5,7}
type(s)
print(s)
返回结果：
{33, 2, 3, 4, 5, 1, 7, 44}

集合是无序的：
例如：

s={'a','h','o','n','b','d','c'}
for item in s:
    print(item)
返回结果：
n
o
c
h
d
a
b

集合的书写定义格式：
格式1：
　　s={element1,element2,element3...}
　　element都为不变类型

格式2：
　　s=set(<可迭代类型>)
　　可迭代类型：字符串、列表、元组、字典

例如：定义格式2

s=set([1,2,3,"hello"]) #遍历列表，把每个元素当作集合中的一个值
print(s)
返回结果：
{1, 2, 3, 'hello'}

s=set((1,2,3))
print(s)
返回结果：
{1, 2, 3}

s=set({'k1':'v1','k2':'v2'})  #以逗号分隔，遍历字典，得到值后不再继续遍历
print(s)
返回结果：
{'k2', 'k1'}

s=set('hello')
print(s)
返回结果：
{'e', 'o', 'h', 'l'}

s=set("hello")
print(s)
返回结果：
{'e', 'o', 'h', 'l'}

********集合的方法：********

1.add()方法：向集合中添加元素

s={1,2,3}
s.add('s')
print(s)
返回结果：
{1, 2, 3, 's'}

2.clear()方法：清空集合

3.copy()方法：复制集合

4.pop()方法：从集合中随机删除一个元素，不特定的顺序删除
　　pop方法可以把删除的元素赋值给变量
例如：

s={'sss',1,2,3}
v=s.pop()
print(v,s)
返回结果：
1 {2, 3, 'sss'}

5.remove()方法：从集合中指定删除一个元素
格式：
　　S.remove(<element>)
如果指定的element在集合中不存在，则报错
例如：

s={'sss',1,2,3}
s.remove('sss')  #注意要使用引号
print(s)
返回结果：
{1, 2, 3}

6.discard()方法：指定元素删除，如果指定元素不存在，则不会报错

********集合的关系操作及其方法********

1.
intersecion()方法：获取2个集合的交集
格式1：
　　S1.intersection(<S2>)
格式2：
　　S1&S2
例如：

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']
p_s=set(python_l)
l_s=set(linux_l)
v=p_s.intersection(l_s)
print(v)
返回结果：
{'szw', 'lcg'}

或者
v=p_s&l_s
print(v)

2.
union()方法：获取2个集合的并集，组成一个集合，并且去重
格式1：
　　S1.union(<S2>)
格式2：
　　S1|S2
例如：

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']
p_s=set(python_l)
l_s=set(linux_l)
v=p_s.union(l_s)
print(v)
返回结果：
{'zjw', 'lcg', 'szw'}

或者
v=p_s|l_s
print(v)

3.
difference()方法：生成2个集合的差集，表示在左面的集合中，只存在于左面集合，在右面集合没有的元素
格式1：
　　S1.difference(<S2>)
格式2：
　　S1-S2
例如：

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']
p_s=set(python_l)
l_s=set(linux_l)
v=p_s.difference(l_s)
print(v)
返回结果：
{'zjw'}

或者
v=p_s-l_s
print(v)

4.
symmetric_difference()方法：集合的交差补集
格式1：
　　S1.symmetric_difference(<S2>)
格式2：
　　S1^S2
例如：

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']
p_s=set(python_l)
l_s=set(linux_l)
v=p_s.symmetric_difference(l_s)
print(v)
返回结果：
{'zjw'}

5.
difference_update()方法：两个集合做完差集(difference)之后，把结果更新回去
格式
　　S1.difference_update(<S2>)
　　S1与S2作差集，然后把结果赋值给S1

例如：

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']
p_s=set(python_l)
l_s=set(linux_l)
p_s.difference_update(l_s)
print(p_s)
返回结果：
{'zjw'}

6.
intersection_update()方法：两个集合做交集（intersection），把结果更新回去
格式：
　　S1.intersection_update(S2)
　　S1与S2作交集，然后把结果赋值给S1
例如：

python_l=['lcg','szw','zjw']
linux_l=['lcg','szw']
p_s=set(python_l)
l_s=set(linux_l)
p_s.intersection_update(l_s)
print(p_s)
返回结果：
{'lcg', 'szw'}

7.
isdisjoint()方法：如果两个集合交集之后，没有结果，返回True，就是两个集合没有交集就返回True
格式：
　　S1.isdisjoint(S2)
例如：

s1={1,2}
s2={3,5}
v=s1.isdisjoint(s2)
print(v)
返回结果：
True

s1={1,2,3,}
s2={2,4,9}
v=s1.isdisjoint(s2)
print(v)
返回结果：
False

8.
issubset()方法：返回一个集合是否是另一个集合的子集合，是子集合返回True，否则返回False
格式：
　　S1.issubset(S2)
例如：

s1={1,2}
s2={1,2,3}
v=s1.issubset(s2)
print(v)
返回结果：
True

9.
issuperset()方法：返回一个集合是否是另一个集合的父集、超集，是返回True，否则返回False
格式：
　　S1.issuperset(S2)
例如：

s1={1,2}
s2={1,2,3}
v=s2.issuperset(s1)
print(v)
返回结果：
True

10.
update()方法：将可迭代对象(字符串、元组、列表、集合)做并集，把结果更新回去
格式：
　　S1.update(<可迭代对象>)
　　作并集之后，把结果赋值给S1

例如：

s1={1,2}
s2={1,2,3}
s1.update(s2)
print(s1)
返回结果：
{1, 2, 3}