1、 獲取字典中的值，但是無異常

當在字典中取值的時候，可以使用如下兩種方式：

>>> d = {'name':'kel'}
>>> d
{'name': 'kel'}
>>> d['name']
'kel'
>>> d.get('name')
'kel'
>>> d.get('not')
>>> d.get('not','not exist')
'not exist'
>>> d['not']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not'
 

一種是使用直接key的方式來進行讀取，也就是dict[key]，當key不存在的時候，會發生KeyError的異常。

另外一種是使用get的方式，當使用get方法的時候，預設情況下返回的None，如果key存在，那麼就會返回這個key對應的值。

當需要在獲取這個鍵的時候，然後刪除這個項，那麼可以使用pop方法，在使用pop方法的時候，使用預設值，從而不會在鍵不存在的時候出現異常，如下所示：

>>> d
{'name': 'kel'}
>>> d.pop('kel')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'kel'
>>> d.pop('kel','key is not exist')
'key is not exist'
>>> d.pop('name')
'kel'
 

pop使用之後，會返回這個鍵所對應的值。

在使用這種預設值的機制下，基本使用的是如下的方法：

>>> d = {'name':'kel'}
>>> if 'name' in d:
...     print d['name']
... else:
...     print 'not found'
... 
kel

也就是引入了in的測試，判斷這個key是不是在dict中，如果在，那麼返回值，如果不在，那麼返回預設值。

2、給字典增加一個條目

setdefault方法主要是用來設定字典的鍵值，當一個鍵存在的時候，直接使用已經存在的值，當鍵不存在的時候，那麼就新增一個值。

>>> d
{'name': 'kel'}
>>> d.setdefault('kel','person')
'person'
>>> d
{'kel': 'person', 'name': 'kel'}
>>> d.setdefault('kel','animal')
'person'
>>> d
{'kel': 'person', 'name': 'kel'}

當開始未存在鍵kel的時候，那麼就會新增一個鍵值對；當後面存在鍵kel的時候，那麼就會取得此值。

最經典的使用setdefault方法如下：

>>> d.setdefault('abc',[]).append('123')
>>> d
{'kel': 'person', 'name': 'kel', 'abc': ['123']}

當字典中的值是列表的時候，那麼就可以使用方法d.setdefault(somekey,[]).append(somevalue)

3、建立字典

建立字典主要有三種方式：

第一種方式：使用命名引數來建立--這種情況下不適合存在不符合變數命名的鍵，和存在關鍵字的鍵，例如for等關鍵字

>>> d = dict(name='kel',age=32)
>>> d
{'age': 32, 'name': 'kel'}

第二種方式：

>>> d = {'name':'kel','age':32}
>>> d
{'age': 32, 'name': 'kel'}

第三種方式：建立一些一些字典具有預設值的時候使用

>>> d = dict.fromkeys(('age','name') ,None)
>>> d
{'age': None, 'name': None}

建立字典最好的方法是使用dict內建函式來使用，dict返回一個完全獨立於d的拷貝，就象d.copy一樣，當d不是一個字典，是一個數對(key,value)的序列時，ditc（t）依然是可以建立一個字典。

4、將列表中的元素交替的作為字典的鍵和值

使用最簡單的方式就是使用zip和切片，從而得到字典的鍵和值，如下所示：

list1 = [1,2,3,4,5]
def dictFromList(keysAndValues):
    return dict(zip(keysAndValues[::2],keysAndValues[1::2]))
print dictFromList(list1)

此方法主要是將列表進行切片，從而得到奇數的key和偶數的value，再使用zip函式，從而得到一個序列對，從而轉換為字典。

def pairwise(iterable):
    itnext =iter(iterable).next
    while True:
        yield itnext(),itnext()
def dictFromSequence(seq):
    return dict(pairwise(seq))

有可以使用生成器的方法，在每次進行跌倒的時候，得到序列的兩個元素，兩個元素作為一個序列對，然後進行轉換為字典，從而在這種方法中，可以提高效能。

注意上面的例子中，將一個迭代器繫結到了本地變數，從而在每次取值的時候，只要使用本地變數即可。

5、獲取一個字典的子集

def sub_dict(somedict,somekeys,default=None):
    return dict([(k,somedict.get(k,default)) for k in somekeys])

def sub_dict_remove(somedict,somekeys,default=None):
    return dict([(k,somedict.pop(k,default)) for k in somekeys])

在兩個方法中，使用的都是列表解析，在使用生成器的時候效率更高，只要將中括號修改的圓括號即可。

第一個方法，不會修改原來的字典；第二個方法會將原來的字典存在的鍵進行刪除。

在上面的兩個方法中，可以增加一些判斷的方法，在列表解析或者生成器裡新增 if k in somedict，從而可以在沒有鍵的時候，忽略這個鍵

6、 反轉字典

d = {'a':5,'b':6,'c':7}
print dict(izip(d.itervalues(),d.iterkeys()))

主要就是使用itertools中的izip來提高速度，從而來反轉字典

7、一個鍵對應多個值

當一個鍵需要對應多個值的時候，例如一個列表，可以使用setdefault方法：

>>> d1 = {}
>>> d1
{}
>>> d1.setdefault('key',[]).append(1)
>>> d1
{'key': [1]}
>>> d1.setdefault('key',[]).append(2)
>>> d1
{'key': [1, 2]}

當值不能重複的時候，可以使用set集合

>>> d3.setdefault('key',set()).add(1)
>>> d3
{'key': set([1])}
>>> d3.setdefault('key',set()).add(2)
>>> d3
{'key': set([1, 2])}

8、 字典的交集和並集

當只考慮字典的鍵的時候，那麼這個時候使用字典的交集和並集，可以將他們轉換為set之後，然後進行相關操作，

>>> phones = {1:1,2:2}
>>> addresses = {1:1,3:3}
>>> for name in set(phones).intersection(addresses):
...     print name,phones[name],addresses[name]
... 
1 1 1

交集的時候使用itersection當使用並集的時候使用union。

9、使用字典做到case語法

animals = []
number_of_felines = 0

def deal_with_a_cat():
    global number_of_felines
    print 'meow'
    animals.append('feline')
    number_of_felines += 1

def deal_with_a_dog():
    print 'bar'
    animals.append('canine')

def deal_with_a_bear():
    print 'wathch our for the *HUG*'
    animals.append('usrine')

tokenDICT = { #使用字典，來繫結各個方法
    'cat':deal_with_a_cat,
    'dog':deal_with_a_dog,
    'bear':deal_with_a_bear,
    }
#simulate,from files to read a word
words = ['cat','bear','cat','dog']
for word in words:
    'find the word method and call it'
    tokenDICT[word]() #根據鍵來呼叫具體的方法
nf = number_of_felines
print 'we met %d feline %s ' % (nf,'s'[nf==1:])
print 'the animals we met were:',' '.join(animals)

構建一個字典，用字串或者其他物件為鍵，以被繫結的方法，函式或者其他的可呼叫體作為值，在每一步中，都用鍵來作為可呼叫值，來進行具體方法的呼叫，從而可以形成case語句的選擇作用。