day_6深浅拷贝，元组字典集合类型定义和各种操作方法

首先我们来讲一下深浅拷贝

1：值拷贝，假设一个列表等于L1 再定义一个L2=L1  这样就是值拷贝 L2只是存的L1存列表的地址，所以当L1发生改变，L2也随之改变

2：浅拷贝，L2=L1.copy（） 这样L2会新开辟一块内存地址放L1的所有值 但是会把L1的所有值的地址都直接复制过来放进去 所以如果L1里面有一个列表 如果这个列表里面值发生改变但是列表的内存地址不会改变所以L2里面还是存着这个列表的内存地址 所以L1里面的小列表发生改变，L2还是会跟着改变

3：深拷贝，from copy import deepcopy   L2= deepcopy(L1) ，这样就会新开辟一块空间L1中的不可变类型的地址就直接拿过来 ，但是可变类型一定重新开辟空间，所以当L1中的所有类型的值发生改变。L2都不会改变

元组

元组可以理解为不可变的列表

# 1.值可以为任意类型
# 2.可以存放多个值 - 可以进行成员运算
# 3.可以存放重复的值 - 可以计算成员出现的次数
# 4.有序存储 - 可以通过索引取值，可以切片

一些常用的操作

索引的取值

跟列表字符串一样 用元组名然后中括号放里面放索引值，索引值从0开始计数，可以为负数，是从倒着开始计数

拼接直接用一个元组加另一个元组

用len可以返回元组的长度

切片用元组名加中括号里面放两个冒号  前面放开始的值，中间放结束值，然后放步长，顾头不顾尾，开头包含，但是不包含结尾，步长可以为负数，从后往前切片，但是前面的值要比中间的大否则不执行

成员运算，  判断一个元素在不在元组中   这个元素 in 这个元组  然后在这里面就会返回True ，否则False

for 循环

元组可以进行for循环遍历

元组的.count方法是求一个对象在元组中出现的次数

元组的.index() 可以放三个值  第一个是需要查找的对象，后面两个放起始的索引，和结束的索引 不过不填 默认查找整个元组

字典类型

字典相关概念

# 容器(集合)：存放多个值的变量
# 单列容器(系统中的单列容器很多)：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}

字典的定义

# 空字典
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['c'] = 3
print(dic)
# 改
dic['c'] = 30
print(dic)
# 查:字典名[key]
print(dic['c']) # 只能查找已有的key，没有崩溃
# 有默认值的查询：有key取出对应value，没有返还默认值，默认值可以自定义
print(dic.get('d', 'http://www.baidu.com'))
# 删
print(dic)
# 清空
# dic.clear()
# pop(k)删除指定key的value并返还删除的value
# res = dic.pop('a')
# 从dic末尾删除，返还(key, value)形成的元组
res = dic.popitem()
print(dic, res)

# 其他方法
# 更新: 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，值就是第二个参数
dic.setdefault('z', 100)
print(dic)

# 字典的循环
# 1.直接循环，就是循环得到key
# for k in dic:
# print(k)

# 2.循环keys
# print(dic.keys())
# for k in dic.keys():
# print(k)

# 3.循环values
# print(dic.values())
# for v in dic.values():
# print(v)

# 同时循环key和value (key, value)
print(dic.items())
# a, b = (1, 2)
# print(a, b)
# for res in dic.items():
# print(res)
# 重点
for k, v in dic.items():
print(k, v)

# 解压赋值
# a, _, _, b = (1, 2, 3, 4)

集合类型

# 空集合：不能用{},因为用来标示空字典
s = set()
print(s, type(s))

# 概念：
# 1.set为可变类型 - 可增可删
# 2.set为去重存储 - set中不能存放重复数据
# 3.set为无序存储 - 不能索引取值
# 4.set为单列容器 - 没有取值的key
# 总结：set不能取值

# 增
s.add('1')
s.add('2')
s.add('1')
print(s)
s.update({'2', '3'})
print(s)

# 删
# res = s.pop()
# print(res)
# s.remove('1')
# print(s)
s.clear()
print(s)

# set运算
# 交集：两个都有 &
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py & lx)
print(py.intersection(lx))

# 合集：两个的合体 |
print(py | lx)
print(py.union(lx))

# 对称交集：抛出共有的办法的合体 ^
print(py ^ lx)
print(py.symmetric_difference(lx))

# 差集：独有的
print(py - lx)
print(py.difference(lx))

# 比较：前提一定是包含关系
s1 = {'1', '2'}
s2 = {'2'}
print(s1 < s2)