深浅拷贝，元祖，字典 ，集合的定义以及基本操作方法
深浅拷贝
# 值拷贝：应用场景最多
值拷贝：
先创建一个列表
ls = [1, 'abc', [10]]
再定义 ls1 = ls 此处ls1会直接将ls中在栈区存放的地址拿过来，也就是列表的门牌号，
所以在 ls 当列表内部的元素发生变化，ls1都会随之变化，因为值拷贝指挥把存储列表的地址拿过来，并不能把值的地址拿过来 浅拷贝：
再定义 ls2 = ls.copy() 使用copy()元素，它会早内存中开辟新列表的空间，但列表中的值地址都是直接从ls列表中拿过来的
所以 ls 内部的不可改变类型的元素地址不会改变，而可变类型元素发生改变，ls2中存放的值会随之变化
深拷贝：
再定义 ls3 = deepcopy(ls) 使用deepcopy()元素， 它会在内存中开辟新的列表空间，ls列表中的不可变类型的地址直接拿过来（优化机制），而可变类型的元素地址会重新开辟新的空间，
当 ls 内部的所有类型的值发生改变，ls3都不会随之变化
元组类型
'''
元组：可以理解为不可变的列表
# 1.值可以为任意类型
# 2.可以存放多个值 - 可以进行成员运算
# 3.可以存放重复的值 - 可以计算成员出现的次数
# 4.有序存储 - 可以通过索引取值，可以切片
'''
# 常用操作
# 1.索引取值
tuple = (1,2,3,4,5)
print(tuple[1],type(tuple[1]))
print(tuple[-3],type(tuple[-3]))
# 2.运算(拼接)
tuple = (1,2,3,4,5)
tuple1 = (5,7,8,9,10)
print(tuple + tuple1)
# 3.长度
tuple = (1,2,3,4,5)
print(len(tuple))
# 4.切片
tuple = (1,2,3,4,5)
print(tuple[1:5:1])
)
# 5.成员运算
tuple = (1,2,3,4,5)
print(1 in tuple) # 判断 1 是不是在 tuple 中，返回bool
print(1 not in tuple) # 判断 1 是不是不在tuple中 返回bool
# 6.for循环
tuple = (1,2,3,4,5)
for i in tuple:
print(i,end = '')
print()
# 方法
tuple = (1,2,3,4,5)
print(tuple.count(5)) # 对象5在tuple元组中出现的次数
tuple = (1,2,3,4,5)
print(tuple.index(3,1,len(tuple))) # 对象3在元组内 从1号位至末尾,第一次出现的索引，此处返还 2
字典类型
字典相关概念
# 容器(集合)：存放多个值的变量
# 单列容器(系统中的单列容器很多)：list | tuple
# 双列容器(map)：只有dict，存放数据 成对出现，dict存放数据采用 key-value键值对方式
# 字典中的key可以为什么类型：key必须为不可变类型
# -- key是取value的唯一依据，key一旦被确定，就需要唯一确定(不能被改变)
# 字典中的value可以为什么类型：value可以为任意类型
# -- value是用来存放世间所有存在的数据
# key要确保唯一性，不能重复，值可以重复，并且可以被改变 => 字典为可变类型
dic = {'a': 10, 1: 20, True: 30, (): 40} # 1和True都是1，key具有唯一性，所以只保留最后一次值
print(dic) # {'a': 10, 1: 30, (): 40}
字典的定义
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 , 英文名称 dict ,格式如下所示：
d = {key1 : value1, key2 : value2 }
不允许同一个key出现两次。创建时如果同一个key被赋值两次，后一个值会被记住，key的命名与变量名的命名一样
而value值它可以为任意类型的值
# 空字典
d1 = {}
d2 = dict()
# 用map映射创建字典
d3 = dict({'a': 1, 'b': 1})
print(d3)
# 用关键字赋值方式
d4 = dict(name='Bob', age=18) # 参数=左侧的名字就是合法的变量名，都会被转化为字符串形式的key
print(d4)
# 创建有多个key值采用默认值的方式: 默认值不写默认None，也可以自定义
d5 = {}.fromkeys('abc', 0)
print(d5)
字典的操作
dic = {'a': 1, 'b': 2}
print(dic)
# 增: 字典名[key] = 值 => key已存在就是修改值，不存在就是新增值
dic = {'a':1,'b':2,'c':3,'d':4}
print(dic)
dic['e'] = 5 # 直接把需要添加的key放入[]中 等号后面放value
print(dic)
# 改
dic = {'a':1,'b':2,'c':3,'d':4}
print(dic)
dic['d'] = 5 # 此处把 ' d ' 对应的value 改成了 5 ，方法与添加一样
print(dic)
# 查:字典名[key]
dic = {'a':1,'b':2,'c':3,'d':4}
print(dic)
print(dic['d']) 此处查询key 'd',返回’d'的value， 它只能查找已有的key，没有会崩溃（报错）
有默认值的查询：如果字典中有所查询的key，那么他会取出对应value，如果没有找到key，他会报错，可以用get()来获取，如果没有找到，他会返还默认值，默认值可以自定义
dic = {'a':1,'b':2,'c':3,}
print(dic.get('d', '未找到')) 此处使用get(),此处并没有'd'这个key,他会返回一个None,如果设定了默认值就返回默认值，此处默认值为 '未找到'
# 删
dic = {'a':3,'b':4,'c':5}
print(dic.clear()) # 清空整个字典，返回值为None
# pop(k)删除指定key的value并返还删除的value
dic = {'a':3,'b':4,'c':5}
print(dic.pop('a')) #此处删除了 'a' ，打印它会返回删除的value
print(dic) # 再次打印不会出现key 'a' 了
# dic = dic.pop('a')
print(dic)
# 从dic末尾删除，返还(key, value)形成的元组
dic = {'a':3,'b':4,'c':5}
dic = dic.popitem() #使用 popitem() 从末尾删除 key和value
print(dic) # 打印后返回（key,value）形成的元祖
# 其他方法
# 更新字典: a有值覆盖，c没被新操作，带下来，b为新增，增加并赋值
dic = {'a': 1, 'c': 2}
d = {'a': 10, 'b': 20}
dic.update(d)
print(dic) # {'a': 10, 'c': 2, 'b': 20}
# 带默认值的新增: 新增key，key已有，啥事不干，没有添加key，值就是第二个参数
setdefault() 方法和 get()方法 类似, 如果key不已经存在于字典中，将会添加key并将value设为默认值。
dic = {'a':3,'b':4,'c':5}
print(dic.setdefault('d','未找到'))
# 字典的循环
# 1.直接循环，就是循环得到key
dic = {'a':1,'b':2,'c':3}
for i in dic: #直接for 循环
print(i) # 此处输出结果为 a,b,c 得到 key
# 2.循环keys
dic = {'a':1,'b':2,'c':3}
print(dic.keys()) # 输出结果为 dict_keys(['a', 'b', 'c']) dic = {'a':1,'b':2,'c':3}
for i in dic.keys(): #for 循环keys()
print(i) # 输出结果为 a,b,c
# 3.循环values
dic = {'a':1,'b':2,'c':3}
print(dic.values()) # 输出的结果为dict_values([1, 2, 3])
dic = {'a':1,'b':2,'c':3}
for i in dic.values():
print(i) # 输出结果为 1，2，3
# 同时循环key和value (key, value)
dic = {'a':1,'b':2,'c':3}
print(dic.items()) #此处输出结果为dict_items([('a', 1), ('b', 2), ('c', 3)])
dic = {'a':1,'b':2,'c':3}
for i in dic.items()：
print(i) # 此处输出结果为（’a',1）('b',2)('c',3)
# 重点****
dic = {'a':1,'b':2,'c':3}
for k,v in dic.items(): # key ,和value一起循环
print(k,v) # 此处输出结果为 a 1 | b 2 | c 3
# 解压赋值
# a, _, _, b = (1, 2, 3, 4)
集合类型
定义空集合不能用 {} ,因为用来标示空字典的，我们定义空集合可以用set()
可以在括号里加（）,从内部括号中传值。
s = set() # 空集合
s = set(('a','b','c'))
print(s, type(s))
如果 {} 中不存value,只存一个元素，# a = {'a','b','c'} 那么他就是一个合集，如果放入key + value那就是字典
# 概念：
# 1.set为可变类型 - 可增可删
# 2.set为去重存储 - set中不能存放重复数据
# 3.set为无序存储 - 不能索引取值
# 4.set为单列容器 - 没有取值的key
# 总结：set不能取值
# 增
a = set(('a','b'))
a.add('c')
print(a) # 使用add() 依次可以传入一个参数，无序添加（因为集合本无序）
用它自己和其他元素的并集更新一个集合：
a = set(('a','b'))
a.update('c','d','e','f') # 直接添加默认只可合并可迭代对象（数字不可迭代）
print(a) # 无序
a = set((1,'b'))
a.update({'c',2}) # 如果需要合并数字，可以在括号中添加可以迭代的括号（）[] {},
print(a) # 打印结果是合集 {2,'b','c',1} (也是无序排列)
# 删
a = set((1,'b'))
a = a.pop() # 删除并返回任意集合元素。如果集合为空，则引发KeyError（报错） pop()不接受人和参数设定
print(a)
a = set((1,'b'))
a.remove(1,) # remove()可以删除指定的值，但是每次只能指定一个值。而且指定的值必须在集合内，否则报错
print(a)
a = set((1,'b'))
a.clear() #从该集合中删除所有元素，返回空集合
print(a)
# set运算
# 交集：两个都有 &
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py & lx) # 算两个集合的交集，返还所求的相同的元素，此处为egon
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py.intersection(lx)) # intersection 的功能等同与 & 号
# 合集：两个的合体
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py | lx) # 将两个集合的并集作为一个新集合返回。(即任何一个集合中的所有元素。)
print(py.uinon(lx)) # union 效果等同与 | 号
# 对称交集：抛出共有的办法的合体 ^
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py ^ lx) # 将两个集合的对称 差分，转化为一个新的集合，(即恰好位于其中一个集合中的所有元素。)
# 理论上可以理解为转换为一个新集合，存放两个集合所有的值，但是因为集合去重效果，会把相同的值，只存放一个
print(py.symmetric_difference(lx)) # symmetric_difference 效果等同与 ^ 号
# 差集：独有的
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py - lx) # 返回 py 中与 lx不重复的值
print(py.difference(lx)) #difference 效果等同与 - 号
print(lx - py) # 返回 lx 中与 lx 不重复的值
print(lx.difference(py)) #difference 效果等同与 - 号
# 比较：前提一定是包含关系
子类与父类的比较
s1 = {'1', '2'}
s2 = {'2'} # s2 中的元素必须在s1中才可比较
print(s1 < s2) # 此处是False,因为s1 要大于s2