day7-集合

一、定义变量是为了吹处理状态的变化，定义变量名是为了获取变量值。
字符串、数字、列表、元组、字典都是为了更好的描述变量的状态
1.可变不可变：变量名不变时，里面内容是否可以变化
# 可变：列表、字典。修改变量的值，ID不变

li = ['df','dfdf']
print(id(li)) # 2076395786824
li[0]='fkjg'
print(li)
print(id(li))  # 2076395786824 同一id地址，列表内内容可变化

# 不可变：字符串、数字、元组修改变量的值，ID变化

name = '马达'
print(id(name)) # 1951111215120
name = 'nkf'
print(id(name)) # 1951110131888 id不变，内容不可变

# 2.访问顺序：
# 可按照索引顺序访问：字符串、列表、元组（都是有序的）
# 映射方式访问;字典（一个key 对应一个value）
# 直接访问：数字

# 3：存放元素个数
# 容器类型（数据类型可存放多个值)：列表、元组、字典
# 原子类型（只能存放一个值)：数字、字符串

二.集合：定义集合可以用大括号{，，，} or 系统内置函数set,set里面的内容必须可迭代
# 由不同元素组成，
# 元素无序，
# 集合中元素必须是不可变类型-只能存放数字、字符串、元组

s = set('hello')
print(s)  # {'l', 'h', 'o', 'e'}
s = set((1,'djf'))
print(s)   # {1, 'djf'}

--add()添加

--clear()清空

--copy()复制

s.add('s')
s.add('3')
s.add(3)
print(s) # {1, 2, 3, 4, 5, 6, 's', '3'}

s.clear()
print(s)  # set()

s1=s.copy()

--pop()  # 集合无序，随机删除

--s.remove()  # 指定删除元素，当删除元素不存在时，会报错

--discard()  # 删除指定元素，元素不存在时也不报错

s = {'df',1,2,3,4,5}
s.pop()   # 集合无序，随机删除
print(s)  # {2, 3, 4, 5, 'df'}

# s.remove() # 指定删除元素，当删除元素不存在时，会报错
s.remove('jflkd')
print(s)     # KeyError: 'jflkd'

s.discard('dfjk') # 删除指定元素，元素不存在时也不报错
print(s)  # {2, 3, 4, 5, 'df'}

--intersection()求交集：我们都有

--union()求并集  ：全部

--difference()求差集：我有你没有

--symmetric_difference()交叉补集 并集-交集 我有你没有的组合

--difference_update：等同于p_s=p_s-l_s

--isdisjoint() 如果两个集合没有交集则返回True,否则返回False
--issubset()判断是否为子集

--issuperset()判断是否为父集

--update(）更新多个值,可迭代的对象都能传进去

# s1.add(1,2,3,4) #更新一个值
# s1.union(s2) #不更新

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)

# # intersection()求交集：我们都有
print(p_s,l_s)                # {'lcg', 'zjw', 'szw'} {'lcg', 'sb', 'szw'}
print(p_s.intersection(l_s))  # 'lcg', 'szw'}
print(p_s&l_s)                # $求交集 {'lcg', 'szw'}

# # union()求并集  ：全部
print(p_s.union(l_s))
print(p_s|l_s)                # |求并集  {'zjw', 'szw', 'lcg', 'sb'}

# # difference()求差集：我有你没有
print('差集',p_s-l_s)         # -求差集： 差集 {'zjw'}
print(p_s.difference(l_s))
print('差集',l_s-p_s)         # 差集 {'sb'}
print(l_s.difference(p_s))

# symmetric_difference()交叉补集 并集-交集 我有你没有的组合
print('交叉补集',p_s.symmetric_difference(l_s))   # 交叉补集 {'sb', 'zjw'}
print('交叉补集',p_s^l_s)  # ^交叉补集符号

python_l=['lcg','szw','zjw','lcg']
linux_l=['lcg','szw','sb']
p_s=set(python_l)
l_s=set(linux_l)
print(p_s,l_s)                   # {'lcg', 'zjw', 'szw'} {'lcg', 'sb', 'szw'}
# print('差集',p_s-l_s)
# difference_update：等同于p_s=p_s-l_s
p_s.difference_update(l_s)       # {'zjw'}
print(p_s)

# isdisjoint() 如果两个集合没有交集则返回True,否则返回False
s1={1,2}
s2={2,3,5}
print(s1.isdisjoint(s2))  # False

s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))#s1 是s2 的子集 True
print(s2.issubset(s1))#False

print(s2.issuperset(s1))#s1 是s2 的父集 True

s1={1,2}
s2={1,2,3,4}
s1.update(s2) #更新多个值,可迭代的对象都能传进去
print(s1)     # {1, 2, 3, 4}

# s1.add(1,2,3,4) #更新一个值
# s1.union(s2) #不更新

s=frozenset('hello') 
# 集合是可变的，frozenset设置不可变集合

print(s) # frozenset({'o', 'e', 'h', 'l'})  
names=['alex','alex','wupeiqi'] 
names=list(set(names)) print(names) 

# 'alex', 'wupeiqi'] 通过集合删除列表中重复值