基础数据类型-dict

字典Dictinary是一种无序可变容器，字典中键与值之间用“：”分隔，而与另一个键值对之间用","分隔，整个字典包含在{}内： dict1 = {key1:value1, key2:value2}

键必须是唯一的，而值不必，创建时如果同一个键被赋值两次，后一个值会被记住

键必须是不可变类型，如字符串，数字，元组（不能是列表），但值可以取任何类型，也可以是自定义类，比如： dict1 = {'k1':'v1', 1:2, (1,2):[1,2]}

(1)访问字典元素：

键放入中括号内访问字典元素： print(dict1['k1'])

(2)添加，修改字典元素：

 dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 dict['Age'] = 8;        # 更新 Age
 dict['School'] = "CSU"  # 添加信息

(3)删除字典元素：

 dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 del dict['Name'] # 删除键 'Name'
 dict.clear()     # 清空字典
 del dict         # 删除字典

(4)字典内置函数len(), str(), type：

 dict2 = {'Name': 'Joshua', 'Age': 7, 'Class': 'Math'}
 print("length of dict2:", len(dict2)) #计算字典元素个数，即键的总数。
 print(str(dict2)) #输出字典以可打印的字符串表示
 print(type(dict2)) #返回输入的变量类型，如果变量是字典就返回字典类型。

 length of dict2: 3
 {'Age': 7, 'Name': 'Joshua', 'Class': 'Math'}
 <class 'dict'>

Result

(5)字典常用内置方法：

-get()

 name = dict2.get('Name') #返回指定键的值，如果值不在字典中返回default值
 print("name:", name)

-item(),keys(),values()

 print(dict2.items())
 for item in dict2.items(): #以列表返回可遍历的(键, 值) 元组数组
     print(item, type(item))
 for key in dict2.keys():  #以列表返回一个字典所有的键
     print(key)
 for value in dict2.values(): #以列表返回字典中的所有值
     print(value)

Code

 dict_items([('Name', 'Joshua'), ('Class', 'Math'), ('Age', 7)])
 ('Name', 'Joshua') <class 'tuple'>
 ('Class', 'Math') <class 'tuple'>
 ('Age', 7) <class 'tuple'>
 Name
 Class
 Age
 Joshua

Result

-clear(),copy()

 #clear(),copy()
 dict3 = dict2.copy() #返回一个字典的浅复制
 print(id(dict2), dict2)
 print(id(dict3), dict3)
 dict3.clear() #清空字典内所有元素
 print(dict3)

Code

 4301648 {'Age': 7, 'Class': 'Math', 'Name': 'Joshua'}
 4301688 {'Age': 7, 'Class': 'Math', 'Name': 'Joshua'}
 {}

Result

最后看以下dict类的定义：

 class dict(object):
     """
     dict() -> new empty dictionary
     dict(mapping) -> new dictionary initialized from a mapping object's
         (key, value) pairs
     dict(iterable) -> new dictionary initialized as if via:
         d = {}
         for k, v in iterable:
             d[k] = v
     dict(**kwargs) -> new dictionary initialized with the name=value pairs
         in the keyword argument list.  For example:  dict(one=1, two=2)
     """
     def clear(self): # real signature unknown; restored from __doc__
         """ D.clear() -> None.  Remove all items from D. """
         pass

     def copy(self): # real signature unknown; restored from __doc__
         """ D.copy() -> a shallow copy of D """
         pass

     @staticmethod # known case
     def fromkeys(*args, **kwargs): # real signature unknown
         """ Returns a new dict with keys from iterable and values equal to value. """
         pass

     def get(self, k, d=None): # real signature unknown; restored from __doc__
         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
         pass

     def items(self): # real signature unknown; restored from __doc__
         """ D.items() -> a set-like object providing a view on D's items """
         pass

     def keys(self): # real signature unknown; restored from __doc__
         """ D.keys() -> a set-like object providing a view on D's keys """
         pass

     def pop(self, k, d=None): # real signature unknown; restored from __doc__
         """
         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
         If key is not found, d is returned if given, otherwise KeyError is raised
         """
         pass

     def popitem(self): # real signature unknown; restored from __doc__
         """
         D.popitem() -> (k, v), remove and return some (key, value) pair as a
         2-tuple; but raise KeyError if D is empty.
         """
         pass

     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
         pass

     def update(self, E=None, **F): # known special case of dict.update
         """
         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
         If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
         If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
         In either case, this is followed by: for k in F:  D[k] = F[k]
         """
         pass

     def values(self): # real signature unknown; restored from __doc__
         """ D.values() -> an object providing a view on D's values """
         pass

Class Dict