一、元组

1.什么是元组(tuple)

python提供的容器型数据类型，是不可变而且有序的（元组就是不可变的列表）

• 不可变 -- 不支持增删改，只支持查找
• 有序 -- 每个元素都对应一个确定的下标

2.元组的字面量和元素

(元素1， 元素2， 元素3...)
其中的元素可以是任何类型的数据，元素的类型可以不一样，且同样的元素可以有多个

a.空的元组

tuple1 = ()
print(tuple1)

b.只有一个元素的元组

tuple2 = (520,)
print(tuple2, type(tuple2))

c.直接用逗号将元素隔开，不加括号，也是一个元组

tuple3 = 'cc', 520, 1314
print(tuple3, type(tuple3))

3.元组获取元素和列表一样

tuple4 = ('cc', 520, 1314, 'forever')

获取单个元素

print(tuple4[0], tuple4[-3])

获取部分元素

print(tuple4[1:3])
print(tuple4[::-1])

补充：特殊的获取方式

1.变量1，变量2... = 元组 -- 用前面的变量依次获取元组元素的值（要求前面变量的个数和元组元素的个数一样）

tuple4 = ('cc', 520, 1314, 'forever')
w, x, y, z = tuple4
print(w, x, y, z)

2.变量1，变量2 = 元组 -- 通过带的变量获取剩余部分的所有元素

（此结构中带*的变量最多只能有一个，不带*的可以有多个,打印带*的变量数据类型为列表）

tuple5 = ('cc', 520, 1314)
name, *num = tuple5
print(name, num)

也可以在其他变量前加*

*name, num = tuple5
print(name, num)

补充：*的用法

1.取元组和列表中的数据

tuple6 = ('cc', 520, 1314)
list1 = ['cc', 520, 1314]
str1 = 'adgdgabc'
print(*tuple6, *list1, *str1)

相关运算（和列表一样）

+ ，*
in ， not in
len（），max（），min（），sum（），tuple（）
print(tuple(list1))  # 类型转换

5.排序

sorted（序列） -- 对序列中的元素排序，无论是什么序列，排序完成后都是产生一个新的列表
注意： 列表.sort（）-- 修改原列表中元素的顺序 ；sorted（列表）-- 将原列表中的元素提出来排序后产生新的列表

join的用法

字符串.join（序列） -- 将序列中的元素取出，用指定的字符串连接在一起，要求序列中的元素必须是字符串

new_str = '1'.join(('cc', 'wo', 'ai', 'ni'))
print(new_str, type(new_str))

list2 = [1314, 10, 520, 25]
another_list = list2.sort()  # None  sort不会产生新的列表
print(list2, another_list)

二、字典

1.什么是字典（dict）

python提供的容器型数据类型，可变且无序
可变 -- 支持元素的增删改
无序 -- 不支持下标操作

2.字面量和元素

用大括号括起来，里面有多个键值对，每个人键值对用逗号隔开，每个键值对就是字典的元素
{key1/value1 , key2/value2 ...}

• 键值对 -- 键/key：值/value (有键就有值，有值就有键，必须成对出现，且键值对脱离字典无意义)
• 键（key） -- 必须是不可变的，而且是唯一的。实际一般将字符串作为键
• 值（value） -- 可以是任意类型的数据

注意：字典存储数据实际是通过值存储的，key是值对应的标签和获取值的方式

dic1 = {'a': 321, 'a': 520, 1314: 'woaini', (1, 2): [3, 4]}
print(dic1) # 值为{'a': 520, 1314: 'woaini', (1, 2): [3, 4]}，体现出键的唯一性，保存后者

dic2 = {[1, 2, 3]: 'xixi'}
print(dic2)  # False  TypeError: unhashable type: 'list',键的不可变性

3.什么时候用字典：多个数据之间互不关联，无共同意义需要区分的就用字典例如：保存一个人的信息

什么时候用列表：存储的多个数据之间意义相同，不需要区分。

dic2 = {'name': '陈儿', 'sex': 'girl', 'age': 18, 'height': 160, 'weight': 95}
print(dic2['age'])

练习，声明变量，保存一个班的学生信息，每个学生需要保存：姓名、电话、年龄

all_students = [
{},
{},
{},
]

字典元素的增删改查

1.查（获取元素对应的值）

• a.字典[key] -- 获取key对应的值（当key不存在的时候会报错）
• b.字典.get(key) -- 获取key对应的值(当key不存在的时候不会报错，取到默认值None)
• 字典.get(key，值1) -- 获取key对应的值(当key不存在的时候不会报错，取到指定的值1)

dic2 = {'name': '陈儿', 'sex': 'girl', 'age': 18, 'height': 160, 'weight': 95}
print(dic2['age'])
print(dic2.get('height'))
print(dic2.get('yanzhi'))  # 字典中不存在此key，None
print(dic2.get('yanzhi', 100))

遍历字典

1.直接通过for in 遍历字典取到的是key（推荐使用）

dic2 = {'name': '陈儿', 'sex': 'girl', 'age': 18, 'height': 160, 'weight': 95}
for key in dic2:
    print(key, end=':')
    print(dic2[key])

2.遍历字典的value（），获取所有值

for value in dic2.values():
    print(value)

3.遍历字典的items（），直接获取key和value（不建议使用）

for key, value in dic2.items():
    print(key, value)

2.增、改

• a.字典[key] = 值，当key不存在的时候，则为添加键值对；当key本身就存在的时候，就是修改key对应的值

dic2 = {'name': '陈儿', 'sex': 'girl', 'age': 18, 'height': 160, 'weight': 95}
# 添加颜值评分
dic2['yanzhi'] = 100
print(dic2)
# 修改身高
dic2['height'] = 165
print(dic2)

3.删

• a.del 字典[key] -- 删除字典中key指定的键值对
• b.字典.pop(key) -- 取出字典中key指定的键值对

dic2 = {'name': '陈儿', 'sex': 'girl', 'age': 18, 'height': 160, 'weight': 95}
del dic2['age']
print(dic2)

dic2.pop('sex')
print(dic2)

4.字典相关操作

• a.比较运算（只支持 == 、！= ）
  只要元素个数以及每个元素的键值对是相等的，则相等，体现了字典的无序性

• b.in 和 not in
  key in 字典：判断字典中指定的key是否存在
  key not in 字典：判断字典中指定的key是否不存在

dic4 = {'a': 1, 'b': 2, 'c': 3}
print('a' in dic4)
print('c' not in dic4)

• c.len(),max(),min()

1.获取字典中键值对的个数

print(len(dic4))

2.获取字典中key的最大值/最小值

print(max(dic4), min(dic4))

• d.类型转换
  dict（数据）-- 数据要求是序列，并且序列中的元素都是有两个元素的序列

print(dict(((1, 2), ('c', 3), (520, 1314))))

字典转换成列表/元组就是将字典的key提出来组成列表/元组/集合的元素

• 1.字典.clear（） -- 清空字典

dic4 = {'a': 1, 'b': 2, 'c': 3}
dic4.clear()
print(dic4)

• 2.字典.copy（）-- 复制字典中的所有元素，产生新的字典

dic4 = {'a': 1, 'b': 2, 'c': 3}
# 直接赋值，修改其中一个的元素，会影响到另外一个
dic5 = dic4
dic4['b'] = 4
print(dic4)
print(dic5)

通过copy，会产生新的地址，赋值过后修改其中一个的元素，另外一个不受影响

dic6 = {'a': 1, 'b': 2, 'c': 3}
dic7 = dic6.copy()
dic6['b'] = 4
print(dic6)
print(dic7)

dict.fromkeys（序列， 值） -- 以序列中所有元素作为key，指定的值作为value产生一个新的字典

new_dict = dict.fromkeys('abc', 10)
print(new_dict)

• 字典.keys（） -- 将字典中所有的key取出产生新的序列
• 字典.values（） -- 将字典中所有的value取出产生新的序列
• 字典.items（） -- 将字典中所有的key和value取出产生新的元组

dic6 = {'a': 1, 'b': 2, 'c': 3}
print(dic6.keys(), dic6.values(), dic6.items())

• 字典.setdefault(key) -- 当key不存在的时候，添加键值对 key:None

• 字典.setdefault(key,value) -- 当key不存在的时候，添加键值对 key：value
  注意：这个操作在key存在的时候，不会进行更改

• 字典1.update（字典2） -- 用字典2中的键值对去更新字典1，如果字典二中的key在字典1中存在，那就用字典2中的value对字典1进行修改，若不存在则为对字典1进行添加

dic6 = {'a': 1, 'b': 2, 'c': 3}
dic6.update({'a': 2, 'd': 4})
print(dic6)

三、集合

集合（set）
可变的，无序的；元素是唯一且不可变的

字面量
{元素1， 元素2，元素3...}

set1 = {1, 2, 'abc', 1, 2}
print(set1)  # 自动去重，体现元素的唯一性

空集合的表示方式

set2 = set()

a.查 -- 只能遍历（无法单独的获取单个元素）

b.增

• 1.集合.add(元素) -- 在集合中添加指定元素

• 2.集合.update（序列） -- 将序列中的元素添加到集合中

set1 = {1, 2, 'abc'}
set1.add('dd')
print(set1)
set1.update('dd')
print(set1)

c.删

集合.remove(元素) -- 将指定元素删除
set1 = {1, 2, 'abc'}
set1.remove(1)

d.数学集合运算

• 交集（&）：将两个元素的公共元素取出产生一个新的集合
• 并集（|）：将两个集合中的元素合并在一起产生新的集合
• 差集（-）：集合1 - 集合2 --> 去掉集合1中包含集合2的部分，剩下的产生一个新的集合
• 补集（^）：将两个集合合并在一起去掉公共部分，剩下的部分产生新的集合
• 子集的判断：集合1 >= 集合2（判断集合1中是否包含集合1） , 集合1 <= 集合2（判断集合2中是否包含集合1）

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}
# 求交集
print(set1 & set2)
# 求并集
print(set1 | set2)
# 求差集
print(set1 - set2)
# 求补集
print(set1 ^ set2)
# 求子集
print(set1 > set2)
print(set1 < set2)