可变不可变：
1.可变：列表、字典、例如列表类型是可变的，我修改了列表中的元素的值，但是列表本身在内存中的地址是没有变化的，所以列表的元素是可以被改变的
>>> name=["gouguoqi","beiye"] >>> id(name) 6828808 >>> name[0]="" >>> print (name) ['', '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:\python35\python3.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("")
print(s) C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'gouguoqi', 'sb', ''}
为什么如果已经有了，在添加，就不会显示呢，因为集合本来就有去重的特性呀，你加个一样的，自然就会自动去重了
s = set(["gouguoqi", "gouguoqi", "sb"])
s.add("") 这是一个字符串
s.add(11) 这是一个数字
s.add("") 这是一个字符串
print(s) 结果就是多了一个数字11和一个字符串"" C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py {'', 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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.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:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 4.5}
当参数是一个元组的时候
S1 = {1,2,3}
S1.update(("gouguoqi",6,))
print (S1)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{'gouguoqi', 1, 2, 3, 6}
当参数是一个集合的时候
S1 = {1,2,3}
S1.update([11,22,"hehe"])
print (S1)
C:\python35\python3.exe D:/pyproject/day12列表/set-集合.py
{1, 2, 3, 11, 22, 'hehe'}
五、不可变集合，这就是不可变集合
S1 = frozenset("hello")
print (S1)
C:\python35\python3.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:\python35\python3.exe D:/pyproject/day12列表/set-集合.py ['gouguoqi', 'miaoye']