菜单

字典操作详解,Python中字典映射类型的学习教程

2019年8月31日 - 4166am金沙下载

Python 学习笔记(九)Python元组和字典(三),python学习笔记

字典常用方法

copy() 返回一个字典的浅复制

示例:浅拷贝d.copy() 

   深拷贝引入import copy   copy.deepcopy()

 1 >>> help(dict.copy)  #help()查看dict.copy的详细内容
 2 Help on method_descriptor:
 3 
 4 copy(...)
 5     D.copy() -> a shallow copy of D  #字典d的浅拷贝
 6 
 7 >>> d ={"name":"python","web":"www.baidu.com"}
 8 >>> e =d
 9 >>> e
10 {'web': 'www.baidu.com', 'name': 'python'}
11 >>> d
12 {'web': 'www.baidu.com', 'name': 'python'}
13 >>> id(e)
14 49259112L
15 >>> id(d)   #可以看出e和d在内存中地址相同,e和d引用的是同一个对象
16 49259112L
17 >>> f=d.copy() #字典d的浅复制   
18 >>> f
19 {'web': 'www.baidu.com', 'name': 'python'}
20 >>> id(f)  #可以看出f与上面的e和d的内存地址不同,f创建了新的字典对象
21 13708552L
22 >>> d["lang"]="python"  #向字典d中添加一个对象,d中发生了变化,字典f并没有收到影响,说明字典f是一个新的字典对象,d 和f 是两个不同的对象
23 >>> d
24 {'lang': 'python', 'web': 'www.baidu.com', 'name': 'python'}
25 >>> f    
26 {'web': 'www.baidu.com', 'name': 'python'}
27 >>> d={"name":"zhangsan","enjoy":["python","tea","book"]}  #新建一个字典
28 >>> e =d.copy()   #对字典进行copy
29 >>> id(d),id(e)  #看出他俩的内存地址不同,是两个不同的对象
30 (13708280L, 13719208L)
31 >>> d["enjoy"]   #从字典d中取出enjoy所对应的列表的值
32 ['python', 'tea', 'book']
33 >>> d["enjoy"].remove("book") #将字典d中key为enjoy,值为book的元素移除
34 >>> d     #d 中的book已经被移除
35 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
36 >>> e    #e中的book也被移除了
37 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
38 >>> id(d["enjoy"]) #查看d['enjoy']的内存地址 与e['enjoy']的内存地址相同,说明是同一对象,copy只进行了浅拷贝,并没有对enjoy列表进行拷贝,只是引用
39 49135752L
40 >>> id(e["enjoy"])
41 49135752L
42 >>> import copy  #引入copy模块进行 深拷贝
43 >>> d
44 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
45 >>> z =copy.deepcopy(d) #深拷贝
46 >>> z
47 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
48 >>> id(d),id(z)  #可看出d和z 是不同的两个对象
49 (13708280L, 13720296L) 
50 >>> id(d['enjoy']),id(z['enjoy'])  #可看出d['enjoy']和z['enjopy'] 内存地址不同,是两个不同对象
51 (49135752L, 50109128L)

clear() 删除字典内所有元素 

  clear是清除字典中的元素,不是把这个字典删除,

  删除字典需要用del

  清空字典也可用e={}

 1 >>> help(dict.clear)
 2 Help on method_descriptor:
 3 
 4 clear(...)
 5     D.clear() -> None.  Remove all items from D. #删除字典中的所有元素
 6 
 7 >>> z
 8 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
 9 >>> z.clear() #清除字典z中的元素
10 >>> z   #字典中的元素为空,字典存在,没有删除字典
11 {}
12 >>> del z  #删除字典可用del 
13 >>> e
14 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
15 >>> e ={}  #清空字典中的元素可以使用e={}
16 >>> e
17 {}
18 >>>

get()  返回指定键的值,如果值不在字典中返回default值

 1 >>> help(dict.get)
 2 Help on method_descriptor:
 3 
 4 get(...)
 5     D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. 如果k存在于d中则返回key所对应的值,否则默认返回None
 6 
 7 >>> d = {"enjoy":["python","tea"],"name":"zhangsan"}
 8 >>> d
 9 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
10 >>> d.get("name") #返回指定键name,所对应的值
11 'zhangsan'
12 >>> d.get("enjoy") #返回指定键enjoy,所对应的值
13 ['python', 'tea']
14 >>> d["name"]  #这种方式也可以获取,与d.get()的区别,就是如果字典中没有key值,将会报错keyError 如下示例
15 'zhangsan'
16 >>> d.get("teacher") #如果d.get("teacher")不存在则返回默认值none
17 >>> d.get("teacher","laoshi") #如果d.get("teacher")不存在,则返回后面的值
18 'laoshi'
19 >>> d["teacher"]
20 Traceback (most recent call last):
21   File "<stdin>", line 1, in <module>
22 KeyError: 'teacher'
23 >>>

setdefault() 和get()类似,
但如果键不存在于字典中,将会添加键并将值设为default

 1 >>> help(dict.setdefault)
 2 Help on method_descriptor:
 3 
 4 setdefault(...)
 5     D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 6 
 7 >>> d
 8 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
 9 >>> d.setdefault("name")  #取出d中key为name的值
10 'zhangsan'
11 >>> d.setdefault("city","beijing") #city 不存在与字典中,则将city添加与字典中,city为key,beijing为value
12 'beijing'
13 >>> d
14 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan'}
15 >>> d.setdefault("teacher")  #teacher 不存在于字典中,则将teacher 作为key,value为none加入字典中
16 >>> d
17 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
18 >>>

items() 以列表返回可遍历的(键, 值) 元组数组

iteritems() 与items()方法类似,返回的是一个迭代器

 1 >>> help(dict.items)
 2 Help on method_descriptor:
 3 
 4 items(...)
 5     D.items() -> list of D's (key, value) pairs, as 2-tuples #通过字典items方法得到的是含有字典key value元组为元素的列表
 6 
 7 >>> d
 8 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
 9 >>> d.items() #得到key、value元组为元素的列表
10 [('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]
11 >>> help(dict.iteritems)
12 Help on method_descriptor:
13 
14 iteritems(...)
15     D.iteritems() -> an iterator over the (key, value) items of D
16 
17 >>> d_iter=d.iteritems()
18 >>> type(d_iter)  
19 <type 'dictionary-itemiterator'>
20 >>> d_iter  
21 <dictionary-itemiterator object at 0x00000000013EDD68>
22 >>> list(d_iter) 
23 [('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]
24 >>>

keys() 以列表返回一个字典所有的键

iterkeys()

 1 >>> help(dict.keys)
 2 Help on method_descriptor:
 3 
 4 keys(...)
 5     D.keys() -> list of D's keys  #用这个方法,得到一个列表,这个列表是以字典key为元素来组成的
 6 
 7 >>> d
 8 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
 9 >>> d.keys() #得到字典中所有的key
10 ['enjoy', 'city', 'name', 'teacher']
11 >>> d.iterkeys() #迭代器
12 <dictionary-keyiterator object at 0x00000000013EDE58>
13 >>>

values() 以列表返回字典中的所有值

itervalues()

1 >>> d.values()  #得到字典value的列表
2 [['python', 'tea'], 'beijing', 'zhangsan', None]
3 >>> d.itervalues() #迭代器
4 <dictionary-valueiterator object at 0x00000000013EDE58>
5 >>>

pop()    删除字典给定键 key
所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。

 1 >>> help(dict.pop)
 2 Help on method_descriptor:
 3 #参数至少有一个key,相应着会返回一个字典中key所对应的value.
  #如果字典中没有key,就返回第二个参数d的值,但如果d的值不写,就会报错
 4 pop(...)
 5     D.pop(k[,d]) -> v, remove specified key and return the corresponding value.  
 6     If key is not found, d is returned if given, otherwise KeyError is raised
 7 
 8 >>> d
 9 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
10 >>> d.pop("enjoy")#删除enjoy键值对,返回的是enjoy对应的value值
11 ['python', 'tea']
12 >>> d
13 {'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
14 >>> d.pop("enjoy","python") #在字典d中已经没有enjoy这个键值对,返回第二个参数python
15 'python'
16 >>>

popitem()  随机返回并删除字典中的一对键和值。

 1 >>> help(dict.popitem)
 2 Help on method_descriptor:
 3 
 4 popitem(...)
 5     D.popitem() -> (k, v), remove and return some (key, value) pair as a
 6     2-tuple; but raise KeyError if D is empty.
 7 
 8 >>> d
 9 {'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
10 >>> d.popitem()   #返回删除的键值对,每次只能删除一个,且是随机删除一个键值对,如果已经没有键值对了,再去删除就会报错
11 ('city', 'beijing')
12 >>> d.popitem()
13 ('name', 'zhangsan')
14 >>> d.popitem()
15 ('teacher', None)
16 >>> d.popitem()
17 Traceback (most recent call last):
18   File "<stdin>", line 1, in <module>
19 KeyError: 'popitem(): dictionary is empty'
20 >>>

update ()   把字典dict2的键/值对更新到dict里

1.返回值是none

2.以字典或可迭代对象为参数

3.如果参数有keys方法,就会循环E中的k,实现D[k]=E[kj]

 1 >>> help(dict.update)
 2 Help on method_descriptor:
 3 
 4 update(...)
 5     D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 6     If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
 7     If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
 8     In either case, this is followed by: for k in F: D[k] = F[k]
 9 
10 >>> d1={"lang":"python"}
11 >>> d2={"name":"zhangsan"}
12 >>> d1.update(d2)
13 >>> d1
14 {'lang': 'python', 'name': 'zhangsan'}
15 >>> d2
16 {'name': 'zhangsan'}
17 >>> d2.update([("city","beijing"),("web","java"),("site","baidu.com")])
18 >>> d2
19 {'site': 'baidu.com', 'city': 'beijing', 'name': 'zhangsan', 'web': 'java'}
20 >>>

has_key() 如果键在字典dict里返回true,否则返回false

 1 >>> help(dict.has_key)
 2 Help on method_descriptor:
 3 
 4 has_key(...)
 5     D.has_key(k) -> True if D has a key k, else False
 6 
 7 >>> d2.has_key("city") #判断key是否存在
 8 True
 9 >>> "city" in d2
10 True
11 >>>

 

学习笔记(九)Python元组和字典(三),python学习笔记 字典常用方法
copy()返回一个字典的浅复制 示例:浅拷贝d.copy() 深拷贝引入im…

Python中字典映射类型的学习教程,python字典

字典是python语言中唯一的映射类型,用花括号{}表示,一个字典条目就是一个键值对,方法keys()返回字典的键列表,values()返回字典的值列表,items()返回字典的键值对列表。字典中的值没有任何限制,它们可以是任意python对象,但字典中的键是有类型限制的,每个键只能对应一个值,且键必须是可哈系的,所有不可变类型都是可哈希的。不可变集合frozenset的元素可作为字典的键,但可变集合set就不行了。

以下是字典类型的常用方法。
clear():删除字典中所有元素。
copy():返回字典(浅复制)的一个副本。
fromkeys(seq,val=None):创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对应的初始值。
get(key,default=None):返回字典中的键key对应的值value,如果字典中不存在此键,则返回default的值。
has_key(key):如果键key在字典中存在,返回True,否则返回False。python2.2后这个方法几乎已废弃不用了,通常用in来替代。
items():返回一个包含字典中键值对元组的列表。
keys():返回一个包含字典中键的列表。
iter():方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表。
pop(key[,default]):和方法get()类似,如果字典中key键存在,删除并返回dict[key],如果key键不存在,且没有给出default的值,引发KeyError异常。
setdefault(key,default=None):和方法get()相似,如果字典中不存在key键,由dict[key]=default为它赋值。
update(dict2):将字典dict2的键值对添加到当前字典中。
values():返回一个包含字典中所有值的列表。

键可以是多种类型,但键是唯一的不重复的,值可以不唯一

>>> d = {'a':1, 'b':2} 
>>> d 
{'b': 2, 'a': 1} 
>>> L = [('Jonh',18), ('Nancy',19)] 
>>> d = dict(L) #通过包含键值的列表创建 
>>> d 
{'Jonh': 18, 'Nancy': 19} 
>>> T = tuple(L) 
>>> T 
(('Jonh', 18), ('Nancy', 19)) 
>>> d = dict(T) #通过包含键值的元组创建 
>>> d 
{'Jonh': 18, 'Nancy': 19} 
>>> d = dict(x = 1, y = 3) #通过关键字参数创建 
>>> d 
{'x': 1, 'y': 3} 
>>> d[3] = 'z' 
>>> d 
{3: 'z', 'x': 1, 'y': 3} 

还有一个创建字典的方法就是 fromkeys(S [ , v]) python里的解释是 New
dict with key from S and value equal to v
,即将S里的元素作为键,v作为所有键的值,v 的默认值为
None。可以通过已存在的字典 d 调用 d.fromkeys(S [, v] )
也可以通过类型调用 dict.fromkeys( S [, v] )

>>> d 
{3: 'z', 'y': 3} 
>>> L1 = [1,2,3] 
>>> d.fromkeys(L1) 
{1: None, 2: None, 3: None} 
>>> {}.fromkeys(L1,'nothing') 
{1: 'nothing', 2: 'nothing', 3: 'nothing'} 
>>> dict.fromkeys(L1,'over') 
{1: 'over', 2: 'over', 3: 'over'} 

字典是无序的,所以不能通过索引来获取值,要通过键来找到关联值。对于不存在的键,会出现错误KeyError

>>> d 
{3: 'z', 'x': 1, 'y': 3} 
>>> d[3] 
'z' 
>>> d['x'] 
1 
>>> d[0] 
Traceback (most recent call last): 
 File "<pyshell#26>", line 1, in <module> 
 d[0] 
KeyError: 0 

字典操作和方法:
len( d )  返回字典d里面的键值对数目
x in d   查询字典d中是否有键 x

>>> d = {'x':1,'y':3} 
>>> len(d) 
2 
>>> 'x' in d 
True 
>>> 'z' not in d 
True 

d [ x ] = y  若键 x 存在,则修改 x 对应的值为 y, 若键 x
不存在,则在字典 d 中增加键值对 x : y

>>> d 
{'x': 1, 'y': 3} 
>>> d['x'] = 1.5 
>>> d 
{'x': 1.5, 'y': 3} 
>>> d['z'] = 5 
>>> d 
{'z': 5, 'x': 1.5, 'y': 3} 

del d[x]  删除字典 d 中键为 x 的键值对,若 x 不存在会出现 KeyError

>>> d = {'z': 5, 'x': 1.5, 'y': 3} 
>>> del d['x'] 
>>> d 
{'z': 5, 'y': 3} 
>>> del d['x'] 
Traceback (most recent call last): 
 File "<pyshell#66>", line 1, in <module> 
 del d['x'] 
KeyError: 'x' 

d.clear() 清空字典d
d.copy() 对字典 d 进行浅复制,返回一个和d有相同键值对的新字典

>>> d 
{'z': 5, 'y': 3} 
>>> d.copy() 
{'z': 5, 'y': 3} 

d.get( x [ , y]) 返回字典 d 中键 x 对应的值,键 x 不存在的时候返回 y,
y 的默认值为None

>>> d = {'z': 5, 'x': 1.5, 'y': 3} 
>>> d.get('x') 
1.5 
>>> del d['x'] 
>>> d.get('x') 
>>> d.get('x','nothing') 
'nothing' 

d.items() 将字典 d 中所有键值对以dict_items的形式返回(Python
2中d.iteritems() 返回一个针对键值对的迭代器对象,Python 3中没有
iteritems 方法了)

>>> d = {'z': 5, 'x': 1.5, 'y': 3} 
>>> d.items() 
dict_items([('z', 5), ('x', 1.5), ('y', 3)]) 
>>> list(d.items()) 
[('z', 5), ('x', 1.5), ('y', 3)] 

d.keys() 将字典 d 中所有的键以dict_keys形式返回(Python 2
中d.iterkeys() 返回一个针对键的迭代器对象,Python 3 没有此语法)

>>> d.keys() 
dict_keys(['z', 'x', 'y']) 
>>> for x in d.keys(): 
 print(x) 


z 
x 
y 

d.pop( x ) 返回给定键 x 对应的值,并将该键值对从字典中删除

>>> d = {'z': 5, 'x': 1.5, 'y': 3} 
>>> d.pop('x') 
1.5 
>>> d.pop('x') 
Traceback (most recent call last): 
 File "<pyshell#92>", line 1, in <module> 
 d.pop('x') 
KeyError: 'x' 

d.popitem( ) 返回并删除字典 d 中随机的键值对

>>> d = {'z': 5, 'x': 1.5, 'y': 3} 
>>> d.popitem() 
('z', 5) 
>>> d.popitem() 
('x', 1.5) 

d.setdefault( x, [ , y ] )  返回字典 d 中键 x 对应的值,若键 x
不存在,则返回 y, 并将 x : y 作为键值对添加到字典中,y 的默认值为 None

>>> d = {'z': 5, 'x': 1.5, 'y': 3} 
>>> d.setdefault('x') 
1.5 
>>> del d['x'] 
>>> d.setdefault('x','Look!') 
'Look!' 
>>> d 
{'z': 5, 'x': 'Look!', 'y': 3} 

d.update( x ) 将字典 x 所有键值对添加到字典 d
中(不重复,重复的键值对用字典 x 中的键值对替代字典 d 中)

>>> d1 = {'x':1, 'y':3} 
>>> d2 = {'x':2, 'z':1.4} 
>>> d1.update(d2) 
>>> d1 
{'z': 1.4, 'x': 2, 'y': 3} 

d.values( ) 将字典里所有的值以dict_values 的形式返回(Python 2
中d.itervalues() 返回针对字典d里所有值的迭代器对象,Python 3无此语法)

>>> d1 
{'z': 1.4, 'x': 2, 'y': 3} 
>>> d1.values() 
dict_values([1.4, 2, 3]) 
>>> list(d1.values()) 
[1.4, 2, 3] 

字典是python语言中唯一的映射类型,用花括号{}表示,一个字典条目就是一个键值对,方法key…

先来看看字典内置方法

方法名字 操作
dict.clear() 删除字典中所有元素
dict.copy() 返回字典(浅复制)的一个副本
dict.fromkeysc(seq,val=None) 创建并返回一个新字典,以seq 中的元素做该字典的键,val 做该字典中所有键对应的初始值(如果不提供此值,则默认为None)
dict.get(key,default=None) 对字典dict 中的键key,返回它对应的值value,如果字典中不存在此键,则返回default 的值(注意,参数default 的默认值为None)
dict.has_key(key) 如果键(key)在字典中存在,返回True,否则返回False. 在Python2.2版本引入in 和not in 后,此方法几乎已废弃不用了,但仍提供一个 可工作的接口。
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.values() 返回一个包含字典中所有值的列表
dict.iter() 方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表。
dict.pop(key[, default]) 和方法get()相似,如果字典中key 键存在,删除并返回dict[key],如果key 键不存在,且没有给出default 的值,引发KeyError 异常。
dict.setdefault(key,default=None) 和方法set()相似,如果字典中不存在key 键,由dict[key]=default 为它赋值。
dict.setdefault(key,default=None) 和方法set()相似,如果字典中不存在key 键,由dict[key]=default 为它赋值。

元组一般用圆括号来表示,如(1,2,3)
列表一般用方括号来表示,如[1,2,3]

而字典(dict)则用大括号来表示,如{‘a’:1,’b’:2,’c’:3}
与php不同,php的key,value是用key=>value来表示,python而是用冒号“:”来分隔。

字典可以使用大括号书写键和值或使用dict函数来创建。
dict函数可以指定两个元组或列表来对应创建字典。如:

items = [(‘name’,’gumby’),(‘age’,’42’)]
d = dict(items)

与列表的区别:

k in d(d为字典),查找的是键,而非value,表达式 v in
l(l为列表)则用来查找值,而不是索引。

一些字典方法:

clear 清除字典。“原地操作”,不会返回值,类似于列表的sort方法
copy方法返回一个相同键值对儿的新字典。浅复制。因为值本身就是相同的,而不是副本。
在副本中替换值的时候,原始字典不受影响。但是如果修改了某个值,原始字典也会改变。避免这个问题的一种方法就是使用深度复制(deep
copy)。
from copy import deepcopy
deepcopy(d)

d.fromkes方法使用给定的值创建新字典。每个键默认对应的是None
get方法获取一个不存在的键时,不会报错,会返回None
has_key方法相法于表达式k in d
items方法将所有的字母项以列表的方式返回。这些列表中的每一项都来自于(键,值)。但是项在返回时没有特殊的顺序。
iteritmes的方法大致相同,但是会返回一个迭代器对象而不是列表。在很多情况下iteritems效率更高。迭代器,相当于decode
json之后的对象,而非数组、
keys方法将字典中的键以列表的形式返回。而iterkeys则返回针对键的迭代器。
pop弹出给定键的值。popitem会弹出最后一个元素(实际上是随机项),但如果想一个接一个地移除并处理字典,popitem效率就会高很多,因为不必先获取字典的键值列表。

values和itervalues方法以列表或迭代器的形式返回字典中的值,返回值的列表可以包含重复项。

创建

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图