python-数据类型之字典

摘要：删除字典元素和字典删除键为的条目删除中所有的条目删除整个字典删除并返回键为的条目二字典相关函数工厂方法工厂函数被用来创建字典。与函数方法相似，如果字典中键存在，删除并返回，如果键不存在，且没有给出的值，引发异常。

Python字典是另一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型。
一、创建字典
（一）字典的增删改查
（1）字典的创建
key:(不可变类型)数字、字符串、元组
value:任何类型

</>复制代码 
>>> dict1={}
>>> dict2={"name": "earth", "port": 80}
>>> dic1,dict2
({}, {"name": "earth", "port": 80})

如果键值是列表，会报错

</>复制代码 
 >>>dict1[[1,2]]={"aa","bbb"}
 Traceback (most recent call last):
 File "", line 1, in 
 TypeError: unhashable type: "list"

键为元组：

</>复制代码 
>>> dict1[1,2]={"sss","ggg"}
>>> dict1
{(1, 2): set(["ggg", "sss"]), "name": "aileen", "sex": u"u5973"}

用工厂的方法创建字典：

</>复制代码 
>>> fdict = dict((["x", 1], ["y", 2]))
>>> fdict
{"y": 2, "x": 1}
>>> fdict=dict(a=3,b=4)            #这个比较常用
>>> fdict
{"a": 3, "b": 4}

内建方法 fromkeys() 来创建一个"默认"字典：
dict.fromkeys(seq[, value]))
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。

</>复制代码 
>>> ddict = {}.fromkeys(("x", "y"), -1)
>>> ddict
{"y": -1, "x": -1}
>>> edict = {}.fromkeys(("foo", "bar"))
>>> edict
{"foo": None, "bar": None}

（2）访问字典的值:字典是无序的所以不能用索引进行访问

</>复制代码 
>>> dict2 = {"name": "earth", "port": 80}
>>> for key in dict2.keys():
...     print "key=%s,value=%s"%(key,dict2[key])
key=name,value=earth
key=port,value=80
>>> for key,value in dict2.items():
...     print key,value
name earth
port 80
>>> for value in dict2.values():
...     print value
earth
80

想访问该字典中的一个数据元素，而它在这个字典中没有对应的键，将会产生一个错误：

</>复制代码 
>>> dict2["sever"]
Traceback (most recent call last):
File "", line 1, in 
KeyError: "sever"

字典的方法：has_key()和 in 以及 not in 操作符都是布尔类型的。
对于前两者而言，如果字典中有该键就返回真(True)，否则返回假(False)。

</>复制代码 
>>> "sever" in dict2    #dict2.has_key("server")
False
>>> "name" in dict2    #dict2.has_key("name")
True
>>> "earth" in dict2.values()
True

（3）字典的更新
通过以下几种方式对一个字典做修改：添加一个新数据项或新元素(即：一个键-值对)；修改一个已存在的数据项；或删除一个已存在的数据项

</>复制代码 
>>> dict2["name"] = "venus"          #更新已有的条目
>>> dict2["port"] = 6969            #更新已有的条目
>>> dict2["arch"] = "sunos5"         #增加新条目
>>> print "host %(name)s is running on port %(port)d"%dict2
host venus is running on port 6969

注：（1）如果字典中该键已经存在，则字典中该键对应的值将被新值替代。
（2）上面的 print 语句展示了另一种在字典中使用字符串格式符( %)的方法。用字典参数可以简化 print 语句，因为这样做你只须用到一次该字典的名字，而不用在每个元素出现的时候都用元组参数表示。

（4）删除字典元素和字典

</>复制代码 
>>> del dict2["name"]   #删除键为”name”的条目
>>> dict2.clear()       #删除dict2中所有的条目
>>> del dict2          #删除整个dict2字典
>>> dict2.pop("name")   #删除并返回键为”name”的条目

（二）字典相关函数
（1）dict()-工厂方法
工厂函数被用来创建字典。如果不提供参数，会生成空字典

</>复制代码 
>>> dict(zip(("x", "y"), (1, 2)))
{"y": 2, "x": 1}
>>> dict([["x", 1], ["y", 2]])
{"y": 2, "x": 1}
>>> dict([("xy"[i-1], i) for i in range(1,3)])
{"y": 2, "x": 1}

调用 dict()方法可以接受字典或关键字参数字典

</>复制代码 
>>> dict8=dict(x=1,y=2)
>>> dict8
{"y": 2, "x": 1}
>>> dict9=dict(**dict8)             #只作为了解 dict()方法的用途
>>> dict9
{"y": 2, "x": 1}
>>> dict9=dict8.copy()   #此方法效率更好
>>> dict9
{"y": 2, "x": 1}

注：copy:dict3、dict2内存不同，改变一个另外一个不变

</>复制代码 
>>> dict3=dict2.copy()
>>> dict3
{"1": 1, "3": 3, "2": 2}
>>> dict3["1"]=4
>>> dict2
{"1": 1, "3": 3, "2": 2}
>>> id(dict3)
4323369880
>>> id(dict2)
4323370160
>>> id(dict2)
4323370160

引用，修改了一个另一个也改了

</>复制代码 
>>> dict4=dict2
>>> id(dict4)
4323370160
>>> id(dict2)
4323370160

(2)len()
对字典调用 len()，它会返回所有元素(键-值对)的数目

</>复制代码 
>>> dict2 = {"name": "earth", "port": 80}
>>> len(dict2)
2

(3)hash():
判断某个对象是否可以做一个字典的键,如果非可哈希类型作为参数传递给 hash()方法，会产生TypeError 错误.返回的是返回 obj 的哈希值

</>复制代码 
>>> hash(3)
3
>>> hash([])
Traceback (most recent call last):
File "", line 1, in 
TypeError: unhashable type: "list"
>>> dict2[{}]="foo"
Traceback (most recent call last):
File "", line 1, in 
TypeError: unhashable type: "dict"

（4）update函数
可以用来将一个字典的内容添加到另外一个字典中，字典中原有的键如果与新添加的键重复，那么重复键所对应的原有条目的值将被新键所对应的值所覆盖。原来不存在的条目则被添加到字典中。

</>复制代码 
>>> dict2= {"host":"earth", "port":80}
>>> dict3= {"host":"venus", "server":"http"}
>>> dict2.update(dict3)
>>> dict2
{"host": "venus", "port": 80, "server": "http"}
>>> dict2.update({"ip":"192.168.1.1"})
>>> dict2
{"ip": "192.168.1.1", "host": "venus", "port": 80, "server": "http"}

(5)get()方法
get方法与键查找(key-lookup)操作符( [ ] )相似，不同的是它允许你为不存在的
键提供默认值。如果该键不存在，也未给出它的默认值，则返回 None。此方法比采用键查找(key-lookup)更灵活，因为你不必担心因键不存在而引发异常。
dict的get方法：

</>复制代码 
>>> dict2
{"ip": "192.168.1.1", "host": "venus", "port": 80, "server": "http"}
>>> dict2.get("host")
"venus"
>>> dict2.get("XXX")
>>> type(dict2.get("XXX"))
>>> dict2.get("XXX","no such key")
"no such key"

（6）Setdefault
检查字典中是否含有某键。 如果字典中这个键存在，你可以取到它的值。 如果所找的键在字典中不存在，你可以给这个键赋默认值并返回此值。

</>复制代码 
>>> myDict = {"host": "earth", "port": 80}
>>> myDict.keys()
["host", "port"]
>>> myDict.items()
[("host", "earth"), ("port", 80)]
>>> myDict.setdefault("port",8080)
80
>>> myDict.setdefault("pot","tcp")
"tcp"
>>> myDict.items()
[("host", "earth"), ("port", 80), ("pot", "tcp")]

(7)Fromkeys(seq,value=None)
创建并返回一个新字典，以 seq 中的元素做该字典的键，val 做该字典中所有键对应的初始值(如果不提供此值，则默认为 None)

</>复制代码 
>>> {}.fromkeys("xyz")
{"y": None, "x": None, "z": None}
>>> {}.fromkeys(("love", "honor"), True)
{"love": True, "honor": True}

(8)Sorted()

</>复制代码 
dic = {"a":31, "bc":5, "c":3, "asd":4, "33":56, "d":0}
print sorted(dic.iteritems(), key=lambda d:d[0], reverse = False )

按照value　排序：

</>复制代码 
dic = {"a":31, "bc":5, "c":3, "asd":4, "33":56, "d":0}
print sorted(dic.iteritems(), key=lambda d:d[1], reverse = False )

可以用以下方法做

</>复制代码 
>>> d={3:13,2:12,1:21}
>>> sorted_key=sorted(d.keys())
>>> for i in sorted_key:
...     print "%s =%s " %(i,d[i]) 

(9)dict.iter()
方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代器，而不是一个列表。

（10）dict.pop(key[, default]) 与popitem函数
方法 get()相似，如果字典中 key 键存在，删除并返回 dict[key]，
如果 key 键不存在，且没有给出 default 的值，引发 KeyError 异常。

</>复制代码 
>>> myDict
{"host": "earth", "port": 80, "pot": "tcp"}
>>> myDict.pop("host")               #pop
"earth"
>>> myDict.pop("hostt","none")
"none"
>>> myDict.pop("hostt")
Traceback (most recent call last):
File "", line 1, in 
KeyError: "hostt"
>>> myDict.popitem()             #popitem
("host", "earth")
>>> myDict.popitem()
("port", 80)
>>> myDict.popitem()
("pot", "tcp")
>>> myDict.popitem()
Traceback (most recent call last):
File "", line 1, in 
KeyError: "popitem(): dictionary is empty"