Day7 - 字典和元组

一、元组

1. 什么是元组(tuple)

"""
元组是容器型数据类型(序列)，将()作为容器的标志，里面多个元素用逗号隔开：(元素1, 元素2, 元素3, ...)
元组不可变(不支持增删改)；元组是有序的(支持下标操作)
元素：任何类型的数据
"""
# 空元祖
t1 = ()
print(t1, type(t1))

2. 元组就是不可变的列表 —— 列表中和可变无关的操作，元组都支持

1）查

t2 = ('长津湖', '战狼', '阿凡达', '悬崖上的金鱼姬')
print(t2[-1], t2[0], t2[1])     # 悬崖上的金鱼姬 长津湖 战狼
print(t2[2:])                   # ('阿凡达', '悬崖上的金鱼姬')
for x in t2:
    print(x, end=' ',)      # 长津湖 战狼 阿凡达 悬崖上的金鱼姬
print()
for index in range(len(t2)):
    print(index, t2[index], end=' ', sep=':')
# 0:长津湖 1:战狼 2:阿凡达 3:悬崖上的金鱼姬

2）相关操作

print()
t1 = (10, 20, 30)
t2 = (111, 222)
print(t1 + t2)      # (10, 20, 30, 111, 222)
print(t1*2)
print((10, 20, 30) == (30, 20, 10))
print((100, 1, 1000) > (100, 2, -1000))
print(10 in t1)

3）相关函数

# max、min、sum、sorted、len、tuple
t1 = (34, 52, 89, 1, 90, 32)
print(max(t1), min(t1), sum(t1), len(t1))      # 90 1 298 6
print(sorted(t1))           # [1, 32, 34, 52, 89, 90]
print(tuple('abc'))         # ('a', 'b', 'c')

4）相关方法

# 元组不支持拷贝 -- 不可变数据在内存中存储的时候同一个数据只会存一份
a = (100, 200, 300)
b = (100, 200, 300)
print(id(a), id(b))         # 2480091444992 2480091444992 地址一样

a = [100, 200, 300]
b = [100, 200, 300]
print(id(a), id(b))         # 2069182684864 2069182953408 地址不一样

t1 = (34, 52, 89, 1, 90, 32)
print(t1.count(34))         # 1

print(t1.index(1))          # 3

3. 元组不只是不可变的列表

1）只有一个元素的元组：(元素,)

list1 = [10]
print(list1)            # [10]

t1 = (10,)
print(t1, type(t1))     # (10,) <class 'tuple'>

2）元组的()在没有歧义的情况下可以省略

t1 = 10, 20, 30
print(t1, type(t1))         # (10, 20, 30) <class 'tuple'>

t2 = 10, 20, 30 * 2
print(t2)                   # (10, 20, 60)

3）使用多个变量直接获取元素(元组和列表都支持)

# a.让变量的个数和元组元素的个数保持一致
t1 = (100, 200, 300)
x, y, z = t1
print(x, y, z)

pos = (200, 45)
x, y = pos
print(x, y)

# b.让变量的个数小于元组中元素的个数，这个时候必须在某一个变量前加*
# 获取元素的时候先让没有*的变量按照位置获取相应的数据，然后再将剩下的数据全部给带*的变量(变*的变量会变成一个列表)
t1 = ('小明', '男', 18, 175, 60)
name, *x = t1
print(name, x)          # 小明 ['男', 18, 175, 60]
*a, b, c = t1
print(a, b, c)          # ['小明', '男', 18] 175 60
m, *n, t = t1
print(m, n, t)          # 小明 ['男', 18, 175] 60

二、认识字典（dict）

1. 为什么要引入字典

# 定义一个变量保存一个学生的信息：姓名、年龄、身高、体重、语文、数学、英语
student = ['lql', 18, 175, 60, 80, 95, 65]
print(student[-1])

student = {'name': 'lql', 'age': 18, 'height': 175, 'weight': 60, '语文': 80, '数学': 95, '英语': 65}
print(student['name'])

# 列表：保存的多个数据意义相同，例如：保存10个学生，10个姓名...
# 字典：保存多个意义不同的数据，例如：人的姓名、年龄、身高、体重 或者 语文、数学、英语的成绩

2. 什么是字典(dict)

"""
1）字典是容器型数据类型(序列)，将{}作为容器的标志，里面多个键值对用逗号(一个键值对就是字典的一个元素：{键1: 值1, 键2: 值2, ...})
2）字典是可变的(支持增删改)；字典无序(不支持下标操作)
3）元素 -- 字典的元素必须是键值对
键 -- 必须是不可变的数据，一般用字符串
值 -- 任何类型的数据都可以作为字典的值
"""
# 空字典
dict1 = {}
print(dict1)

# 字典无序
print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})     # True
print([10, 20] == [20, 10])                         # False


# 键必须是不可变类型的数据
dict1 = {10: 100, 'a': 200, 6: 300}
print(dict1)            # {10: 100, 'a': 200, 6: 300}

# print({10: 100, 'a': 200, [6]: 300})  # 列表不能作为键 type: 'list'
# print({10: 100, 'a': 200, {1: 20}: 300})    # 字典不能作为键 type: 'dict'

# 值可以是任何类型的数据
dict1 = {'电影名': '肖申克的救赎', '票房': 13.84, '上映时间': 1988}
print(dict1['电影名'])
dict2 = {'a': 10, 'b': 23.4, 'c': 'abc', 'd': [10, 20, 30], 'e': {'x': 100}, 'f': lambda x: x*2}
print(dict2)

三、字典的增删改查

1. 查 – 获取值

1）查单个：

"""
字典[键] -- 获取指定键对应的值，键不存在会报错
字典.get(键) -- 获取指定键对应的值，键不存在不会报错返回None
字典.get(键, 默认值) -- 获取指定键对应的值，键不存在不会报错返回默认值
"""
student = {'name': 'lql', 'age': 18, 'height': 175, 'weight': 60, '语文': 80, '数学': 95, '英语': 65}
print(student['name'])            # lql
print(student['数学'])            # 95

print(student.get('name'))      # lql
print(student.get('数学'))      # 95

list1 = [{'name': '小明', 'age': 20}, {'name': '小花', 'age': 16}]
print(list1[-1]['age'])         # 16

key = 'height'
print(student[key])             # 175

# print(student['gender'])      # 报错 KeyError: 'gender'
print(student.get('gender'))    # None
print(student.get('gender', '男'))   # 男

student = {'name': 'lql', 'age': 18, 'height': 175, 'weight': 60, '语文': 80, '数学': 95, '英语': 65}
print(student['英语'])
print(student.get('score'))
print(student.get('score', 0))
print(student.get('score', 100))
print(student.get('score', '没有该键'))

2）遍历

print('=========================遍历=============================')
"""
for 键 in 字典:
    循环体
"""
student = {'name': 'lql', 'age': 18, 'height': 175, 'weight': 60, '语文': 80, '数学': 95, '英语': 65}
for x in student:
    print(x, ':', student[x], end=' ', sep='')

2. 增、改

print()
print('======================增、改=====================')
# 字典[键] = 值 -- 当键不存在的时候就添加键值对；当键存在的时候就修改键对应的值
# 字典.setdefault(键, 值) -- 键不存在的时候添加键值对，存在的时候不作为
dog = {'name': '财财', 'age': 3, 'breed': '金毛'}
print(dog)          # {'name': '财财', 'age': 3, 'breed': '金毛'}

dog['gender'] = '公'
print(dog)    # {'name': '财财', 'age': 3, 'breed': '金毛', 'gender': '公'}

dog['name'] = '旺财'
print(dog)    # {'name': '旺财', 'age': 3, 'breed': '金毛', 'gender': '公'}

dogs = [
    {'name': '财财', 'age': 3, 'breed': '金毛'},
    {'name': '小白', 'age': 2, 'breed': '哈士奇'},
    {'name': '小黄', 'breed': '田园犬'},
    {'name': '小花', 'breed': '泰迪'}
]
for dog in dogs:
    # dog['age'] = 0 # 使得已有年龄的狗也修改了年龄
    dog.setdefault('age', 0)
print(dogs)

3. 删

"""
del 字典[键] -- 删除指定键对应的键对
字典.pop(键) -- 取出指定键对应的值
"""
student = {'name': 'lql', 'age': 18, 'height': 175, 'weight': 60, '语文': 80, '数学': 95, '英语': 65}
del student['weight']
print(student)
# {'name': 'lql', 'age': 18, 'height': 175, '语文': 80, '数学': 95, '英语': 65}
result = student.pop('height')
print(result, student)
# 175 {'name': 'lql', 'age': 18, '语文': 80, '数学': 95, '英语': 65}

四、字典的相关操作函数和方法

1. 相关操作

# 字典不支持+、*、>、<、>=、<=,支持in和not in
# 键 in 字典 -- 判断字典中是否存在指定的键
d1 = {'a': 10, 'b': 20, 'c': 30}
print(10 in d1)         # False
print('b' in d1)        # True

2. 相关函数

# max、min、sum、sorted字典都支持，但是一般不用(操作对象都是键)
# len(字典)
"""
dict(数据) -- 将指定数据转换成字典。数据必须满足以下要求：
              a.数据本身是一个序列
              b.序列中的元素是有且只有两个元素的小序列
              c.小序列中的第一个元素必须是不可变的数据
              
"""
data1 = ['ab', (10, 20), ['name', '小明']]
result = dict(data1)
print(result)       # {'a': 'b', 10: 20, 'name': '小明'}

# 补充：将字典转换成列表或者元组的时候
d1 = {'a': 10, 'b': 20, 'c': 30}
list1 = list(d1)
print(list1)        # ['a', 'b', 'c']

3. 字典相关方法

# 1）字典.clear()
# 2）字典.copy()
# 3）
# 字典.keys() -- 获取所有的键
# 字典.values() -- 获取所有的值
# 字典.items() -- 将字典的键值对转换成元组，以序列的形式返回
d1 = {'a': 10, 'b': 20, 'c': 30}
print(d1.keys())        # dict_keys(['a', 'b', 'c']) 是序列
print(d1.values())      # dict_values([10, 20, 30])  是序列
print(d1.items())       # dict_items([('a', 10), ('b', 20), ('c', 30)])

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

# 4）字典.update(序列) -- 将序列中的元素作为键值对添加到字典(序列必须是能够转换成字典的序列)
# 字典1.update(字典2) -- 将字典2中的键值对全部添加到字典1中
d1 = {'a': 10, 'b': 20, 'c': 30}
d1.update({'d': 30, 'e': 40})
print(d1)       # {'a': 10, 'b': 20, 'c': 30, 'd': 30, 'e': 40}