====== 元祖 ======

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)
# 成都
# 达州
# 绵阳
# 南充
# 广元
for index in range(len(tuple4)) :  
    print(tuple4[index])
# 成都
# 达州
# 绵阳
# 南充
# 广元

补充1：特殊的获取方式

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

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

2.变量1，*变量2 = 元祖 —— 通过带 * 的变量获取元祖中剩余的部分

注意：这个结构中带 * 的变量只能有一个，不带 * 的变量可以有多个

name, *scores = ('小明', 100, 89, 67, 99)
print(name, scores)  # 小明 [100, 89, 67, 99]

name, num,  *scores = ('小明', 100, 89, 67, 99)
print(name, num, scores)  # 小明 100 [89, 67, 99]

*info, num1, num2 = ('小明', 100, 89, 67, 99)
print(info, num1, num2)  # ['小明', 100, 89] 67 99

info1, *nums, num1 = ('小明', 100, 89, 67, 99)
print(nums)  # [100, 89, 67]

补充2： * 的用法

# 1.取元祖和列表中的数据
nums = (1, 2, 3)
print(*nums)  # 1 2 3

nums2 = [11, 22, 33]
print(*nums2)  # 11 22 33

4.相关运算（和列表一样）

+,*

in / not in

len(),max(),min(),sum(),tuple()

tuple1 = (1, 2, 3)
tuple2 = ('aa', 'bb')
print(tuple1 + tuple2)  # (1, 2, 3, 'aa', 'bb')
print(tuple1 * 3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

print('aaa' in tuple2)  # False

5.排序

sorted(序列) —— 对序列中的元素排序，产生一个新的序列（不管是什么序列，排完后最后都是列表）

注意：

列表.sort() —— 修改元列表中元素的顺序

sorted(列表) —— 产生一个新的列表

nums = (1, 34, 89, 9)
new_nums = sorted(nums, reverse=True)
print(new_nums, nums)  # [89, 34, 9, 1] (1, 34, 89, 9) 原列表不变
print(new_nums, tuple(new_nums), nums)  # [89, 34, 9, 1] (89, 34, 9, 1) (1, 34, 89, 9)

print(sorted('sadsadsafeerw'))  # ['a', 'a', 'a', 'd', 'd', 'e', 'e', 'f', 'r', 's', 's', 's', 'w']

new_strs = sorted('sadsadsafeerw')
print(str(new_strs))  # ['a', 'a', 'a', 'd', 'd', 'e', 'e', 'f', 'r', 's', 's', 's', 'w']

join的使用

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

new_str = '*'.join(['a', 'b', 'c' ])
# new_str = '*'.join(['a', 'b', 'c', 22])  22数字不可以
print(new_str, type(new_str))  # a*b*c <class 'str'>

new_str = ' '.join(['how', 'are', 'you' ])
print(new_str, type(new_str))  # how are you <class 'str'>

list1 = [1, 345, 90, 9]
new_list = list1.sort()    # None; sort不会产生新的列表
print(list1, new_list)  # [1, 9, 90, 345] None

====== 字典 ======

1.什么是字典（dict）

Python提供的容器型数据类型，可变并且无序

可变 —— 支持元素的增、删、改

无序 —— 不支持下标操作

2.字面量和元素

用大括号{}括起来，里面多个 键值对 ，每个 键值对 用逗号隔开， 键值对 就是字典的元素

如：{key1:value, key2:value2, key3:value3...}

键值对 —— 键/key：值/value（键值对）;键值对必须成对出现，而且脱离字典，单独出现没有意义

键/key —— 必须是不可变，并且唯一，实际一般将字符串作为 键

值/value —— 可以是任意类型的数据

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

dict1 = {}  # 空字典,无意义
print(type(dict1))  # <class 'dict'>

dict1 = {'a': 100, 10: 200, (1, 2): 'abc', 'a': 111, 'b': [1, 11, 111]}
print(dict1)  # {'a': 111, 10: 200, (1, 2): 'abc', 'b': [1, 11, 111]}，其中键/key唯一不可变，value为任意类型的数据

# dict2 = {[1, 2]: 110}
# print(dict2)  # 错误！键值为列表，可变 故TypeError: unhashable type: 'list'

3.什么时候使用字典

多个没有相同意义的数据（需要区分），就使用字典。如：保存一个人的不同信息

什么时候使用列表：存储多个数据是有相同意义的数据（不需要区分），就使用列表。如：保存一个班的学生信息

# person = ['小明', 18, '男', 160, 90, 89]  列表来存，不清楚具体指什么
# print(person[1])
# person[-2]

person = {'name': '小明', 'age': 18, 'sex': '男', 'height': 160, 'weight': 90, 'score': 89}
print(person['age'])  # 18   用字典来存，取其年龄

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

all_students = [
    {'name': '小明', 'tel': '123456789', 'age': 20},
    {'name': '小红', 'tel': '12345678', 'age': 21},
    {'name': '小兵', 'tel': '1234567', 'age': 22},
    {'name': '小江', 'tel': '123456', 'age': 23}
]
print(all_students[0])  # {'name': '小明', 'tel': '123456789', 'age': 20}

====== 字典元素的增删改查 ======

1.查（获取值）

注意：字典中的键值对单独拿出来没有任何意义

a.字典[key] —— 获取字典中key对应的值

注意：当key不存在的时候，会报错key Error

car = {'color': '黄色', 'type': '跑车', 'price': 500000}
print(car['color'])  # 黄色
print(car['price'])  # 500000
# print(car['speed'])  #key Error: 'speed'  car中没有speed

b.字典.get（key） —— 获取字典中key对应值，当key不存在的时候不会报错，并且取到一个默认值None

字典.get（key，值1） —— 获取字典中key对应值

car = {'color': '黄色', 'type': '跑车', 'price': 500000}
print(car.get('type'))  # 跑车
print(car.get('speed'))  # None  car中没有speed  取默认值None

print(car.get('color', '红色'))  # 黄色  car中存在color
print(car.get('speed', 0))  # 0   car中没有speed  为0

c.遍历字典

注意: 直接通过for-in遍历字典取到的是key

dict1 = {'a': 100, 'b': 200, 'c': 300}

# 遍历字典到的是key(推荐使用★★★)
for key in dict1 :
    # key
    print(key, end=' ')  # a b c
    # value
    print(dict1[key])
# a
# 100
# b
# 200
# c
# 300

print(dict1.values(), dict1.items())  # dict_values([100, 200, 300]) dict_items([('a', 100), ('b', 200), ('c', 300)])
# 遍历字典的values(),获取所有的值
for value in dict1.values():
    print(value)  # 100 200 300

# values = []
# for key in dict1:
#     values.append(dict1[key])
# for value in values:
#     print(value)


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

# items = []
# for key in dict1:
#     items.append((key, dict1[key]))
# for key,value in items:
#     print(key, value)

2.增、改

字典[key] = 值 —— 当key不存在就添加键值对；当key存在的时候就是修改key对应的值

movie = {'name': '一人之下', 'type': '动漫', 'time': 120}

# 添加/增
movie['score'] = 7.9
print(movie)  # {'name': '一人之下', 'type': '动漫', 'time': 120, 'score': 7.9}

# 修改/改
movie['type'] = '国漫'
print(movie)  # {'name': '一人之下', 'type': '国漫', 'time': 120, 'score': 7.9}

3.删（删除键值对）

a.

del 字典[key] —— 删除字典中对应的键值对

b.

字典.pop(key) —— 取出字典中key对应的值

movie1 = {'name': '一人之下', 'type': '动漫', 'time': 120, 'score': 7.9}
del movie['time']  # 删除time键值对
print(movie)  # {'name': '一人之下', 'type': '国漫', 'score': 7.9}

name = movie.pop('name')  # 取出对应的值
print(movie, name)  # {'type': '国漫', 'score': 7.9} 一人之下

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

输入需要修改的信息，例如输入：name -->> 修改名字，age -->> 修改年龄...abc -->> 提示'没有该信息'

"""
请输入要修改的信息: name
请输入新的名字: 李四
{'name': '李四', 'age': 30, 'score': 80}

请输入要修改的信息: age
请输入新的年龄: 18
{'name': '张三', 'age': 18, 'score': 80}

请输入要修改的信息: abc
没有该信息！
"""
student = {'name': '张三', 'age': 30, 'score': 80}
message = input('请输入要修改的信息:')

if student.get(message):
    if message == 'name':
        new_name= input('请输入新的名字:')
        student['name'] = new_name
    elif message == 'age':
        new_age = int(input('请输入新的年龄:'))
        student['age'] = new_age
    else:
        new_score = input('请输入新的分数:')
        student['score'] = new_score

    print(student)

else:
    print('没有该信息!')

====== 字典的相关操作 ======

1.比较运算

==，!=

注意：判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序

字典不支持 > 和 < 符号

print({'a': 11, 'b': 22} == {'b': 22, 'a': 11})  # True
print({'a': 11, 'b': 22} != {'b': 22, 'a': 11})  # False
print({'a': 11, 'b': 22, 'c': 33} != {'b': 22, 'a': 11})  # True
# print({'a': 11, 'b': 22} > {'b': 22, 'a': 11})  # 字典不支持该运算，故报错TypeError: '>' not supported between instances of 'dict' and 'dict'

2. in / not in

key in 字典 —— 判断字典中指定的key是否存在

key not in 字典 —— 判断字典中指定的key是否不存在

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

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

dict(数据) —— 该数据要求是序列，并且序列中的元素都是有两个元素的子序列

dict1 = {'a': 1, 'z': 2, 'c': 3}
print(len(dict1))  # 3 获取字典中键值对的个数
print(max(dict1), min(dict1))  # z a 获取字典中key的最大值/最小值

print(dict([(1, 2), ('a', 'b'), [10, 'abc']]))  # 将列表转换成字典,{1: 2, 'a': 'b', 10: 'abc'}

# 字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖/集合的元素
dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
print(list(dict2))  # ['name', 'color', 'height']

4.相关方法

1.

字典.clear() —— 清空字典

注意：清空容器推荐使用clear操作，而不是重新赋一个空的容器★

dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
print(id(dict2))  # 33546576  清空前的地址
dict2.clear()  # 清空
print(dict2, id(dict2))  # {} 33546576  清空后的地址，相同

# 只有容器本身不存在的时候，可以使用
dict2 = {}
print(id(dict2))  # 6485888 新的地址

2.

字典.copy() —— 复制字典中的元素，产生一个新的字典

# 直接赋值，修改其中一个元素，会影响另外一个
dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
dict3 = dict2
print(dict3)  # {'name': '小明', 'color': '蓝色', 'height': 170}
dict3['name'] = '小小'  # 修改name为小小
print(dict3)  # {'name': '小小', 'color': '蓝色', 'height': 170}
print(dict2)  # {'name': '小小', 'color': '蓝色', 'height': 170}

# copy赋值，会产生新的地址，赋值后相互不影响
dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
dict4 = dict2.copy()
print(dict4)  # {'name': '小明', 'color': '蓝色', 'height': 170}
del dict4['color']  # 删除dict4中的color
print(dict4)  # {'name': '小明', 'height': 170}
print(dict2)  # {'name': '小明', 'color': '蓝色', 'height': 170}

3.

dict.fromkeys(序列, 值) —— 以序列中所有的元素作为key，指定的值作为value创建一个新的字典

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

new_dict = dict.fromkeys(['name', 'age', 'tel'])
print(new_dict)  # {'name': None, 'age': None, 'tel': None}

4.

字典.keys() —— 将字典所有的key取出产生一个新的序列

字典.values() —— 将字典所有的value取出产生一个新的序列

字典.items() —— 将字典所有的key和value作为一个元祖取出产生一个新的序列

dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
print(dict2.keys(), dict2.values(),dict2.items())  # dict_keys(['name', 'color', 'height']) dict_values(['小明', '蓝色', 170]) dict_items([('name', '小明'), ('color', '蓝色'), ('height', 170)])

5.

字典.setdefault(key, value=None)

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

字典.setdefault(key, value) —— 当key不存在的时候，添加键值对key:value

注意：这个操作当key存在的时候，不会修改

dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
dict2.setdefault('name2', '小小')
dict2.setdefault('sex')
print(dict2)  # {'name': '小明', 'color': '蓝色', 'height': 170, 'name2': '小小', 'sex': None}

6.

字典1.update(字典2) —— 使用字典2中的键值对取更新字典1，如果字典2中的key在字典1中本身存在就是修改，不存在就添加

dict2 = {'name': '小明', 'color': '蓝色', 'height': 170}
dict2.update({'height': 180, 'age': 18})
print(dict2)  # {'name': '小明', 'color': '蓝色', 'height': 180, 'age': 18}

dict2.update([('a', 100), ('age', 30)])
print(dict2)  # {'name': '小明', 'color': '蓝色', 'height': 180, 'age': 30, 'a': 100}

====== 集合 ======

1.什么是集合（set）

可变的，无序的；元素是唯一并且不可变

2.字面量

{元素1，元素2，元素3...}

set1 = {1, 23, 'abc'}
print(set1)  # {'abc', 1, 23}
# set1 = {1, 23, 'abc', [1, 2]}  # 错误！不能是字典TypeError: unhashable type: 'list'

# 表示空集合（没有意义）
set2 = set()
print(type(set2))  # <class 'set'>

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

list1 = [1, 2, 3, 1, 2]
list1 = list(set(list1)) # 先转换成集合再转换成列表
print(list1)  # [1, 2, 3]

3.增删改查

1.查

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

set1 = {1, 38, 90, 8}
for item in set1 :
    print(item)
# 8
# 1
# 90
# 38

2.增

集合.add（元素） —— 在集合中添加指定的元素

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

set1 = {1, 38, 90, 8}

set1.add('abc')
print(set1)  # {1, 38, 8, 'abc', 90}

set1.update('abc')
print(set1)  # {1, 38, 8, 'abc', 'b', 90, 'a', 'c'}

set1.update({'aa': 10,'bb': 20})
print(set1)  # {1, 38, 8, 'abc', 'bb', 'b', 'aa', 90, 'a', 'c'}

3.删

集合.remove（元素） —— 删除集合中指定的元素

set1 = {1, 38, 90, 8}
set1.remove(90)
print(set1)  # {8, 1, 38}

4.数学集合运算

交集（ & ）：获取两个集合公共的元素产生一个新的集合

并集（ | ）：将两个集合中的元素合并在一起产生一个新的集合

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

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

子集的判断：集合1 > 集合2 —— 判断集合1中是否包含集合2；集合1 < 集合2 —— 判断集合1中是否包含集合2

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

# 交集
print(set1 & set2)  # {4, 5, 6}
# 并集
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集
print(set1 - set2)  # {1, 2, 3}
# 补集
print(set1 ^ set2)  # {1, 2, 3, 7, 8}
# 子集的判断
print({1, 2, 3, 9, 18} > {1, 2, 3, 0})  # False
print({1, 2, 3, 9, 18} > {1, 2, 3})  # True
print({1, 2, 3, 9, 18} < {1, 2, 3, 0})  # False
print({1, 2, 3, 9, 18} < {1, 2, 3})  # False
print({1, 2, 3} > {1, 2, 3})  # False
print({1, 2, 3} < {1, 2, 3})  # False
print({1, 2, 3} <= {1, 2, 3}) # True
print({1, 2, 3, 4} < {1, 2, 3})  # False
print(set2 < set1)  # False