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])  # 敲代码
    
    
posted on 2019-09-14 11:20  天狼大大  阅读(130)  评论(0编辑  收藏  举报