Python基础（五）

今日主要内容

• 字典
  • 增
  • 删
  • 改
  • 查
• 字典嵌套

一、字典（dict）

（一）什么是字典

• 字典是可变类型数据，可迭代数据类型，无序的数据结构

• 字典可以存储大量的数据，存储量要比列表还大

• 字典利用键值对将数据关联起来

  • 第一个键值对的值是第二个键值对的键，所有数据相关联

  dic = {"ZXD": "hobby", "hobby": "play", "play": "DNF"}
  s = dic[dic[dic["ZXD"]]]
  print(s)

• 字典是根据key查找value，所以字典的查找速度要比列表快得多的多

• 字典所有的操作都是针对key进行的

• 字典的键是可哈希的（不可变类型），且唯一的，定义字典时若输入重复的键，取最后一个键值对

  • 不可变类型数据是可哈西的
  • 可变类型数据是不可哈希的

（二）字典的增

• dict[key] = value	利用key添加键值对
  dict.setdefault(key, value)	若字典中无key，则添加key：value

1. dict[key] = value

   • 利用键添加键值对

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   dic["hobby"] = "漂亮年轻的小姐姐"
   print(dic)
   # {'name': 'ZXD', 'age': 23, 'sex': 'man', 'hobby': '漂亮年轻的小姐姐'}

2. dict.setdefault(key, value)

   • 有两个参数，第一个是必填参数，需填入key；第二个参数默认为None，可填入value
   • 此方法有返回值，返回的是key的value
   • 在字典中查找有无此key，如果有，则返回key对应的value
   • 若没有，将此key添加到字典中。若填入第二个参数，则作为此key的value，若没有此键的值为None

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   res1 = dic.setdefault("age", 18)
   res2 = dic.setdefault("hobby", "漂亮年轻的小姐姐")
   print(res1)  # 23
   print(res2)  # 漂亮年轻的小姐姐
   print(dic)
   # {'name': 'ZXD', 'age': 23, 'sex': 'man', 'hobby': '漂亮年轻的小姐姐'}

（三）字典的删

• dict.pop(key)	根据key删除键值对
  dict.popitem()	随即删除键值对
  dict.clear()	清空字典
  del	各种删除

1. dict.pop(key)

   • 根据key删除字典中的键值对
   • 此方法有返回值，返回的是删除的键对应的值

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   det = dic.pop("sex")
   print(det)  # man
   print(dic)  # {'name': 'ZXD', 'age': 23}

2. dict.popitem()

   • 随即删除字典中的键值对，但是python3.6及以上版本默认删除最后一个键值对
   • 此方法没有参数，填入参数会报错
   • 此方法有返回值，以元组的形式返回随即删除的键值对

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   det = dic.popitem()
   print(det)  # ('sex', 'man')
   print(dic)  # {'name': 'ZXD', 'age': 23}

3. dict.clear()

   • 清空字典

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   dic.clear()
   print(dic)  # {}

4. del

   • 各种删除

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   del dic["sex"]
   print(dic)  # {'name': 'ZXD', 'age': 23}
   del dic
   print(dic)  # NameError: name 'dic' is not defined

（四）字典的改

• dict[key] = value	利用key修改value
  dict1.update(dict2)	将dict2更新到dict1中

1. dict[key] = value

   • 利用key修改value
   • 若要修改key，需要删除此键值对，并新增

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   dic["sex"] = "superman"
   print(dic)  # {'name': 'ZXD', 'age': 23, 'sex': 'superman'}

2. dict1.update(dict2)

   • 将dict2更新到dict1中：
     • 若key存在，更新key对应的value
     • 若key不存在，将键值对添加到dict1中

   dic1 = {"name": "ZXD", "age": 23}
   dic2 = {"sex": "man", "age": 18}
   dic1.update(dic2)
   print(dic1)  # {'name': 'ZXD', 'age': 18, 'sex': 'man'}

（五）字典的查

• dict[key]	通过key查看value
  dict.get()	查询key对应的值
  dict.setdefault(key, value)	查询key对应的值

1. dict[key]

   • 通过key查询键对应的值
   • 若key不在字典中，会报错

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   print(dic["name"])  # ZXD
   print(dic["hobby"])  # KeyError: 'hobby'
   
   

2. dict.get()

   • 有两个参数，第一个参数是必填参数，需填入key值，第二个参数默认为None，可填入value
   • 查找字典中有无此key，如果有，返回键对应的值
   • 如果没有，返回None，若有第二个参数，返回第二个参数

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   res1 = dic.get("name")
   res2 = dic.get("hobby", "没有爱好")
   print(res1)  # ZXD
   print(res2)  # 没有爱好
   

3. dict.setdefault(key, value)

   • 有两个参数，第一个是必填参数，需填入key；第二个参数默认为None，可填入value
   • 此方法有返回值，返回的是key的value
   • 在字典中查找有无此key，如果有，则返回key对应的value
   • 若没有，将此key添加到字典中。若填入第二个参数，则作为此key的value，若没有此键的值为None

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   res1 = dic.setdefault("age", 18)
   res2 = dic.setdefault("hobby", "漂亮年轻的小姐姐")
   print(res1)  # 23
   print(res2)  # 漂亮年轻的小姐姐
   print(dic)
   # {'name': 'ZXD', 'age': 23, 'sex': 'man', 'hobby': '漂亮年轻的小姐姐'}
   

（六）字典的其他操作

• 解构

  • 把线性结构的元素解开，并顺序的赋给其他变量，左边接纳的要与右边解开的个数一致

  a, b, c = 1, 2, 3  # 解构的过程
  print(a)
  print(b)
  print(c)
  

  • 如果变量名和变量数量不对应，在结构的过程中会报错

  a, b = 1, 2, 3, 4
  print(a, b)  # ValueError: too many values to unpack (expected 2)
  

  • 赋值的过程中，*表聚合
  • 输出的过程中，*表打散

  a, *b = 1, 2, 3, 4
  print(a, b)  # 1 [2, 3, 4]
  print(a, *b)  # 1 2 3 4
  

• dict.keys()	得到所有键
  dict.values()	得到所有值
  dict.items()	得到所有键值对

1. dict.keys()

   • 获取字典所有的key，得到的是一个伪列表
   • 得到的是一个可迭代对象，可以用for循环进行遍历

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   print(dic.keys())  # dict_keys(['name', 'age', 'sex'])
   
   for el in dic.keys():
    print(el, end=" ")  # name age sex
   

2. dict.values()

   • 获取字典所有的value，得到的是一个伪列表
   • 得到的是一个可迭代对象，可以用for循环进行遍历

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   print(dic.values())  # dict_values(['ZXD', 23, 'man'])
   
   for el in dic.values():
    print(el, end=" ")  # ZXD 23 man 
   

3. dict.items()

   • 获取字典所有的键值对，以元组形式存储，得到的是一个伪列表
   • 得到的是一个可迭代对象，可以用for循环进行遍历

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   print(dic.items())
   # dict_items([('name', 'ZXD'), ('age', 23), ('sex', 'man')])
   
   for el in dic.items():
    print(el, end=" ")  
   # ('name', 'ZXD') ('age', 23) ('sex', 'man') 
   

   • 利用解构

   dic = {"name": "ZXD", "age": 23, "sex": "man"}
   for key, value in dic.items():
    print(key, value)
   

   运行结果：
   name ZXD
   age 23
   sex man
   

二、字典嵌套

• 核心思想：无论嵌套多少字典，一层一层利用key就可以找到value

  dic = {
      "7点": {"晨练": ["跑步", "拉伸"]},
      "7点45": {"洗漱": ["洗头", "刷牙"], "吃早餐": ["面包", "牛奶"]},
      "8点30": {"上课": {"课前": ["回顾", "预习"], "上课": "认真听讲"}, "下课": ["休息", "敲代码"]},
      "12点30": ["吃午饭", "午休"],
      "14点30": {"自习": ["整理笔记", "写作业"]},
      "18点30": ["吃晚饭", "休息"],
      "19点30": {"自习": ["预习", "看视频"]},
  }
  
  # 想找到"敲代码"
  print(dic["8点30"]["下课"][1])  # 敲代码