字典

• 字典可以存儲任意類型對象，與列表、集合不同的是，字典的每個元素都是由一個鍵和一個值組成的“鍵值對”，鍵和值通過冒號分開。下面的代碼演示了如何定義和使用字典。

            
              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)