python set() 集合的添加删除、交集、并集、差集、交叉补集、集合的方法介绍以及使用案例

可变不可变：

1.可变：列表、字典、例如列表类型是可变的，我修改了列表中的元素的值，但是列表本身在内存中的地址是没有变化的，所以列表的元素是可以被改变的

>>> name=["gouguoqi","beiye"]

>>> id(name)

6828808

>>> name[0]="123"

>>> print (name)

['123', 'beiye']

>>> id(name)

6828808

>>> 

 

2、不可变：字符串 、数字、元组（本身就不能变）之前也讲过，字符串在内存中定义之后就不可以变了，而列表就可以变，就是因为那个链表的概念

>>> name="gouguoqi"

>>> id(name)

7227568

>>> name="hehe"

>>> id(name)

7222192

 

访问顺序：

1.直接访问：数字

2.顺序访问：字符串、列表、元组

3、映射方式访问：字典   key value

存放元素个数：

容器类型：列表、元素、字典    （可以存放多个元素）

原子（只能存在一种数据类型）：数字、字符串

一、什么是集合

1、由不同元素的组成的集合，可作为字典的key

2、无序排列的可hash的值

3、集合中的元素必须是不可变类型

>>> s={1,2,3,4,5,6} 这是一个集合不是字典。字典是这样的s = {"key":"value","key2":"value2"}

集合用set表示，有去重特性

>>> s={1,2,3,4,5,6,6,6,6,6,6}

>>> type(s)

<class 'set'>

>>> print (s)

{1, 2, 3, 4, 5, 6}

 

集合是无序的（hello world本来是在前面的，打印出来就后面去了）

>>> s={"hello","world","gouguoqi","beiye"}

>>> for n in s:

...     print (n)

...

gouguoqi

beiye

hello

world

 

集合当中必须是不可变类型

把列表放到集合里面直接就报错了。因为列表是可变的

>>> s={[1,2,3],"hello"}

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list'

二、创建集合(重复就会去除，然后以for循环的方式把元素一个一个添加到集合里面)

>>> s = set("goguoqi")

>>> print (s)

{'o', 'g', 'i', 'q', 'u'}

 
s = set("hello")
print(s)
s = set(["gouguoqi", "gouguoqi", "sb"])
print(s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'l', 'e', 'h', 'o'}

{'sb', 'gouguoqi'}

 

三、集合的内置方法

1.add(self, *args, **kwargs)   (只能更新一个值)

Add an element to a set.   element  [ˈelɪmənt]  元素
This has no effect if the element is already present.    effect   [ɪˈfekt]  影响

添加一个元素到集合里面，如果这个元素已经有了，不影响

增加一个集合元素"11"

s = set(["gouguoqi", "gouguoqi", "sb"])
s.add("11")
print(s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'gouguoqi', 'sb', '11'}

为什么如果已经有了，在添加，就不会显示呢，因为集合本来就有去重的特性呀，你加个一样的，自然就会自动去重了

s = set(["gouguoqi", "gouguoqi", "sb"])
s.add("11")     这是一个字符串
s.add(11)  这是一个数字
s.add("11")   这是一个字符串
print(s)   结果就是多了一个数字11和一个字符串"11"

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'11', 11, 'gouguoqi', 'sb'}

2. clear(self, *args, **kwargs)

Remove all elements from this set      element  [ˈelɪmənt]  元素

从这个集合里面移除所有元素

s = set(["gouguoqi", "gouguoqi", "sb"])
s.clear()
print(s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

set()

3. copy(self, *args, **kwargs)

Return a shallow copy of a set    shallow   [ˈʃæləʊ]  浅

浅拷贝一个集合

s = set(["gouguoqi", "gouguoqi", "sb"])
v = s.copy()
print (s)
print (v)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'gouguoqi', 'sb'}

{'gouguoqi', 'sb'}

4. pop(self, *args, **kwargs)

Remove and return an arbitrary set element.   arbitrary    [ˈɑ:bɪtrəri]  任意的
Raises KeyError if the set is empty.

删除集合中任意的一个元素（）

如果集合为空，报错 TypeError: pop expected at least 1 arguments, got 0

s = {1,2,3,4,5,6,"s"}
s.pop()
print (s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{1, 2, 3, 4, 5, 6}

5. remove(self, *args, **kwargs)

Remove an element from a set; it must be a member.    [ˈmembə(r)]  成员
If the element is not a member, raise a KeyError

删除指定的元素，如果指定的删除的元素不在集合里面，则报错

a = {1,2,3,4,5,6,"s"}
a.remove("s")
print (a)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{1, 2, 3, 4, 5, 6}

当指定被删除元素不存在时

a = {1,2,3,4,5,6,"s"}
a.remove("ss")
print (s)

KeyError: 'ss'

6. discard(self, *args, **kwargs)   discard  丢弃

Remove an element from a set if it is a member.
If the element is not a member, do nothing

如果指定元素存在，就从集合中删除，如果不是集合中的一个元素(等价于被指定删除的元素不存在)，就什么也不做

a = {1,2,3,4,5,6,"s"}
a.discard("s")
v = a.discard("sss")
print (a)
print (v)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{1, 2, 3, 4, 5, 6}

None

四、集合的运算

7.集合关系。运算交，差，并集

取2个列表的交集     既会python，又会linux的人

这叫2个列表的关系运算

python_1 = ["ggq","ytj","mr"]
linux_1 = ["ggq","ytj"]
python_1_and_linux1 = []     既会py又会linux开始的时候不知道定义一个空列表
for p_name in python_1:   开始循环python_1里面的名字
    if p_name in linux_1:   如果python_1里面的名字也在linux_1
        python_1_and_linux1.append(p_name)我就把这个名字追加到既会py又会linux
print (python_1_and_linux1)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

['ggq', 'ytj']

如果没有集合的话，就只能像上面这样写了，很low也很麻烦

python_1 = ["ggq","ytj","mr","mr","ggq"]
p_s = set(python_1)
print (p_s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'ytj', 'ggq', 'mr'}

8.集合可以去重，如果有这样的需求想去除列表里面的重复元素的话就很简单了，直接把列表转换成集合就行了，但是有个弊端，就只转换之后，集合是无序的了 

9. intersection(self, *args, **kwargs)  [ˌɪntəˈsekʃn] 交叉

Return the intersection of two sets as a new set

求2个集合的交集（也就是取出来既会py又会linux的人）

python_1 = ["ggq","ytj","mr","mr","ggq"]
linux_1 = ["ggq","ytj"]
p_s = set(python_1)   #把列表转换为集合
l_s = set(linux_1)   #把列表转换为集合
print (p_s,l_s)
print (p_s.intersection(l_s)) #可以用集合的intersection方法
print (p_s&l_s)  #用&也是一样的效果 这是求交集的符号 &

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'ggq', 'mr', 'ytj'} {'ggq', 'ytj'}

{'ggq', 'ytj'}

{'ggq', 'ytj'}

10. union(self, *args, **kwargs)     并集

Return the union of sets as a new set

求2个集合的并集（就是把2个集合合并成一个集合，因为集合有去重特性，所以就是把2个集合合并成一个集合并去除重复的）

python_1 = ["ggq","ytj","mr","mr","ggq"]
linux_1 = ["ggq","ytj","sb"]
p_s = set(python_1)
l_s = set(linux_1)
print (p_s,l_s)
print (p_s.union(l_s))   #求并集的方法

print (p_s|l_s)          #求并集的符号 |

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'ytj', 'ggq', 'mr'} {'ytj', 'ggq', 'sb'}

{'ggq', 'mr', 'sb', 'ytj'}

{'ggq', 'mr', 'sb', 'ytj'}

11. difference(self, *args, **kwargs)   差集

Return the difference of two or more sets as a new set

求差集

python_1 = ["ggq","ytj","mr","mr","ggq"]
linux_1 = ["ggq","ytj","sb"]
p_s = set(python_1)
l_s = set(linux_1)
print (p_s,l_s)
print (p_s.difference(l_s))  #差集的方法
print (p_s-l_s)         #求差集的符号 -

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'ytj', 'ggq', 'mr'} {'ytj', 'ggq', 'sb'}

{'mr'}

{'mr'}

12. symmetric_difference(self, *args, **kwargs) 交叉补集

Return the symmetric difference of two sets as a new set

就是2个集合交叉一下，扣掉两者共有的，剩下的就是

python_1 = ["ggq","ytj","mr","mr","ggq"]
linux_1 = ["ggq","ytj","sb"]
p_s = set(python_1)
l_s = set(linux_1)
print (p_s,l_s)
print (p_s.symmetric_difference(l_s)) #交叉补集的方法
print (p_s^l_s)    #交叉补集的符号 ^

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'mr', 'ggq', 'ytj'} {'ggq', 'sb', 'ytj'}

{'mr', 'sb'}

{'mr', 'sb'} 

13. difference_update(self, *args, **kwargs)

Remove all elements of another set from this set

python_1 = ["ggq","ytj","mr","mr","ggq"]
linux_1 = ["ggq","ytj","sb"]
p_s = set(python_1)
l_s = set(linux_1)
print (p_s,l_s)
p_s = p_s-l_s
p_s.difference_update(l_s)#这个方法相当于给p_s重新赋值了p_s = p_s-l_s

p_s -= l_s            #用符号来表示 -=
print (p_s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'mr', 'ytj', 'ggq'} {'ytj', 'sb', 'ggq'}

{'mr'}

14. intersection_update(self, *args, **kwargs)

Update a set with the intersection of itself and another.

python_1 = ["ggq","ytj","mr","mr","ggq"]
linux_1 = ["ggq","ytj","sb"]
p_s = set(python_1)
l_s = set(linux_1)
print (p_s,l_s)
p_s = p_s&l_s
p_s.intersection_update()#这个方法相当于给ps重新赋值了 p_s = p_s&l_s
print (p_s)
p_s &= l_s   #用符号来表示就是 &=
print (p_s)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'ggq', 'mr', 'ytj'} {'sb', 'ggq', 'ytj'}

{'ggq', 'ytj'}

{'ggq', 'ytj'}

15. isdisjoint(self, *args, **kwargs)

Return True if two sets have a null intersection

如果2个集合没有交集（相同的元素），就返回True

 

如果2个集合有交集（相同的元素），就返回False

S1 = {1,2,3}
S2 = {4,5,6,1}
print (S1.isdisjoint(S2))

 C:python35python3.exe D:/pyproject/day12列表/set-集合.py

False

16. issubset(self, *args, **kwargs)

Report whether another set contains this set。  whether 是否   contains 包含

报告是否另一个集合包含这个集合

相当于 s1<=s2  就为True

专业说法就是 s1 是s2的子集，或者是s2是s1的父集

S1 = {1,2,3}
S2 = {1,2,3,4.5}
print (S1.issubset(S2))   #这个方法是判断S1是否是S2的子集

print (s1<=s2)   #用符号表示 <=

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

True

True

如果S1不是S2的子集，就Flase了

很明显，现在S1是S2的父集了，所以就为False了

S1 = {1,2,3,4.5}
S2 = {1,2,3}
print (S1.issubset(S2))

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

False

17. issuperset (self, *args, **kwargs)

Report whether this set contains another set

报告是否这个集合包含另一个集合

相当于S1 >= S2   就为True

专业说法就是S1是S2的父集。

S1 = {1,2,3,4.5}
S2 = {1,2,3}
print (S1.issuperset(S2))  #这个方法是判断S1是否是S2的父集

print (S1 >= S2)  #用符号表示就是  >=

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

True

True

 

如果S1不是S2的父集，就返回False

这很明显了，S1是S2的子集了，所以就是False

S1 = {1,2,3}
S2 = {1,2,3,4.5}
print (S1.issuperset(S2))

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

False

18. update(self, *args, **kwargs) 用来更新多个值，参数是可迭代对象

Update a set with the union of itself and others

就是把S2中的所有元素更新到S1里面去，给S1重新赋值了，以前那些求交集、合集的并没有真实改变S1的值，而这个update就改变了S1的值

当参数是一个集合的时候

S1 = {1,2,3}
S2 = {1,2,4.5}
S1.update(S2)
print (S1)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{1, 2, 3, 4.5}

当参数是一个元组的时候

S1 = {1,2,3}
S1.update(("gouguoqi",6,))
print (S1)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{'gouguoqi', 1, 2, 3, 6}

当参数是一个集合的时候

S1 = {1,2,3}
S1.update([11,22,"hehe"])
print (S1)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

{1, 2, 3, 11, 22, 'hehe'}

五、不可变集合，这就是不可变集合

S1 = frozenset("hello")
print (S1)

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

frozenset({'l', 'h', 'e', 'o'})

把列表用集合进行去重之后，在变回列表的类型

names = ["gouguoqi","miaoye","gouguoqi"]
# a  = set(names)
# print (a)
# b = list(a)
# print (b)
print (list(set(names)))   #把上面四行改成一行

C:python35python3.exe D:/pyproject/day12列表/set-集合.py

['gouguoqi', 'miaoye']