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语句的选择作用。