Python里唯一的映射類型是字典。
映射類型對象里，hash值(key)和指向的對象(值)是一對多的關系。
字典對象是可變的，這一點上很像列表，它也可以存儲任意個數任意類型的Python對象，其中包括容器類型。字典類型和序列類型的區別是存儲和訪問數據的方式不同。序列類型只用數字類型的鍵（從序列開始按數值順序索引。）映射類型的鍵(key)可以是其他的對象類型（一般是字符串），映射類型的鍵直接或間接地和存儲的數據值相關聯。而在映射類型中，數據是無序排列的。
一個字典條目的語法格式是 鍵：值。 多條字典條目被包含在{}里。
創建字典和賦值
>>> dict1 = {}>>> dict2 = {1:80, 'string':'sss', 2.3:['list']}>>> dict1,dict2({}, {1: 80, 'string': 'sss', 2.3: ['list']})>>> dict3 = dict((['x',1],['y',2]))>>> dict3{'y': 2, 'x': 1}
訪問字典中的值
遍歷一個字典，只需要循環查看它的鍵
>>> for key in dict2.keys():PRint 'key = %s, value = %s' % (key, dict2[key])key = 1, value = 80key = string, value = ssskey = 2.3, value = ['list']
也可以不用keys()方法，用迭代器來訪問：
>>> for i in dict2:print 'key = %s, value = %s' % (i, dict2[i])key = 1, value = 80key = string, value = ssskey = 2.3, value = ['list']
要得到字典里的某個元素的值，使用字典[鍵]的方式：
>>> dict2 = {1:80, 'string':'sss', 2.3:['list']}>>> dict2['string']'sss'>>> dict2[string]Traceback (most recent call last):File "<pyshell#2>", line 1, in <module>dict2[string]NameError: name 'string' is not defined
如果沒有對應的鍵，就會報錯。
判斷一個字典中是否有某個鍵可以用in 以及 not in操作符
>>> 1 in dict2True>>> 'sss' in dict2False
字典中的鍵不允許改變，所以我們用數字和字符串作為鍵，列表和其他字典不允許作為鍵。
映射類型操作符
字典可以和所有標注類型操作符一起工作但不支持拼接和重復一類的操作。
字典的鍵查找操作符[]是唯一僅用于字典的操作符，它和切片操作符很相像，但是[]里不只是數字索引。
字典的比較cmp(dict1, dict2)
先比較字典的長度（鍵的數量），再比較字典的鍵，再比較字典的值，然后是完全匹配。
映射類型相關函數
dict()
如果不提供參數，會生成空字典。當容器類型對象作為一個參數傳遞給dict()時，如果參數是可迭代的，那么這個序列必須是成對出現的。每個值的對中，第一個元素是鍵，第二個元素是值。如果輸入參數是（另）一個映射對象，對其調用dict()會從存在的字典里復制內容來生成新的字典。新生成的字典是原來字典的淺復制，它與用copy()方法生成的字典對象一樣，但是比用copy()方法慢。
>>> dict(zip(('x', 'y'), (1, 2))){'y': 2, 'x': 1}>>> dict([['x', 1], ['y', 2]]){'y': 2, 'x': 1}>>> dict([('xy'[i-1], i) for i in range(1,3)]){'y': 2, 'x': 1}>>> dict(x=1, y=2){'y': 2, 'x': 1}>>> dict8 = dict(x=1, y=2)>>> dict8{'y': 2, 'x': 1}>>> dict9 = dict(**dict8)>>> dict9{'y': 2, 'x': 1}>>> dict9 = dict8.copy()>>> dict9{'y': 2, 'x': 1}
hash()
hash()本身不是為字典設計的方法，但它可以判斷一個對象是否可以做字典的鍵。只有這個對象是可哈希的，才可以作為字典的鍵（函數的返回值是整數，不產生錯誤和異常）
如果用比較操作符比較兩個數值，發現它們相等，那么即使兩者數據類型不同，也會得到相同的哈希值。
如果是非可哈希對象作為參數，會產生TypeError錯誤。
函數 操作
dict([container]) 創建字典的工廠函數。如果提供了容器類(container) ， 就
用其中的條目填充字典，否則就創建一個空字典。
len(mapping) 返回映射的長度(鍵-值對的個數)
映射類型的內建方法
| 方法名字 | 操作 |
| dict.clear() | 刪除字典中所有元素 |
| dict.copy() | 返回字典(淺復制)的一個副本 |
| dict.fromkeysc(seq,val=None) | 創建并返回一個新字典，以seq 中的元素做該字典的鍵，val 做該字典中所有鍵對應的初始值(如果不提供此值，則默認為None) |
| dict.get(key,default=None) | 對字典dict 中的鍵key,返回它對應的值value，如果字典中不存在此鍵，則返回default 的值(注意，參數default 的默認值為None) |
| dict.has_key(key) | 如果鍵(key)在字典中存在，返回True，否則返回False. 在Python2.2版本引入in 和not in 后，此方法幾乎已廢棄不用了，但仍提供一個可工作的接口。 |
| dict.items() | 返回一個包含字典中(鍵, 值)對元組的列表 |
| dict.keys() | 返回一個包含字典中鍵的列表 |
| dict.iter() | 方法iteritems(), iterkeys(), itervalues()與它們對應的非迭代方法一樣，不同的是它們返回一個迭代子，而不是一個列表。 |
| dict.popc(key[, default]) | 和方法get()相似，如果字典中key 鍵存在，刪除并返回dict[key]，如果key 鍵不存在，且沒有給出default 的值，引發KeyError 異常。 |
| dict.setdefault(key,default=None) | 和方法set()相似，如果字典中不存在key 鍵，由dict[key]=default 為它賦值。 |
| dict.update(dict2) | 將字典dict2 的鍵-值對添加到字典dict |
| dict.values() | 返回一個包含字典中所有值的列表 |
字典的鍵
字典中的值沒有任何限制，可以是任意Python對象，但是字典中的鍵是有類型限制的。
1、不允許一個鍵對應多個對象，當有鍵沖突時，取最后的賦值。
>>> dict1 = {'a':123,'a':'abc'}>>> dict1{'a': 'abc'}
2、鍵必須是可哈希的，像字典和列表這樣的可變類型是不可哈希的，不能作為鍵。所有的不可變類型都是可哈希的，可以作為鍵。但是數值相等的數字哈希值相同，所以是相同的鍵。元組是不可變類型，但是它不是一成不變的，用元組做有效的鍵，元組中必須只包括像數字和字符串這樣的不可變參數，才可以作為字典中有效的鍵。
>>> dict2 = {1:'abc', 1.0:'123'}>>> dict2{1: '123'}>>> dict3 = {(1,2,3):'123'}>>> dict3{(1, 2, 3): '123'}>>> dict4 = {([1,2,3],2):'123'}Traceback (most recent call last):File "<pyshell#6>", line 1, in <module>dict4 = {([1,2,3],2):'123'}TypeError: unhashable type: 'list'
集合類型
數學上，把 set 稱做由不同的元素組成的集合，集合(set)的成員通常被稱做集合元素(set elements)。Python把這個概念引入到它的集合類型對象里。集合對象是一組無序排列的可哈希的值，所以可以做字典中的鍵。
和其他容器類型一樣，集合可以用in和 not in操作符檢查成員，由len()內建函數得到集合的基數（大小），用for循環迭代集合成員。但是因為集合本身無序，不可以為集合創建索引或執行切片操作，也沒有鍵來獲取集合中元素的值。
集合(sets)有兩種類型，可變集合(set)和不可變集合(frozenset)。其中可變集合可以添加刪除元素，但它是不可哈希的。不可變集合不可更改元素，但它可哈希。
Python的集合操作符是這樣的
| Python符號 | 說明 |
| in | 是...的成員 |
| not in | 不是...的成員 |
| == | 等于 |
| != | 不等于 |
| < | 是...的（嚴格）子集 |
| <= | 是...的（非嚴格）子集 |
| > | 是...的（嚴格）超集 |
| >= | 是...的（非嚴格）超集 |
| & | 交集 |
| | | 并集 |
| - | 差補或相對補集 |
| ^ | 對稱差分 |
創建集合類型和給集合類型賦值
集合與列表([])和字典({})不同，沒有特別的語法格式。列表和字典可以分別用他們自己的工廠方法list()和dict()創建，這是集合被創建的唯一方法——用集合的工廠方法 set() 和 frosenset():
>>> s = set('hellopython')>>> sset(['e', 'h', 'l', 'o', 'n', 'p', 't', 'y'])>>> t = frozenset(['a','b','c','d','e'])>>> tfrozenset(['a', 'c', 'b', 'e', 'd'])>>> type(t)<type 'frozenset'>>>> type(s)<type 'set'>>>> len(s)8
訪問集合中的值
>>> 'e' in sTrue>>> 'a' in sFalse>>> for i in s:print iehlonpty
更新集合
如下操作：
>>> s.add('z')>>> sset(['e', 'h', 'l', 'o', 'n', 'p', 't', 'y', 'z'])>>> s.update('abc')>>> sset(['a', 'c', 'b', 'e', 'h', 'l', 'o', 'n', 'p', 't', 'y', 'z'])>>> s.remove('z')>>> sset(['a', 'c', 'b', 'e', 'h', 'l', 'o', 'n', 'p', 't', 'y'])>>> s -= set('python')>>> sset(['a', 'c', 'b', 'e', 'l'])
集合類型操作符
如上表表示。
此處只寫出一些運算符的使用方法：
>>> a = set('abcd')>>> b = frozenset('cdef')>>> a | b #并set(['a', 'c', 'b', 'e', 'd', 'f'])>>> a & b #交set(['c', 'd'])>>> a - b #差set(['a', 'b'])>>> a ^ b #對稱差分set(['a', 'b', 'e', 'f'])>>> b | afrozenset(['a', 'c', 'b', 'e', 'd', 'f'])>>> b ^ afrozenset(['a', 'b', 'e', 'f'])
如果兩個集合是不同類型的結合，那么結果類型和左操作數的類型相同
集合類型操作符（僅用于可變集合）
(Union) Update ( |= )
這個方法可以添加多個成員，和上面額update()等價
>>> a = set('abcd')>>> a |= set('happy')>>> aset(['a', 'c', 'b', 'd', 'h', 'p', 'y'])
保留/交集更新( &= )
>>> a = set('abdef')>>> a &= set('abcd')>>> aset(['a', 'b', 'd'])
差更新(-=)和對稱差分更新)(^=)不贅述
集合類型內建方法
| 可用于全部集合的方法 | 操作 |
| s.issubset(t) | 如果s 是t 的子集，則返回True,否則返回False |
| s.issuperset(t) | 如果t 是s 的超集，則返回True,否則返回False |
| s.union(t) | 返回一個新集合，該集合是s 和t 的并集 |
| s.intersection(t) | 返回一個新集合，該集合是s 和t 的交集 |
| s.difference(t) | 返回一個新集合，該集合是s 的成員，但不是t 的成員 |
| s.symmetric_difference(t) | 返回一個新集合，該集合是s 或t 的成員，但不是s 和t 共有的成員 |
| s.copy() | 返回一個新集合，它是集合s 的淺復制 |
| 可變集合類型的方法 | 操作 |
| s.update(t) | 用t 中的元素修改s, 即，s 現在包含s 或t 的成員 |
| s.intersection_update(t) | s 中的成員是共同屬于s 和t 的元素 |
| s.difference_update(t) | s 中的成員是屬于s 但不包含在t 中的元素 |
| s.symmetric_difference_update(t) | s中的成員更新為那些包含在s 或t 中，但不 是s和t 共有的元素 |
| s.add(obj) | 在集合s 中添加對象obj |
| s.remove(obj) | 從集合s 中刪除對象obj；如果obj 不是集合s 中的元素(obj not in s)，將引發KeyError 錯誤 |
| s.discard(obj) | 如果obj 是集合s 中的元素，從集合s 中刪除對象obj |
| s.pop() | 刪除集合s 中的任意一個對象，并返回它 |
| s.clear() | 刪除集合s 中的所有元素 |
新聞熱點
疑難解答
