python中字典的应用方法_字典中的方法

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"", line 1, in 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"", line 1, in 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"", line 1, in KeyError:'Bob'

字典中的这个pop方法必须指定一个键作为参数，若没有参数，也报错，这与列表中的pop方法不同。

>>>stu

{'Alice': 'c++7', 'Jack': 'python5'}>>>stu.pop()

Traceback (most recent call last):

File"", line 1, in TypeError: pop expected at least1 arguments, got 0

popitem()方法：没有任何参数，它随机删除字典中的一个键值对，并以元组的形式将这个删除的键值对返回。

>>>stu

{'Alice': 'c++7', 'Jack': 'python5'}>>>stu.popitem()

('Alice', 'c++7') #将删除的键值对以元组的形式返回

当字典为空时，若继续删除，则报错。

>>>stu

{}>>>stu.popitem()

Traceback (most recent call last):

File"", line 1, in 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']}