Python dict

 

字典是另一种可变容器模型，且可存储任意类型对象.

字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中,键必须是唯一的，但值则不必.

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1) 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

2) 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

d = {key1 : value1, key2 : value2 }


基本操作

　d = dict(name='visaya', age=20)

　d = dict(zip(['name', 'age'], ['visaya', 20]))

d1={1:"a",2:None,3:"b","x":[1,2,3]}

{1: 'a', 2: None, 3: 'b', 'x': [1, 2, 3]}

#当有相同的key，则取最后一个值
d2={"a":1,"a":2,"a":3}

#键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

d3={1:"a","x":1,(1,2,"c"):23}

{1: 'a', 'x': 1, (1, 2, 'c'): 23}

d4={[1,2]:1}

TypeError: unhashable type: 'list' 



{'a': 3}

#select value

d1[1]

'a'
　#嵌套

　dd={1:{"name":"Tom"},2:"python","email":"***@gmail.com"}

　dd[1]["name"]

　'Tom'

#modify value

d1[1]="a"
d2["a"]=123

#delete value

#delete all objects but keep dict itself
d2.clear()

#delete specific item
del d1[2]

#drop dict object

d3=d2

del d3


#排序
dict1 = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
sorted(dict1.keys())
sorted(dict1.values())
#按照key排序
sorted(dict1.items(),key=lambda d:d[0])
#按照values排序
sorted(dict1.items(),key=lambda d:d[1])

 

函数

cmp(dict1, dict2)

如果两个字典的元素相同返回0，如果字典dict1大于字典dict2返回1，如果字典dict1小于字典dict2返回-1

d1={1:"a",2:"b"}
d2={2:"a",3:"b"}
d3={1:"a",2:"c"}
d4={1:"a",2:"b",3:"c"}
d5={1:"a",2:"b"}

cmp(d1,d2)
-1
cmp(d3,d1)
1
cmp(d1,d4)
-1
cmp(d1,d5)
0

 

len(dict) return 字典的元素个数

len(d1)

2

 

str(dict) return 字符串(适于人阅读的形式，以可打印的字符串表示)

print "output is:\n%s" % str(d1)

output is: 
{1: 'a', 2: 'b'}

 

type(dict) return 输入的变量类型

print "d1's data type is: %s" % type(d1)

d1's data type is: <type 'dict'>

 

方法

dict.clear() 用于删除字典内所有元素

d5.clear()
d5

{}

 

dict.copy() return一个字典的浅复制

d1

{1: 'a', 2: 'b'}

d5=d1.copy()
d5

{1: 'a', 2: 'b'}

 

dict.fromkeys(seq[, value])) return字典,用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

seq1=[1,2,3]
seq2=(4,5,6)
dict1={}
dict1=dict1.fromkeys(seq1)
dict1

{1: None, 2: None, 3: None}

value1=["a","b","c"]
dict1.fromkeys(seq1,value1)

{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}

dict1.fromkeys(seq2,"a")

{4: 'a', 5: 'a', 6: 'a'}

dict1.fromkeys(['a', 'b'], 1)

{'a': 1, 'b': 1}

 

dict.get(key, default=None) return 指定键的值value，如果值不在字典中返回默认值None

d1

{1: 'a', 2: 'b'}

d1.get(1)

'a'

#如果指定键的值不存在时，返回该默认值值
d1.get(3,"c")

'c'

#等价于

k=3

if k in d1.keys():

　　print d1[k]

else:

　　d1[k]="c"
　　
　　print d1[k]

 

dict.has_key(key) return 如果键key在字典里返回true，否则返回false 用于判断键key是否存在于字典中，如果键在字典dict里返回true，否则返回false

d1.has_key(1)

True

d1.has_key(3)

False

 

dict.items() return用于以列表返回可遍历的(键, 值) 元组数组

d1.items()

[(1, 'a'), (2, 'b')]

 

dict.keys() return 一个字典所有的键key

d1.keys()

[1, 2]

 

dict.setdefault(key, default=None) return NUll 和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值

d1.setdefault(1,"c")
'a'
d1.setdefault(3,"c")
'c'

 

dict.update(dict2) return NULL 用于把字典dict2的键/值对更新到dict里

　d1={1:"a",2:"b"}

　d2={2:"c",4:"d"}

　d1.update(d2)

{1: 'a', 2: 'c', 4: 'd'}

#等价于

　for k in d2.keys():

　　　d1[k]=d2[k]

　print d1

 

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

d1.values()

['a', 'a', 'h']

 

dict.pop() return 从列表中移除的元素对象 

dd={1:{"name","Tom"},2:"python","email":"***@gmail.com"}   
    
dd.pop("email")

'***@gmail.com'
dd

{1: {'name': 'Tom'}, 2: 'python'}

dd.pop(2)

'python'

dd

{1: {'name': 'Tom'}}

 

dd={1:{"name","Tom"},2:"python","email":"***@gmail.com"}       


for key in dd:
    print key,dd[key]

#与上面等价  
for key in dd.keys():
    print key,dd[key]
    
for values in dd.values():
    print values
    
for k,v in dd.items():
    print str(k)+":"+str(v)

 

dict1={"a":1,"b":2,"c":3}
for k,v in dict1.items():
    print k,v

a 1
c 3
b 2


#用iter的形势比较节省内存
for k,v in dict1.iteritems():
    print k,v

a 1
c 3
b 2


for k in dict1.iterkeys():
    print k

a
c
b

    
for v in dict1.itervalues():
    print v

1
3
2

　for (k,v) in zip(dict1.iterkeys(),dict1.itervalues()):

　print k,v