python 字典学习2

copy


>>> a = 5
>>> b = a
>>> b 
5
对象有类型，变量无类型，变量其实是一个标签。


>>> id(a)
139774080
>>> id(b)
138774080
果然，并没有两个5，就一个，只不过是贴了两张标签而已。


>>> ad = {"name":"qiwsir", "lang":"python"}
>>> bd = ad
>>> bd
{'lang':'python','name':'qiwsir'}
>>> id(ad)
3072239652L
>>> id(bd)
3072239652L
是的，验证了。的确是一个对象贴了两个标签。这是用赋值的方式，实现的所谓“


假装拷贝”。


>>> cd = ad.copy()
>>> cd
{'lang':'python','name':'qiwsir'}
>>> id(cd)
3072239788L
果然不同 ，这次得到的cd是跟原来的ad不同的，它在内存中另辟了一个空间。


>>> cd["name"] = "itdiffer.com"
>>> cd
{'lang': 'python', 'name': 'itdiffer.com'}
>>> ad
{'lang': 'python', 'name': 'qiwsir'}
变量是对象的标签，对象有类型二变量无类型。


>>> bd
{'lang': 'python'.'name': 'qiwsir'}
>>> bd["name"] = "laoqi"
>>> ad
{'lang': 'python'.'name': 'laoqi'}
>>> bd
{'lang': 'python'.'name': 'laoqi'}
修改了bd所对应的“对象”，结果发现ad的“对象”也变了。


>>> x = {"name":"qiwsir", "lang":["python", "java", "c"]}
>>> y = x.copy()
>>> y
{'lang':['python', 'java', 'c'], 'name': 'qiwsir'}
>>> id(x)
3072241012L
>>> id(x)
30722421284L
y是从x拷贝过来的，两个在内存中是不同的对象。


>>> y["lang"].remove("c")
>>> y
{'lang':['python','java'],'name': 'qiwsir'}
>>> x
{'lang':['python','java'],'name': 'qiwsir'}
这是什么原因呢？


>>> y["name"] = "laoqi"
>>> y
{'lang':['python','java'],'name': 'laoqi'}
>>> x
{'lang':['python','java'],'name': 'qiwsir'}
前面所说的原理是有效的，为什么到值是类别的时候就不能奏效了呢？


要破解这个迷局还得用di()
>>> id(x)
3072241012L
>>>  id(y)
3072241284L
y,y对应着两个不同对象，的确如此。单这个对象（字典）是由两个键值对组成的。


其中一个键的值是列表。


>>> id(x["lang"])
3072243276L
>>> id(y["lang"])
3072243276L
发现了这样一个事实，列表是同一对象。




但是，作为字符串为值得那个键值对，是分属不同对象。
>>> id(x["name"])
3072245184L
>>> id(y["name"])
3072245408L
这个事实，就说明了为什么修改一个列表，另外一个也跟着修改；而修改一个的字


符串，另外一个不跟随的原因了。


深层的原因，这跟python存储的数据类型特点有关，python只存储节本类型的数据


，比如in，str,对于不是基础类型的，比如刚才字典的值是列表，python不会再被


复制的那个对象中重新存储，而是用引用的方式，指向原来的值。


在python中，有一个“深拷贝（deep copy）”。不过，要用import来导入一个模块


。
>>> import copy
>>> z = copy.deepcopy(x)
>>> z
{'lang':['python','java'],'name':'qiwsir'}
用copy.deepcopy()深拷贝了一个新的副本。


>>> id(x["lang"])
3072243276L
>>> id(z["lang"])
3072245068L
果然是另外一个“窝”，不是引用了。如果按照这个结果，修改其中一个列表中的


元素，应该不影响另外一个了。


>>> x
{'lang':['python', 'java'], 'name': 'qiwsir'}
>>> x["lang"].remove("java")
>>> x
{'lang':['python'], 'name': 'qiwsir'}
>>> z
{'lang':['python', 'java'], 'name': 'qiwsir'}


>>> x["lang"].append("c++")
>>> x
{'lang':['python', 'c++'], 'name': 'qiwsir'}
这就是所谓浅拷贝和深拷贝。




clear
在交互模式中，用help是一个很多的习惯。


>>> help(dict.clear)


clear(...)
    D.clear() -> Nonee. Remove all items from D.
这是一个清空字典中所有元素的操作。


>>> a = {"name":"qiwsir"}
>>> a.clear()
>>> a
{}
这就是clear的含义，将字典清空，得到的是“空”字典。这个上节说的del有着很


大的区别。del是将字典删除，内存中就没有它了，不是为“空”。


>>> del a
>>> a
NameError: name 'a' is not defined
果然删除了。






get,setdefault


>>> d
{'lang': 'python'}
>>> d.get("lang")
'python'


dict.get()就是要得到字典中某个键的值，不过，它不是那么“严厉”罢了。因为


类似获得字典中键的值得方法，上节已经有过，如d['lang']就能得到对应的


值"python",可是，如果要获取的键不存在：


>>> print d.get("name")
None


>>> d["name"]
keyError: 'name'
这就是dict.get()和dict['key']的区别。


>>> d = {"lang":"python"}
>>> newd = d.get("name", 'qiwsir')
>>> newd
'qiwsir'
>>> d
{'lang': 'python'}
以d.get("name", 'qiwsir')的方式，如果不能得到键"name"的值，就返回后面指定


的值"qiwsir"。这就是文档中那句话，D[k] if k in D, else d.的含义。




另外一个跟get在功能上有相识地方的D.setdefault(k),其含义是：
>>> d
{'lang':'python'}
>>> d.setdefault("lang")
'python'
在字典中，有"lang"这个键，那么就返回它的值。


>>> d.setdefault("name", "qiwsir")
'qiwsir'
>>> d
{'lang': 'python', 'name': 'qiwsir'}
没有"name"这个键，于是返回d.setdefault("name","qiwsir")指定的值"qiwsir",
并且将键值对'name':'qiwsir'添加到原来的字典中。


如果这样操作：
>>> d.setdefault("web")
返回了，只不过没有显示出来。返回None
>>> d
{'lang': 'python','web': None, 'name': 'qiwsir'}




items/iteritems,keys/iterkeys,values/itervalues


D.items()能够得到一个关于字典的列表，列表中的元素是由字典中的键和值组成的


元组。
>>> dd = {"name":"qiwsir", "lang":"python", "web":"www.itdiffer.com"}
>>> dd_kv = dd.items()
>>> dd_kv
[('lang','python'),('web', 'www.itdiffer.com'),('name', 'qiwsir')]


跟items类似的就是iteritems,看这个词的特点，是由iter和items拼接而成的，后


部分items就不用说了，肯定是在告诉我们，得到的结果跟D.items()的结果类似。


是的，iterable，它的含义是“可迭代的”，这里的iter是指的名词iterator的前


部分，意思是“迭代器”。合起来，"iteritems"的含义就是：


>>> dd
{'lang': 'python', 'web':'www.itdiffer.com', 'name': 'qiwsir'}
>>> dd_iter = dd.iteritems()
>>> type(dd_iter)
<type 'dictionary-itemiterator'>
>>> dd_iter
<dictionary-itemiterator object at 0xb72b9a2c>
>>> list(dd_iter)
[('lang','python'),('web', 'www.itdiffer.com'),('name', 'qiwsir')]
得到的dd_iter的类型，是一个'dictionary-itemiterator'类型，不过这种迭代器


类型的数据不能直接输出，必须用list()转换一下，才能看到里面的真面目。


>>> dd
{'lang': 'python', 'web': 'www.itdiffer.com', 'name': 'qiwsir'}
>>> dd.keys()
['lang', 'web', 'name']
>>> dd.values()
['python', 'www.itdiffer.com','qiwsir']






pop,popitem


在列表(3)中，有关于删除列表中元素的函数pop和remove，这两个的区别在于


list.remove(x)用来删除指定的元素，而list.pop([i])用于删除指定索引的元素，


如果不提供索引值，就默认删除最后一个。


>>> dd
{'lang': 'python','web': 'www.itdiffer.com', 'name': 'qiwsir'}
>>> dd.pop("name")
'qiwsir'
"'name':'qiwsir'"这个键值对就被删除了。


>>> dd
{'lang': 'python','web': 'www.itdiffer.com'}


值得注意的是，pop函数中的参数是不能省略的，这跟列表中的那个pop有所不同。
>>> dd.pop()
TypeError:pop expected an least 1 arguments,got 0


如果要删除字典中没有的键值对，也会报错。
>>> dd.pop("name")
keyError:'name'


D.pop(k[,d])是以字典的键为参数，删除指定键的键值对。
pop的参数，可以是两个，上面的例子中只写了一个。如果写两个，那么就先检查K


是不是存在于字典中的键，如果是，就返回它所对应的值，如果不是，就返回参数


中的第二个，当然，如果不写第二个参数，就会如同上面举例一样报错。




有意思的是D.popitem()倒是跟list.pop()有相似之处，不用写参数（list,pop是可


以不写参数），但是，D.popitem()不是删除最后一个，前面已经交代过了，dict没


有顺序，也就没有最后和最先了，它是随机删除一个，并将所删除的返回。


popitem(...)
   D.popitem() -> (k,v),remove and return some (key, value) pair as a 2-


tuple; but raise keyError if D is empty.
如果字典是空的，就要报错了


>>> dd
{'lang': 'python', 'web': 'www.itdiffer.com'}
>>> dd.popitem()
('lang', 'python')
>>> dd
{'web': 'www.itdiffer.com'}
成功地删除了一对，注意是随机的，不是删除前面显示的最后一个。并且返回了删


除的内容，返回的数据格式是tuple。


>>> dd.popitem()
('web', 'www.itdiffer.com')
>>> dd
{}
都删了，现在那个字典成空的了。


>>> dd.popitem()
keyErro:'popitem(): dictionary is empty'






update
更新字典内容


>>> d1 = {"lang":"python"}
>>> d2 = {"song":"I dreamed a dream"}
>>> d1.update(d2)
>>> d1
{"lang":"python", "song":"I dreamed a dream"}
>>> d2
{"song":"I dreamed a dream"}
这样就把字典d2更新入了d1那个字典，于是d1中就多了一些内容，把d2的内容包含


进来了。d2当然还存在，并没有受到影响。


>>> d2
{"song":"I dreamed a dream"}
>>> d2.update([("name","qiwsir"),("web","itdiffer.com")])
>>> d2
{'web': 'itdiffer.com', 'name': 'qiwsir','song': 'I dreamed a dream'}
列表的元组是键值对。




has_key
这个函数的功能是判断字典中是否存在某个键


跟前一节中遇到的 k in D类似


>>> d2
{'web': 'itdiffeer.com', 'name': 'qiwsir', 'song': 'I dreamde a dream'}
>>> d2.has_key("web")
True
>>> "web" in d2
True