第 15 章　生成数据

第 15 章　生成数据 - 图1

数据可视化指的是通过可视化表示来探索数据，它与数据挖掘紧密相关，而数据挖掘指的是使用代码来探索数据集的规律和关联。数据集可以是用一行代码就能表示的小型数字列表，也可以是数以吉字节的数据。

漂亮地呈现数据关乎的并非仅仅是漂亮的图片。以引人注目的简洁方式呈现数据，让观看者能够明白其含义，发现数据集中原本未意识到的规律和意义。

所幸即便没有超级计算机，也能够可视化复杂的数据。鉴于Python的高效性，使用它在笔记本电脑上就能快速地探索由数百万个数据点组成的数据集。数据点并非必须是数字，利用本书前半部分介绍的基本知识，也可以对非数字数据进行分析。

在基因研究、天气研究、政治经济分析等众多领域，大家都使用Python来完成数据密集型工作。数据科学家使用Python编写了一系列令人印象深刻的可视化和分析工具，其中很多也可供你使用。最流行的工具之一是matplotlib，它是一个数学绘图库，我们将使用它来制作简单的图表，如折线图和散点图。然后，我们将基于随机漫步概念生成一个更有趣的数据集——根据一系列随机决策生成的图表。

我们还将使用Pygal包，它专注于生成适合在数字设备上显示的图表。通过使用Pygal，可在用户与图表交互时突出元素以及调整其大小，还可轻松地调整整个图表的尺寸，使其适合在微型智能手表或巨型显示器上显示。我们将使用Pygal以各种方式探索掷骰子的结果。

15.1　安装matplotlib

首先，需要安装matplotlib，我们将使用它来制作开始的几个图表。如果你还未使用过pip，请参阅12.2.1节。

15.1.1　在Linux系统中安装matplotlib

如果你使用的是系统自带的Python版本，可使用系统的包管理器来安装matplotlib，为此只需执行一行命令：

  1. $ sudo apt-get install python3-matplotlib

如果你使用的是Python 2.7，请执行如下命令：

  1. $ sudo apt-get install python-matplotlib

如果你安装了较新的Python版本，就必须安装matplotlib依赖的一些库：

  1. $ sudo apt-get install python3.5-dev python3.5-tk tk-dev
  2. $ sudo apt-get install libfreetype6-dev g++

再使用pip来安装matplotlib：

  1. $ pip install --user matplotlib

15.1.2　在OS X系统中安装matplotlib

Apple的标准Python安装自带了matplotlib。要检查系统是否安装了matplotlib，可打开一个终端会话并尝试导入matplotlib。如果系统没有自带matplotlib，且你的Python是使用Homebrew安装的，则可以像下面这样安装matplotlib：

  1. $ pip install --user matplotlib

注意　安装包时可能需要使用pip3，而不是pip。另外，如果这个命令不管用，你可能需要删除标志--user。

15.1.3　在Windows系统中安装matplotlib

在Windows系统中，首先需要安装Visual Studio。为此，请访问https://dev.windows.com/，单击Downloads，再查找Visual Studio Community——一组免费的Windows开发工具。请下载并运行该安装程序。

接下来，需要下载matplotlib安装程序。为此，请访问https://pypi.python.org/pypi/matplotlib/，并查找与你使用的Python版本匹配的wheel文件（扩展名为.whl的文件）。例如，如果你使用的是32位的Python 3.5，则需要下载matplotlib-1.4.3-cp35-none-win32.whl。

注意　如果找不到与你安装的Python版本匹配的文件，请去http://www.lfd.uci.edu/-gohlke/pythonlibs/#matplotlib看看，这个网站发布安装程序的时间通常比matplotlib官网早些。

将这个.whl文件复制到你的项目文件夹，打开一个命令窗口，并切换到该项目文件夹，再使用pip来安装matplotlib：

  1. > cd python_work
  2. python_work> python -m pip install --user matplotlib-1.4.3-cp35-none-win32.whl

15.1.4　测试matplotlib

安装必要的包后，对安装进行测试。为此，首先使用命令python或python3启动一个终端会话，再尝试导入matplotlib：

  1. $ python3
  2. >>> import matplotlib
  3. >>>

如果没有出现任何错误消息，就说明你的系统安装了matplotlib，可以接着阅读下一节。

注意　如果你在安装过程中遇到了麻烦，请参阅附录C。如果依然无济于事，请向他人寻求帮助。对于你遇到的问题，只要向经验丰富的Python程序员提供少量的信息，他们很可能很快就能帮你解决。

15.1.5　matplotlib画廊

要查看使用matplotlib可制作的各种图表，请访问http://matplotlib.org/的示例画廊。单击画廊中的图表，就可查看用于生成图表的代码。

15.2　绘制简单的折线图

下面来使用matplotlib绘制一个简单的折线图，再对其进行定制，以实现信息更丰富的数据可视化。我们将使用平方数序列1、4、9、16和25来绘制这个图表。

只需向matplotlib提供如下数字，matplotlib就能完成其他的工作：

mpl_squares.py

  1. import matplotlib.pyplot as plt
  3. squares = [1, 4, 9, 16, 25]
  4. plt.plot(squares)
  5. plt.show()

我们首先导入了模块pyplot，并给它指定了别名plt，以免反复输入pyplot。在线示例大都这样做，因此这里也这样做。模块pyplot包含很多用于生成图表的函数。

我们创建了一个列表，在其中存储了前述平方数，再将这个列表传递给函数plot()，这个函数尝试根据这些数字绘制出有意义的图形。plt.show()打开matplotlib查看器，并显示绘制的图形，如图15-1所示。查看器让你能够缩放和导航图形，另外，单击磁盘图标可将图形保存起来。

{%}

图15-1　使用matplotlib可制作的最简单的图表

15.2.1　修改标签文字和线条粗细

图15-1所示的图形表明数字是越来越大的，但标签文字太小，线条太细。所幸matplotlib让你能够调整可视化的各个方面。

下面通过一些定制来改善这个图形的可读性，如下所示：

mpl_squares.py

  1. import matplotlib.pyplot as plt
  3. squares = [1, 4, 9, 16, 25]
  4. plt.plot(squares, linewidth=5) ❶
  6. # 设置图表标题，并给坐标轴加上标签
  7. plt.title("Square Numbers", fontsize=24) ❷
  8. plt.xlabel("Value", fontsize=14) ❷
  9. plt.ylabel("Square of Value", fontsize=14)
  11. # 设置刻度标记的大小
  12. plt.tick_params(axis='both', labelsize=14) ❹
  14. plt.show()

参数linewidth（见❶）决定了plot()绘制的线条的粗细。函数title()（见❷）给图表指定标题。在上述代码中，出现了多次的参数fontsize指定了图表中文字的大小。

函数xlabel()和ylabel()让你能够为每条轴设置标题（见❸）；而函数tick_params()设置刻度的样式（见❹），其中指定的实参将影响x轴和y轴上的刻度（axis='both'），并将刻度标记的字号设置为14（labelsize=14）。

最终的图表阅读起来容易得多了，如图15-2所示：标签文字更大，线条也更粗。

{%}

图15-2　现在图表阅读起来容易得多

15.2.2　校正图形

图形更容易阅读后，我们发现没有正确地绘制数据：折线图的终点指出4.0的平方为25！下面来修复这个问题。

当你向plot()提供一系列数字时，它假设第一个数据点对应的 x 坐标值为0，但我们的第一个点对应的 x 值为1。为改变这种默认行为，我们可以给plot()同时提供输入值和输出值：

mpl_squares.py

  1. import matplotlib.pyplot as plt
  3. input_values = [1, 2, 3, 4, 5]
  4. squares = [1, 4, 9, 16, 25]
  5. plt.plot(input_values, squares, linewidth=5)
  7. # 设置图表标题并给坐标轴加上标签
  8. --snip--

现在plot()将正确地绘制数据，因为我们同时提供了输入值和输出值，它无需对输出值的生成方式作出假设。最终的图形是正确的，如图15-3所示。

{%}

图15-3　根据数据正确地绘制了图形

使用plot()时可指定各种实参，还可使用众多函数对图形进行定制。本章后面处理更有趣的数据集时，将继续探索这些定制函数。

15.2.3　使用scatter()绘制散点图并设置其样式

有时候，需要绘制散点图并设置各个数据点的样式。例如，你可能想以一种颜色显示较小的值，而用另一种颜色显示较大的值。绘制大型数据集时，你还可以对每个点都设置同样的样式，再使用不同的样式选项重新绘制某些点，以突出它们。

要绘制单个点，可使用函数scatter()，并向它传递一对 x 和 y 坐标，它将在指定位置绘制一个点：

scatter_squares.py

  1. import matplotlib.pyplot as plt
  3. plt.scatter(2, 4)
  4. plt.show()

下面来设置输出的样式，使其更有趣：添加标题，给轴加上标签，并确保所有文本都大到能够看清：

  1. import matplotlib.pyplot as plt
  3. plt.scatter(2, 4, s=200) ❶
  5. # 设置图表标题并给坐标轴加上标签
  6. plt.title("Square Numbers", fontsize=24)
  7. plt.xlabel("Value", fontsize=14)
  8. plt.ylabel("Square of Value", fontsize=14)
  10. # 设置刻度标记的大小
  11. plt.tick_params(axis='both', which='major', labelsize=14)
  13. plt.show()

在❶处，我们调用了scatter()，并使用实参s设置了绘制图形时使用的点的尺寸。如果此时运行scatter_squares.py，将在图表中央看到一个点，大致如图15-4所示。

{%}

图15-4　绘制单个点

15.2.4　使用scatter()绘制一系列点

要绘制一系列的点，可向scatter()传递两个分别包含x值和y值的列表，如下所示：

scatter_squares.py

  1. import matplotlib.pyplot as plt
  3. x_values = [1, 2, 3, 4, 5]
  4. y_values = [1, 4, 9, 16, 25]
  6. plt.scatter(x_values, y_values, s=100)
  8. # 设置图表标题并给坐标轴指定标签
  9. --snip--

列表x_values包含要计算其平方值的数字，而列表y_values包含前述每个数字的平方值。将这些列表传递给scatter()时，matplotlib依次从每个列表中读取一个值来绘制一个点。要绘制的点的坐标分别为 (1, 1)、(2, 4)、(3, 9)、(4, 16)和(5, 25)，最终的结果如图15-5所示。

{%}

图15-5　由多个点组成的散点图

15.2.5　自动计算数据

手工计算列表要包含的值可能效率低下，需要绘制的点很多时尤其如此。可以不必手工计算包含点坐标的列表，而让Python循环来替我们完成这种计算。下面是绘制1000个点的代码：

scatter_squares.py

  1. import matplotlib.pyplot as plt
  3. x_values = list(range(1, 1001)) ❶
  4. y_values = [x**2 for x in x_values]
  6. plt.scatter(x_values, y_values, s=40) ❷
  8. # 设置图表标题并给坐标轴加上标签
  9. --snip--
  11. # 设置每个坐标轴的取值范围
  12. plt.axis([0, 1100, 0, 1100000]) ❸
  14. plt.show()

我们首先创建了一个包含 x 值的列表，其中包含数字1~1000（见❶）。接下来是一个生成 y 值的列表解析，它遍历 x 值（for x in x_values），计算其平方值（x**2），并将结果存储到列表y_values中。然后，将输入列表和输出列表传递给scatter()（见❷）。

由于这个数据集较大，我们将点设置得较小，并使用函数axis()指定了每个坐标轴的取值范围（见❸）。函数axis()要求提供四个值：x 和 y 坐标轴的最小值和最大值。在这里，我们将 x 坐标轴的取值范围设置为0~1100，并将 y 坐标轴的取值范围设置为0~1 100 000。结果如图15-6所示。

{%}

图15-6　Python绘制1000个点与绘制5个点一样容易

15.2.6　删除数据点的轮廓

matplotlib允许你给散点图中的各个点指定颜色。默认为蓝色点和黑色轮廓，在散点图包含的数据点不多时效果很好。但绘制很多点时，黑色轮廓可能会粘连在一起。要删除数据点的轮廓，可在调用scatter()时传递实参edgecolor='none'1：

1在2.0.0版本的matplotlib中，scatter()函数的实参edgecolor默认为'none'。——译者注

  1. plt.scatter(x_values, y_values, edgecolor='none', s=40)

将相应调用修改为上述代码后，如果再运行scatter_squares.py，在图表中看到的将是蓝色实心点。

15.2.7　自定义颜色

要修改数据点的颜色，可向scatter()传递参数c，并将其设置为要使用的颜色的名称，如下所示：

  1. plt.scatter(x_values, y_values, c='red', edgecolor='none', s=40)

你还可以使用RGB颜色模式自定义颜色。要指定自定义颜色，可传递参数c，并将其设置为一个元组，其中包含三个0~1之间的小数值，它们分别表示红色、绿色和蓝色分量。例如，下面的代码行创建一个由淡蓝色点组成的散点图：

  1. plt.scatter(x_values, y_values, c=(0, 0, 0.8), edgecolor='none', s=40)

值越接近0，指定的颜色越深，值越接近1，指定的颜色越浅。

15.2.8　使用颜色映射

颜色映射（colormap）是一系列颜色，它们从起始颜色渐变到结束颜色。在可视化中，颜色映射用于突出数据的规律，例如，你可能用较浅的颜色来显示较小的值，并使用较深的颜色来显示较大的值。

模块pyplot内置了一组颜色映射。要使用这些颜色映射，你需要告诉pyplot该如何设置数据集中每个点的颜色。下面演示了如何根据每个点的 y 值来设置其颜色：

scatter_squares.py

  1. import matplotlib.pyplot as plt
  3. x_values = list(range(1, 1001))
  4. y_values = [x**2 for x in x_values]
  6. plt.scatter(x_values, y_values, c=y_values, cmap=plt.cm.Blues,
  7.     edgecolor='none', s=40)
  9. # 设置图表标题并给坐标轴加上标签
  10. --snip--

我们将参数c设置成了一个 y 值列表，并使用参数cmap告诉pyplot使用哪个颜色映射。这些代码将 y 值较小的点显示为浅蓝色，并将 y 值较大的点显示为深蓝色，生成的图形如图15-7所示。

{%}

图15-7　使用颜色映射Blues的图表

注意　要了解pyplot中所有的颜色映射，请访问http://matplotlib.org/，单击Examples，向下滚动到Color Examples，再单击colormaps_reference。

15.2.9　自动保存图表

要让程序自动将图表保存到文件中，可将对plt.show()的调用替换为对plt.savefig()的调用：

  1. plt.savefig('squares_plot.png', bbox_inches='tight')

第一个实参指定要以什么样的文件名保存图表，这个文件将存储到scatter_squares.py所在的目录中；第二个实参指定将图表多余的空白区域裁剪掉。如果要保留图表周围多余的空白区域，可省略这个实参。

动手试一试

15-1 立方：数字的三次方被称为其立方。请绘制一个图形，显示前5个整数的立方值，再绘制一个图形，显示前5000个整数的立方值。

15-2 彩色立方：给你前面绘制的立方图指定颜色映射。

15.3　随机漫步

在本节中，我们将使用Python来生成随机漫步数据，再使用matplotlib以引人瞩目的方式将这些数据呈现出来。随机漫步是这样行走得到的路径：每次行走都完全是随机的，没有明确的方向，结果是由一系列随机决策决定的。你可以这样认为，随机漫步就是蚂蚁在晕头转向的情况下，每次都沿随机的方向前行所经过的路径。

在自然界、物理学、生物学、化学和经济领域，随机漫步都有其实际用途。例如，漂浮在水滴上的花粉因不断受到水分子的挤压而在水面上移动。水滴中的分子运动是随机的，因此花粉在水面上的运动路径犹如随机漫步。我们稍后将编写的代码模拟了现实世界的很多情形。

15.3.1　创建RandomWalk()类

为模拟随机漫步，我们将创建一个名为RandomWalk的类，它随机地选择前进方向。这个类需要三个属性，其中一个是存储随机漫步次数的变量，其他两个是列表，分别存储随机漫步经过的每个点的 x 和 y 坐标。

RandomWalk类只包含两个方法：__init__()和fill_walk()，其中后者计算随机漫步经过的所有点。下面先来看看__init__()，如下所示：

random_walk.py

  1. from random import choice ❶
  3. class RandomWalk():
  4.     """一个生成随机漫步数据的类"""
  6.     def __init__(self, num_points=5000): ❷
  7.         """初始化随机漫步的属性"""
  8.         self.num_points = num_points
  10.         # 所有随机漫步都始于(0, 0)
  11.         self.x_values = [0] ❸
  12.         self.y_values = [0]

为做出随机决策，我们将所有可能的选择都存储在一个列表中，并在每次做决策时都使用choice()来决定使用哪种选择（见❶）。接下来，我们将随机漫步包含的默认点数设置为5000，这大到足以生成有趣的模式，同时又足够小，可确保能够快速地模拟随机漫步（见❷）。然后，在❸处，我们创建了两个用于存储x和y值的列表，并让每次漫步都从点(0, 0)出发。

15.3.2　选择方向

我们将使用fill_walk()来生成漫步包含的点，并决定每次漫步的方向，如下所示。请将这个方法添加到random_walk.py中：

random_walk.py

  1.     def fill_walk(self):
  2.           """计算随机漫步包含的所有点"""
  4.         # 不断漫步，直到列表达到指定的长度
  5.         while len(self.x_values) < self.num_points: ❶
  7.             # 决定前进方向以及沿这个方向前进的距离
  8.             x_direction = choice([1, -1]) ❷
  9.             x_distance = choice([0, 1, 2, 3, 4])
  10.             x_step = x_direction  x_distance ❸
  12.             y_direction = choice([1, -1])
  13.             y_distance = choice([0, 1, 2, 3, 4])
  14.             y_step = y_direction  y_distance ❹
  16.             # 拒绝原地踏步
  17.             if x_step == 0 and y_step == 0: ❺
  18.                 continue
  20.             # 计算下一个点的x和y值
  21.             next_x = self.x_values[-1] + x_step ❻
  22.             next_y = self.y_values[-1] + y_step
  24.             self.x_values.append(next_x)
  25.             self.y_values.append(next_y)

在❶处，我们建立了一个循环，这个循环不断运行，直到漫步包含所需数量的点。这个方法的主要部分告诉Python如何模拟四种漫步决定：向右走还是向左走？沿指定的方向走多远？向上走还是向下走？沿选定的方向走多远？

我们使用choice([1, -1])给x_direction选择一个值，结果要么是表示向右走的1，要么是表示向左走的-1（见❷）。接下来，choice([0, 1, 2, 3, 4])随机地选择一个0~4之间的整数，告诉Python 沿指定的方向走多远（x_distance）。（通过包含0，我们不仅能够沿两个轴移动，还能够沿y轴移动。）

在❸和❹处，我们将移动方向乘以移动距离，以确定沿 x 和 y 轴移动的距离。如果x_step为正，将向右移动，为负将向左移动，而为零将垂直移动；如果y_step为正，就意味着向上移动，为负意味着向下移动，而为零意味着水平移动。如果x_step和y_step都为零，则意味着原地踏步，我们拒绝这样的情况，接着执行下一次循环（见❺）。

为获取漫步中下一个点的 x 值，我们将x_step与x_values中的最后一个值相加（见❻），对于 y 值也做相同的处理。获得下一个点的 x 值和 y 值后，我们将它们分别附加到列表x_values和y_values的末尾。

15.3.3　绘制随机漫步图

下面的代码将随机漫步的所有点都绘制出来：

rw_visual.py

  1. import matplotlib.pyplot as plt
  3. from random_walk import RandomWalk
  5. # 创建一个RandomWalk实例，并将其包含的点都绘制出来
  6. rw = RandomWalk() ❶
  7. rw.fill_walk()
  8. plt.scatter(rw.x_values, rw.y_values, s=15) ❷
  9. plt.show()

我们首先导入了模块pyplot和RandomWalk类，然后创建了一个RandomWalk实例，并将其存储到rw中（见❶），再调用fill_walk()。在❷处，我们将随机漫步包含的 x 和 y 值传递给scatter()，并选择了合适的点尺寸。图15-8显示了包含5000个点的随机漫步图（本节的示意图未包含matplotlib查看器部分，但你运行rw_visual.py时，依然会看到）。

{%}

图15-8　包含5000个点的随机漫步

15.3.4　模拟多次随机漫步

每次随机漫步都不同，因此探索可能生成的各种模式很有趣。要在不多次运行程序的情况下使用前面的代码模拟多次随机漫步，一种办法是将这些代码放在一个while循环中，如下所示：

rw_visual.py

  1. import matplotlib.pyplot as plt
  3. from random_walk import RandomWalk
  5. # 只要程序处于活动状态，就不断地模拟随机漫步
  6. while True:
  7.     # 创建一个RandomWalk实例，并将其包含的点都绘制出来
  8.     rw = RandomWalk()
  9.     rw.fill_walk()
  10.     plt.scatter(rw.x_values, rw.y_values, s=15)
  11.     plt.show()
  13.     keep_running = input("Make another walk? (y/n): ") ❶
  14.     if keep_running == 'n':
  15.         break

这些代码模拟一次随机漫步，在matplotlib查看器中显示结果，再在不关闭查看器的情况下暂停。如果你关闭查看器，程序将询问你是否要再模拟一次随机漫步。如果你输入y，可模拟多次随机漫步：这些随机漫步都在起点附近进行，大多沿特定方向偏离起点，漫步点分布不均匀等。要结束程序，请输入n。

注意　如果你使用的是Python 2.7，别忘了将❶处的input()替换为raw_input()。

15.3.5　设置随机漫步图的样式

在本节中，我们将定制图表，以突出每次漫步的重要特征，并让分散注意力的元素不那么显眼。为此，我们确定要突出的元素，如漫步的起点、终点和经过的路径。接下来确定要使其不那么显眼的元素，如刻度标记和标签。最终的结果是简单的可视化表示，清楚地指出了每次漫步经过的路径。

15.3.6　给点着色

我们将使用颜色映射来指出漫步中各点的先后顺序，并删除每个点的黑色轮廓，让它们的颜色更明显。为根据漫步中各点的先后顺序进行着色，我们传递参数c，并将其设置为一个列表，其中包含各点的先后顺序。由于这些点是按顺序绘制的，因此给参数c指定的列表只需包含数字1~5000，如下所示：

rw_visual.py

  1. --snip--
  2. while True:
  3.     # 创建一个RandomWalk实例，并将其包含的点都绘制出来
  4.     rw = RandomWalk()
  5.     rw.fill_walk()
  7.     point_numbers = list(range(rw.num_points)) ❶
  8.     plt.scatter(rw.x_values, rw.y_values, c=point_numbers, cmap=plt.cm.Blues,
  9.         edgecolor='none', s=15)
  10.     plt.show()
  12.     keep_running = input("Make another walk? (y/n): ")
  13.     --snip--

在❶处，我们使用了range()生成了一个数字列表，其中包含的数字个数与漫步包含的点数相同。接下来，我们将这个列表存储在point_numbers中，以便后面使用它来设置每个漫步点的颜色。我们将参数c设置为point_numbers，指定使用颜色映射Blues，并传递实参edgecolor=none以删除每个点周围的轮廓。最终的随机漫步图从浅蓝色渐变为深蓝色，如图15-9所示。

{%}

图15-9　使用颜色映射Blues着色的随机漫步图

15.3.7　重新绘制起点和终点

除了给随机漫步的各个点着色，以指出它们的先后顺序外，如果还能呈现随机漫步的起点和终点就更好了。为此，可在绘制随机漫步图后重新绘制起点和终点。我们让起点和终点变得更大，并显示为不同的颜色，以突出它们，如下所示：

rw_visual.py

  1. --snip--
  2. while True:
  3.     --snip--
  4.     plt.scatter(rw.x_values, rw.y_values, c=point_numbers, cmap=plt.cm.Blues,
  5.         edgecolor='none', s=15)
  7.     # 突出起点和终点
  8.     plt.scatter(0, 0, c='green', edgecolors='none', s=100)
  9.     plt.scatter(rw.x_values[-1], rw.y_values[-1], c='red', edgecolors='none',
  10.         s=100)
  12.     plt.show()
  13.     --snip--

为突出起点，我们使用绿色绘制点(0, 0)，并使其比其他点大（s=100）。为突出终点，我们在漫步包含的最后一个 x 和 y 值处绘制一个点，将其颜色设置为红色，并将尺寸设置为100。请务必将这些代码放在调用plt.show()的代码前面，确保在其他点的上面绘制起点和终点。

如果你现在运行这些代码，将能准确地知道每次随机漫步的起点和终点（如果起点和终点不明显，请调整它们的颜色和大小，直到明显为止）。

15.3.8　隐藏坐标轴

下面来隐藏这个图表中的坐标轴，以免我们注意的是坐标轴而不是随机漫步路径。要隐藏坐标轴，可使用如下代码：

rw_visual.py

  1. --snip--
  2. while True:
  3.     --snip--
  4.     plt.scatter(rw.x_values[-1], rw.y_values[-1], c='red', edgecolors='none',
  5.         s=100)
  7.     # 隐藏坐标轴
  8.     plt.axes().get_xaxis().set_visible(False) ❶
  9.     plt.axes().get_yaxis().set_visible(False)
  11.     plt.show()
  12.     --snip--

为修改坐标轴，使用了函数plt.axes()（见❶）来将每条坐标轴的可见性都设置为False。随着你越来越多地进行数据可视化，经常会看到这种串接方法的方式。

如果你现在运行rw_visual.py，将看到一系列图形，但看不到坐标轴。

15.3.9　增加点数

下面来增加点数，以提供更多的数据。为此，我们在创建RandomWalk实例时增大num_points的值，并在绘图时调整每个点的大小，如下所示：

rw_visual.py

  1. --snip--
  2. while True:
  3.     #创建一个RandomWalk实例，并将其包含的点都绘制出来
  4.     rw = RandomWalk(50000)
  5.     rw.fill_walk()
  7.     # 绘制点并将图形显示出来
  8.     point_numbers = list(range(rw.num_points))
  9.     plt.scatter(rw.x_values, rw.y_values, c=point_numbers, cmap=plt.cm.Blues,
  10.         edgecolor='none', s=1)
  11.     --snip--

这个示例模拟了一次包含50 000个点的随机漫步（以模拟现实情况），并将每个点的大小都设置为1。最终的随机漫步图更纤细，犹如云朵，如图15-10所示。正如你看到的，我们使用简单的散点图制作出了一件艺术品！

请尝试修改上述代码，看看将漫步包含的点数增加到多少后，程序的运行速度变得极其缓慢或绘制出的图形变得很难看。

{%}

图15-10　包含50 000个点的随机漫步

15.3.10　调整尺寸以适合屏幕

图表适合屏幕大小时，更能有效地将数据中的规律呈现出来。为让绘图窗口更适合屏幕大小，可像下面这样调整matplotlib输出的尺寸：

rw_visual.py

  1. --snip--
  2. while True:
  3.     # 创建一个RandomWalk实例，并将其包含的点都绘制出来
  4.     rw = RandomWalk()
  5.     rw.fill_walk()
  7.     # 设置绘图窗口的尺寸
  8.     plt.figure(figsize=(10, 6))
  9.     --snip--

函数figure()用于指定图表的宽度、高度、分辨率和背景色。你需要给形参figsize指定一个元组，向matplotlib指出绘图窗口的尺寸，单位为英寸。

Python假定屏幕分辨率为80像素/英寸，如果上述代码指定的图表尺寸不合适，可根据需要调整其中的数字。如果你知道自己的系统的分辨率，可使用形参dpi向figure()传递该分辨率，以有效地利用可用的屏幕空间，如下所示：

  1. plt.figure(dpi=128, figsize=(10, 6))

动手试一试

15-3 分子运动：修改rw_visual.py，将其中的plt.scatter()替换为plt.plot()。为模拟花粉在水滴表面的运动路径，向plt.plot()传递rw.x_values和rw.y_values，并指定实参值linewidth。使用5000个点而不是50 000个点。

15-4 改进的随机漫步：在类RandomWalk中，x_step和y_step是根据相同的条件生成的：从列表[1, -1]中随机地选择方向，并从列表[0, 1, 2, 3, 4]中随机地选择距离。请修改这些列表中的值，看看对随机漫步路径有何影响。尝试使用更长的距离选择列表，如0~8；或者将-1从 x 或 y 方向列表中删除。

15-5 重构：方法fill_walk()很长。请新建一个名为get_step()的方法，用于确定每次漫步的距离和方向，并计算这次漫步将如何移动。然后，在fill_walk()中调用get_step()两次：

  1. x_step = self.get_step()
  2. y_step = self.get_step()

通过这样的重构，可缩小fill_walk()的规模，让这个方法阅读和理解起来更容易。

15.4　使用Pygal模拟掷骰子

在本节中，我们将使用Python可视化包Pygal来生成可缩放的矢量图形文件。对于需要在尺寸不同的屏幕上显示的图表，这很有用，因为它们将自动缩放，以适合观看者的屏幕。如果你打算以在线方式使用图表，请考虑使用Pygal来生成它们，这样它们在任何设备上显示时都会很美观。

在这个项目中，我们将对掷骰子的结果进行分析。掷6面的常规骰子时，可能出现的结果为1~6点，且出现每种结果的可能性相同。然而，如果同时掷两个骰子，某些点数出现的可能性将比其他点数大。为确定哪些点数出现的可能性最大，我们将生成一个表示掷骰子结果的数据集，并根据结果绘制出一个图形。

在数学领域，常常利用掷骰子来解释各种数据分析，但它在赌场和其他博弈场景中也得到了实际应用，在游戏《大富翁》以及众多角色扮演游戏中亦如此。

15.4.1　安装Pygal

请使用pip来安装Pygal（如果还未使用过pip，请参阅12.2.1节）。

在Linux和OS X系统中，应执行的命令类似于下面这样：

  1. pip install --user pygal==1.7

在Windows系统中，命令类似于下面这样：

  1. python -m pip install --user pygal==1.7

注意　你可能需要使用命令pip3而不是pip，如果这还是不管用，你可能需要删除标志--user。

15.4.2　Pygal画廊

要了解使用Pygal可创建什么样的图表，请查看图表类型画廊：访问http://www.pygal.org/，单击Documentation，再单击Chart types。每个示例都包含源代码，让你知道这些图表是如何生成的。

15.4.3　创建Die类

下面的类模拟掷一个骰子：

die.py

  1. from random import randint
  3. class Die():
  4.     """表示一个骰子的类"""
  6.     def __init__(self, num_sides=6): ❶
  7.         """骰子默认为6面"""
  8.         self.num_sides = num_sides
  10.     def roll(self):
  11.         """"返回一个位于1和骰子面数之间的随机值"""
  12.         return randint(1, self.num_sides) ❷

方法__init__()接受一个可选参数。创建这个类的实例时，如果没有指定任何实参，面数默认为6；如果指定了实参，这个值将用于设置骰子的面数（见❶）。骰子是根据面数命名的，6面的骰子名为D6，8面的骰子名为D8，以此类推。

方法roll()使用函数randint()来返回一个1和面数之间的随机数（见❷）。这个函数可能返回起始值1、终止值num_sides或这两个值之间的任何整数。

15.4.4　掷骰子

使用这个类来创建图表前，先来掷D6骰子，将结果打印出来，并检查结果是否合理：

die_visual.py

  1. from die import Die
  3. # 创建一个D6
  4. die = Die() ❶
  6. # 掷几次骰子，并将结果存储在一个列表中
  7. results = []
  8. for roll_num in range(100): ❷
  9.     result = die.roll()
  10.     results.append(result)
  12. print(results)

在❶处，我们创建了一个Die实例，其面数为默认值6。在❷处，我们掷骰子100次，并将每次的结果都存储在列表results中。下面是一个示例结果集：

  1. [4, 6, 5, 6, 1, 5, 6, 3, 5, 3, 5, 3, 2, 2, 1, 3, 1, 5, 3, 6, 3, 6, 5, 4,
  2.  1, 1, 4, 2, 3, 6, 4, 2, 6, 4, 1, 3, 2, 5, 6, 3, 6, 2, 1, 1, 3, 4, 1, 4,
  3.  3, 5, 1, 4, 5, 5, 2, 3, 3, 1, 2, 3, 5, 6, 2, 5, 6, 1, 3, 2, 1, 1, 1, 6,
  4.  5, 5, 2, 2, 6, 4, 1, 4, 5, 1, 1, 1, 4, 5, 3, 3, 1, 3, 5, 4, 5, 6, 5, 4,
  5.  1, 5, 1, 2]

通过快速扫描这些结果可知，Die类看起来没有问题。我们见到了值1和6，这表明返回了最大和最小的可能值；我们没有见到0或7，这表明结果都在正确的范围内。我们还看到了1~6的所有数字，这表明所有可能的结果都出现了。

15.4.5　分析结果

为分析掷一个D6骰子的结果，我们计算每个点数出现的次数：

die_visual.py

  1. --snip--
  2. # 掷几次骰子，并将结果存储在一个列表中
  3. results = []
  4. for roll_num in range(1000): ❶
  5.     result = die.roll()
  6.     results.append(result)
  8. # 分析结果
  9. frequencies = []
  10. for value in range(1, die.num_sides+1): ❷
  11.     frequency = results.count(value) ❸
  12.     frequencies.append(frequency) ❹
  14. print(frequencies)

由于我们将使用Pygal来进行分析，而不是将结果打印出来，因此可以将模拟掷骰子的次数增加到1000（见❶）。为分析结果，我们创建了空列表frequencies，用于存储每种点数出现的次数。在❷处，我们遍历可能的点数（这里为1~6），计算每种点数在results中出现了多少次（见❸），并将这个值附加到列表frequencies的末尾（见❹）。接下来，我们在可视化之前将这个列表打印出来：

  1. [155, 167, 168, 170, 159, 181]

结果看起来是合理的：我们看到了6个值——掷D6骰子时可能出现的每个点数对应一个；我们还发现，没有任何点数出现的频率比其他点数高很多。下面来可视化这些结果。

15.4.6　绘制直方图

有了频率列表后，我们就可以绘制一个表示结果的直方图。直方图是一种条形图，指出了各种结果出现的频率。创建这种直方图的代码如下：

die_visual.py

  1. import pygal
  2. --snip--
  4. # 分析结果
  5. frequencies = []
  6. for value in range(1, die.num_sides+1):
  7.     frequency = results.count(value)
  8.     frequencies.append(frequency)
  10. # 对结果进行可视化
  11. hist = pygal.Bar() ❶
  13. hist.title = "Results of rolling one D6 1000 times."
  14. hist.x_labels = ['1', '2', '3', '4', '5', '6'] ❷
  15. hist.x_title = "Result"
  16. hist.y_title = "Frequency of Result"
  18. hist.add('D6', frequencies) ❸
  19. hist.render_to_file('die_visual.svg')

为创建条形图，我们创建了一个pygal.Bar()实例，并将其存储在hist中（见❶）。接下来，我们设置hist的属性title（用于标示直方图的字符串），将掷D6骰子的可能结果用作 x 轴的标签（见❷），并给每个轴都添加了标题。在❸处，我们使用add()将一系列值添加到图表中（向它传递要给添加的值指定的标签，还有一个列表，其中包含将出现在图表中的值）。最后，我们将这个图表渲染为一个SVG文件，这种文件的扩展名必须为.svg。

要查看生成的直方图，最简单的方式是使用Web浏览器。为此，在任何Web浏览器中新建一个标签页，再在其中打开文件die_visual.svg（它位于die_visual.py所在的文件夹中）。你将看到一个类似于图15-11所示的图表（为方便印刷，我稍微修改了这个图表；默认情况下，Pygal生成的图表的背景比你在图15-11中看到的要暗）。

{%}

图15-11　使用Pygal创建的简单条形图

注意，Pygal让这个图表具有交互性：如果你将鼠标指向该图表中的任何条形，将看到与之相关联的数据。在同一个图表中绘制多个数据集时，这项功能显得特别有用。

15.4.7　同时掷两个骰子

同时掷两个骰子时，得到的点数更多，结果分布情况也不同。下面来修改前面的代码，创建两个D6骰子，以模拟同时掷两个骰子的情况。每次掷两个骰子时，我们都将两个骰子的点数相加，并将结果存储在results中。请复制die_visual.py并将其保存为dice_visual.py，再做如下修改：

dice_visual.py

  1. import pygal
  3. from die import Die
  5. # 创建两个D6骰子
  6. die_1 = Die()
  7. die_2 = Die()
  9. # 掷骰子多次，并将结果存储到一个列表中
  10. results = []
  11. for roll_num in range(1000):
  12.     result = die_1.roll() + die_2.roll() ❶
  13.     results.append(result)
  15. # 分析结果
  16. frequencies = []
  17. max_result = die_1.num_sides + die_2.num_sides ❷
  18. for value in range(2, max_result+1): ❸
  19.     frequency = results.count(value)
  20.     frequencies.append(frequency)
  22. # 可视化结果
  23. hist = pygal.Bar()
  25. hist.title = "Results of rolling two D6 dice 1000 times." ❹
  26. hist.x_labels = ['2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12']
  27. hist.x_title = "Result"
  28. hist.y_title = "Frequency of Result"
  30. hist.add('D6 + D6', frequencies)
  31. hist.render_to_file('dice_visual.svg')

创建两个Die实例后，我们掷骰子多次，并计算每次的总点数（见❶）。可能出现的最大点数12为两个骰子的最大可能点数之和，我们将这个值存储在了max_result中（见❷）。可能出现的最小总点数2为两个骰子的最小可能点数之和。分析结果时，我们计算2到max_result的各种点数出现的次数（见❸）。我们原本可以使用range(2, 13)，但这只适用于两个D6骰子。模拟现实世界的情形时，最好编写可轻松地模拟各种情形的代码。前面的代码让我们能够模拟掷任何两个骰子的情形，而不管这些骰子有多少面。

创建图表时，我们修改了标题、x 轴标签和数据系列（见❹）。（如果列表x_labels比这里所示的长得多，那么编写一个循环来自动生成它将更合适。）

运行这些代码后，在浏览器中刷新显示图表的标签页，你将看到如图15-12所示的图表。

{%}

图15-12　模拟同时掷两个6面骰子1000次的结果

这个图表显示了掷两个D6骰子时得到的大致结果。正如你看到的，总点数为2或12的可能性最小，而总点数为7的可能性最大，这是因为在6种情况下得到的总点数都为7。这6种情况如下：1和6、2和5、3和4、4和3、5和2、6和1。

15.4.8　同时掷两个面数不同的骰子

下面来创建一个6面骰子和一个10面骰子，看看同时掷这两个骰子50 000次的结果如何：

different_dice.py

  1. from die import Die
  3. import pygal
  5. # 创建一个D6和一个D10
  6. die_1 = Die()
  7. die_2 = Die(10) ❶
  9. # 掷骰子多次，并将结果存储在一个列表中
  10. results = []
  11. for roll_num in range(50000):
  12.     result = die_1.roll() + die_2.roll()
  13.     results.append(result)
  15. # 分析结果
  16. --snip--
  18. # 可视化结果
  19. hist = pygal.Bar()
  21. hist.title = "Results of rolling a D6 and a D10 50,000 times." ❷
  22. hist.x_labels = ['2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12',
  23.     '13', '14', '15', '16']
  24. hist.x_title = "Result"
  25. hist.y_title = "Frequency of Result"
  27. hist.add('D6 + D10', frequencies)
  28. hist.render_to_file('dice_visual.svg')

为创建D10骰子，我们在创建第二个Die实例时传递了实参10（见❶）。我们还修改了第一个循环，以模拟掷骰子50 000次而不是1000次。可能出现的最小总点数依然是2，但现在可能出现的最大总点数为16，因此我们相应地调整了标题、x轴标签和数据系列标签（见❷）。

图15-13显示了最终的图表。可能性最大的点数不是一个，而是5个，这是因为导致出现最小点数和最大点数的组合都只有一种（1和1以及6和10），但面数较小的骰子限制了得到中间点数的组合数：得到总点数7、8、9、10和11的组合数都是6种。因此，这些总点数是最常见的结果，它们出现的可能性相同。

{%}

图15-13　同时掷6面骰子和10面骰子50 000次的结果

通过使用Pygal来模拟掷骰子的结果，能够非常自由地探索这种现象。只需几分钟，就可以掷各种骰子很多次。

动手试一试

15-6 自动生成标签：请修改die.py和dice_visual.py，将用来设置hist.x_labels值的列表替换为一个自动生成这种列表的循环。如果你熟悉列表解析，可尝试将die_visual.py和dice_visual.py中的其他for循环也替换为列表解析。

15-7 两个D8骰子：请模拟同时掷两个8面骰子1000次的结果。逐渐增加掷骰子的次数，直到系统不堪重负为止。

15-8 同时掷三个骰子：如果你同时掷三个D6骰子，可能得到的最小点数为3，而最大点数为18。请通过可视化展示同时掷三个D6骰子的结果。

15-9 将点数相乘：同时掷两个骰子时，通常将它们的点数相加。请通过可视化展示将两个骰子的点数相乘的结果。

15-10 练习使用本章介绍的两个库：尝试使用matplotlib通过可视化来模拟掷骰子的情况，并尝试使用Pygal通过可视化来模拟随机漫步的情况。

15.5　小结

在本章中，你学习了：如何生成数据集以及如何对其进行可视化；如何使用matplotlib创建简单的图表，以及如何使用散点图来探索随机漫步过程；如何使用Pygal来创建直方图，以及如何使用直方图来探索同时掷两个面数不同的骰子的结果。

使用代码生成数据集是一种有趣而强大的方式，可用于模拟和探索现实世界的各种情形。完成后面的数据可视化项目时，请注意可使用代码模拟哪些情形。请研究新闻媒体中的可视化，看看其中是否有图表是以你在这些项目中学到的类似方式生成的。

在第16章中，我们将从网上下载数据，并继续使用matplotlib和Pygal来探索这些数据。