您的位置：首页 > 编程语言 > Python开发

Python学习之字典的基本操作及字典中的函数

2017-05-04 23:48 746 查看
在上一篇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
>>>


好了，以上就是对于字典的基本操作和字典中的函数的操作，都是常见的操作和函数。当然，字典中的函数不仅仅是这些，慢慢来，以后还多的是呢。

明天更新集合。

晚安！
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签：  python 函数 编程语言 脚本语言
相关文章推荐
新的分享
章节导航