字典常用方法
copy() 返回一个字典的浅复制
示例：浅拷贝d.copy()
深拷贝引入import copy copy.deepcopy()
>>> help(dict.copy) #help()查看dict.copy的详细内容
Help on method_descriptor: copy(...)
D.copy() -> a shallow copy of D #字典d的浅拷贝 >>> d ={"name":"python","web":"www.baidu.com"}
>>> e =d
>>> e
{'web': 'www.baidu.com', 'name': 'python'}
>>> d
{'web': 'www.baidu.com', 'name': 'python'}
>>> id(e)
49259112L
>>> id(d) #可以看出e和d在内存中地址相同，e和d引用的是同一个对象
49259112L
>>> f=d.copy() #字典d的浅复制
>>> f
{'web': 'www.baidu.com', 'name': 'python'}
>>> id(f) #可以看出f与上面的e和d的内存地址不同，f创建了新的字典对象
13708552L
>>> d["lang"]="python" #向字典d中添加一个对象，d中发生了变化，字典f并没有收到影响，说明字典f是一个新的字典对象，d 和f 是两个不同的对象
>>> d
{'lang': 'python', 'web': 'www.baidu.com', 'name': 'python'}
>>> f
{'web': 'www.baidu.com', 'name': 'python'}
>>> d={"name":"zhangsan","enjoy":["python","tea","book"]} #新建一个字典
>>> e =d.copy() #对字典进行copy
>>> id(d),id(e) #看出他俩的内存地址不同，是两个不同的对象
(13708280L, 13719208L)
>>> d["enjoy"] #从字典d中取出enjoy所对应的列表的值
['python', 'tea', 'book']
>>> d["enjoy"].remove("book") #将字典d中key为enjoy，值为book的元素移除
>>> d #d 中的book已经被移除
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> e #e中的book也被移除了
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> id(d["enjoy"]) #查看d['enjoy']的内存地址 与e['enjoy']的内存地址相同，说明是同一对象，copy只进行了浅拷贝，并没有对enjoy列表进行拷贝，只是引用
49135752L
>>> id(e["enjoy"])
49135752L
>>> import copy #引入copy模块进行 深拷贝
>>> d
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> z =copy.deepcopy(d) #深拷贝
>>> z
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> id(d),id(z) #可看出d和z 是不同的两个对象
(13708280L, 13720296L)
>>> id(d['enjoy']),id(z['enjoy']) #可看出d['enjoy']和z['enjopy'] 内存地址不同，是两个不同对象
(49135752L, 50109128L)
clear() 删除字典内所有元素
clear是清除字典中的元素，不是把这个字典删除，
删除字典需要用del
清空字典也可用e={}
>>> help(dict.clear)
Help on method_descriptor: clear(...)
D.clear() -> None. Remove all items from D. #删除字典中的所有元素 >>> z
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> z.clear() #清除字典z中的元素
>>> z #字典中的元素为空，字典存在，没有删除字典
{}
>>> del z #删除字典可用del
>>> e
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> e ={} #清空字典中的元素可以使用e={}
>>> e
{}
>>>
get() 返回指定键的值，如果值不在字典中返回default值
>>> help(dict.get)
Help on method_descriptor: get(...)
D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. 如果k存在于d中则返回key所对应的值,否则默认返回None >>> d = {"enjoy":["python","tea"],"name":"zhangsan"}
>>> d
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> d.get("name") #返回指定键name，所对应的值
'zhangsan'
>>> d.get("enjoy") #返回指定键enjoy,所对应的值
['python', 'tea']
>>> d["name"] #这种方式也可以获取，与d.get()的区别，就是如果字典中没有key值，将会报错keyError 如下示例
'zhangsan'
>>> d.get("teacher") #如果d.get("teacher")不存在则返回默认值none
>>> d.get("teacher","laoshi") #如果d.get("teacher")不存在，则返回后面的值
'laoshi'
>>> d["teacher"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'teacher'
>>>
setdefault() 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
>>> 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 >>> d
{'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
>>> d.setdefault("name") #取出d中key为name的值
'zhangsan'
>>> d.setdefault("city","beijing") #city 不存在与字典中，则将city添加与字典中，city为key,beijing为value
'beijing'
>>> d
{'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan'}
>>> d.setdefault("teacher") #teacher 不存在于字典中，则将teacher 作为key，value为none加入字典中
>>> d
{'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
>>>
items() 以列表返回可遍历的(键, 值) 元组数组
iteritems() 与items()方法类似，返回的是一个迭代器
>>> help(dict.items)
Help on method_descriptor: items(...)
D.items() -> list of D's (key, value) pairs, as 2-tuples #通过字典items方法得到的是含有字典key value元组为元素的列表 >>> d
{'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
>>> d.items() #得到key、value元组为元素的列表
[('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]
>>> help(dict.iteritems)
Help on method_descriptor: iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D >>> d_iter=d.iteritems()
>>> type(d_iter)
<type 'dictionary-itemiterator'>
>>> d_iter
<dictionary-itemiterator object at 0x00000000013EDD68>
>>> list(d_iter)
[('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]
>>>
keys() 以列表返回一个字典所有的键
iterkeys()
>>> help(dict.keys)
Help on method_descriptor: keys(...)
D.keys() -> list of D's keys #用这个方法，得到一个列表，这个列表是以字典key为元素来组成的 >>> d
{'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
>>> d.keys() #得到字典中所有的key
['enjoy', 'city', 'name', 'teacher']
>>> d.iterkeys() #迭代器
<dictionary-keyiterator object at 0x00000000013EDE58>
>>>
values() 以列表返回字典中的所有值
itervalues()
>>> d.values() #得到字典value的列表
[['python', 'tea'], 'beijing', 'zhangsan', None]
>>> d.itervalues() #迭代器
<dictionary-valueiterator object at 0x00000000013EDE58>
>>>
pop() 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
>>> help(dict.pop)
Help on method_descriptor:
#参数至少有一个key,相应着会返回一个字典中key所对应的value.
#如果字典中没有key,就返回第二个参数d的值，但如果d的值不写，就会报错
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 >>> d
{'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
>>> d.pop("enjoy")#删除enjoy键值对，返回的是enjoy对应的value值
['python', 'tea']
>>> d
{'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
>>> d.pop("enjoy","python") #在字典d中已经没有enjoy这个键值对，返回第二个参数python
'python'
>>>
popitem() 随机返回并删除字典中的一对键和值。
>>> help(dict.popitem)
Help on method_descriptor: popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty. >>> d
{'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
>>> d.popitem() #返回删除的键值对，每次只能删除一个，且是随机删除一个键值对，如果已经没有键值对了，再去删除就会报错
('city', 'beijing')
>>> d.popitem()
('name', 'zhangsan')
>>> d.popitem()
('teacher', None)
>>> d.popitem()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
>>>
update () 把字典dict2的键/值对更新到dict里
1.返回值是none
2.以字典或可迭代对象为参数
3.如果参数有keys方法，就会循环E中的k,实现D[k]=E[kj]
>>> help(dict.update)
Help on method_descriptor: update(...)
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and 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] >>> d1={"lang":"python"}
>>> d2={"name":"zhangsan"}
>>> d1.update(d2)
>>> d1
{'lang': 'python', 'name': 'zhangsan'}
>>> d2
{'name': 'zhangsan'}
>>> d2.update([("city","beijing"),("web","java"),("site","baidu.com")])
>>> d2
{'site': 'baidu.com', 'city': 'beijing', 'name': 'zhangsan', 'web': 'java'}
>>>
has_key() 如果键在字典dict里返回true，否则返回false
>>> help(dict.has_key)
Help on method_descriptor: has_key(...)
D.has_key(k) -> True if D has a key k, else False >>> d2.has_key("city") #判断key是否存在
True
>>> "city" in d2
True
>>>