题目
听闻坊间流传，python 中的字典（dict）是不不少人喜爱的一种基础数据类型。相比列表（list）虽然同样是可变的容器型基础数据类型，但是字典在获取任何数据时的速度都是飞快，而列表则会随着长度的增加而不断损失速度。也许正是如此本题的题目才会是“可爱的”吧。下面我们将首先学习字典的基础知识，然后进行一个对应的练习。
新知识
字典（dict，全称 dictionary）在不同编程语言中的名字不同例如 “hash” 、“map”，它的形式很像我们使用的字典，有一个键 key 表示一个名字，还有一个值 value 表示键的数据。把键值对（key-value）方在大括号中就就是我们说的字典了。
不过我们先来看看列表和字典的区别。使用列表我们可以做下面的事情：
>>> things = ['a', 'b', 'c', 'd']
>>> print(things[1])
b
>>> things[1] = 'z'
>>> print(things[1])
z
>>> print(things)
['a', 'z', 'c', 'd']
>>>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
我们想要使用列表中的一个元素，可以使用数字作为索引找到这个元素。而字典几乎任何东西作为“索引”，其实也就是 key 只不过需要注意 key 必须是不可变的数据类型（可参考 37题答案——数据类型）
>>> stuff = {'name': 'Zed', 'age': 36， 'height': 6*12+2}
>>> print(stuff['name'])
Zed
>>> print(stuff['age'])
36
>>> print(stuff['height'])
74
>>> stuff['city'] = "San Francisco"
>>> print(stuff['city'])
San Francisco
>>>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
字符串是不能改变的，例如我收钱帮你买了一台 ’bpple’ 牌的 ‘NacBook’ 笔记本恐怕你就要着急了。字符串如果改变意思就不一样了，正如真正的字典一样。而数字也是不可变的，又如我给你换了台 2028 款的 MacBook，恐怕你不也还是不会安心到那里去（会不会因为我成功预测 apple 公司十年后的产品而免费得到一台呢 哈哈），所以数字也是可以用来作为字典的键
>>> stuff[1] = "Wow"
>>> stuff[2] = "Neato"
>>> print(stuff[1])
Wow
>>> print(stuff[2])
Neato
>>>print(stuff)
{'city': 'San Francisco', 2: 'Neato',
'name': 'Zed', 1: 'Wow', 'age': 36,
'height': 74}
>>>- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
注意到了么，字典中键值对的顺序是不固定的，它是无序的。此外，作为容器字典是可进可出的，我们可以使用 del 删除某一个键值对
>>> del stuff['city']
>>> del stuff[1]
>>> del stuff[2]
>>> stuff
{'name': 'Zed', 'age': 36, 'height': 74}
>>>- 1
- 2
- 3
- 4
- 5
- 6
剩下的就是基础练习和加分练习了。
加分练习
- 在 Python 文档中找到 dictionary （又叫 dicts，dict）的相关内容，学着掌握 dict 的更多操作。
- 找到一些 dict 无法做到的事情。例如比较重要的是个就是 dict 的内容是无序的，可以检查一下是否真是这样。
- 试着把
for-loop执行到 dict 上面，然后试着在for-loop中使用 dict 的items()函数，看看会有什么样的结果。
我的答案
40.0 基础练习
# 创建了一个包含多个城市名称的字典
cities = {'CA': 'San Francisco', 'MI': 'Detroit', 'FL': 'Jacksonville'}
# 为 cities 增加两个新的城市。
cities['NY'] = 'New York'
cities['OR'] = 'Portland'
# 创建一个函数，从字典中通过简写获得城市名称
def find_city(themap, state): # map 是内置函数 所以使用了 themap
if state in themap:
return themap[state]
else:
return "Not found."
# ok pay attetion!
cities['_find'] = find_city
# 原文中
# print "State? (ENTER to quit)",
# state = raw_input("> ")
#
# 这种写法 python 3 似乎做不到了，参考打印的结果改下成了下面的写法
while True:
state = input("State? (ENTER to quit) > ")
if not state: break
# this line is the most important ever! study!
# 据说搞不懂的可以看看下一题
city_found = cities['_find'](cities, state)
print(city_found)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
40.1 字典的帮助文档
查看文档的方法大家应该都还记得吧，我的到了下面这些信息，按照惯例，为列出有下划线的方法
class dict(object)
| dict() -> new empty dictionary
| 创建一个新的空字典
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
|
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| 从可迭代对象创建字典
|
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
| 使用关键词参数创建
|
| Methods defined here:
|
| clear(...)
| D.clear() -> None. Remove all items from D.
| 清空字典
|
| copy(...)
| D.copy() -> a shallow copy of D
| 和列表类似是浅拷贝，如果子内容的列表或字典改变，
| 拷贝体的子内容也会改变。深拷贝则不会。
|
| fromkeys(iterable, value=None, /) from builtins.type
| Returns a new dict with keys from iterable and values equal to value.
| 生成一个新字典，其键来自可迭代对象，默认值是 None
|
| get(...)
| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
| 获取若干键的值，如果键不存在则返回 None
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
| 返回一个包含 键-值 的元祖的列表
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
| 返回一个包含键的列表
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised
| 移除指定的键值对，并返回值
|
| popitem(...)
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.
| 移除一对键值对，并以元祖返回键值对，
| 如果字典为空，则返回 KeyError
|
| setdefault(...)
| D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
| 接受两个值，如 k，d 如果 k 是已经存在的键则返回值，
| 如果键不存在，则 k 为键， d 为值存入字典
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
| 把字典或可迭代对象更新到当前字典
|
| values(...)
| D.values() -> an object providing a view on D's values
| 返回只包含值的列表- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
40.2 字典不能做的事情
和列表相比，可以看到字典本身就没有任何和顺序有关的操作，比如从前端加如元素、排序等
40.3 对字典使用 for 循环
总之，先按照要求做做看把。
d = {'1': 'a', '2': 'b', '3': 'c', '4':'d'}
# 使用 for 循环遍历字典
for k in d:
print("当前的键是 %r, 它的值是：%r" % (k, d.get(k)))
for k, v in d.items():
print(k, v)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
字典在 for 循环中只能遍历出键，而不会遍历出对应的值。
遍历 d.items() 时则会获取到键值对组成的元祖，因此需要两个变量分别获取键和值。