基础数据类型-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'>

(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)

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

-clear(),copy()

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

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

最后看以下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