# 哈希散列

字典准确地来说是一种映射数据结构，也就是哈希表，或者称为散列表。注意，所有不可变数据类型都可以作为散列表的键，不可变数据类型有str、type和tuple。但是如果tuple中含有可变数据类型的索引，那么该数据类型不可作为散列表的键。

# 字典构造方法

```python
a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})

a == b == c == d == e
>>>True
```

# 字典推导(dict comprehension)

字典推导跟列表推导的使用方法差不多，并且这种推导构造方法还蔓延到其他数据结构上。

```python
DIAL_CODES = [(86, 'China'), (91, 'India'), (1, 'Unite States'), (7, 'Russia')]

country_code = {country: code for code, country in DIAL_CODES}
code_country = {code: country.upper() for country, code in country_code.items() if code > 1}
```

# 常见映射方法

dict、defaultdict和OrderedDict，后两个数据类型是dict的变种，位于collections模块下。

| 方法                         | dict | defaultdict | OrderedDict | 描述                                                         |
| ---------------------------- | ---- | ----------- | ----------- | ------------------------------------------------------------ |
| `d.clear()`                  | y    | y           | y           | 移除所有元素                                                 |
| `d.__contains__(k)`          | y    | y           | y           | 检查元素k是否在字典对象d中                                   |
| `d.copy()`                   | y    | y           | y           | 浅复制                                                       |
| `d.__copy__()`               |      | y           |             | `copy.copy()`                                                |
| `d.default_factory()`        |      | y           |             | 在`__missing__`函数中被调用，给未找到的元素设置默认值        |
| `d.__delitem__(k)`           | y    | y           | y           | `del d[k]`移除键为k的元素                                    |
| `d.fromkeys(it, [initial])`  | y    | y           | y           | 将迭代器it中元素设为映射里的键，如果有initial参数，就把它作为这些键对应的值，默认为None |
| `d.get(k, [default])`        | y    | y           | y           | 返回键k对应的值，如果不存在键k，则返回None或者default        |
| `d.__getitem__(k)`           | y    | y           | y           | `d[k]`返回键为k的值                                          |
| `d.items()`                  | y    | y           | y           | 返回d所有的键值对                                            |
| `d.__iter__()`               | y    | y           | y           | 返回键的迭代器                                               |
| `d.keys()`                   | y    | y           | y           | 返回所有键                                                   |
| `d.__len__()`                | y    | y           | y           | `len(d)`返回键值对的数量                                     |
| `d.__missing__(k)`           |      | y           |             | 当`__getitem__`找不到对应键时候，方法被调用                  |
| `d.move_to_end(k, [last])`   |      |             | y           | 把键为k的元素移动到最靠前或者最靠后的位置，last默认值为True  |
| `d.pop(k, [default])`        | y    | y           | y           | 返回键k对应的值，并且移除该键值对。如果不存在k，则返回None或者default |
| `d.popitem()`                | y    | y           | y           | 随机返回一个键值对，并且移除该键值对。                       |
| `d.__reversed__()`           |      |             | y           | 返回倒序的键的迭代器                                         |
| `d.setdefault(k, [default])` | y    | y           | y           | 如果字典里有键k，返回该值，并且把它设置为default值；如果没有键k，则让`d[k]=default`，并返回default值。 |
| `d.__setitem__(k, v)`        | y    | y           | y           | `d[k]=v`，设置k键的值为v                                     |
| `d.update(m, [**kargs])`     | y    | y           | y           | m可以是映射或者键值对迭代器，用来更新d                       |
| `d.values()`                 | y    | y           | y           | 返回字典里所有的值                                           |


<!-- markdown for nginx, see https://phus.lu -->
<script>
!function(){
	var dom = {
		element: null,
		get: function (o) {
			var obj = Object.create(this)
			obj.element = (typeof o == "object") ? o : document.createElement(o)
			return obj
		},
		add: function (o) {
			var obj = dom.get(o)
			this.element.appendChild(obj.element)
			return obj
		},
		text: function (t) {
			this.element.appendChild(document.createTextNode(t))
			return this
		},
		attr: function (k, v) {
			this.element.setAttribute(k, v)
			return this
		}
	}

	if (!document.head) return
	head = dom.get(document.head)
	head.add('meta').attr('charset', 'utf-8')
	head.add('meta').attr('name', 'viewport').attr('content', 'width=device-width,initial-scale=1')

	if (!document.body) {
		document.write(["<div class=\"container\">",
		"<h3>nginx.conf</h3>",
		"<textarea rows=6 cols=50>",
		"# download markdown.html to /wwwroot",
		"location ~ \\.md$ {",
		"    default_type text/html;",
		"    add_after_body /markdown.html;",
		"}",
		"</textarea>",
		"</div>"].join("\n"))
		return
	}

	var bodytext = document.body.innerHTML
	document.body.innerHTML = ''

	div = dom.get('div').attr('class', 'container')

	div.add('script').attr('src', 'https://cdnjs.cloudflare.com/ajax/libs/marked/0.5.2/marked.min.js').attr('integrity', 'sha256-zFUosuESzULu5P+SZdjRRtBZR8+1u5RZDlbt3Q5KL8U=').attr('crossorigin', 'anonymous')
	div.add('link').attr('rel', 'stylesheet').attr('href', 'https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown-light.min.css').attr('integrity', 'sha256-WQx0Y6LLZeGv3V3NVVge+YIL5MIOt45RPuFdkyNodls=').attr('crossorigin', 'anonymous')

	title = decodeURIComponent(document.location.pathname.replace(/.*\//, '').replace(/\.html$/, ''))
	document.title = '《' + title.replace(/\.md$/, '') + '》'
	tbody = div.add('table').add('tbody')
	tbody.add('tr').add('th').text(title).attr('class', 'octicon-book')
	tbody.add('tr').add('td').add('div').attr('id', 'readme').attr('class', 'markdown-body')

	wait = function (name, callback) {
		var interval = 10; // ms
		window.setTimeout(function() {
			if (window[name]) {
				callback(window[name])
			} else {
				window.setTimeout(arguments.callee, interval)
			}
		}, interval)
	}
	wait('marked', function() {
		document.getElementById("readme").innerHTML = marked.parse(bodytext)
	})

	document.body.appendChild(div.element)
}()
</script>

<style>
body {
	margin: 0;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.markdown-body {
	float: left;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.container {
	padding-right: 15px;
	padding-left: 15px;
	margin-right: auto;
	margin-left: auto;
}
@media (min-width: 768px) {
	.container {
		max-width: 80%;
	}
}
@media (min-width: 992px) {
	.container {
		max-width: 70%;
	}
}
@media (min-width: 1200px) {
	.container {
		max-width: 60%;
	}
}
table {
	width: 100%;
	max-width: 100%;
	margin-bottom: 20px;
	border: 1px solid #ddd;
	padding: 0;
	border-collapse: collapse;
}
table th {
	font-size: 14px;
}
table tr {
	border: 1px solid #ddd;
	padding: 5px;
}
table th, table td {
	border: 1px solid #ddd;
	font-size: 14px;
	line-height: 20px;
	padding: 3px;
	text-align: left;
}
.octicon-book {
	background-position: center left;
	background-repeat: no-repeat;
	padding-left: 20px;
	background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'%3E%3Cpath d='M3,5 L7,5 L7,6 L3,6 L3,5 L3,5 Z M3,8 L7,8 L7,7 L3,7 L3,8 L3,8 Z M3,10 L7,10 L7,9 L3,9 L3,10 L3,10 Z M14,5 L10,5 L10,6 L14,6 L14,5 L14,5 Z M14,7 L10,7 L10,8 L14,8 L14,7 L14,7 Z M14,9 L10,9 L10,10 L14,10 L14,9 L14,9 Z M16,3 L16,12 C16,12.55 15.55,13 15,13 L9.5,13 L8.5,14 L7.5,13 L2,13 C1.45,13 1,12.55 1,12 L1,3 C1,2.45 1.45,2 2,2 L7.5,2 L8.5,3 L9.5,2 L15,2 C15.55,2 16,2.45 16,3 L16,3 Z M8,3.5 L7.5,3 L2,3 L2,12 L8,12 L8,3.5 L8,3.5 Z M15,3 L9.5,3 L9,3.5 L9,12 L15,12 L15,3 L15,3 Z' /%3E%3C/svg%3E");
}
</style>