python字典（dictionary）使用：基本函数code实例，字典的合并、排序、copy，函数中*args 和**kwargs做形参和实参

python字典dictionary几个不常用函数例子

一、字典声明

如，d={};

d= {'x':1,'b':2}

d1 = dict(x=1,y=2,z=3)
    d2 = dict(a=3,b=4,c=5)

二 、方法说明：

参考：http://blog.csdn.net/wangran51/article/details/8440848

Operation	Result	Notes
len(a)	the number of items in a 得到字典中元素的个数
a[k]	the item of a with key k 取得键K所对应的值	(1), (10)
a[k] = v	set a[k] to v 设定键k所对应的值成为v
del a[k]	remove a[k] from a 从字典中删除键为k的元素	(1)
a.clear()	remove all items from a 清空整个字典
a.copy()	a (shallow) copy of a 得到字典副本
k in a	True if a has a key k, else False 字典中存在键k则为返回True，没有则返回False	(2)
k not in a	Equivalent to not k in a   字典中不存在键k则为返回true,反之返回False	(2)
a.has_key(k)	Equivalent to k in a, use that form in new code 等价于k in a
a.items()	a copy of a's list of (key, value) pairs 得到一个键，值的list	(3)
a.keys()	a copy of a's list of keys 得到键的list	(3)
a.update([b])	updates (and overwrites) key/value pairs from b从b字典中更新a字典，如果键相同则更新，a中不存在则追加	(9)
a.fromkeys(seq[, value])	Creates a new dictionary with keys from seq and values set to value	(7)
a.values()	a copy of a's list of values	(3)
a.get(k[, x])	a[k] if k in a, else x	(4)
a.setdefault(k[, x])	a[k] if k in a, else x (also setting it)	(5)
a.pop(k[, x])	a[k] if k in a, else x (and remove k)	(8)
a.popitem()	remove and return an arbitrary (key, value) pair	(6)
a.iteritems()	return an iterator over (key, value) pairs	(2), (3)
a.iterkeys()	return an iterator over the mapping's keys	(2), (3)
a.itervalues()	return an iterator over the mapping's values	(2), (3)

注意：items(), keys(), values()都返回一个list，即[]

如：dict.items()输出为	[('a', 'b'), (1, 2), ('hello', 'world')]  

 三、一些基本函数的使用code：

[wizad@sr104 lmj]$ vim test.py   
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for k in dict:
  print "dict[%s]="%k,dict[k]


key="c"
if "c" not in dict:
  print "it is not in %s" %key


print "-------------"
print dict.items()
print dict.keys()
print dict.values()


print "-------------"
iter = dict.iteritems()
for it in iter:
  print "iteritems is:",it
  print type(it)


print "-------------"
key_iter = dict.iterkeys()
for ki in key_iter:
  print "key_iter is",ki
  print type(ki)


print "-------------"
val_iter = dict.itervalues()
for vi in val_iter:
  print "val_iter is",vi
  print type(vi)
print "-------------"

程序输出结果如下：

dict[a]= apple
dict[b]= banana
dict[o]= orange
dict[g]= grape
it is not in c
-------------
[('a', 'apple'), ('b', 'banana'), ('o', 'orange'), ('g', 'grape')]
['a', 'b', 'o', 'g']
['apple', 'banana', 'orange', 'grape']
-------------
iteritems is: ('a', 'apple')
<type 'tuple'>
iteritems is: ('b', 'banana')
<type 'tuple'>
iteritems is: ('o', 'orange')
<type 'tuple'>
iteritems is: ('g', 'grape')
<type 'tuple'>
-------------
key_iter is a
<type 'str'>
key_iter is b
<type 'str'>
key_iter is o
<type 'str'>
key_iter is g
<type 'str'>
-------------
val_iter is apple
<type 'str'>
val_iter is banana
<type 'str'>
val_iter is orange
<type 'str'>
val_iter is grape
<type 'str'>
-------------

四、其他字典操作

#合并两个字典，无序
    1）直接通过dict()初始化实现
    d1 = dict(x=1,y=2,z=3)
    d2 = dict(a=3,b=4,c=5)
    print d1,d2
    
    d3 = dict(d1,**d2)
    #等同于 
    d3 = dict(d1,a=3,b=4,c=5)
    
    print d3
    输出为
        {'y': 2, 'x': 1, 'z': 3} {'a': 3, 'c': 5, 'b': 4}
        {'a': 3, 'c': 5, 'b': 4, 'y': 2, 'x': 1, 'z': 3}
    
    #dict()函数后面第一参数是dictionary，其他参数必须是多个展开的确定项如dict(d1,a=3,b=4,c=5)，不能是dict，如果传入一个dict可以使用**kwargs传递，如 d3 = dict(d1,**{'a': 3, 'c': 5, 'b': 4})

#*args 和**kwargs

  a）*args 和**kwargs做实参

传递整体对象匹配函数的多个形参，*args 没有key值，**kwargs有key值，*args用于list，**kwargs用于字典，如
        def fun_var_args_call(arg1, arg2, arg3):  
            print "arg1:", arg1  
            print "arg2:", arg2  
            print "arg3:", arg3  
      
        args = ["two", 3] #list  
        fun_var_args_call(1, *args)
        输出为：
            arg1: 1  
            arg2: two  
            arg3: 3  

    b）*args 和**kwargs做形参：多余参数项收集器

        而*args用函数的多余参数项为单个值的情况，将所有多余参数收集为list
        foo(*args,**kwargs):
            print 'args=',args
            print 'kwargs=',kwargs
        
        foo(1,2,3)
        输出为
            args= (1, 2, 3)
            kwargs= {}
        foo(1,2,3,a=1,b=2,c=3) 
        输出为
            args= (1, 2, 3)
            kwargs= {'a': 1, 'c': 3, 'b': 2}   



    2）字典的update函数实现：
    dict = {"a" : "apple", "b" : "banana"}
    print dict
    dict2 = {"c" : "grape", "d" : "orange"}
    dict.update(dict2)
    print dict
    3）udpate()的等价语句
    D = {"key1" : "value1", "key2" : "value2"}
    E = {"key3" : "value3", "key4" : "value4"}
    for k in E:
        D[k] = E[k]
    print D
    
    输出：
    {'key3': 'value3', 'key2': 'value2', 'key1': 'value1', 'key4': 'value4'}






#zip建立字典
    print zip(['a','b'],[1,2]) #返回list
    d = dict(zip([1,2],['a','b']))
    print d
    输出为：
        [('a', 1), ('b', 2)]
        {1: 'a', 2: 'b'}


#设置默认值
    dict = {}
    dict.setdefault("a")
    print dict
    dict["a"] = "apple"
    dict.setdefault("a","default")
    print dict


#调用sorted()排序
    dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
    print dict  


#按照key排序 
    print sorted(dict.items(), key=lambda d: d[0])


#按照value排序 
    print sorted(dict.items(), key=lambda d: d[1])


#字典的浅拷贝
    dict = {"a" : "apple", "b" : "grape"}
    dict2 = {"c" : "orange", "d" : "banana"}
    dict2 = dict.copy()
    print dict2


#字典的深拷贝
    import copy
    dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
    dict2 = copy.deepcopy(dict)
    dict3 = copy.copy(dict)
    dict2["b"]["g"] = "orange"
    print dict
    dict3["b"]["g"] = "orange"
    print dict