Dict字典

Dict

列表可以存储大量的数据，数据之间的关联性不强，而且列表的查询速度比较慢

1. {}括起来的，以键值对形式存储的容器型数据类型：

   { key_1: value, key_2: value, key_3: value, ······}

   dict = {'璃月':
          {'name':'刻晴','age':'18','sex':'女'},
           '稻妻':
           ['yoimiya','Mae Sakura','Sparkle']
          }
   

   • 字典在python3.5x前(包括3.5版本)，是无序的；在3.6x以及之后，会按照初次建立字典的顺序排列，但是学术上并不认为有序；3.7x以后都是有序的

   • 字典的查询速度非常快，存储关联性的数据

     ​ 字典的键值对会存在一个散列表（稀疏数组）这样的空间中，每一个单位称作一个表元，表元里面记录着key：value,如果你想要找到这个key对应的值，先要对这个key进行hash获取一串数字咱们简称为门牌号（非内存地址），然后通过门牌号，确定表元，对比查询的key与被锁定的key是否相同，如果相同，将值返回，如果不同，报错。

   • 字典的缺点：用空间换时间

     散列表必须是稀疏的

2. 创建字典：

   # 方式1
   dic = dict((('one',1),('two',2),('three',3)))
   print(dic)
   ---->{'one': 1, 'two': 2, 'three': 3}
   # 方式2
   dic = dict(one=1,two=2,three=3)
   print(dic)
   ---->{'one': 1, 'two': 2, 'three': 3}
   # 方式3
   dic = dict({'one': 1, 'two': 2, 'three': 3})
   print(dic)
   ---->{'one': 1, 'two': 2, 'three': 3}
   

   定义一个空字典：dic = {}

   dic = dict({'one':1,'one':2,'three':3})
   print(dic)
   ------>{'one': 2, 'three': 3}
   # 不会报错，会沿用后一个的键值对，前面的被后面的覆盖掉了
   # 由此可知，键是唯一的
   

3. 字典的嵌套

   value可以是任意数据类型

   key只能是不可变的数据类型：int、str、(bool、tuple几乎不用)

4. 新增元素

   • 语法：字典[key] = value # 有则改，无则增

     结果：字典被修改，新增了元素

   • 语法：.setdefault() # 有则不变，无则增加

     dic = dict({'one':1,'two':2})
     dic.setdefault('three') # 添加键
     print(dic)
     ------->{'one': 1, 'two': 2, 'three': None}
     dic.setdefault('three',3) # 
     print(dic)
     ----->{'one': 1, 'two': 2, 'three': 3}
     

5. 更新元素

   • 语法：字典[key] = value # 此处的key是已有的key

     结果：字典被修改，元素被更新

     字典key不可重复，所以对已存在的key执行可以更新

   • update

6. 删除元素

   语法：字典.pop(key)

   结果：按key删除键值对，有返回值，值为对应key的value

   dic = dict({'one':1,'two':2,'three':3})
   ret = dic.pop('two')
   print(dic,ret)
   ---->{'one': 1, 'three': 3} 2
   
   # 当你想要删除一个键时，你不知道这个键在不在字典里，你可以这样做
   dic = dict({'one':1,'two':2,'three':3})
   ret = dic.pop('four','False')
   print(dic,ret)
   ----->{'one': 1, 'two': 2, 'three': 3} False
   # 如果pop中输入的只有'four'，运行报错，当传入第二个参数时，表示如果没有要删掉的键，就返回第二个参数，同时也不会报错
   
   

   语法：del 字典名[key] # key存在于字典中，不存在的key会报错

   dic = dict({'one':1,'two':2,'three':3})
   del dic['three']
   print(dic)
   ------>{'one':1,'two':2}
   

7. 清空字典

   语法：字典.clear()

   结果：字典被修改，元素被清空

8. 字典查询

   • 字典不支持下标索引，可以用key索引出value
   • .get()

   # 1.用key索引
   dic = dict({'one':1,'two':2,'three':3})
   print(dic['two'])------->2
   print(dic['four'])-------->报错
   
   # 2.用get(输入没有的key时不会报错)
   dic = dict({'one':1,'two':2,'three':3})
   print(dic.get('three'))------>3
   print(dic.get('four'))------->None
   print(dic.get('four',False))--------->False
       # 可以设置返回值
   

   • .items()，该方法可以返回字典中的所有键值对，并且返回的数据类型是元组，可以通过将items()给一个变量，来得到一个包含字典所有键值对的元组列表

     my_dict = {"apple": 5, "banana": 3, "orange": 2}
     my_list = list(my_dict.items())
     print(my_list)
     ---->dict_items([('apple', 5), ('banana', 3), ('orange', 2)])
     # 可以转成列表类型，元素为元组
     # 用元组的拆包来获取键值对的键与值
     for key,value in my_dict.items():
         print(key,value)
     ---------------------------------
     apple 5
     banana 3
     orange 2
     

   • .keys() # 取字典的所有key

     my_dict = {"apple": 5, "banana": 3, "orange": 2}
     my_list = list(my_dict.keys())
     print(my_list)
     ---->dict_keys(['apple', 'banana', 'orange'])
     

   • .values() # 取字典的所有value

     my_dict = {"apple": 5, "banana": 3, "orange": 2}
     my_list = list(my_dict.values())
     print(my_list)
     ---->dict_values(['apple', 'banana', 'orange'])
     

   • 以上的字典经过特殊的方法得出的特殊的数据类型，可以通过强转成列表来操作

   遍历

   • 先获取keys，用for循环一个个取出来，再索引出value
   • 直接对字典用for循环，与第二点的效果一样

   • 遍历过程中，不可以改变字典的大小

dic = {'k1':2,'k2':3,'k3':4,'asdf':5}
for key in dic.keys():
    if 'k' in key:
        dic.pop(key)
print(dic)
# 以上代码运行报错，就是因为字典大小发生变化
# 因为不能在遍历时改变大小，所以循环的条件不能与字典有直接的关系
# 修改上述代码
for key in list(dic.keys()):
    if 'k' in key:
        dic.pop(key)
print(dic)----->{'asdf': 5}
# 将其转化为列表，属于是从一个新的可迭代对象处取值

9. 统计字典内元素数量： .len()

10. dict.fromkeys(可迭代对象，value)

    # 字符串
    dic = dict.fromkeys('asd',123)
    print(dic)
    ------>{'a': 123, 's': 123, 'd': 123}
    
    # 列表
    dic = dict.fromkeys(['a','s','d'],123)
    print(dic)
    ------>{'a': 123, 's': 123, 'd': 123}
    

    由前面学的代码块的缓存机制和深浅copy的知识可知，上面字典里，3个key的value都是指向同一个地址

    dic = dict.fromkeys(['a','s','d'],[123])
    print(dic)
    ---->{'a': [123], 's': [123], 'd': [123]}
    

​ 如果对 ‘a’ 的value追加一个元素

dic = dict.fromkeys(['a','s','d'],[123])
dic['a'].append(666)
print(dic)

那么三个元素的value都会随之改变

{'a': [123, 666], 's': [123, 666], 'd': [123, 666]}