Python元组，字典，集合操作

1. 元组(tuple)
   （一个不可变序列）
   定义一个元组:a = ( )

2. 元组的解包
   （解包后为多个数据为列表存放）

使每个变量从a元组中拿取一个元素

a = (1,2,3,4)
b,c,d,e = a

b,c各取一个位置对应元素，其余元素作为列表放入变量d中

a = (1,2,3,4)
b,c,*d = a

b,d各取一个位置对应元素，其余元素作为列表放入变量c中

a = (1,2,3,4)
b,*c,d = a

（元组其他操作和列表差不多）

3. 字典(dict)（键值对）
   （无序）（key值不能为可变类型）
   数据结构 映射(mapping)
   字典的作用其实和列表类似，用来存储对象的容器
   列表存储数据的性能非常好，但是查询数据的性能很差。字典正好相反
   在字典当中每一个元素都有唯一的一个名字 通过这个名字可以快速查询到指定的元素
   这个唯一的名字我们一般称之为 键(key) 通过key我们可以查询value 值
   所以字典我们也称之为键值对(key-value)
   每个字典当中可以有多个键值对，每一个键值对我们可以称之为一项(item)
   语法: {key:value,key:value…}
   字典中的键是不能重复的，如果重复后面的会替换前面的

dict可以将双值子序列转换为字典
例如:

a = [("name","xiaoming"),("age",15)]
b = dict(a)

此时b的内容为：{'name': 'xiaoming', 'age': 15}

---

len（） 函数可以获取字典中键的个数

---

in 与 not in 查看字典中是否包含指定的键

---

字典名[键名] 可以查看键所对应的值

---

get(key,[default]) 该方法是用来根据键来获取字典当中的值
如何键不存在 则返回None
也可以指定第二个参数为默认返回值

---

修改字典
字典名[键名] = value 可以修改字典中对应键的值
如果字典中没有 则添加一个键值对

---

setdefault(key,value) 向字典中添加一个键值对
如果键存在 则返回已有键所对应的值
如果键不存在 则返回添加键所对应的值

a = {'name': 'xiaoming', 'age': 15}
b = a.setdefault("name","zhangsan")

此时b中的值为 xiaoming
如果不存在则直接添加

---

update( )
将一个字典中的键值对 添加到另一个字典中

a = {"name1":"xiaoming","age1":15}
b = {"name2":"zhangsan","age2":16}
a.update(b)

此时a中字典的内容为：
{'name1': 'xiaoming', 'age1': 15, 'name2': 'zhangsan', 'age2': 16}
如果b中与a中的键值对名相同，则b的键值对会覆盖a

---

del 用来删除键值对

a = {'name': 'xiaoming', 'age': 15}
del a["name"]

此时a中的内容为: a = {'age': 15}

---

.popitem( ) 随机删除一个键值对，一般都会删除最后一个
它会将删除之后的键值对作为返回值 返回的是一个元组

a = {'name': 'xiaoming', 'age': 15}
a.popitem()

此时a中的内容为:a = {"name":"xiaoming"}

---

.pop(key,[default]) 根据key来删除指定的键
返回删除键的值
如果没有默认出现错误提示，可定义返回值来取代错误提示

a = {'name': 'xiaoming', 'age': 15}
a.pop("name")

此时a中的内容为: a = {'age': 15}

---

.clear( ) 清空字典

4. 潜复制
   .copy
   浅复制只会复制字典表层内容，如果存在字典中还有字典情况，只会复制字典的地址，不会复制字典中的内容
   用于对字典进行一个浅复制

d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
a = d.copy()
d["a"]["name"] = "猫和老鼠"
d["b"] = 3
print(a)
print(d)

此时屏幕输出内容为：

{'a': {'name': '猫和老鼠', 'age': 18}, 'b': 2, 'c': 3}
{'a': {'name': '猫和老鼠', 'age': 18}, 'b': 3, 'c': 3}

5. 遍历字典
   .keys() 该方法返回的是一个序列，保存的是字典中所有的键
   .values() 该方法返回的是一个序列，保存的是字典中的值
   .items() 该方法会返回字典中所有的项 。它返回的也是一个序列
   这个序列当中包含有双值子序列 双值就是字典中的key-value

a = {"name":"xiaoming","age":15,"high":"180cm"}
b = a.keys()
c = a.values()
d = a.items()

内容分别为：
a:dict_keys(['name', 'age', 'high'])
b:dict_values(['xiaoming', 15, '180cm'])
c:dict_items([('name', 'xiaoming'), ('age', 15), ('high', '180cm')])

---

遍历一个字典可以这样

a = {"name":"xiaoming","age":15,"high":"180cm"}
for b,c in a.items():
	print(b,"=",c)

实现的效果屏幕输出为：
name = xiaoming
.age = 15
.high = 180cm

6. 集合(set)
   （既不支持index索引值取值 也不支持key键取值）
   集合和列表非常相似
   不同点:
   1 集合中只能存储不可变对象
   2 集合中存储的对象是无序的
   3 集合中不能出现重复的元素

s = {20,10,1,2,3,4,100,1,2,3,4,1,1,1}

结果为:a = {1, 2, 3, 4, 100, 10, 20}

---

set( ) 可以将序列和字典转换为集合
使用set()函数将字典转换为集合的时候，只会包含字典中的键

s = set({'a':1,'b':2,'c':3})

其中s为：s = {'c', 'a', 'b'}

---

7. 集合的运算

交集运算

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
s3 = s1 & s2

s3的值：s3 = {3,4,5}

---

并集运算

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
s3 = s1 | s2

s3的值：s3 = {1, 2, 3, 4, 5, 6, 7}

---

异或运算

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
s3 = s1 ^ s2

s3的值：s3 = {1, 2, 6, 7}

---

差集运算
（前面的集合中哪些元素是后面集合中没有的）

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
s3 = s1 - s2
s4 = s2 - s1

s3的值:s3 = {1,2}
s4的值:s4 = {6,7}

---

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

s1 = {1,2,3}
s2 = {1,2,3}
s3 = s1 > s2
s4 = s1 >= s2

s3的值:False
s4的值:True