第7节-元组&字典&集合

1.元组

（1）元组不能为空，而且至少还要有1个逗号；当元组不是空元组时，括号可以省略，

但是my_tuple=， my_tuple=(,)都会报错

（2）元组的访问/提取类似列表，通用操作与列表相同

2.拆包

2.1元组的拆包：

a,b,c = (1,2,3)，变量个数需与元素个数一一对应，否则会报错；如果不一致，可以在变量前面加*进行补足；
a,b,*c,d = (1,2,3,4,5,6,7),*表示补足变量，补足的变量位置得到列表
注意：语句中*只能出现一次

2.2列表的拆包：

my_list=[1,2,3], a,b = my_list,
注意：*补足同样适用，补足变量位置返回的也是列表

2.3字符串拆包：

my_str=‘i love china’，a,b,c = my_str
注意：*补足同样适用，补足变量位置返回的也是列表

3.字典

3.1字典的定义

（1）每一个键值对我们称其为一项(item)
（2）字典的键可以是任意的不可变对象(int str bool tuple…)

（3）字典的值可以是任意对象
（4）字典的键是不能重复的，如果出现重复的后面的会替换前面的

3.2字典的创建

（1）常规创建键值对
（2）dict（）函数方式
dict（）可以将一个含有双值子序列的序列转换为字典
双值序列：序列中有两个值，例如：[1,2]，（‘a’,‘b’）,‘ab’
子序列：如果序列中的元素也是序列，那么这个元素就是子序列[(1，2)]
含有双值子序列的序列：[（’name‘，’郭靖‘），（’name‘，'黄蓉’）]

（2.1）元组内变量赋值方式：
dict（name1=’郭靖‘，name2=‘黄蓉’）转换为{’name1‘=’郭靖‘，’name2‘：'黄蓉}
name1，name2表示变量，不能用引号括起来

（2.2）列表内元组对方式：
dict([（’name‘，’郭靖‘），（’name‘，'黄蓉’）])转换为{’name1‘=’郭靖‘，’name2‘：'黄蓉}，注意：必须用括号括起来表示一对键值对，且元组内元素有且仅有2个

3.3字典的使用

（1）len（）获取字典中键值对的个数

（2）in / not in检查字典中是否包含指定的键（注意：只能判断key而无法判断value或者key-value）

（3）dict[key]可以根据键获取字典当中的值，不能通过index来访问，因为默认都是键；如果key不存在会报错；

（4）get（）方法：dict.get(key,default)，通过key值拿到value，如果key值不存在，可以返回default值；如果不加入default，当key值不存在时返回None不会报错

（5）dict[key]=value重新赋值修改；如果key值不存在，则会直接在字典的最后位置添加新的键值对

（6）dict.setdefault(key,default)：如果key已存在则返回字典中的value；如果key不存在则直接在字典的最后位置添加key-value，value=default，并返回default

（7）dict.update()将其他字典中的key-value添加到当前字典当中
dict1.update(dict2)：更新的是dict1

（8）del dict[key] 删除字典当中的key-value （注意：字典中没有remove（）方法）

（9）dict.popitem()随机删除一个键值对，一般都会删除最后一个，并将删除后的键值对作为返回值返回，返回的是一个元组，第一个元素是key，第二个元素是value

（10）dict.pop(key，default)根据key来删除键值对，如果key存在，则返回对应的value；如果key值不存在，则返回default

（11）dict.clear（）清空字典

3.4浅拷贝&深拷贝

（1）赋值：相当于一个引用（指向相同的内存地址id），既不是深拷贝也不是浅拷贝

（2）浅拷贝&深拷贝,id()都不一样，用于序列嵌套（内层嵌套的序列与外层序列会有不同的内存地址）场景：

import copy
（3）浅拷贝：dict.copy(),copy.copy(dict)
只拷贝最外层的内存地址，内层的序列相当于直接引用（如下图：内存地址一样），修改内层序列时相当于直接修改了引用，因此内层序列会同时变化

（4）深拷贝：copy.deepcopy(dict)
拷贝到最内层的地址（如下图：内存地址不同），修改内层序列时只会修改拷贝后的id位置，因此原内层序列不会同时变化

3.5 字典的遍历：

（1）dict.keys（）方法：返回一个序列，保存的是字典中所有键，可以通过for循环遍历，也可以通过list强制转换为列表进行其他操作
for key in dict.keys():
print(dict[key])

（2）dict.values（）方法：返回一个序列，保存的是字典中所有值

（3）dict.items（）方法：返回一个序列，保存的是字典中所有项，此序列中国包含双值子序列，双值就是字典当中的key-value
for key， value in dic.items():
print(key,value)

4. 集合

4.1集合与列表的不同点：

1、集合只能存储不可变对象：元素不可为列表，字典
2、集合中存储的对象是无序的：集合中元素的位置随机存储，不存在索引
3、集合中不能出现重复的元素：不会报错，但存储时自动去重（因此可以通过强制转换作去重功能使用）

4.2集合的创建

s={1，2，3}
创建空集合 s=set（），注意是（），因为是方法，其他的空序列用方法创建时也是（）；而{ }默认是字典
t=tuple（）
l=list（）
d=dict（）

set（）方法可以将列表、元组、字典转换为集合

s =set（dict）将字典转换为集合时，将变为只有keys的集合

4.3集合的访问

因为集合无索引，所以需要先通过list（）转换在进行访问/提取

4.4集合的使用

in
not in
len（）
s.add（）向集合中添加方法
s1.update（s2）将一个集合中的元素添加到另一个集合中
set（‘hello’）与{‘hello’}不同：字符串是序列，转换时按元素进行转换，同时去重

s.pop（）删除方法，因为无序所以随机删除，返回删除的元素
s.remove（xxx）删除指定元素，括号中是具体的元素
s.clear（）清空集合

4.5集合的运算

交集运算&： s1 & s2返回包含相同元素的集合
并集运算| ： s1 | s2返回全部去重后所有元素的集合
差集运算- ： s1 - s2 返回s1中去除s1&s2后的元素集合
异或运算^： s1 ^ s2返回s1 | s2中去除s1&s2后的元素集合

<= 检查一个集合是否是另一个集合的子集
< 检查一个集合是否是另一个集合的真子集
>= 检查一个集合是否是另一个集合的超集
> 检查一个集合是否是另一个集合的真超集

4.6可变对象

内存中存储的对象有三要素：id、 type、 value

可变对象：序列中元素改变（包含增加、删除）但序列id不变

集合属于可变对象，因为可以通过s.add（）增加却不改变集合id，但str和tuple完全不可增加、删除、修改