字典的內建方法的使用

• python常用的字典內建函数

  • 在一个字典中键是唯一的存在的；值是可以重复的，不是唯一的

  函数表达式	表达含义
  len(dict)	返回映射的长度(键值对的个数)
  hash(obj)	返回obj的哈希值
  dict.copy()	返回字典的一个副本,指向的地址是不同的
  dict.clear()	删除字典中所有的元素
  dict.fromkeys(seq, val=None)	创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值(如果不提供此，默认为None)
  dict.get(key)	通过字典dict中的键key,返回它对应的值value，如果字典中不存在此键，返回defaul的值;default的值默认为None
  dict.items()	返回一个包含字典中(键、值)对元组的列表
  dict.keys()	返回一个包含字典中所有键的列表
  dict.value()	返回一个包含字典中所有值的列表
  dict.iter()	方法iteritems(),iterkeys(),itervalues()与他们对应的非迭代方法一样，不同的是他们返回一个迭代对象，而不是一个列表
  dict.pop(key[,default])	和方法get()相似，如果字典中key键存在，删除并返回dict[key],如果key键不存在，且没有给出default的值，引发KeyError异常
  dict.setdefault(key,default=None)	和方法set()相似，如果字典中不存在key键，由dict[key]=default为它赋值,并返回这个值
  dict.update(dict2)	将字典dict2的键值对添加到字典dict中-->两个字典间的合并
  dict.has_key(key)	返回一个bool值来判断这个字典中是否存在这个键

  # len(dict)
  In [75]: dict1 = {'a':1,'b':2,'c':3}
  In [76]: len(dict1)
  Out[76]: 3
  
  # hash(obj)
  In [77]: hash('a')
  Out[77]: 12416037344 
  
  # dict.copy()                       # copy的是字典的一个副本,copy前后两者指向的地址是不一样的
  In [79]: dict2 = dict1.copy()
  In [80]: dict2
  Out[80]: {'a': 1, 'b': 2, 'c': 3}
  In [81]: dict1 is dict2
  Out[81]: False
  In [82]: id(dict1)
  Out[82]: 140294038350376
  In [83]: id(dict2)
  Out[83]: 140294037485000
  
  # dicty.clear()                     # 删除字典中所有的键值对(所有的元素)
  In [84]: dict2
  Out[84]: {'a': 1, 'b': 2, 'c': 3}
  In [85]: dict2.clear()
  In [86]: dict2
  Out[86]: {}
  
  # dict.fromkeys(seq, val=None)      # 先创建一个列表，然后根据列表中的元素作为字典的键创建一个新的字典
  In [87]: seq = ["a","b"]
  In [89]: dict1.fromkeys(seq)
  Out[89]: {'a': None, 'b': None}
  In [92]: dict1.fromkeys(seq, 1)
  Out[92]: {'a': 1, 'b': 1}
  
  # dict.get(key)                     # 通过字典的键获取对应的值
  n [93]: dict1
  Out[93]: {'a': 1, 'b': 2, 'c': 3}
  In [94]: dict1['a']
  Out[94]: 1
  
  # dict.items()                      # 返回一个包含字典中键值对元组的列表
  In [96]: dict1
  Out[96]: {'a': 1, 'b': 2, 'c': 3}
  In [97]: dict1.items()
  Out[97]: [('a', 1), ('c', 3), ('b', 2)]
  
  # dict.keys()                       # 返回一个列表包含这个字典中所有的键
  In [98]: dict1.keys()
  Out[98]: ['a', 'c', 'b']
  
  # dict.values()                     # 返回一个列表包含这个字典中所有的值
  In [99]: dict1.values()
  Out[99]: [1, 3, 2]
  
  # dict.items()                      # iteritems、iterkeys、itervalues、返回的是一个可以迭代的对象
  In [135]: dict1
  Out[135]: {'a': 1, 'b': 2, 'c': 3}
  In [136]: dict1.items()
  Out[136]: [('a', 1), ('c', 3), ('b', 2)]
  
  In [100]: print dict1.iteritems()
  <dictionary-itemiterator object at 0x7f98c0555628>
  In [102]: for i in dict1.iteritems():
   ...:     print i
   ...:     
  ('a', 1)
  ('c', 3)
  ('b', 2)
  
  # dict.pop()                        # 通过字典中唯一的键删除这个键值对，返回这个键值对的值
  In [107]: dict1.pop('a')
  Out[107]: 1
  In [108]: dict1
  Out[108]: {'b': 2, 'c': 3}
  
  # dict.setdefault(key,defaute=None) # 通过键值对的形式为字典添加修改元素
  In [117]: dict1.setdefault('f',5)
  Out[117]: 5
  In [118]: dict1
  Out[118]: {'a': 1, 'b': 2, 'c': 3, 'd': None, 'f': 5}
  
  # dict.update(dict2)                # 字典的合并-->将dict2中的键值对添加到dict中
  In [122]: dict1
  Out[122]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 5}
  In [123]: dict2 = {'zz':22,'xx':33}
  In [124]: dict1.update(dict2)
  In [125]: dict1
  Out[125]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 5, 'xx': 33, 'zz': 22}
  
  # dict.has_key(key)                 # 返回一个bool值来判定这个字典是否存在这个键
  n [126]: dict2
  Out[126]: {'xx': 33, 'zz': 22}
  In [127]: dict2.has_key("xx")
  Out[127]: True
  In [128]: dict2.has_key("xxx")
  Out[128]: False