python学习笔记之字典

zh_

字典

• 字典使用大括号
• 字典属于映射类型，不属于序列类型（字符串，列表，元组属于序列类型）
• 字典使用中括号进行索引
  1.   >>> dict1 = {10:'one' , 20:'two' , 30:'three'}
     
  2.   >>> dict1[20]
     
  3.   'two'

  复制代码
  冒号前为key（键），冒号后为value（值）。通过中括号索引key，打印value
• 使用dict创建字典（dict只有一个参数，其中dict内容，可以使用元组也可使用列表，只要构成映射关系即可）
  1.   >>> dict2 = dict(((1,'z'),(2,'h'),(3,'a'),(4,'n'),(5,'g')))
     
  2.   >>> dict2
     
  3.   {1: 'z', 2: 'h', 3: 'a', 4: 'n', 5: 'g'}

  复制代码
  
  
• 直接使用key=value的方式创建字典
  1.   >>> dict3 = dict(a = '1' , b = '2')
     
  2.   >>> dict3
     
  3.   {'a': '1', 'b': '2'}

  复制代码
  不能将key用引号括起来
  1.   >>> dict3 = dict('a' = '1' , b = '2')
     
  2.   SyntaxError: keyword can't be an expression

  复制代码
  因为给了key是a之后，就会把a以字符串的形式包裹起来
• 若直接给字典的键赋值，如果键本来就在字典里面存在，则改写键所对应的值；如果键不存在，则创建一个新的键，并为它赋值
  1.   >>> dict3['a']
     
  2.   '1'
     
  3.   >>> dict3['a'] = '12345'
     
  4.   >>> dict3
     
  5.   {'a': '12345', 'b': '2'}
     
  6.   >>> dict3['c'] = '234'
     
  7.   >>> dict3
     
  8.   {'a': '12345', 'b': '2', 'c': '234'}

  复制代码
  
  
• 字典的内建函数
  • fromkeys()创建并返回一个新的字典，有两个参数fromkeys(s[,v])，s是键值，v（可选参数，默认为none）是键所对应的值
    1.   >>> dict1 = {}
       
    2.   >>> dict1.fromkeys((1,2,3))
       
    3.   {1: None, 2: None, 3: None}
       
    4.   >>> dict1.fromkeys((1,2,3),'a')
       
    5.   {1: 'a', 2: 'a', 3: 'a'}

    复制代码
    不能使用以下方式试图给每个key一次赋值
    1.   >>> dict1.fromkeys((1,2,3),('a','b','c'))
       
    2.   {1: ('a', 'b', 'c'), 2: ('a', 'b', 'c'), 3: ('a', 'b', 'c')}

    复制代码
    
    
  • 试图修改某个key的值，实际上会新建一个字典
    1.   >>> dict1.fromkeys((1,2,3),'a')
       
    2.   {1: 'a', 2: 'a', 3: 'a'}
       
    3.   >>> dict1.fromkeys((1,3),'b')
       
    4.   {1: 'b', 3: 'b'}

    复制代码
    
    
• 访问字典的几个方法
  • keys()
    返回字典键的引用
    1.   >>> dict1 = dict1.fromkeys(range(5),'y')
       
    2.   >>> dict1
       
    3.   {0: 'y', 1: 'y', 2: 'y', 3: 'y', 4: 'y'}
       
    4.   >>> for each in dict1.keys():
       
    5.          print(each)
       
    6. 
       
    7.   0
       
    8.   1
       
    9.   2
       
    10.   3
        
    11.   4

    复制代码
    
    
  • values()
    返回键的值
    1.   >>> for each in dict1.values():
       
    2.          print(each)
       
    3. 
       
    4.   y
       
    5.   y
       
    6.   y
       
    7.   y
       
    8.   y  

    复制代码
    
    
  • items()
    返回每一项的值
    1.   >>> for each in dict1.items():
       
    2.          print(each)
       
    3. 
       
    4.   (0, 'y')
       
    5.   (1, 'y')
       
    6.   (2, 'y')
       
    7.   (3, 'y')
       
    8.   (4, 'y')

    复制代码
    
    
  • get()方法：当使用print打印一个字典中没有的键值得时候会报错，如下
    1.   >>> dict1
       
    2.   {0: 'y', 1: 'y', 2: 'y', 3: 'y', 4: 'y'}
       
    3.   >>> dict1[5]
       
    4.   Traceback (most recent call last):
       
    5.       File "<pyshell#94>", line 1, in <module>
       
    6.           dict1[5]
       
    7.   KeyError: 5

    复制代码
    使用get方法打印不存在的键返回的是none对象
    1.   >>> dict1.get(5)
       
    2.   >>> print(dict1.get(5))
       
    3.   None

    复制代码
    可以设置没有该键值得返回值
    1.   >>> dict1.get(5,'NO')
       
    2.   'NO'

    复制代码
    
    
• clear()方法清空字典
  1.   >>> dict1
     
  2.   {0: 'y', 1: 'y', 2: 'y', 3: 'y', 4: 'y'}
     
  3.   >>> dict1.clear()
     
  4.   >>> dict1
     
  5.   {}

  复制代码
  
  
• copy()方法：浅拷贝（浅拷贝！= 赋值：地址不同）
• pop()
  1.   >>> a
     
  2.   {1: 'one', 2: 'two', 3: 'three'}
     
  3.   >>> a.pop(2)
     
  4.   'two'
     
  5.   >>> a
     
  6.   {1: 'one', 3: 'three'}

  复制代码
  
  
• popitem()：随机弹出一个键值
  1.   >>> a.popitem()
     
  2.   (3, 'three')
     
  3.   >>> a
     
  4.   {1: 'one'}

  复制代码
  
  
• setdefault()：setdefault设置初始值，后面给元素赋值后再使用setdefault不会改变该值
  1.   >>> a
     
  2.   {1: 'one'}
     
  3.   >>> a.setdefault('小白')
     
  4.   >>> a
     
  5.   {1: 'one', '小白': None}
     
  6.   >>> a.setdefault(2, 0)
     
  7.   0
     
  8.   >>> a
     
  9.   {1: 'one', '小白': None, 2: 0}
     
  10.   >>> a[2] += 1
      
  11.   >>> a
      
  12.   {1: 'one', '小白': None, 2: 1}
      
  13.   >>> a.setdefault(2, 0)
      
  14.   1
      
  15.   >>> a
      
  16.   {1: 'one', '小白': None, 2: 1}

  复制代码
  
  
• update()利用一个字典或者映射来更新一个字典
  1.   >>> a
     
  2.   {1: 'one', '小白': None}
     
  3.   >>> b = {'小白':'dog'}
     
  4.   >>> a.update(b)
     
  5.   >>> a
     
  6.   {1: 'one', '小白': 'dog'}

  复制代码
  
  
• python字典不支持一键多值，相同的键值会覆盖上一次键值
  1.   >>> dict1 = {1:'one', 1:'yi'}
     
  2.   >>> dict1[1]
     
  3.   'yi'

  复制代码
  
  
• python会调用内部的散列函数，将key值作为参数进行转换，得到一个唯一的地址（相同的键值(123/123.0)转换得到相同的地址），然后将value存放在地址中
• key值必须是可哈希的，即键值必须可以通过散列函数计算出唯一地址
• 由于字典存放方式（使用哈希算法存储），所以使用in和not in查找key是否存在于字典中的效率更高，时间复杂度O(1)