字典中的方法

　　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']}