小白学习Python的第六天

一. 元组与字典

1.什么是元组(tuple)

"""
元组就是不可变的列表
元组是容器型数据类型，将()作为容器的标志，里面多个元素用逗号隔开：(元素1, 元素2, 元素3, ...)
元组不可变(不支持元素的增删改)；元组是有序的（支持下标操作）
元素：任何类型的数据都可以，并且可以重复
"""

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

空元组

t2 = ()

2.只有一个元素的元组:(元素,)

# 如果一个元组中有且只有一个元素，那么唯一的元素后面必须加逗号
t3 = (23)
print(t3, type(t3))   # 23 <class 'int'>

t4 = (1,)
print(t4, type(t4))   # (1,) <class 'tuple'>

3.省略括号

# 在没有歧义的情况下可以省略元组的()，直接将多个元素用逗号隔开来表示一个元组

t5 = 'abc', 's', '1', 10, 5
print(t5, type(t5))   # ('abc', 's', '1', 10, 5) <class 'tuple'>

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

4.获取元素
1）列表获取元素的方法元组都支持

song = ('葫芦娃', '海阔天空', '霸王别姬', '夜曲', '稻香', '下山')
print(song[1], song[-5])   # 海阔天空 海阔天空
print(song[2:])   # ('霸王别姬', '夜曲', '稻香', '下山')

for i in song:
    print('i', i)

for index, num in enumerate(song):
    print(index, num)

for index in range(len(song)):
    print(song[index])

2）让变量的个数和元组中元素的个数保持一致来获取元组所有元素的值

# 变量1, 变量2, 变量3, ... = 元组
t7 = (10, 102, 32)
x, y, z = t7
print(x, y, z)   # 10 102 32

# m, n = t7   # ValueError: too many values to unpack (expected 2)
# m, n, l, o = t7   # ValueError: not enough values to unpack (expected 4, got 3)

3）同时用多个变量获取元组元素的时候，变量的个数可以比元组中元素的个数少，但是必须有且只有一个变量前有*

stu = ('小明', '男', 30, 89, 70, 170)
x, y, *z = stu
print(x, y, z)   # 小明 男 [30, 89, 70, 170]

x, *y, z = stu
print(x, y, z)   # 小明 ['男', 30, 89, 70] 170
*x, y, z = stu
print(x, y, z)   # ['小明', '男', 30, 89] 70 170

name, sex, *message, height = stu
print(name, sex, message, height)   # 小明 男 [30, 89, 70] 170

5.元组相关操作

# 列表相关操作元组都支持
print((1, 2, 3) + ('a', 'b'))   # (1, 2, 3, 'a', 'b')
t1 = (1, 2, 3)
t2 = ('abc', 'name')
print(t1*3)   # (1, 2, 3, 1, 2, 3, 1, 2, 3)

print((1, 2, 5, 10) > (10, 0))   # False
print(10 in (1, 2))   # False

print(sum((10, 20, 30)))   # 60
print(max((10, 50)))   # 50
print(min((10, 54, 5)))   # 5

nums = (1, 2, 5, 78, 99)

new_nums = sorted(nums)
print(new_nums)   # [1, 2, 5, 78, 99]
print(len(nums))   # 5

print(tuple('abc'))   # ('a', 'b', 'c')
print(tuple(new_nums))   # (1, 2, 5, 78, 99)

二. 字典

1.什么时候使用字典
同时保存多个意义不同的数据就使用字典
2.什么是字典（dict）

"""
字典是容器型数据类型，将{}作为容器的标志，里面多个元素用逗号隔开（元素必须是键值对）：
{键1:值1, 键2:值2, 键3:值3, ...}

字典是可变的（支持增删改）；字典是无序的（不支持下标操作）
元素：必须是键值对；
     键 - 必须是不可变的（数字、字符串、元组），一般使用字符串；功能：键是用来对值进行描述和区分的
          是唯一的
     值 - 没有要求
"""

1）空字典

d1 = {
    
    }
print(type(d1))   # <class 'dict'>

2）键是不可变

d2 = {
    
    'name': '小明', 10: 100, (1, 2): 200}
print(d2)   # {'name': '小明', 10: 100, (1, 2): 200}

# 报错！列表不能作为key
# d2 = {'name': '小明', 10: 100, [1, 2]: 200}   # TypeError: unhashable type: 'list'

3）键是唯一的

d3 = {
    
    'name': '小明', 'age': 18, 'name': '张三'}
print(d3)   # {'name': '张三', 'age': 18}

4）字典无序

print({
    
    'a': 10, 'b': 20} == {
    
    'b': 20, 'a': 10})   # True

3.字典的增删改查
1）查 - 获取值
1.1）获取单个值

"""
a.字典[key] - 获取指定key对应的值(如果key不存在会报错)
b.字典.get(key) - 获取指定key对应的值(如果key不存在不会报错，返回None)
  字典.get(key, value) - 获取指定key的值(如果key不存在不会报错，返回指定的默认值)
"""

dog = {
    
    'name': '财财', 'age': 2, 'sex': '母狗', 'breed': '土狗'}

print(dog['sex'])   # 母狗
print(dog.get('age'))   # 2
print(dog.get('breed', '公'))   # 土狗

# 报错！
# print(dog['weight'])   # KeyError: 'weiget'
print(dog.get('weight'))   # None
print(dog.get('weight', 0))   # 0

1.2）遍历

"""
for 变量 in 字典:
    pass

注意：变量依次取到的是字典的key

"""
# 键值对离开了字典无效

dog = {
    
    'name': '财财', 'age': 2, 'sex': '母狗', 'breed': '土狗'}
for key in dog:
    print(key, dog[key])

2）增、改

"""
字典[key] = 值 - 当key存在就是修改指定key对应的值；当key不存在的时候就是添加键值对
"""
dog['name'] = '大黄'
print(dog)   # {'name': '大黄', 'age': 2, 'sex': '母狗', 'breed': '土狗'}

dog['weight'] = 15
print(dog)   # {'name': '大黄', 'age': 2, 'sex': '母狗', 'breed': '土狗', 'weight': 15}

3）删
del 字典[key] - 删除指定key对应的键值对
字典.pop(key) - 取出指定key对应的值,并且返回

dog = {
    
    'name': '财财', 'age': 2, 'sex': '母狗', 'breed': '土狗'}
del dog['sex']
print(dog)   # {'name': '财财', 'age': 2, 'breed': '土狗'}

del_name = dog.pop('name')
print(dog)   # {'age': 2, 'breed': '土狗'}
print(del_name)   # 财财

三. 字典的实际应用

# 练习：定义一个变量保存一个班级的信息，班级信息主要包含：班级名称、位置、容量、班主任、讲师、所有学生
# 班主任：姓名、性别、年龄、电话号码、QQ
# 讲师：姓名、性别、年龄、电话号码、QQ、级别
# 所有学生：多个学生，每个学生包含：姓名、性别、年龄、学历、专业电话
class1 = {
    
    
    'name': 'Python2004',
    'location': '9教师',
    'capacity': 50,
    'class_teacher': {
    
    
        'name': '张老师',
        'sex': '女',
        'age': 30,
        'tel': '110',
        'qq': '78615421'
    },
    'teacher': {
    
    
        'name': '骆昊',
        'gender': '男',
        'age': 35,
        'tel': '1562121545',
        'qq': '665632',
        'rank': '特级讲师',
    },
    'students': [
        {
    
    'name': '小明', 'gender': '男', 'age': 20},
        {
    
    'name': '小花', 'gender': '男', 'age': 23},
        {
    
    'name': '张三', 'gender': '男', 'age': 21},
        {
    
    'name': 'tom', 'gender': '男', 'age': 22},
        {
    
    'name': '小兰', 'gender': '女', 'age': 21},
    ]
}
print(class1)
# 获取班主任的名字
print(class1['class_teacher']['name'])   # 张老师
print(class1['teacher']['name'], class1['teacher']['rank'])   # 骆昊 特级讲师

# 计算班级所有学生的平均年龄
total = 0
for i in class1['students']:
    total += i['age']
print(total / len(class1['students']))

四. 字典相关操作

字典不支持加法、乘法运算，也不支持比较大小
1.in 和 not in
key in 字典 - 判断字典中是否存在指定的键

d1 = {
    
    'a': 10, 'b': 20, 'c': 30}
print(10 in d1)   # False
print('a' in d1)   # True

2.相关函数:len、dict
1）获取长度

print(len(d1))   # 3

2）字典的类型转换

"""
dict(数据) - 将指定数据转换成字典，数据的要求:
            a.数据本身是序列
            b.序列中的每个元素必须是长度为2的小序列
            c.小序列中的第一个元素是不可变的数据

list(字典) - 将指定字典转换成列表(将字典的key作为列表元素)
"""

data = ['ab', (10, 20), ['abc', 123]]
print(dict(data))   # {'a': 'b', 10: 20, 'abc': 123}

d1 = {
    
    'a': 10, 'b': 20, 'c': 30}
print(list(d1))   # ['a', 'b', 'c']

3.相关方法
1）字典.clear() - 清空字典

# 已经有一个坑，重复利用就行
d1 = {
    
    'a': 10, 'b': 20, 'c': 30}
d1.clear()
print(d1)   # {}

# 这个相当于重新放一个空的字典进去，不建议使用，效率低
d1 = {
    
    'a': 10, 'b': 20, 'c': 30}
d1 = {
    
    }
print(d1)   # {}

2）字典.copy() - 复制字典产生一个一模一样的新的字典并返回

d1 = {
    
    'a': 10, 'b': 20, 'c': 30}
d2 = d1
d3 = d1.copy()
print(d2)   # {'a': 10, 'b': 20, 'c': 30}
print(d3)   # {'a': 10, 'b': 20, 'c': 30}

d1['c'] = 300
print(d2)   # {'a': 10, 'b': 20, 'c': 300}
print(d1)   # {'a': 10, 'b': 20, 'c': 300}
print(d3)   # {'a': 10, 'b': 20, 'c': 30}

3）dict.fromkeys(序列) - 创建一个新的字典，键是序列中的每个元素，值都是None
 dict.fromkeys(序列,值) - 创建一个新的字典，键是序列中的每个元素，值是指定的值

print(dict.fromkeys('abc'))   # {'a': None, 'b': None, 'c': None}
print(dict.fromkeys(['name', 'age', 'sex']))   # {'name': None, 'age': None, 'sex': None}
print(dict.fromkeys('abc', 100))   # {'a': 100, 'b': 100, 'c': 100}
print(dict.fromkeys('abc', [10, 20, 30]))   # {'a': [10, 20, 30], 'b': [10, 20, 30], 'c': [10, 20, 30]}

4）keys、values、items

"""
字典.keys() - 获取字典所有的key（返回值是序列但是不是列表）
字典.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)])

5）字典.setdefault(键,值) - 在字典中添加键值对(只添加不修改)

d1.setdefault('name', '小明')
print(d1)   # {'a': 10, 'b': 20, 'c': 30, 'name': '小明'}

# 不会修改已经存在的键值对
d1.setdefault('a', 111)
print(d1)   # {'a': 10, 'b': 20, 'c': 30, 'name': '小明'}

6）字典1.update(字典2) - 将字典2中所有的键值对都添加到1中

# 注意:字典2不一定是字典，也可以是能转换成字典的序列
# 如果键存在，则会更新键的值
d1 = {
    
    'a': 10, 'b': 20, 'c': 30}
d1.update({
    
    'name': '张三', 'age': 20})
print(d1)   # {'a': 10, 'b': 20, 'c': 30, 'name': '张三', 'age': 20}

d1.update(('nm', [10, 20]))
print(d1)   # {'a': 10, 'b': 20, 'c': 30, 'name': '张三', 'age': 20, 'n': 'm', 10: 20}