dict是我非常喜欢的一种数据类型，我甚至基于这种映射的概念发明了新的词组：KV编程论（后期有时间再说）。
dict在Python的代码中用途非常广泛，类似武术中的马步，好好练习，习以为常，能助你以后在代码编写过程中如鱼得水，风生水起。
废话少说，今天我们就来看看dict的基础练习与代码示例。
DE8UG的代码环境为：
- Windows10
- python3.7
概念
字典的基本创建格式：{键1: 值1，键2: 值2。。。}，例如: {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}，大括号是必须的，里面的各种符号，逗号，引号，冒号等都是英文符号。
注意：键的内容不能重复。且可变类型的值不能作为键。因为键的位置是需要唯一的，需要用它去映射后面的值。
更专业的说法是键需要是可hashable的。对于hashable，在官方文档有解释：
hashable -- 可哈希
一个对象的哈希值如果在其生命周期内绝不改变，就被称为 可哈希 （它需要具有 hash() 方法），并可以同其他对象进行比较（它需要具有 eq() 方法）。可哈希对象必须具有相同的哈希值比较结果才会相同。
可哈希性使得对象能够作为字典键或集合成员使用，因为这些数据结构要在内部使用哈希值。
大多数 Python 中的不可变内置对象都是可哈希的；可变容器（例如列表或字典）都不可哈希；不可变容器（例如元组和 frozenset）仅当它们的元素均为可哈希时才是可哈希的。 用户定义类的实例对象默认是可哈希的。 它们在比较时一定不相同（除非是与自己比较），它们的哈希值的生成是基于它们的 id()。
除了使用{}创建字典，还可以用字典的类dict来生成新的字典对象。
dict类的构造形式有：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
于是，我们用{"one": 1, "two": 2, "three": 3}举例，还可以有以下几种格式建立新的字典
>>> 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 # 这里直接用==判断前面几个字典变量是相同的
函数
下面我们先定义一个字典d，然后介绍字典的相关操作和代码示例。
d = dict([('two', 2), ('one', 1), ('three', 3)])
| 操作 | 含义 |
|---|---|
| list(d) | 返回字典 d 中使用的所有键的列表。 |
| len(d) | 返回字典 d 中的项数 |
| d[key] | 返回 d 中以 key 为键的项。 如果映射中不存在 key 则会引发 KeyError。 |
| d[key] = value | 将 d[key] 设为 value。 |
| del d[key] | 将 d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。 |
| key in d | 如果 d 中存在键 key 则返回 True，否则返回 False。 |
| key not in d | 等价于 not key in d。 |
| iter(d) | 返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。 |
| clear() | 移除字典中的所有元素。 |
| copy() | 返回原字典的浅拷贝。 |
| get(key[, default]) | 如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。 |
| items() | 返回由字典项 ((键, 值) 对) 组成的一个新视图。 参见 视图对象文档。 |
| keys() | 返回由字典键组成的一个新视图。 参见 视图对象文档。 |
| pop(key[, default]) | 如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError。 |
| popitem() | 从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO 的顺序被返回。在 3.7 版更改: 现在会确保采用 LIFO 顺序。 在之前的版本中，popitem() 会返回一个任意的键/值对。 |
| reversed(d) | 返回一个逆序获取字典键的迭代器。 这是 reversed(d.keys()) 的快捷方式。注意，这个在python3.8才支持 |
| setdefault(key[, default]) | 如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。 |
| update([other]) | 使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 None。update() 接受另一个字典对象，或者一个包含键/值对（以长度为二的元组或其他可迭代对象表示）的可迭代对象。 如果给出了关键字参数，则会以其所指定的键/值对更新字典: d.update(red=1, blue=2)。 |
| values() | 返回由字典值组成的一个新视图,在 3.7 版更改: 字典顺序会确保为插入顺序 |
代码示例:
这里主要是两种调用方式：
- d作为参数。比如func(d)，表示python内置函数把字典作为参数。
- d作为对象，调用字典自己的方法。比如d.func(...)
In [1]: d = dict([('two', 2), ('one', 1), ('three', 3)])
In [2]: list(d)
Out[2]: ['two', 'one', 'three']
In [3]: len(d)
Out[3]: 3
In [4]: d['two']
Out[4]: 2
In [5]: d['two']=222
In [6]: d['two']
Out[6]: 222
In [7]: del d['two']
In [8]: d
Out[8]: {'one': 1, 'three': 3}
In [9]: 'two' in d
Out[9]: False
In [10]: 'one' in d
Out[10]: True
In [11]: iter(d)
Out[11]:
In [12]: dd=d.copy()
In [13]: dd
Out[13]: {'one': 1, 'three': 3}
In [14]: d.get('one')
Out[14]: 1
In [15]: d.keys()
Out[15]: dict_keys(['one', 'three'])
In [16]: d.items()
Out[16]: dict_items([('one', 1), ('three', 3)])
In [17]: d.pop()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
----> 1 d.pop()
TypeError: pop expected at least 1 arguments, got 0
In [18]: d.pop('one')
Out[18]: 1
In [19]: d
Out[19]: {'three': 3}
In [20]: d['name']='de8ug'
In [21]: d['city']='beijing'
In [22]: d
Out[22]: {'three': 3, 'name': 'de8ug', 'city': 'beijing'}
In [23]: d.popitem()
Out[23]: ('city', 'beijing')
In [24]: d
Out[24]: {'three': 3, 'name': 'de8ug'}
In [25]: reversed(d)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
----> 1 reversed(d)
TypeError: 'dict' object is not reversible
注意，这里的reversed函数出错了，因为我当前环境是python3.7，这个新的功能是在python3.8才生效。具体在：https://docs.python.org/3.8/whatsnew/3.8.html
Guido在信中有介绍：
reversed() is supported for both dicts and dictviews since version 3.8 (14.10.2018).
这样就让字典变得有序，可以逆转了。参考代码：
>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]
你可以安装python3.8试一下。
ok，希望上面的代码你都自己练习一遍，这样在以后用到某个方法时候才能知道怎么回事儿。
有任何问题欢迎留言，wx搜索：python随身听，【在看】一下，下期见。
本篇文章由一文多发平台ArtiPub自动发布