字典中的方法
clear()方法：清空字典中的所有元素。这个方法是将字典清空，得到一个空字典，这个字典对象依然在内存中，此时，它是一个空字典而不是垃圾，不会被作为垃圾处理。
>>> stu {'B': 123, 'C': 123, 'A': 123} >>> stu.clear() >>> stu {}
clear方法与del和dict = {}的区别：
clear方法是将字典清空，得到一个空字典，这个字典对象依然在内存中，此时，它是一个空字典而不是垃圾，不会被作为垃圾处 理。
del是直接将字典删除，删除后内存中就没有这个对象了。
>>> stu = {'Lily': 'python5', 'Jack': 'python5'}
>>> del stu # del后内存中没有stu对象
>>> stu
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'stu' is not defined
dict = {}是将变量重新指向了一个新的空字典对象，此时的原字典对象并没有被删除或清空，它依然存在于内存之中，但是成为了垃圾，等待着被python自动回收。
>>> stu = {'Lily': 'python5', 'Jack': 'python5'}
>>> stu
{'Lily': 'python5', 'Jack': 'python5'}
>>> stu = {} # 变量stu重新指向了一个新的空字典对象，原字典对象成为垃圾
>>> stu
{}
get()方法：返回字典中某个键对应的值。
当指定的键存在于字典中时，返回该键对应的值。
>>> stu = {'Lily': 'python5', 'Jack': 'python5'}
>>> stu.get('Lily')
'python5'
当指定的键不存在于字典中时，默认返回None，而不报错，这是和通过dict[key]取值的区别。
>>> stu = {'Lily': 'python5', 'Jack': 'python5'}
>>> stu.get('Tom') # 没有此键，返回空值
>>> stu['Tom']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Tom'
get()方法可指定第二个可选参数，此参数默认值为None，当指定的键不存在于字典中时，若无第二个参数，则返回None，若有第二个参数，则返回get方法的第二个参数给定的值。
>>> stu {'Lily': 'python5', 'Jack': 'python5'} >>> stu.get('Tom', 'java6') # 没有此键，返回其第二个参数给定的值 'java6'
setdefault()方法：这个方法与get()方法类似，可以用来取出字典中指定键的值。
当指定的键存在于字典中时，返回该键对应的值。
>>> stu = {'Lily': 'python5', 'Jack': 'python5'}
>>> stu.setdefault('Jack') # 字典中有这个键，取出对应键的值
'python5'
>>> stu # 原字典不变
{'Lily': 'python5', 'Jack': 'python5'}
setdefault()方法可指定第二个可选参数，此参数默认值为None，当指定的键不存在于字典中时，若无第二个参数，则返回默认值None，若有第二个参数，则返回get方法的第二个参数给定的值，并将此键值对添加到字典中。
>>> stu {'Lily': 'python5', 'Jack': 'python5'} >>> stu.setdefault('Alice', 'c++7') # 键不在字典中，返回其指定值，默认None 'c++7' >>> stu # 并将此键值对添加到字典中 {'Lily': 'python5', 'Alice': 'c++7', 'Jack': 'python5'} >>> stu.setdefault('Tom') # 没有指定第二个参数的值，默认None >>> stu # 添加到字典中的键值对的值就为None {'Lily': 'python5', 'Alice': 'c++7', 'Tom': None, 'Jack': 'python5'}
items()方法：取出字典中所有的键值对，返回一种名为字典视图的特殊类型，其结果可迭代。
>>> stu {'Lily': 'python5', 'Alice': 'c++7', 'Jack': 'python5'} >>> stu.items() # 将键值对放在元组中，所有的元组放在列表中，返回dict_ items类对象 dict_items([('Lily', 'python5'), ('Alice', 'c++7'), ('Jack', 'python5')])
keys()方法：取出字典中所有的键，返回的结果可迭代。
>>> stu {'Lily': 'python5', 'Alice': 'c++7', 'Jack': 'python5'} >>> stu.keys() # 将所有的键放在列表中，返回一个dict_keys类对象 dict_keys(['Lily', 'Alice', 'Jack'])
values()方法：取出字典中所有的值，返回的结果可迭代。
>>> stu {'Lily': 'python5', 'Alice': 'c++7', 'Jack': 'python5'} >>> stu.values() # 将所有的值放在列表中，返回一个dict_values类对象 dict_values(['python5', 'c++7', 'python5'])
pop()方法：删除字典中的键值对。这个方法必须指定一个参数键。
当指定的键存在于字典中时：
>>> stu {'Lily': 'python5', 'Alice': 'c++7', 'Jack': 'python5'} >>> stu.pop('Lily') # 删除指定的键及其值，并将值返回 'python5' >>> stu {'Alice': 'c++7', 'Jack': 'python5'}
这个方法可以指定第二个可选参数，当指定的键不存在于字典中时，就返回方法中指定的第二个参数的值。
>>> stu {'Alice': 'c++7', 'Jack': 'python5'} >>> stu.pop('Bob', 'java3') # 指定的键不存在与字典中，返回第二个参数指定的值 'java3' >>> stu {'Alice': 'c++7', 'Jack': 'python5'}
当指定的键不存在于字典中且不知道第二个参数时，报错。
>>> stu {'Alice': 'c++7', 'Jack': 'python5'} >>> stu.pop('Bob') Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Bob'
字典中的这个pop方法必须指定一个键作为参数，若没有参数，也报错，这与列表中的pop方法不同。
>>> stu {'Alice': 'c++7', 'Jack': 'python5'} >>> stu.pop() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: pop expected at least 1 arguments, got 0
popitem()方法：没有任何参数，它随机删除字典中的一个键值对，并以元组的形式将这个删除的键值对返回。
>>> stu {'Alice': 'c++7', 'Jack': 'python5'} >>> stu.popitem() ('Alice', 'c++7') # 将删除的键值对以元组的形式返回
当字典为空时，若继续删除，则报错。
>>> stu {} >>> stu.popitem() Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'popitem(): dictionary is empty'
update()方法：更新原字典，其返回值为None。它的参数可以是字典，或其他某种可迭代的对象。
>>> stu1 = {'Alice': 'c++7', 'Jack': 'python5'}
>>> stu2 = {'A':123}
>>> stu1.update(stu2) # 参数为字典，将字典stu2纳入stu1中，更stu1
>>> stu1
{'Alice': 'c++7', 'A': 123, 'Jack': 'python5'}
>>> stu2 # 字典stu2不变
{'A': 123}
>>> stu2.update([('B', 333), ('D', 99)]) # 参数为列表中以元组为元素，每个元组作为一个键值对
>>> stu2
{'B': 333, 'D': 99, 'A': 123}
引例：
>>> stu = {'name':'Jack', 'age':22}
>>> stu1 = stu # 这种方式只是假装拷贝
>>> stu1
{'name': 'Jack', 'age': 22}
>>> id(stu)
139817437969096
>>> id(stu1) # 两者地址完全相同
139817437969096
这种用赋值的方式实现的所谓“假装拷贝”，真实情况是两个变量和同一个对象之间建立了引用关系。修改任意一个，另一个也会随着改变。
>>> stu1['sex'] = 'm' >>> stu1 # 修改了stu1 {'name': 'Jack', 'sex': 'm', 'age': 22} >>> stu # stu也随着改变 {'name': 'Jack', 'sex': 'm', 'age': 22}
copy()方法：复制字典对象。得到的新的字典和原字典内容一致，但他们存于不同的内存空间中。修改其中一个不会对另一个产生影响。
>>> stu {'name': 'Jack', 'sex': 'm', 'age': 22} >>> stu {'name': 'Jack', 'sex': 'm', 'age': 22} >>> stu2 = stu.copy() # 复制 >>> stu2 {'name': 'Jack', 'age': 22, 'sex': 'm'} >>> id(stu) 139817437969096 >>> id(stu2) # 二者内存地址不同 139817437425608 >>> stu2['age'] = 33 # 修改stu2 >>> stu2 {'name': 'Jack', 'age': 33, 'sex': 'm'} >>> stu # 不会对stu产生影响 {'name': 'Jack', 'sex': 'm', 'age': 22}
再看下面这种情况：
>>> x = {'name':'Jack', 'lang':['python', 'java', 'c++']}
>>> y = x.copy() # 复制x并赋值给y
>>> y
{'name': 'Jack', 'lang': ['python', 'java', 'c++']}
>>> id(x)
139817437431560
>>> id(y) # x和y的内存地址也不同
139817437423304
>>> y['name'] = 'Alice' # 修改y中的name键的值
>>> y
{'name': 'Alice', 'lang': ['python', 'java', 'c++']}
>>> x # x中不会发生改变
{'name': 'Jack', 'lang': ['python', 'java', 'c++']}
>>> y['lang'].remove('c++') # 修改y中的lang键的内容
>>> y
{'name': 'Alice', 'lang': ['python', 'java']}
>>> x # x中的lang键的内容随之改变
{'name': 'Jack', 'lang': ['python', 'java']}
分析上述原因：由两个对象的内存地址可发现，x和y的内存地址不同，x的name键值对的内存地址和y的也不同；但是x的lang键的内存地址却和y的相同，即这两个对象的键值对之一的值——列表是同一个对象，但其字符串类型的值却是不同的对象。
至此，我们可以简要作结论：当copy()的时候，列表、元组等对象任然是复制了引用，并没有建立一个新的对象。我们称之为“浅拷贝”。
>>> id(x['name']) 139817437434800 >>> id(y['name']) # 二者不同 139817437435584 >>> id(x['lang']) 139817437431112 >>> id(y['lang']) # 两者相同 139817437431112 # 元组时，依然相同 x1 = {'name': 'Jack', 'lang': ('python', 'java')} >>> x1 {'name': 'Jack', 'lang': ('python', 'java')} >>> y = x1.copy() >>> y {'name': 'Jack', 'lang': ('python', 'java')} >>> id(y['lang']) 139817437431624 >>> id(x1['lang']) 139817437431624
引入“深拷贝”：python中有个copy模块，可以解决“深拷贝”的问题。
>>> import copy # 导入copy模块 >>> x {'name': 'Jack', 'lang': ['python', 'java']} >>> y = copy.deepcopy(x) # 深拷贝 >>> y {'name': 'Jack', 'lang': ['python', 'java']} >>> id(x['lang']) # x的lang(列表对象)和y的不再相同 139817437431112 >>> id(y['lang']) 139817408632648 >>> y['lang'].remove('java') # 修改y的lang(列表对象) >>> y {'name': 'Jack', 'lang': ['python']} >>> x # x的不再随之改变 {'name': 'Jack', 'lang': ['python', 'java']}
