python字典

字典dict

• key-value键值对的数据的集合
• 可变的、无序的、key不重复,key可hash

字典dict定义初始化

• d = dict() 或者d = {}
• dict(**kwargs)使用name=value对初始化一个字典(函数参数关键字可构造字典)

 d = dict(a=1,b=2)
 -------------------------------------
{'a': 1, 'b': 2}
--------------------------------------
 d = dict("a"=1,"b"=2)这样写是错误的,这样定义时,a必须是标识符,不能是字符串,字符串是能改变,也不能赋值

• dict(iterable, ** kwarg)使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构

d = dict(((1,'a'),(2,'b'))) 
d = dict(([1,'a'],[2,'b'],{3,"abc"}))
------------------------------------
{1: 'a', 2: 'b'}
{1: 'a', 2: 'b', 'abc': 3}

• dict(mapping, **kwarg) 使用一个字典构建另一个字典

d = {'a':10, 'b':20, 'c':None, 'd':[1,2,3]}  

• 类方法
  • dict.fromkeys(iterable, value)

  dict.fromkeys(range(3))
  dict.fromkeys(range(3),"abc")
  ---------------------------------
  {0: None, 1: None, 2: None}
  {0: 'abc', 1: 'abc', 2: 'abc'}
  

字典元素的访问

• d[key]
  • 返回key对应的值value
  • key不存在抛出KeyError异常

     da = {1:10,2:20,3:30}
     da[2], da.get(1), da.get(10),da.get(10,100)   #100 是缺省值
    ----------------------------------
     (20, 10, None, 100)
    

• get(key[, default])
  • 返回key对应的值value
  • key不存在返回缺省值，如果没有设置缺省值就返回None
• setdefault(key[, default])
  • 返回key对应的值value
  • key不存在，添加kv对，value设置为default，并返回default，如果default没有设置，缺省为None

    da = {1:10,2:20,3:30}
    da.setdefault(3,1000), da.setdefault(12,1000)
    --------------------------------------------------
    (30, 1000)
    
    da
    --------------------------------------------------
    {1: 10, 2: 20, 3: 30, 12: 1000}
    

字典增加和修改

• d[key] = value
  • 将key对应的值修改为value
  • key不存在添加新的kv对
• update([other]) -> None
  • 使用另一个字典的kv对更新本字典
  • key不存在，就添加
  • key存在，覆盖已经存在的key对应的值
  • 就地修改
  • d.update(red=1)
  • d.update(((‘red’,2),))
  • d.update({‘red’:3})

  d1 = {1:10,2:20,3:30}
  d2 = {1:"a",10:"b",20:"c"}
  d3 = dict(((3,"xyz"),),a = "abcd")
  
  d1.update(d2)
  ---------------------------------------
  d1
  --------------------------------------
  {1: 'a', 2: 20, 3: 30, 10: 'b', 20: 'c'}
  ---------------------------------------
  d1.update(d3)
  ----------------------------------------
  d1
  ----------------------------------------
  {1: 'a', 2: 20, 3: 'xyz', 10: 'b', 20: 'c', 'a': 'abcd'}
  

字典删除

• pop(key[, default])

  • key存在，移除它，并返回它的value
  • key不存在，返回给定的default
  • default未设置，key不存在则抛出KeyError异常

  d = {1: 'a', 2: 20, 3: 'xyz', 10: 'b', 20: 'c', 'a': 'abcd'}
  
  d1.pop(1),d1.pop(100,None)
  -------------------------------------
  ('a', None)
  
  d
  -------------------------------------
  {2: 20, 3: 'xyz', 10: 'b', 20: 'c', 'a': 'abcd'}
  

• popitem()

  • 移除并返回一个任意的键值对
  • 字典为empty，抛出KeyError异常

d = {2: 20, 3: 'xyz', 10: 'b', 20: 'c', 'a': 'abcd'}
d.popitem()
-------------------------------------------
('a', 'abcd')   #随机弹出一个键值对

• clear() 清空字典

字典删除

• del语句

a = True  
del a
a
--------------------------------------------------------------------------
NameError                                Traceback (most recent call last)
<ipython-input-63-3f786850e387> in <module>
----> 1 a
NameError: name 'a' is not defined

b = [6]  
d = {'a': 1, 'b': b, 'c': [1,3,5]}  

del d['c']
del b[0]   

b,d
---------------------------------------
([], {'a': 1, 'b': []})  

• del a[‘c’]看着像删除了一个对象，本质上减少了一个对象的引用，del 实际上删除的是名称(引用地址)，而不是对象

字典遍历

• 遍历key

  • for … in dict

  d = {'a': 1, 'b': "x", 'c': [1,3,5]}
  for k in d:  
  print(k,end = " ")
  ------------------------------------
  a b c 
  

  • for … in dict.keys()

  d = {'a': 1, 'b': "x", 'c': [1,3,5]}
  for k in d.keys():  
  print(k,end=" ")
  ------------------------------------
   a b c
  

  • 快速拿到,keys

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  ke=list(d.keys())
  
  ke
  --------------------------------------
  ['a', 'b', 'c'] 
  

  • 快速拿到values

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  va=list(d.values())
  
  va
  --------------------------------------
  [1, 'x', [1, 3, 5]] 
  
  --------------------------------------
  d = {'a': 1, 'b': "x", 'c': [1,3,5]}
  dk = [k for k in d.keys()]      #列表解析式拿到keys,values
  dv = [v for v in d.values()]
  

• 遍历value

  • for k in d:
     print(d[k])

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  for k in d:
      print(d[k],end = " ")
  --------------------------------------
  1 x [1, 3, 5] 
  

• for k in d.keys():
   print(d.get(k))

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  for k in d.keys():
      print(d.get[k],end = " ")
  --------------------------------------
  1 x [1, 3, 5] 
  

• for v in d.values():
   print(v)

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  for v in d.values():
  print(v,end=' ')
  --------------------------------------
  1 x [1, 3, 5] 
  

---

字典遍历

• for … in dict

  • 遍历item，即kv对
  • for item in d.items():
     print(item)

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  for item in d.items():
      print(item,end = " ")
  -----------------------------------------
  ('a', 1) ('b', 'x') ('c', [1, 3, 5])    #得到的是二元组结构
  

• for item in d.items():
   print(item[0], item[1])

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  for item in d.items():
      print(item[0], item[1])
  -----------------------------------------
  a 1
  b x
  c [1, 3, 5]
  

• for k,v in d.items():
   print(k, v)

  d = {'a': 1, 'b': "x", 'c': [1,3,5]} 
  for k,v in d.items():
      print(k,v)         # K, V对直接解构
  ---------------------------------------------
  a 1
  b x
  c [1, 3, 5]  
  

• for k, _ in d.items():
   print(k)

• for _ , v in d.items():
   print(v)

字典的key

• key的要求和set的元素要求一致
• set的元素可以就是看做key，set可以看做dict的简化版
• hashable 可哈希才可以作为key，可以使用hash()测试

---

defaultdict

• collections.defaultdict([default_factory[, …]])
• 第一个参数是default_factory，缺省是None，它提供一个初始化函数。当key不存在的时候，会调用这个工厂函数来生成key对应的value
• 构造一个字典，values是列表，为其添加随机个元素

  import random
  d1 = {}
  for k in 'abcdef':
      for v in range(random.randint(1, 5)):
          if k not in d1.keys():
              d1[k] = []
          d1[k].append(v)
  print(d1)
  ------------------------------------------
  {'a': [0, 1], 'b': [0, 1], 'c': [0, 1, 2, 3, 4], 'd': [0], 'e': [0, 1], 'f': [0, 1]} 
  
  

  from collections import defaultdict
  import random
  d1 = defaultdict(list)
  for k in 'abcdef':
      for v in range(random.randint(1, 5)):
          d1[k].append(v)
  print(d1)
  ------------------------------------------
  defaultdict(<class 'list'>, {'a': [0, 1, 2], 'b': [0, 1, 2], 'c': [0], 'd': [0], 'e': [0, 1], 'f': [0]})
  

  d={}
  for k,v in zip('abcd',range(4)):
      d[k]=v
  print(d)
  ------------------------------------------
  {'a': 0, 'b': 1, 'c': 2, 'd': 3}
  

OrderedDict

• collections.OrderedDict([items])

  • key并不是按照加入的顺序排列，可以使用OrderedDict记录顺序

      from collections import OrderedDict
  import random
  d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
  print(d)
  
  keys = list(d.keys())
  random.shuffle(keys)
  print(keys)
  
  od = OrderedDict()
  for key in keys:
      od[key] = d[key]
  print(od)
  print(od.keys())
  ------------------------------------------
  {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
  ['orange', 'apple', 'pear', 'banana']
  OrderedDict([('orange', 2), ('apple', 4), ('pear', 1), ('banana', 3)])
  odict_keys(['orange', 'apple', 'pear', 'banana'])
  
  

• 有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印

• 3.6版本的Python的字典就是记录key插入的顺序（IPython不一定有效果）应用场景：

• 假如使用字典记录了N个产品，这些产品使用ID由小到大加入到字典中除了使用字典检索的遍历，有时候需要取出ID，但是希望是按照输入的顺序，因为输入顺序是有序的,否则还需要重新把遍历到的值排序