编程入门09：Python字典类型
现在让我们来学习另一种复合数据类型“字典”（dict）——字典是用花括号括起来的“键值对”（Key-value pair），键和值之间用冒号分隔，键值对之间用逗号分隔。键在一个字典中具有唯一性，其作用就相当于序列中的索引号——与索引号只能是整数不同，任何不可变对象都能作为键（通常会使用字符串）。字典与列表一样是可变对象，你可以用赋值的方式直接修改元素，而且字典还允许给原本不存在的键赋值，即添加新元素：
In [1]: d1 = {"010":"北京", "021":"上海", "022":"天津"}
In [2]: d1["021"]
Out[2]: '上海'
In [3]: d1["020"] = "广州"
In [4]: d1
Out[4]: {'010': '北京', '020': '广州', '021': '上海', '022': '天津'}
字典元素的排列是“无序”的——输出字典时元素的顺序并不保留定义时的顺序，字典类型不属于序列而是属于“映射”（Mapping）。字典也支持迭代，字典直接作为迭代器取到的是键，字典提供三个专门方法keys()、values()、items()分别返回键、值或键值对的序列：
In [5]: list(d1) # 字典直接转列表只保留键
Out[5]: ['010', '021', '022', '020']
In [6]: d1.keys()
Out[6]: dict_keys(['010', '021', '022', '020'])
In [7]: d1.values()
Out[7]: dict_values(['北京', '上海', '天津', '广州'])
In [8]: d1.items() # 此方法返回序列中的元素是元组
Out[8]: dict_items([('010', '北京'), ('021', '上海'), ('022', '天津'), ('020', '广州')])
In [9]: for k, v in d1.items(): # 字典元素的迭代循环
...: print("{}: {}".format(k, v))
...:
010: 北京
021: 上海
022: 天津
020: 广州
字典名加方括号指定键可以返回元素的值，但如果指定的键不存在就会发生错误，因此推荐使用专门的get()方法来取值（当键不存在时返回None或是指定的默认值）；字典还提供专门的setdefault()方法用于元素初始赋值（当键不存在时添加键并赋指定的默认值，否则保持原值不变）。
In [10]: d1.get("023", "无")
Out[10]: '无'
In [11]: d1.setdefault("023", "重庆")
Out[11]: '重庆'
In [12]: d1
Out[12]: {'010': '北京', '020': '广州', '021': '上海', '022': '天津', '023': '重庆'}
In [13]: d1.setdefault("023", "重庆市")
Out[13]: '重庆'
In [14]: d1
Out[14]: {'010': '北京', '020': '广州', '021': '上海', '022': '天津', '023': '重庆'}
In [15]: txt = "Good good study, day day up!" # 这段代码统计文本中每个字符的出现次数
...: d2 = {} # IPython一次交互允许输入多条语句（按Ctrl+Enter换行）
...: for c in txt:
...: d2.setdefault(c, 0)
...: d2[c] += 1
...: print(sorted(d2.items(), key=lambda i:i[1], reverse=True)) # 序列按元素值降序排列
...:
[('d', 5), (' ', 5), ('o', 4), ('y', 3), ('u', 2), ('a', 2), ('G', 1), ('g', 1), ('s', 1), ('t', 1), (',', 1), ('p', 1), ('!', 1)]
上面最后一段代码中实现排序功能的sorted函数用key参数指定一个函数对象作为排序依据，本例使用lambda关键词定义了一个“匿名函数”，其写法为lambda 参数:返回值——匿名函数作为参数相比完整的函数声明更简单也更清晰。
如果用花括号括起来的不是键值对而是单一对象，就定义了一个“集合”（Set）——注意“{}”是空字典，定义空集合要使用不带参数的set函数。Python集合类型就相当于数学中的集合概念，集合中的元素也是无序的，可以进行“交”（&）“并”（|）“差”（-）和“对称差”（^）等集合运算，在编程中常会把列表和元组等对象转为集合来去除重复的元素。
In [16]: {1, 2, 3, 4} & {3, 4, 5, 6} # 交集
Out[16]: {3, 4}
In [17]: {1, 2, 3, 4} | {3, 4, 5, 6} # 并集
Out[17]: {1, 2, 3, 4, 5, 6}
In [18]: {1, 2, 3, 4} - {2, 3} # 差集
Out[18]: {1, 4}
In [19]: {1, 2, 3, 4} ^ {3, 4, 5, 6} # 对称差集
Out[19]: {1, 2, 5, 6}
In [20]: set(txt.split()) # 字符串拆成列表再转为集合
Out[20]: {'Good', 'day', 'good', 'study,', 'up!'}
接下来让我们再做一个综合练习——基于“L系统”绘制一株“分形植物”：
"""使用L系统模拟的分形植物
"""
import turtle as tt
def generate(n, result="[X]"):
"""传入迭代次数和生成式返回结果序列
"""
rules = {"X": "F-[[X]+X]+F[+FX]-X",
"F": "FF"}
for _ in range(n):
for k, v in rules.items():
result = result.replace(k, v)
return result
def draw(cmds, size=2):
"""传入结果序列和线段长度绘制图形
"""
stack = []
for cmd in cmds:
if cmd == "F":
tt.forward(size)
elif cmd == "-":
tt.left(25)
elif cmd == "+":
tt.right(25)
elif cmd == "X":
pass
elif cmd == "[":
stack.append((tt.position(), tt.heading()))
elif cmd == "]":
position, heading = stack.pop()
tt.penup()
tt.setposition(position)
tt.setheading(heading)
tt.pendown()
else:
raise ValueError("Unknown Cmd: {}".format(ord(cmd)))
tt.update()
def main():
"""绘图程序主函数
"""
tt.TurtleScreen._RUNNING = True
tt.hideturtle()
tt.tracer(0)
tt.color("green")
tt.speed(0)
tt.left(60)
tt.pensize(2)
tt.penup()
tt.goto(-tt.window_width()/3, -tt.window_height()/3)
tt.pendown()
plant = generate(6)
draw(plant)
tt.exitonclick()
if __name__ == "__main__":
main()
09_plant.png
以上程序使用一个字典来描述“L系统”文法的替换规则，因为只有两条规则，其实写两次replace方法就行，但用字典会更灵活——你可以继续改进生成函数增加一个规则参数，在调用时传入特定的规则字典，就能画出各种不同的分形图案了。
——编程原来是这样……
编程小提示：L系统
“L系统”是由匈牙利生物学家林登麦伊尔（Lindenmayer）于1968年提出的有关生长发展中的细胞交互作用的数学模型，目前被用来模拟各种生物体的形态，也能用于生成任何自相似的分形结构。例如以下文法描述了一株分形植物：
变量 : X F
常量 : + − [ ]
初始 : X
规则 : (X → F-[[X]+X]+F[+FX]-X), (F → FF)
角度 : 25°
X只用于迭代，F是画线段，+是右转，-是左转，方括号表示入栈和出栈。你可以用交互模式查看每次迭代的结果：
In [1]: from plant import generate
In [2]: generate(0)
Out[2]: '[X]'
In [3]: generate(1)
Out[3]: '[FF-[[X]+X]+FF[+FFX]-X]'
In [4]: generate(2)
Out[4]: '[FFFF-[[FF-[[X]+X]+FF[+FFX]-X]+FF-[[X]+X]+FF[+FFX]-X]+FFFF[+FFFFFF-[[X]+X]+FF[+FFX]-X]-FF-[[X]+X]+FF[+FFX]-X]'
迭代6次所生成的结果已长达31209个字符——简单规则蕴育出复杂结果，我们的世界就是因此而变得千姿百态……要了解L系统的详情可参看维基百科 https://en.wikipedia.org/wiki/L-system
