think in python 11 字典

字典
字典类似于列表，但更加通用

键值对 ，字典是 键与值之间的映射，每个键都映射到一个值上

dict可以创建一个不包含任何项的字典

eng2sp = dict()
print eng2sp

还可以给字典添加新项

eng2sp['one']='SS'
print eng2sp

或者直接赋值

eng2sp = {
    'one':'1',
    'two':"2",
    'three':"3"
}
print  eng2sp

print eng2sp['one']

len可以用在字典上

print len(eng2sp)

如果一个键不在字典里面，输出就会报错，可以用in判断

print 'one' in eng2sp

使用字典作为计数器
比如计算每个字幕出现次数

def histogram(s):
    d = dict()
    for i in s:
        if i in d:
            d[i] +=1
        else:
            d[i] = 1
    return d
w =  histogram("brontosaurus")

循环和字典
如果在for循环中使用字典，会遍历字典的键

def print_hist(h):
    for c in h:
        print c,h[c]
print_hist(w2)

反向查找
给定一个字典d和键k，找到v是很容易的。 但是给定值v 通过v来查找k 就没那么简单了，因为很可能多个k的值是同一个。
初级版本：

def reverse_lookup(d,v):
    for k in d:
        if d[k]==v:
            return k
    raise ValueError

字典和列表
列表可以在字典中以值得形式出现
例如

def invert_dict(d):
    inverse = dict()
    for key in d:
        val = d[key]
        if val not in inverse:
            inverse[val] = [key]
        else:
            inverse[val].append(key)
    return inverse   ```
利用字典来实现缓存
我们之前的`fibonacci`函数 会重复计算一些已经计算过的值，那么我们建一个 字典 缓存起来，如果计算过 就返回这个值。

known = {0:0,1:1}
def fibonacci(n):
if n in known:
return known[n]
res = fibonacci(n-1)+fibonacci(n-2)
known[n]=res
return res

ackermann 也可以简历一个缓存

cache = {}
def ackermann(m, n):
if m == 0:
return n+1
if n == 0:
return ackermann(m-1, 1)
try:
return cache[m, n]
except KeyError:
cache[m, n] = ackermann(m-1, ackermann(m, n-1))
return cache[m, n]

练习
1. 读入'words.txt'并将单词以字典的形式存储
   ```
        def get_words():
            r = []
            lin = open('words.txt')
            for line in lin:
                word = line.strip()
                r.append(word)
            return r
        words = get_words()
         
        def word2dict(w):
            word = dict()
            for i in range(len(w)-1):
                word[w[i]]=True
            return word
         
        dict_word=word2dict(words)

1. 利用字典get方法，将histogram写得更紧凑

       def histogram_get(s):
           d = dict()
           for i in s:
               t = d.get(i,0)
               d[i] = t+1
           return d
   
   w2 = histogram_get("brontosaurus")

2. 字典方法有一个keys,以列表的方式返回字典所有的键，修改print_hist按照字典顺序打印字典的键和他们的值

       def print_keys(h):
           r = h.keys()
           for i in r:
               print i,h[i]
   
   print_keys(w2)

3. 修改reverse_lookup使它建立一个包含所有映射到v键的列表

       def reverse_lookup2(d,v):
           r = []
           for k in d:
               if d[k]==v:
                   r.append(k)
   
       return r

4. 利用setdefault来写个更简洁的invert_dict

       def invert_dict2(d):
           inverse = dict()
           for key in d:
               inverse.setdefault(d[key],[]).append(key)
           return inverse

术语表

• 字典(dictionary):从键的集合到对应的值的集合的映射
  
• 键值对(key-value pair):键到值得映射的战士
  
• 项(item):键值对的另一个名称
  
• 键(key):字典中出现在键值对的前一部分的对象
  
• 值(value):字典中出现在键值对后一部分的对象
  
• 实现(implementation):进行计算的一个具体方式
  
• 散列表(hashtable):python字典的是先用的算法
  
• 散列函数(hash function):散列表中用来计算一个键的位置的函数
  
• 可散列(hashable):拥有散列函数的类型
  
• 查找(lookup):字典的一个操作，接受一个键，并找到它对应的值。
  
• 反向查找(reverse lookup):字典的一个操作，通过一个值来找到它对应的一个或多个键
  
• 单件(singleton):只包含一个元素的列表
  
• 直方图(histogram):一个计数器的集合
  
• 备忘(memo):将计算结果存储起来，以避免将来进行不必要的计算
  
• 标志(flag):用于标记一个条件是否为真的布尔变量