关于python中字典的一些总结

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