一、元祖（tuple）

1.什么是元祖（tuple)
定义：python提供的容器型数据类型，（元祖就是不可变的列表）
不可变：不支持增删改
有序：可以通过下标来获取元素

2.字面量和元素
（元素1，元素2，元素3....）
说明：
元素：任何类型的数据，类型可互不相同，元素可重复

point = (100, 30)
print(point, type(point))  # (100, 30) <class 'tuple'>

注意：

情况1.空元祖

tuple1 = ()
print(type(tuple1))  # <class 'tuple'>

情况2.只有一个元素的元祖,在元素后面加逗号

tuple2 = (100,)
print(tuple2, type(tuple2))   # (100,) <class 'tuple'>

情况3.直接将多个元素用逗号隔开，不加括号表示也是一个元祖

tuple3 = 1, 2, 3
print(tuple3, type(tuple3))   # (1, 2, 3) <class 'tuple'>

3.元祖获取元素和列表一样
输出：一个元祖

tuple4 = ('成都', '达州', '绵阳', '南充', '广元')
# 获取单个元素
print(tuple4[1], tuple4[-1])  # 达州 广元
# 获取部分元素
print(tuple4[0:3])  # ('成都', '达州', '绵阳')
print(tuple4[::-1])  # ('广元', '南充', '绵阳', '达州', '成都')

# 遍历 -> 拿到的是元素本身
for city in tuple4:
    print(city)  

补充：特殊的获取方式
a.变量1， 变量2... = 元祖
说明：用前面的变量依次获取元素的值
要求：变量个数和元祖元素个数一致,不然程序会报错

point = (100, 200)
x, y = point   # x, y = (100, 200)  <==> x, y = 100, 200
print(x, y)  # 100 200

b.变量1， 变量2 = 元祖
说明：通过带的变量获取元祖中剩余的部分
输出：*号是一个列表
注意：带*号的变量只能是一个，其他变量可以有多个

name, *scores = ('小张', 100, 200, 30, 3)
print(name, scores)  # 小张 [100, 200, 30, 3]

name, num, *scores = ('小张', 100, 200, 30, 3)
print(name, num, scores)  # 小张 100 [200, 30, 3]

*info, num = ('笑绽放', 100, 11, 333, 23)
print(info, num)  # ['笑绽放', 100, 11, 333] 23

说明：*的用法

作用：取元祖和列表中的数据

nums = (1, 2, 3)
print(*nums[::-1])  # 3 2 1

4.相关运算
+，*
in/not in
len(),max(),min(),sum(),tuple()

tuple1 = (1, 2, 4)
tuple2 = ('sd', 'dffd')
print(tuple2 + tuple1)  # ('sd', 'dffd', 1, 2, 4)
print(tuple2*2)  # ('sd', 'dffd', 'sd', 'dffd')

print('dff' in tuple2)  # False

5.排序
sorted(序列)
作用：对序列中的元素排序（升序）-从小到大
输出：新的列表(不管是什么序列，拍完后都是列表）

注意：
列表.sort（） 修改原列表中的元素的顺序
sorted - 产生一个新的列表

nums = (1, 34, 34, 5656)
print(sorted(nums))  # [1, 34, 34, 5656]
print(sorted('dfdfd'))  # ['d', 'd', 'd', 'f', 'f']

join函数
字符串特殊
字符串.join(序列）
作用：将序列中的元素取出，用指定的字符串连接在一起
要求：序列中的元素必须是字符串
*输入：序列
输出：字符串

new_str = ''.join(['d', 's', 't'])
print(new_str, type(new_str))   # dst <class 'str'>

list1 = [1, 33, 334, 2]
list1.sort()   # None  sort不会产生新的列表
print(list1)  # [1, 2, 33, 334]

二、字典(dict）

1.什么是字典？

定义：python提供的容器型数据类型（序列）
可变：支持增删改
无序：不支持下标操作，不能获取元素

2.字面量和元素

定义:用大括号括起来，里面有多个键值对，每个键值对用逗号隔开，
{key1:value, key2:value2, key3:value3...}
键值对就是字典的元素
键值对：键（key)：值(value)
键：不可变的，唯一，不可重复，一般将字符串作为key
值：可以是任意类型的数据
注意：
1.键值对必须成对出现，而且脱离字典单独出现没有意义
2.字典存数据，实际是通过值来存储的(key是值对应的标签和获取值的方式)
补充：列表和字典不可以作为key值

# 列表和字典不可作为key
dict1 = {}  # 空字典
dict1 = {'a': 134, 10: 11, (1, 2): 'abc'}
print(dict1)

# dict2 = {[1, 2]: 120}
# TypeError: unhashable type: 'list'
# 类型错误：列表不能希哈化

3.使用场景

什么时候用字典：
多个没有相同意义的数据（需要区分），可以通过key来区分多个数据的不同，
例如：保存一个人的不同信息，一辆车的不同信息
什么时候用列表：
存储的数据是具有相同意义的数据（不需要区分）
例如：储存一个班的学生信息，保存所有的价格

# 练习：申明一个变量，保存一个班的学生信息，每个学生需要保存姓名，电话，年龄
all_student = []
student1 = {'name': '小黄', 'tel': 111111, 'age': 18}  # 保存学生不同的信息
student2 = {'name': '小才', 'tel': 111111, 'age': 18}
student3 = {'name': '小四', 'tel': 111111, 'age': 18}
student4 = {'name': '小五', 'tel': 111111, 'age': 18}
all_student.append(student1)
all_student.append(student2)
all_student.append(student3)
all_student.append(student4)   # 保存学生到列表中
print(all_student[::-1])

4.字典元素的增删改查

a.查（获取值）
注意：字典中的键值对单独拿出来没有意义

1.字典[key]
目的：获取字典中key的值
注意：当key值不存在时，会报错 keyError

car = {'color': '黄色', 'type': '跑车', 'price': 500000}
print(car['color'])  # 黄色

2.字典.get(key)
目的：获取字典中key的值
注意：当key不存在时，不会报错，并且取到一个默认值None
应用：可以判断key是否存在
字典.get(key, 值1）
目的：获取字典中key的值
注意：当key不存在时，不会报错，并且取到指定的值1

print(car.get('type'))  # 跑车
print(car.get('speed'))   # None

print(car.get('color', '红色'))  # 黄色
print(car.get('speed', 0))  # 0

如何选择：
确定时，用1,不确定时，用2或者3

3.遍历
注意：直接通过for - in 遍历字典取到的是key，然后通过key来取值

dict1 = {'a': 100, 'b': 200, 'c': 300}
# 遍历字典取到的是key（推荐使用）只需要遍历一次
for key in dict1:
    print(key)
    print(dict1[key])

# 遍历字典的values()，获取所有的值
for value in dict1.values():
    print(value)

# 遍历字典的items（），直接获取key和value（不建议使用）
for key, value in dict1.items():
    print(key, value)

b.增（增加键值对）、改
a.字典[key] = 值
目的：
key不存在:添加键值对
key存在：修改key的值

movie = {'name':'xiaohua', 'type': '卡通', 'time': 120}

# 添加
movie['score'] = 7.9
print(movie)  # {'name': 'xiaohua', 'type': '卡通', 'time': 120, 'score': 7.9}

# 修改
movie['type'] = '相当搞笑'
print(movie)  # {'name': 'xiaohua', 'type': '相当搞笑', 'time': 120, 'score': 7.9}

c.删（删除键值对）
1.del 字典[key]
目的：删除指定的key对应的键值对

2.字典.pop(key)
目的：取出字典中key对应的值
注意:可以赋值给变量拿来使用

movie = {'name': 'xiaohua', 'type': '相当搞笑', 'time': 120, 'score': 7.9}
del movie['time']
print(movie)  # {'name': 'xiaohua', 'type': '相当搞笑', 'score': 7.9}

name = movie.pop('name')  # xiaohua
print(movie, name)  #  {'type': '相当搞笑', 'score': 7.9} xiaohua

应用实例

# 练习：用一个字典保存一个学生的信息:{'name': '张三', 'age': 30, 'score': 80}

student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息：')
if message == 'name':
    new_name = input('请输入新的名字：')
    student['name'] = new_name
    print(student)
elif message == 'age':
    new_age = input('请输入新的年龄：')
    student['age'] = new_age
    print(student)
elif message == 'score':
    new_score = input('请输入新的分数：')
    student['score'] = new_score
    print(student)
else:
    print('没有该信息')

5.相关运算

1.比较运算
== !=
注意：
判断两个字典是否相等：只看键值对是否一样，不管顺序
字典是不支持<和>符号

print({'a': 11, 'b': 22} == {'b': 22, 'a': 11})   # True

2. in / not in
key in 字典
目的：判断字典中指定的key是否存在
key not in 字典
目的：判断字典中指定的key是否不存在

dict2 = {'a': 1, 'b': 2, 'c': 3}
print('a' in dict2)   # True
print(1 in dict2)

3.len(),max(),min()

dict(数据)
要求：
1.序列
2.序列中的元素都是有两个元素的子序列

# 获取字典中键值对的个数
dict2 = {'a': 1, 'b': 2, 'c': 3}
print(len(dict2))  # 3

# 获取字典中key的最大值/最小值
dict2 = {'a': 1, 'b': 2, 'c': 3}
print(max(dict2), min(dict2))    # c a

# 将列表转化为字典
print(dict([(1, 3), ('a', 'b')]))   # {1: 3, 'a': 'b'}

# 字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖/集合的元素
dict2 = {'a': 1, 'b': 2, 'c': 3}
print(list(dict2))  # ['a', 'b', 'c']

6.相关方法

1.字典.clear（）

目的:清空字典(建议使用）
输入：字典
输出：空字典
建议：清空容器推荐clear操作，而不是重新赋一个空的容器
（会先删，在重新开辟空间）

dict2 = {'a': 1, 'b': 2, 'c': 3}
dict2.clear()
print(dict2, id(dict2))  # {} 5263296

# 只有本身不存在的时候，可以使用
dict3 = {}
print(id(dict3))  # 8552240

2.字典.copy（）

目的：复制字典中的元素
输入：字典
输出：复制后的字典
注意：拷贝赋值，会产生新的地址，赋值后相互不影响

dict2 = {'a': 1, 'b': 2, 'c': 3}
dict3 = dict2.copy()
print(dict3)  # {'a': 1, 'b': 2, 'c': 3}
dict2['a'] = 100
print(dict2)  # {'a': 100, 'b': 2, 'c': 3}
print(dict3)  # {'a': 1, 'b': 2, 'c': 3}

# 赋值就是赋变量对应的地址
# 直接赋值，修改其中一个的元素，会影响另外一个

dict2 = {'a': 1, 'b': 2, 'c': 3}
dict3 = dict2
print(dict3)  # {'a': 1, 'b': 2, 'c': 3}
dict2['a'] = 100
print(dict2)  # {'a': 100, 'b': 2, 'c': 3}
print(dict3)  # {'a': 100, 'b': 2, 'c': 3}

3.dict.fromkeys(序列，值）

目的： 以序列中的所有元素作为key,指定的值作为value创建一个新的字典
即给多个key赋一样的值
输出：字典
输入：值只能是一个

new_dict = dict.fromkeys('abc', 100)
print(new_dict)  # {'a': 100, 'b': 100, 'c': 100}

4.

4.1 字典.keys()

目的：将字典所有的key取出来产生一个新的序列

4.2 字典.values()

目的： 将字典所有的value取出来产生一个新的序列

4.3 字典.items()

目的：将字典所有的key和value作为一个元祖取出产生一个新的序列

dict2 = {'a': 1, 'b': 2, 'c': 3}
print(dict2.keys())  # dict_keys(['a', 'b', 'c'])
print(dict2.values())  # dict_values([1, 2, 3])
print( dict2.items())  # dict_items([('a', 1), ('b', 2), ('c', 3)])

5.字典.setdefault(key, value = None)

5.1 字典.setdefault(key)

目的：当key值不存在时，添加键值对key:None

5.2 字典.setdefault(key, value = None)

目的：当key值不存在时，添加键值对key:value
注意：这个操作当key存在的时候，不会修改

dict2 = {'a': 1, 'b': 2, 'c': 3}
dict2.setdefault('name', '小胡')
dict2.setdefault('sex')
print(dict2)   # {'a': 1, 'b': 2, 'c': 3, 'name': '小胡', 'sex': None}

6.字典1.update(字典2)

目的：使用字典2中的键值对去更新字典1，
注意：如果字典2中的key,字典1中本来就存在就是修改，不存在就是添加

dict2 = {'a': 1, 'b': 2, 'c': 3}
dict2.update({'a': 22222, 'age': 18})
print(dict2)  # {'a': 22222, 'b': 2, 'c': 3, 'age': 18}

三、集合（set）

1.什么是集合？
可变：
无序：
元素是唯一并且不可变的

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

set1 = {1, 32, 'abc'}
print(set1)  # {32, 1, 'abc'}

# 表示空集合
set2 = set()
print(type(set2))   # <class 'set'>

# 自带去重功能
set3 = {1, 2, 4, 3, 2, 1, 4}
print(set3)   # {1, 2, 3, 4}

# 使列表元素唯一
list1 = [1, 2, 3, 4, 2, 1]
list1 = list(set(list1))
print(list1)  # {1, 2, 3, 4}

3.增删改查

a.查

集合不能单独的获取单个元素，只能是一个一个的遍历

set1 = {1, 3, 33}
for item in set1:
    print(item)   

b.增

1.集合.add（元素）
目的：在集合中添加指定的元素

set1 = {1,3,33}
set1.add('哈哈'）
print（set1）  # {1, 3, '哈哈', 33}

2.集合.update(序列）
目的： 将序列中的元素添加到集合中

set1 = {1, 3, '哈哈', 33}
set1.update('abc') 
print(set1)    # {1, 'a', 3, 33, 'b', 'c', '哈哈'}

set1.update({'ddd': 22323})
print(set1)   # {1, 'a', 3, 33, 'b', 'c', 'ddd', '哈哈'}

c. 删

集合.remove(元素）
目的：删除集合中指定的元素

set1 = {1, 3, 33}
set1.remove(33)
print(set1)

4.数学集合运算

a.交集（&）

目的：获取两个集合公共的部分，产生新的集合

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)  # {4, 5, 6}

b.并集(|)

目的：将两个集合中的元素合并在一起（去重后）产生一个新的集合

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}

c.补集（-）

目的：集合1 - 集合2 -> 去掉集合1中包含集合2的部分，剩下的产生一个新的集合

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 - set2)  # {1, 2, 3}

d.差集（^)

目的：将两个集合合并在一起，去掉公共部分，剩下的部分产生一个新的集合

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 ^ set2)  # {1, 2, 3, 7, 8}

e.子集的判断：

集合1 > 集合2
目的： 判断集合1中是否包含集合2
集合1 < 集合2
目的：判断集合2中是否包含集合1
输出：布尔值

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}

print({1, 2, 3} > {1, 2})  # True
print({1, 2, 3} > {1, 2, 0})  # False

print({1, 2, 3} > {1, 2, 3})  # False
print({1, 2, 3} >= {1, 2, 3})  # True