字典

字典--python数据类型之一

• 字典关键字--dict

• 字典：无序，可变，可迭代，数据类型

• 键：可哈希（不可变）且唯一

• 不可变数据 可哈希

• 可变数据 不可哈希

• 不可哈希：int（整型）和bool（布尔值）

• 字典的特性：

  1. 存储量比列表要大
  2. 运行速度比列表快
  3. 可以存储多种数据类型
  4. 将数据和数据之间关联

• 字典的增加：

  • dic["键"] = "值"

    dic = {}                    #定义一个空的字典
    dic[1] = "狮子"              #添加一个键值对
    dic[2] = "老虎"              #再添加一个键值对，默认在最后添加
    print(dic)                  #查看添加后的字典
    

  • dic.setdefault("键","值")

    dic = {}                #定义一个空的字典
    dic.setdefault(1,"狮子") #添加一个键值对
    dic.setdefault(2,"老虎") #再添加一个键值对，默认在最后添加
    print(dic)              #查看添加后的字典
    

  • dic.update ({3:"傻傻分不清楚"})

    dic = {1:"狮子",2:"老虎"}             #定义一个字典
    dic.update({3:"傻傻分不清楚"})         #添加键值对，默认最后一个
    print(dic)                           #查看字典
    

• 字典的删除

  • del dic 删除整个定义的字典

    dic = {1:"狮子"，2:"老虎"}    #定义一个字典
    del dic                     #删除整个字典
    print(dic)                  #查找字典时报错，没有定义这个字典
    

  • dic.pop(键) 根据键删除字典的键值对,有返回值，是被删除的值

  • dic.pop()   括号发黄时，括号中需要参数

    dic = {1:"狮子",2:"老虎"}      #定义一个字典
    dic.pop(1)                    #删除字典中的键值对，且返回值
    print(dic)                    #查看删除后的字典
    

  • dic.popitem()            随机删除    python3.6默认删除最后一个

    dic = {1:"狮子",2:"老虎"}      
    dic.popitem()
    print(dic)
    

  • dic.clear 清空

    dic = {1:"狮子",2:"老虎"}        #定义一个字典
    dic.clear                       #清空字典的内容
    print(dic)                      #查看字典，结果是一个{}
    

• 字典的改

  • 键的改

    dic = {1:"狮子",2:"老虎"}         #定义一个字典
    dic[1] = "老虎"                  #更改字典中对应的键
    print(dic)                      #查看
    

  • dic.update

    dic = {1:"狮子",2:"老虎"}
    dic.update({2:"傻傻分不清楚"})
    print(dic)
    

    • 字典的合并 dic.update({需要合并的字典})

      dic = {1:"狮子",2:"老虎"}
      dic.update({3:"傻傻分不清楚",4:"你好"})
      print(dic)
      

• 字典的查

  • dic.get(键)

    • 如果键值不存在，返回值为None

    dic = {1:"狮子",2:"老虎"}        #定义一个字典
    print(dic.get(1))               #查找1对应的键值,具有返回值
    print(dic.get(3,"不存在"))       #可以指定返回值
    

  • 根据键查找

    • 如果不存在，就会保存

    dic = {1:"狮子",2:"老虎"}       #定义一个字典
    print(dic[1])                  #查找对应的键值
    

  • dic.setdefault (键)

    • 如果不存在，就会自动添加该键，返回值为None

    dic = {1:"狮子",2:"老虎"}        #定义一个字典
    print(dic.setdefault(1))        #查找1对应的键值
    print(dic.setdefault(3))        #查找不到，添加到最后一位，结果为None
    print(dic)                      #其结果为dic = {1:"狮子",2:"老虎",3:None}
    

  • 高仿列表可以迭代

    for k,v in dic.items()
            print(k,v)
    

  • dic.keys() 获取字典中的键

    • 查出字典中所有的键

      dic = {1:"狮子",2:"老虎"}           #定义一个字典
      print(dic.keys())                  #以高仿列表的方式打印
      

    • 如果出现字典的嵌套，可以打印嵌套中吗？

      dic = {1:"狮子"，2:"老虎",3:"傻傻分不清楚"，4:{3:"老虎",4:"狮子",5:"老虎"}}
      #dic.keys()只打印字典第一层的键
      print(dic.keys())               #结果1  2  3  4
      

  • dic.values() 获取字典中的值

    • 查出字典中所有的值

      dic = {1:"狮子",2:"老虎"}            #定义一个字典
      print(dic.values)                          #以高仿列表的方式所有的值
      

    • 如果出现字典的嵌套，可以打印吗？

      dic = {1:"狮子"，2:"老虎",3:"傻傻分不清楚"，4:{3:"老虎",4:"狮子",5:"老虎"}}
      #dic.values()  嵌套中的字典会以值得方式打印
      print(dic.values())    
      #结果为dict_values(['狮子', '老虎', '傻傻分不清楚', {3: '老虎', 4: '狮子', 5: '老虎'}])
      

• 解构

  a,b,c = 1,2,3        #解构的赋值是迭代赋值，可迭代对象之间可以不加逗号，不可迭代对象之间必须加逗号                        分割
  print(a,b,c)         #结果为1  2   3
  a,b,v = "你好啊"
  print(a,b,c)         #结果为你   好    啊
  

  • 当变量超出赋值对象对报错

  • 当赋值对象超出变量时，也会报错

    • 解决方式

      a,b,*c = 1,2,3,4,5,6,7      #最后一个变量将剩余的值以列表的方式全部赋值给他
      print(a,b,c)                #结果为1  2  (3,4,5,6,7) 
      

    • a,b,*c = 1,2,3,4,5,6,7      #打包
      print(a,b,c)                #解包
      

• 字典的嵌套

  dic = {1:"狮子"，2:"老虎",3:"傻傻分不清楚"，4:{3:"老虎",4:"狮子",5:"老虎"}}
  #字典的嵌套可以在嵌套外和嵌套内的键值相同，且不相互影响，但一般不建议这样写
  print(dic[4][4])
  

• 字典和列表的区别

  1. 字典比列表存储要更大
  2. 字典比列表查找速度更快
  3. 字典比列表查找更方便