字典

• 字典可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。下面的代码演示了如何定义和使用字典。

            
              def main():
    scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
    # 通过键可以获取字典中对应的值
    print(scores['骆昊'])
    print(scores['狄仁杰'])
    # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
    for elem in scores:
        print('%s\t--->\t%d' % (elem, scores[elem]))
    # 更新字典中的元素
    scores['白元芳'] = 65
    scores['诸葛王朗'] = 71
    scores.update(冷面=67, 方启鹤=85)
    print(scores)
    if '武则天' in scores:
        print(scores['武则天'])
    print(scores.get('武则天'))
    # get方法也是通过键获取对应的值但是可以设置默认值
    print(scores.get('武则天', 60))
    # 删除字典中的元素
    print(scores.popitem())
    print(scores.popitem())
    print(scores.pop('骆昊', 100))
    # 清空字典
    scores.clear()
    print(scores)


if __name__ == '__main__':
    main()

            
          

• 字典在不同语言中都有所提及，只是叫法不同，在c语言中即map，java中即HashTable or HashMap。

• 创建字典
  使用"{}“创建字典，使用”:“指明“键:值”对，各对之间用”,"分隔开。
  键必须是不可变的且不重复，值可以是任意类型。

• 访问字典
  使用"[]"运算符，键作为索引，即相当于列表中的下标，在字典中，键值对是无序的，与插入先后并无关系。

• 字典支持的运算符和方法
  len(my_dict)可以得到字典中键-值对的数量；
  key in my_dict可以快速判断key是否为字典中的键，时间复杂度为O(1)，in即等价于my_dict.has_key(key)；
  for key in my_dict可以枚举字典中的键，其中键是无序的；
  此外，还有.items()返回全部键-值对，.keys()返回全部键，.values()返回全部值，.clear()清空字典等方法。

• 练习：读取一个字符串，计算每个字母出现的次数。

方法一：可以生成具有26个元素的列表，将每个字母转化为相应的索引值，每出现一次，将索引值对应的元素加1，代码如下。

            
              s = 'asdqwfvsdbeg'
lst = [0] * 26
for i in s:
    lst[ord(i) - 97] += 1
print(lst)

            
          

方法二：生成一个字典，字母作为键，对应出现的次数作为值，代码如下。

            
              s = 'sasfqgdsherhet'
d = {}
for i in s:
    if i in d:
        d[i] += 1
    else:
        d[i] = 1
print(d)

            
          

• 练习：读取小说“emma.txt”，打印前10个最常见单词，仍使用字典解决，代码如下。

            
              f = open('emma.txt')
word_freq = {}
for line in f:
    words = line.strip().split()  # 将一行的文本根据空格切分成若干单词
    for word in words:
        if word in word_freq:
            word_freq[word] += 1
        else:
            word_freq[word] = 1
freq_word = []
for word, freq in word_freq.items():
    freq_word.append((freq, word))
freq_word.sort(reverse=True)
for freq, word in freq_word[:10]:
    print(word)
f.close()

            
          

• 练习：翻转字典，生成一个新字典，键为原字典的值，值为原字典的键。
  同一个值，可能对应多个键，需要用列表存储，代码如下。

            
              d1 = {'zhang': 123, 'wang': 456, 'li': 123, 'zhao': 456}
d2 = {}
for name, room in d1.items():
    if room in d2:
        d2[room].append(name)
    else:
        d2[room] = [name]
print(d2)

            
          

---

集合

• Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算，下面是基本代码。

            
              def main():
    set1 = {1, 2, 3, 3, 3, 2}
    print(set1)
    print('Length =', len(set1))
    set2 = set(range(1, 10))
    print(set2)
    set1.add(4)
    set1.add(5)
    set2.update([11, 12])
    print(set1)
    print(set2)
    set2.discard(5)
    # remove的元素如果不存在会引发KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍历集合容器
    for elem in set2:
        print(elem ** 2, end=' ')
    print()
    # 将元组转换成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    print(set3.pop())
    print(set3)
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))
    # 判断子集和超集
    print(set2 <= set1)
    # print(set2.issubset(set1))
    print(set3 <= set1)
    # print(set3.issubset(set1))
    print(set1 >= set2)
    # print(set1.issuperset(set2))
    print(set1 >= set3)
    # print(set1.issuperset(set3))


if __name__ == '__main__':
    main()

            
          

• Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符，上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如＆运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。

• 集合即无序不重复元素（键）集，和字典类似，但无“值”。

• 使用set()函数创建集合，或使用{key1,key2,…}的方式。使用.add(‘body’)添加元素，.remove(‘body’)删除元素。

• 集合运算符：“-”求差集，”&“求交集，”|“求并集，”!=“为不等于，”==“为等于，”in“为成员，”for … in“为枚举。

• 练习：中文分词，如“我爱北京天安门”，分为“我/爱/北京/天安门”。

使用正向最大匹配算法，从左到右取尽可能长的词，但可能会出现逻辑错误。
前提需要有词典收录中文词汇，如命名词典为“lexcion.txt”，先对词典进行操作，在返回字典集合的同时，还要返回词典中最长字段的长度，代码如下。

            
              def load_dict(filename):
    word_dict = set()
    max_len = 1
    f = open(filename)
    for line in f:
        word = str(line.strip())  # 在python2中有unicode函数，是一种编码标准，在python3中改为了str函数
        word_dict.add(word)
        if len(word) > max_len:
            max_len = len(word)
    return max_len, word

            
          

接着实现正向最大匹配算法，按照最大长度递减进行分词，后续代码如下。

            
              def fmm_word_seg(sent, max_len, word_dict):
    begin = 0
    words = []
    sent = str(sent)
    while begin < len(sent):
        for end in range(begin + max_len, begin, -1):
            if sent[begin:end] in word_dict:
                words.append(sent[begin:end])
                break
        begin = end
    return words
max_len, word_dict = load_dict('lexicon.dic')
sent = input()
words = fmm_word_seg(sent, max_len, word_dict)
for word in words:
    print(word)