在上一篇Python学习之字典当中，学习了Python一种独特的数据对象类型，字典以及如何创建字典和创建字典的方法。
这一篇主要学习字典的基本操作及字典中的函数。对于字典的基本操作。
获取字典的长度
使用内置函数len(dict)
>>> test = {"a":"1","b":"3","c":"4"}
>>> test
{'a': '1', 'c': '4', 'b': '3'}
>>> len(test)
3通过键来查找字典中的值
>>> print test
{'a': '1', 'c': '4', 'b': '3', 'd': '5'}
>>> test['d']
'5'
>>> test['3'] #如果字典中不存在键，那么就会报错
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
test['3']
KeyError: '3'
>>> test['a']
'1'
>>> 向字典中增加键值对
>>> print test
{'a': '1', 'c': '4', 'b': '3', 'd': '5'}
>>> test["e"] = "6"
>>> test
{'a': '1', 'c': '4', 'b': '3', 'e': '6', 'd': '5'}
>>> 从字典中删除一个键值对
>>> print test
{'a': '1', 'c': '4', 'b': '3', 'e': '6', 'd': '5'}
>>> del test['a']
>>> print test
{'c': '4', 'b': '3', 'e': '6', 'd': '5'}
>>> 判断某个键是否存在于字典中
关键代码 key in dict，如果存在则返回true,如果不存在，则返回false
>>> print test
{'c': '4', 'b': '3', 'e': '6', 'd': '5'}
>>> 'c' in test
True
>>> 'a' in test
False
>>> 'f' in test
False
>>> 字典中字符串的格式化输出
>>> print test
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> print "the web\'s name is %(name)s ,the web\'s website is %(website)s."%test
the web's name is baidu ,the web's website is https://www.baidu.com.
>>>
从以上代码中，我们可以看到，字符串中如果调用字典中的key，使用%( )s，然后在结尾使用% dict从字典中检索key。
不过字典中的字符串的格式化输出不怎么实用。
下面我们写一个网页代码来小试牛刀一下
>>> code = "<html><head><title>%(string)s</title><body><p>This is the %(page)s</p></body></head></html>"
>>> testdict = {"string":"test page","page":"test page"}
>>>> code % testdict
'<html><head><title>test page</title><body><p>This is the test page</p></body></head></html>'
>>>
其实这个例子并没有什么实际意义，但是很好玩儿呀！
接着上面的，从这里开始，开始学习字典中的函数
和前面所讲述的其他对象一样，字典中也有一些函数，通过这些函数，可以实现对字典的操作。
1、copy和deepcopy
通常，copy就是简单的理解为将原来的东西复制一份，但是如果以为copy的含义仅仅是这个，那么孩子，涉世未深，还得探索呀。在Python中，或者说其他的编程语言中，copy可不仅仅是那么简单的。
>>> a = 1
>>> b = a
>>> b
1
上面的代码中，我们可以看到，我们似乎是得到了两个1，但是真的是这样吗？我们知道，在Python中，对象有类型，变量无类型。所以，我们可以看得出，变量只是一个标签而已，相当于爸爸有1块钱，然后爸爸把1块钱给了孩子，那么孩子得到的依然使这1块钱，1块钱的实质是不变得。粗糙理解一下啊。我也是新手，不知道例子举得恰不恰当。不信，我们可以通过id( )来验证。
>>> a = 1
>>> b = a
>>> b
1
>>> id(a)
10728248
>>> id(b)
10728248
>>>
在其它的数据类型中，也是同样，这里只实验一下字典类型
>>> test
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> demo = test
>>> demo
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> id(test)
11179680
>>> id(demo)
11179680
>>>
我们可以看到又是一个对象贴了两个标签，这是用赋值的方式实现对象的所谓的“假装拷贝”。那么如果是copy的方法呢
>>> test
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> demo = test.copy()
>>> demo
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> id(test)
11179680
>>> id(demo)
11349728
>>>
我们发现，这次得到的demo和原来的demo是不同的，它在内存中另开辟了一个空间。如果我尝试修改demo，那么对于原来的test应该不会造成影响，实验的结果会不会是如我所说的呢？
>>> test
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> demo = test.copy()
>>> demo
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> id(test)
11179680
>>> id(demo)
11349728
>>> demo ["name1"] = "google"
>>> demo
{'website': 'https://www.baidu.com', 'name': 'baidu', 'name1': 'google'}
>>> test
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>>
如果不用copy，直接用赋值的方式改变结果呢？
>>> test
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> demo = test
>>> demo
{'website': 'https://www.baidu.com', 'name': 'baidu'}
>>> demo ["name1"] = "google"
>>> demo
{'website': 'https://www.baidu.com', 'name': 'baidu', 'name1': 'google'}
>>> test
{'website': 'https://www.baidu.com', 'name': 'baidu', 'name1': 'google'}
>>> id(test)
11179680
>>> id(demo)
11179680
>>>
我们发现如果修改了demo对象的值，那么test对象的值也跟着改变了
前方高能预警，然而事情并非想象的那么简单，为甚呢？我也不解，慢慢来看吧！
>>> test = {"name":"website","web":["baidu","google","360"]}
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> demo = test.copy()
>>> demo
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> id(test)
11349728
>>> id(demo)
11351568
>>>
通过实验发现，test和demo在内存中是两个不同的对象
>>> demo['web'].remove('360')
>>> demo
{'web': ['baidu', 'google'], 'name': 'website'}
>>> test
{'web': ['baidu', 'google'], 'name': 'website'}
>>> 上面的代码中，我们尝试将字典中的web对应的列表中的360移除，按照我们之前的推测，demo和test在内存中是属于两个不同的对象，但是，我们发现，当我们移除demo中的360后，test中web对应的列表也跟着变化了。是不是开始晕圈圈了呢。
解释：在demo所对应字典的对象中，键‘web’对应的值是一个列表，为[‘baidu’, ‘google’, ‘360’]，当用remove移除列表中的一个元素360后，变为[‘baidu’, ‘google’]
毋庸置疑，前面所说的原理是有效的，但是为什么当值是列表的时候就不奏效了呢？
为了解决这个迷惑，我们还得用id( )来破解，我为什么要说破解呢，我又不是一个hacker。
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> demo = test.copy()
>>> demo
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> id(test)
11349728
>>> id(demo)
11351568
>>> demo['web'].remove('360')
>>> demo
{'web': ['baidu', 'google'], 'name': 'website'}
>>> test
{'web': ['baidu', 'google'], 'name': 'website'}
>>> id(demo)
11351568
>>> id(test)
11349728
>>>
test和demo对应着两个不同的对象，确实这样，但是这个对象（字典）是由两个键值对组成的，其中一个键的值是列表。
>>> test = {"name":"website","web":["baidu","google","360"]}
>>> demo = test.copy()
>>> id(test['web'])
140262388822528
>>> id(demo['web'])
140262388822528
>>>
注意：我们发现了这样一个事实，列表是同一个对象，但是，作为字符串为值得键值对应的是分属不同的对象。
>>> test = {"name":"website","web":["baidu","google","360"]}
>>> demo = test.copy()
>>> id(test["web"])
140262388728536
>>> id(demo["web"])
140262388728536
>>> id(test["name"])
140262388812848
>>> id(demo["name"])
140262388812848
>>> demo['web'].remove('360')
>>> demo
{'web': ['baidu', 'google'], 'name': 'website'}
>>> test
{'web': ['baidu', 'google'], 'name': 'website'}
>>> id(test['name'])
140262388812848
>>> id(demo['name'])
140262388812848
>>> demo['name']="website1" #改变name的值，下面的id就看到了
>>> demo
{'web': ['baidu', 'google'], 'name': 'website1'}
>>> test
{'web': ['baidu', 'google'], 'name': 'website'}
>>> id(test['web'])
140262388728536
>>> id(demo['web'])
140262388728536
>>> id(demo['name'])
140262388826688
>>> id(test['name'])
140262388812848
>>>
这个事实说明了为什么修改一个列表，另外一个列表也跟随的原因了；而修改一个字符串，另外一个字符串不跟随着修改的原因了。
那么问题来了，我们想要在改被复制中的字典中，修改字典中的key所对应的value的值，怎么办？
所以copy我们称为浅拷贝
所谓浅拷贝意思就是，Pyhon中的存储的对象类型为基本数据类型和，复杂数据类型，如果是基本数据类型，比如是int,str等，那么在被复制的字典中，就会重新存储，但是，如果是复杂的列表的对象类型，那么Python使用copy就对被复制对象的数据进行引用。所以如果对象太复杂了，那么还是别费劲了，引用一下就可以了。
所以Python引入了深拷贝deep copy，但是，要通过import copy导入一个模块
>>> import copy
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> demo = copy.deepcopy(test)
>>> demo
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> id(test["name"])
140262388812848
>>> id(demo["name"])
140262388812848
>>> id(test['web'])
140262388822600
>>> id(demo['web'])
140262388822888
>>>
发现，对于列表不再是简单的引用了。
>>> import copy
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> demo = copy.deepcopy(test)
>>> demo
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> id(test["name"])
140262388812848
>>> id(demo["name"])
140262388812848
>>> id(test['web'])
140262388822600
>>> id(demo['web'])
140262388822888
>>> demo['web'].remove('360')
>>> demo
{'web': ['baidu', 'google'], 'name': 'website'}
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>>
果然不再跟随着改变了，哈哈，试一试才过瘾
试一下append（），大声的告诉我，你已经忘了。
>>> demo['web'].append('sina')
>>> demo
{'web': ['baidu', 'google', 'sina'], 'name': 'website'}
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>>
使用clear
>>>help(dict.clear)
help on method_descriptor:
clear(...)
D.clear() -> None. Remove all items from D.
(END)
dict.clear（）意思是指将字典中的所有元素都清空。使字典成为一个空字典
而之前我们接触过del dict这个是指将字典从内存中删除，不存在了。
上代码，我也不喜欢婆婆妈妈，长篇大论
>>> a = {'a':1,'b':2}
>>> a
{'a': 1, 'b': 2}
>>> a.clear()
>>> a
{}
>>> b = {'a':1,'b':2}
>>> del b
>>> b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined
>>>
函数之get和setdefault
get（）和之前的dict[ ]是由区别的，
get（）中如果指定的Key不存在，则返回None，但是dict[ ]就会报错
上代码
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> print test.get('web')
['baidu', 'google', '360']
>>> print test.get('haha') #返回None
None
>>> test['web']
['baidu', 'google', '360']
>>> test['haha'] #报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'haha'
>>>
注意，但是get还有一种用法，我们使用帮助
>>>help(dict.get)
>get(...)
D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
(END)
意思就是如果键对应的值不存在则返回可选参数d,默认为None
>>> print test.get('haha','python')
python
>>>
setdefault( )函数
help(dict.setdefault)
Help on method_descriptor:
setdefault(…)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
(END)
解释：如果key存在，则返回value，如果不存在，则返回None，并将其添加到字典中，如果不存在，在后面指定可选参数，则将不存在的Key和value添加到字典中。
以下代码中可以解释这一含义。
>>> test
{'web': ['baidu', 'google', '360'], 'name': 'website'}
>>> print test.setdefault('web')
['baidu', 'google', '360']
>>> print test.setdefault('haha')
None
>>> print test
{'web': ['baidu', 'google', '360'], 'haha': None, 'name': 'website'}
>>> print test.setdefault('code','python')
python
>>> print test
{'web': ['baidu', 'google', '360'], 'code': 'python', 'haha': None, 'name': 'website'}
>>>
除了以上字典中的函数，在字典中，还有’
items/iteritems,keys/iterkeys,values/itervalues函数
这三组函数有相似的地方，所以在这里只实验第一种函数，相信另外两种函数只要同学们一看就会懂。
help(dict.items)
Help on method_descriptor:
items(…)
D.items() -> list of D’s (key, value) pairs, as 2-tuples
(END)
解释，列出字典中的键值对，列表中的元素是由Key和value组成的一个元组
代码：
>>> test
{'web': ['baidu', 'google', '360'], 'code': 'python', 'haha': None, 'name': 'website'}
>>> test.items()
[('web', ['baidu', 'google', '360']), ('code', 'python'), ('haha', None), ('name', 'website')]
>>>
itertems( )函数
help(dict.iteritems)
Help on method_descriptor:
iteritems(…)
D.iteritems() -> an iterator over the (key, value) items of D
(END)
先看代码
>>> test
{'web': ['baidu', 'google', '360'], 'code': 'python', 'haha': None, 'name': 'website'}
>>> test.iteritems()
<dictionary-itemiterator object at 0x7f9161dcff70>
>>> type(test.iteritems())
<type 'dictionary-itemiterator'>
>>> list(test.iteritems())
[('web', ['baidu', 'google', '360']), ('code', 'python'), ('haha', None), ('name', 'website')]
>>>
我们可以看到，如果直接使用dict.iteritems( )，那么我们将会得到一个dictionary-itemiterator类型，不过这种迭代器类型的数据不能直接输出，必须要使用List( )转换才能输出。
另外的两种函数也同这个类似。
pop和popitem函数
不知道你是否记得在学习列表的时候，删除列表中的元素的函数是哪一个吗？悄悄告诉我，你是不是忘了。哈哈
没错，就是pop和remove，这两个的区别在于
list.remove(x)用来删除指定的元素，而list.pop([x])用于删除指定索引的元素，如果不提供索引值，就会默认删除最后一个
help(dict.pop)
Help on method_descriptor:
pop(…)
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
(END)
解释：删除指定键的键值对，如果Key没有被发现，则返回可选给定的可选参数，否则，则会引发KeyError错误。
还是看代码吧：
>>> test
{'web': ['baidu', 'google', '360'], 'code': 'python', 'haha': None, 'name': 'website'}
>>> test.pop('code')
'python'
>>> test
{'web': ['baidu', 'google', '360'], 'haha': None, 'name': 'website'}
>>> test.pop('code')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'code'
>>> test.pop('code','python')
'python'
>>> test
{'web': ['baidu', 'google', '360'], 'haha': None, 'name': 'website'}
>>>
popitem( )函数和List.pop（）相似，可以不用写参数，但是注意，popitem（）是随机删除，而list.pop（）是删除最后一个
代码呈上：
>>> test
{'web': ['baidu', 'google', '360'], 'haha': None, 'name': 'website'}
>>> demo.popitem()
('web', ['baidu', 'google', 'sina'])
>>> demo.popitem()
('name', 'website')
>>>
注意，如果字典中没有值得话，当使用popitem的时候，就会提示字典已经为空了，没有可以要删除的东西了。
update函数
顾名思义，更新字典中的值
help(dict.update)
Help on method_descriptor:
update(…)
D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
(END)
>>> up = {"test":"this is test"}
>>> down = {"yes":"you are right"}
>>> up.update(down)
>>> up
{'test': 'this is test', 'yes': 'you are right'}
>>> down.update([("code","python"),("code1","java")])
>>> down
{'code1': 'java', 'yes': 'you are right', 'code': 'python'}
>>>
hash_key函数
help(dict.has_key)
Help on method_descriptor:
has_key(…)
D.has_key(k) -> True if D has a key k, else False
(END)
解释：这个函数的功能是判断字典中是否存在某个键
如果存在，则返回true,否则返回false
本节学习的最后一个函数了，以代码的方式结束
>>> test
{'web': ['baidu', 'google', '360'], 'haha': None, 'name': 'website'}
>>> test.has_key('web')
True
>>> test.has_key('code')
False
>>>
好了，以上就是对于字典的基本操作和字典中的函数的操作，都是常见的操作和函数。当然，字典中的函数不仅仅是这些，慢慢来，以后还多的是呢。
明天更新集合。
晚安！
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
