精通Python自动化脚本-运维人员宝典完整目录：
第一章 Python脚本概述
第二章 Python脚本调试和性能测试
第三章 单元测试-单元测试框架的介绍
第四章 自动化常规运维活动
第五章 文件、目录和数据处理
第六章 文件存档、加密和解密
第七章 文本处理和正则表达式
第八章 文档和报告
第九章 操作各类文件
第十章 网络基础 – Socket编程
第十一章 使用Python脚本处理邮件
第十二章 使用Telnet和SSH远程监控主机
第十三章 创建图形化用户界面
第十四章 处理Apache和其它的日志文件
第十五章 SOAP和REST API通讯
第十六章 网络抓取 – 从网站上提取有用的信息
第十七章 数据收集及报表
第十八章 MySQL和SQLite数据库管理
本章中我们将学习科学计算中统计所使用的高级Python库。我们会学习Python的NumPy, Pandas, Matplotlib和Plotly模块。我们将学习到数据可视化的技术以及如何对收集的数据绘图。
本章中主要学习如下课题：
- NumPy模块
- Pandas模块
- 数据可视化
NumPy模块
NumPY是一个可对数组进行有效运算的Python模块。NumPy是一个Python科学计算的基础包。这个包常被用作Python的数据分析。NumPy数组是一个多值网格。
在Terminal中使用如下命令安装NumPy：
|
1 |
$ pip3 install numpy |
我们将使用numpy库来对numpy数组执行运算。下面我们来看如何创建一个numpy数组。为此创建一个脚本simple_array.py并在其中编写如下内容：
|
1 2 3 4 5 6 |
import numpy as np my_list1 = [1,2,3,4] my_array1 = np.array(my_list1) print(my_list1, type(my_list1)) print(my_array1, type(my_array1)) |
运行脚本，我们将得到如下输出：
|
1 2 3 |
3 simple_array.py [1, 2, 3, 4] <class 'list'> [1 2 3 4] <class 'numpy.ndarray'> |
上例中，我们以np导入了numpy库来使用numpy的功能。然后我们创建了一个简单的列表，将其使用np.array()函数将其转化为数组。最后，我们打印了numpy数组及其类型，来学习常规的数组和numpy数组之间的不同。
上例是一个简单的一维数组。下面我们来看一个多维数组的示例。为此我们需要创建另一个列表，让我们一起来看另一个示例吧。创建一个名为mult_dim_array.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 |
import numpy as np my_list1 = [1,2,3,4] my_list2 = [11,22,33,44] my_lists = [my_list1, my_list2] my_array = np.array(my_lists) print(my_lists, type(my_lists)) print(my_array, type(my_array)) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 |
$ python3 mult_dim_array.py [[1, 2, 3, 4], [11, 22, 33, 44]] <class 'list'> [[ 1 2 3 4] [11 22 33 44]] <class 'numpy.ndarray'> |
上例中我们导入了numpy模块。然后我们创建了两个列表：my_list1和my_list2。接着我们创建了另一个列表（my_list1和my_list2）的列表，并在该列表（my_lists）上应用了np.array()函数，将其存储在一个名为my_array的对象中。最后我们打印出了这个numpy数组。
下面我来看可作用于数组的更多操作。我们将学习如何在知道数组的大小以及我们所创建的数组的数据类型，这里我们使用created array。为此我们仅需应用shape()函数并来获取数组的大小，以及使用dtype() 函数来了解所创建数组的数据类型。下面就来看一个示例。创建一个名为size_and_dtype.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import numpy as np my_list1 = [1,2,3,4] my_list2 = [11,22,33,44] my_lists = [my_list1, my_list2] my_array = np.array(my_lists) print(my_array) size = my_array.shape print(size) data_type = my_array.dtype print(data_type) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 5 |
$ python3 size_and_dtype.py [[ 1 2 3 4] [11 22 33 44]] (2, 4) int64 |
上例中，我们以my_array.shape对数组应用了shape函数来获取数据的大小。输出结果为(2, 4)。然后我们以my_array.dtype对数组应用了dtype函数，得到的输出为int64。
下面我们来看一些特殊数组的示例。
首先，我们会使用np.zeros() 创建一个所值为0的数组，如下所示：
|
1 2 3 4 5 6 7 8 |
$ python3 Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24) [Clang 6.0 (clang-600.0.57)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import numpy as np >>> np.zeros(5) array([0., 0., 0., 0., 0.]) >>> |
在创建所有值为0的数据之后，我们将使用numpy的 np.ones()函数来创建所有值为1的数组，如下所示：
|
1 2 3 4 5 6 7 |
>>> np.ones((5,5)) array([[1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]]) >>> |
np.ones((5,5)) 创建一个 5*5的数组，其中的值均为1。
下面，我们将使用numpy的np.empty()函数创建一个空数组，如下所示：
|
1 2 3 4 |
>>> np.empty([2,2]) array([[1.13224202e+277, 1.03103236e-259], [0.00000000e+000, 2.78134232e-309]]) >>> |
np.empty()并不会像np.zeros()函数那样将数组中的值设为0。因此，速度可能会更快。此外，它要求用户手动在数组中输入所有值，所以使用时要格外小心。
下面我们来看如何使用np.eye() 函数来创建单位数组（identity array），它将生成主对角线的值全为1的数组，如下所示：
|
1 2 3 4 5 6 7 |
>>> np.eye(5) array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]]) >>> |
下面我们来看range函数，用于使用numpy中的np.arange()来创建数组，如下所示：
|
1 2 |
>>> np.arange(10) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) |
np.arange(10)函数创建一个0-9的数组。我们定义了范围10，，因此数组的索引值以0开始。
使用数组和标量
这一部分中，我们来看使用NumPy对数组进行不同的算术运算。首先要创建一个多维数组，如下：
|
1 2 3 4 5 6 7 8 9 10 11 |
$ python3 Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24) [Clang 6.0 (clang-600.0.57)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import numpy as np >>> from __future__ import division >>> arr = np.array([[4,5,6],[7,8,9]]) >>> arr array([[4, 5, 6], [7, 8, 9]]) >>> |
这里我们导入了numpy模块来使用numpy的功能，接着我们导入了__future__模块来处理浮点数。然后我们创建了一个二维数组，来对其执行不同的操作。
下面我们来看数组上的一些算术运算。首先，我们将学习数组的乘法，如下所示：
|
1 2 3 4 |
>>> arr * arr array([[16, 25, 36], [49, 64, 81]]) >>> |
以上的乘法运算中，我们对arr数组自身进行了相乘来获取到一个相乘后的数组。我们也可以对两个不同的数组进行相乘。
下面我们来看数组的减法运算，如下所示：
|
1 2 3 4 |
>>> arr - arr array([[0, 0, 0], [0, 0, 0]]) >>> |
如前例所示，我们仅仅使用了一个 – 运算符来进行两个数组的减法。在数组相减之后，我们获得了结果数组，如以上代码所示。
下面我们来看含有标量数组的算术运算。我们来看一些示例：
|
1 2 3 4 |
>>> 1 / arr array([[0.25 , 0.2 , 0.16666667], [0.14285714, 0.125 , 0.11111111]]) >>> |
上例中，我们使用1除以了我们的数组并得到了输出。记住，我们导入了__future__ 模块，有助于这类运算，来处理数组中的浮点值。
下面我们来看numpy数组的指数运算，如下所示：
|
1 2 3 4 |
>>> arr ** 3 array([[ 64, 125, 216], [343, 512, 729]]) >>> |
上例中，我们对数组进行了立方运算，得到了一个数组中各项值立方的输出。
数组索引
数组的索引是通过将数组作为索引来实现的。对于索引数组，原数组的拷贝会被返回。numpy数组可使用除元组外的其它序列或通过使用其它数组来索引。数组的最后一个元素可使用-1作为索引，倒数第二的索引可使用-1，以此类推。
因此，要在数组上执行索引运算，首先我们创建一个numpy数组，我们将使用range()函数来创建一个数组，如下所示：
|
1 2 3 4 5 6 7 8 9 |
$ python3 Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24) [Clang 6.0 (clang-600.0.57)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import numpy as np >>> arr = np.arange(0,16) >>> arr array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) >>> |
上例中，我们创建了一个范围为16的数组arr，即0-15。
下面我们将对数组arr执行一个不同的索引运算。首先，我们来获取数组中指定索引的值：
|
1 2 3 |
>>> arr[7] 7 >>> |
上例中，我们通过索引值访问了数组，在向数组arr传递了索引值之后，索引返回了值7，这也正是我们所传入的具体索引数。
在获取具体索引的值之后，我们将获取一个范围内的值。我们来看如下示例：
|
1 2 3 4 5 |
>>> arr[2:10] array([2, 3, 4, 5, 6, 7, 8, 9]) >>> arr[2:10:2] array([2, 4, 6, 8]) >>> |
上例中，首先我们访问了数组并获取一个范围内的值(2-10)。结果以array([2, 3, 4, 5, 6, 7, 8, 9])显示了输出。第二个例子中的arr[2:10:2]，实际上是说以步长间隔2访问范围在2-10的数组。这类索引的语法为arr[_start_value_:_stop_value_:_steps_]。因此，第二条命令的输出结果为array([2, 4, 6, 8])。
我们还可以获取一个数组中从指定索引直到结尾的值，如下例所示：
|
1 2 3 |
>>> arr[5:] array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) >>> |
如我们在上例中所见，我们访问了数组中从第5个开始直到结果的值。结果得到了输出array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])。
下面我们来看看numpy数组的切片。在切片中，实际上我们获取了原数组的某一部分并将其存储在指定的数组名中。一起来看一个示例：
|
1 2 3 4 |
>>> arr_slice = arr[0:8] >>> arr_slice array([0, 1, 2, 3, 4, 5, 6, 7]) >>> |
上例中，我们获取了原数组的一个切片。结果我们获取了数组的一个切片，值为0,1,2,…..,7。我们还要将更新付下赋给数组的切片。我们来看一个示例：
|
1 2 3 4 |
>>> arr_slice[:] = 29 >>> arr_slice array([29, 29, 29, 29, 29, 29, 29, 29]) >>> |
上例中，我们设置了数组切片中的所有值为29。但对数组切片赋值的一个重点是赋给切版的值同样会被赋给原数组。
下面我们来看在向数组切片赋值后原数组的效果：
|
1 2 3 |
>>> arr array([29, 29, 29, 29, 29, 29, 29, 29, 8, 9, 10, 11, 12, 13, 14, 15]) >>> |
下面我们来看另一个运算：即数组的复制。数组的切片和拷贝的区别在于在进行数组的切片时，所做的修改会应用到原数组上。在获取数组的拷贝时，则给出一个原数组的明确的拷贝。因此，对数组拷贝所应用的改变不会影响到原数组。让我们来看一个复制数组的示例：
|
1 2 3 4 |
>>> cpying_arr = arr.copy() >>> cpying_arr array([29, 29, 29, 29, 29, 29, 29, 29, 8, 9, 10, 11, 12, 13, 14, 15]) >>> |
上例中，我们仅仅接收了一个原数组的拷贝。使用array_name.copy()来实现拷贝，输出为原数组的一个拷贝。
二维数组的索引
二维数组是一个数组的数组。这一数组中的数据元素的位置通常引用两个索引值而非单个，分别表示数据表格的行和列。下面我们将做该类型数组的索引。
下面我们来看一个二维数组的示例：
|
1 2 3 4 5 6 |
>>> td_array = np.array(([5,6,7],[8,9,10],[11,12,13])) >>> td_array array([[ 5, 6, 7], [ 8, 9, 10], [11, 12, 13]]) >>> |
上例中，我们创建了一个名为td_array的二维数组。在创建数组后，我们打印出了数组。下面我们还将通过索引获取td_array中的值。一起来看通过索引获取值的示例：
|
1 2 3 |
>>> td_array[1] array([ 8, 9, 10]) >>> |
上例中，我们访问了数组中索引为1的值并获取了输出。在这类索引中，访问值时我们获取到了整个数组。除了获取整个数组外，我们还可获取指定值。来看一个示例：
|
1 2 3 |
>>> td_array[1,0] 8 >>> |
上例中，我们通过传入两个值行和列访问了td_array。正如在输出中所见，我们获得的值为8。
我们还可以另一种方式创建二维数组。首先，设置一个长度更大的二维数组。这里我们设置为10。那么我们创建一个值全部为0的示例数组，然后在其中填入值。示例如下：
|
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 |
>>> td_array = np.zeros((10, 10)) >>> td_array array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]) >>> for i in range(10): ... td_array[i] = i ... >>> td_array array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], [2., 2., 2., 2., 2., 2., 2., 2., 2., 2.], [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.], [4., 4., 4., 4., 4., 4., 4., 4., 4., 4.], [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.], [6., 6., 6., 6., 6., 6., 6., 6., 6., 6.], [7., 7., 7., 7., 7., 7., 7., 7., 7., 7.], [8., 8., 8., 8., 8., 8., 8., 8., 8., 8.], [9., 9., 9., 9., 9., 9., 9., 9., 9., 9.]]) >>> |
上例中，我们创建了一个10*10的二维数组。
下面我人们再对其做一些特别的索引，如下例所示：
|
1 2 3 4 5 6 |
>>> td_array[[1,3,5,7]] array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], [3., 3., 3., 3., 3., 3., 3., 3., 3., 3.], [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.], [7., 7., 7., 7., 7., 7., 7., 7., 7., 7.]]) >>> |
上例中，我们获取了指定的索引值，因此得到以上输出。
通用数组函数
能用函数对numpy数组中的每一个元素执行操作。下面我们来看一个在数组上执行多个通用函数的示例。首先，我们获取数组的平方根。创建一个名为sqrt_array.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 |
import numpy as np array = np.arange(16) print("The Array is : ", array) Square_root = np.sqrt(array) print("Square root of given array is : ", Square_root) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 5 |
$ python3 sqrt_array.py The Array is : [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15] Square root of given array is : [0. 1. 1.41421356 1.73205081 2. 2.23606798 2.44948974 2.64575131 2.82842712 3. 3.16227766 3.31662479 3.46410162 3.60555128 3.74165739 3.87298335] |
上例中，我们使用numpy的一个函数range创建了一个简单的数组。然后我们对所生成的数组应用于sqrt()函数，来获取数组的平方根。在获取数组的平方根之后，我们将对数组应另一个能用方法，即指数函数exp()。我来看一个示例。创建一个名为expo_array.py的脚本并编写如下内容：
|
1 2 3 4 5 6 |
import numpy as np array = np.arange(16) print("The array is : ", array) exp = np.exp(array) print("Exponential of give array is : ", exp) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 5 6 |
$ python3 expo_array.py The array is : [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15] Exponential of give array is : [1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03 2.20264658e+04 5.98741417e+04 1.62754791e+05 4.42413392e+05 1.20260428e+06 3.26901737e+06] |
上例中，我们使用numpy的range函数创建了一个简单的数组。然后对所生成的数组应用了exp()函数来获取数组的指数（以 e为底的自然指数）。
Pandas模块
这一部分中，我们将学习pandas模块。pandas模块提供了快速灵活的数组结构，设计用于处理结构化和时间序列数据。pandas模块用于数据分摊。pandas建立在NumPy 和Matplotlib等包的基础上，让我们可以进行大部的分析和可视化。要使用这一模块，首先需要进行导入。
首先通过运行如下命令来安装示例中所需的包：
|
1 2 |
$ pip3 install pandas $ pip3 install matplotlib |
这里，我们将来看一些使用pandas模块的示例。我们会学习两具数据 结构：序列（Series）和数据帧（DataFrames）。我们还将看看如何使用pandas从csv文件中读取数据。
序列
pandas序列是一个一维数组。其中可包含任意数据类型。它的标签被称为索引。下面我们来看一个不声明索引的序列和一个声明了索引的序列。首先，我们来看一个未声明索引的序列。创建一个名为series_without_index.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 |
import pandas as pd import numpy as np s_data = pd.Series([10,20,30,40], name = 'numbers') print(s_data) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 5 6 |
$ python3 series_without_index.py 0 10 1 20 2 30 3 40 Name: numbers, dtype: int64 |
上例中，我们学习未声明索引的序列。首先我们导入了两个模块：pandas和numpy。然后我创建了存储序列数据的对象s_data。在这个序列中，我们创建一个列表而没有声明索引，传入了name属性来为列表赋予一个名称，然后我们打印出了数据。在输出中，左列是数据的索引。即便我们没有传入索引，pandas还是会暗自赋予一个索引。这个索引从0开始。在数据列的下面是序列的名称以及值的数据类型。
下面，我们来看一个声明了索引的序列示例。这里我们还将执行索引和切片操作。为此创建一个名为series_with_index.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 |
import pandas as pd import numpy as np s_data = pd.Series([10, 20, 30, 40], index = ['a', 'b', 'c', 'd'], name = 'numbers') print(s_data) print() print('The data at index 2 is: ', s_data[2]) print('The data from range 1 to 3 are:\n', s_data[1:3]) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
$ python3 series_with_index.py a 10 b 20 c 30 d 40 Name: numbers, dtype: int64 The data at index 2 is: 30 The data from range 1 to 3 are: b 20 c 30 Name: numbers, dtype: int64 |
上例中，我们在 index 属性中为数据传入了索引值。输出中左列为我们传入的索引值。
In the preceding example, we provided an index value for our data in the index attribute. In the output, the left column is the index values that we provided.
数据帧
这一部分中，我们针学习pandas的数据帧（DataFrames）。数据帧是二维的带标签数据结构，它有不同列并可以包含不同的数据类型。数据帧与SQL表格或电子表格类似。在使用pandas时数据帧是最常用的对象。
下面我们来看一个从csv文件读入数据帧的示例。那么我们应该在系统中要有一个 csv 文件。如果你的系统中暂没有csv文件，创建一个名为employee.csv,的文件如下：
|
1 2 3 4 5 6 |
Id, Name, Department, Country 101, John, Finance, US 102, Mary, HR, Australia 103, Geeta, IT, India 104, Rahul, Marketing, India 105, Tom, Sales, Russia |
下面，我我将读取这一csv文件到数据帧中。为此创建一个名为read_csv_dataframe.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 |
import pandas as pd file_name = 'employee.csv' df = pd.read_csv(file_name) print(df) print() print(df.head(3)) print() print(df.tail(1)) |
运行脚本，我们将得到如下输出：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
$ python3 read_csv_dataframe.py Id Name Department Country 0 101 John Finance US 1 102 Mary HR Australia 2 103 Geeta IT India 3 104 Rahul Marketing India 4 105 Tom Sales Russia Id Name Department Country 0 101 John Finance US 1 102 Mary HR Australia 2 103 Geeta IT India Id Name Department Country 4 105 Tom Sales Russia |
上例中，首先我们创建了一个名为employee.csv的csv文件。我们使用pandas模块创建了一个数据帧。目的是将csv文件读取到数据帧中。接着我们创建了一个df对象，并将我们读取的csv内容赋给它。然后我们打印了数据帧。这里，我们使用了head()和tail()方法来获取指定行数的数据。我们指定了head(3)，表示要打印数据的前三行。还指定了tail(1)，表示要打印数据的最后一行。
数据可视化
数据可视化是一个描述努力以视觉方式理解数据意义的词语。这一部分，我们将来看以下的数据可视化技术：
- Matplotlib
- Plotly
Matplotlib
Matplotlib是一个Python中的数据可视化库，仅需使用几行代码通过它可生成图表、直方图、能量光谱（power spectra）、柱状图、 error charts,、散点图等。Matplotlib通常会简化工作并完成一些非常复杂的图表。
要在Python程序中使用matplotlib，首先要安装matplotlib，在终端中执行如下命令来安装matplotlib：
|
1 |
$ pip3 install matplotlib |
我们还应安装一个包tkinter来实现图形化展示。使用如下命令来进行安装：
|
1 |
$ sudo apt install python3-tk |
译者注：Mac 安装包中已自动集成，无需单独安装
既然已经在系统中安装了matplotlib，就让我们来看一些示例吧。在画图表时，有两个重要的组成部分：figure和数轴。figure是作为画图窗口的容器。可以有不同类型的独立数值。数轴是是我们绘制数据及相关联的标签的区域。数轴包含 x 轴 和 y 轴。
下面，我们来看一些matplotlib的示例。首先看一个简单的示例。创建一个名为simple_plot.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 |
import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 5, 10) y = x**2 plt.plot(x, y) plt.title('sample plot') plt.xlabel('x axis') plt.ylabel('y axis') plt.show() |
运行脚本如下：
|
1 |
$ python3 simple_plot.py |
输出结果如下：
上例中，我们导入了两具模块，matplotlib和numpy来对数据进行可视化以及分别创建数组x和y。然后，我们以及plt.plot(x,y)绘制了两个数据。接着我们使用xlabel(), ylabel()和title()函数对绘图添加了标题和标签，并使用plt.show()函数来显示绘图。因为我们是在Python中使用Matplotlib，要记得在最后一行添加plt.show()来显示绘图。
下面我们将创建两个数组来在绘图中显示两个曲线，并对这两个曲线应用样式。在下例中，我们将使用ggplot样式来绘图。ggplot是一个用于声明式地创建图形的系统，它基于图形的语法。要画图我们只需传入数据，然后告诉ggplot如何映射变量以及使用哪些图形原语（primitive），它就会处理剩下的细节。大多情况下，我们以ggplot()的样式开始。
创建一个名为simple_plot2.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import matplotlib.pyplot as plt from matplotlib import style style.use('ggplot') x1 = [0,5,10] y1 = [12,16,6] x2 = [6,9,11] y2 = [6,16,8] plt.subplot(2,1,1) plt.plot(x1, y1, linewidth=3) plt.title('sample plot') plt.xlabel('x axis') plt.ylabel('y axis') plt.subplot(2,1,2) plt.plot(x2, y2, color='r', linewidth=3) plt.xlabel('x2 axis') plt.ylabel('y2 axis') plt.show() |
运行脚本如下：
|
1 |
$ python3 simple_plot2.py |
得到的结果如下：
上例中，首先我们导入了所需的模块，然后我们使用了ggplot样式来绘图。我们创建了两组数组：即x1, y1 和 x2, y2。然后使用了subplot函数plt.subplot()，因为它允许我们在同一个画布上绘制不同的图形。如果想要在不同的画布上绘制图形的话，也可以使用plt.figure()来代替plt.subplot()。
下面我们来看使用plt.figure()函数来绘制数组并使用Matplotlib来保存生成的图像。我们能以savefig()方法进行不同格式的保存，如png, jpg, pdf等等。我们会将前面的图像保存在名为my_sample_plot.jpg的文件中。下面我们来看一个示例。为此创建一个名为simple_plot3.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import matplotlib.pyplot as plt from matplotlib import style style.use('ggplot') x1 = [0,5,10] y1 = [12,16,6] x2 = [6,9,11] y2 = [6,16,8] plt.figure(1) plt.plot(x1, y1, color='g', linewidth=3) plt.title('sample plot') plt.xlabel('x axis') plt.ylabel('y axis') plt.savefig('my_sample_plot1.jpg') plt.figure(2) plt.plot(x2, y2, color='r', linewidth=3) plt.xlabel('x2 axis') plt.ylabel('y2 axis') plt.savefig('my_sample_plot2.jpg') plt.show() |
运行脚本如下：
|
1 |
$ python3 simple_plot3.py |
输出结果如下：
译者注：执行时如出现如下报错，请安装 Pillow，因 Matplotlib 默认并不支持jpg 格式：
|
1 2 3 4 |
ValueError: Format 'jpg' is not supported (supported formats: eps, pdf, pgf, png, ps, raw, rgba, svg, svgz) # 安装 pillow pip3 install pillow |
上例中，我们使用了plt.figure()函数来在不同的画布上进行绘制。然后，我们使用了plt.plot()函数。该函数有不同的参数，用于绘图时使用。在上例中，我使用了x1, x2, y1和 y2等参数。这些分别是用于绘图的象限点。
然后我们使用了color参数来为画的线传入具体的颜色，第三个参数我们使用了linewidth，用于给定画线的宽度。接着，我们使用了savefig()方法来以指定的格式保存了图像。你可以在运行Python脚本的当前目录中查看图像（如未指定保存目录）。
我们还可以通过直接访问目录来打开图片，或者使用如下的方法来使用matplotlib打开所生成的图片。下面我们来看一个打开所保存图像的示例。为此创建一个名为open_image.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 |
import matplotlib.pyplot as plt import matplotlib.image as mpimg plt.imshow(mpimg.imread('my_sample_plot1.jpg')) plt.show() |
运行脚本如下：
|
1 |
$ python3 open_image.py |
我们将得到如下输出：
下例中，我们使用了Matplotlib的imshow()函数来打开所保存的图像。
下面我们来看绘图的不同类型。Matplotlib允许我们创建不同类型的绘图来处理数组中的数据，比如直方图、散点图、柱状图等等。选取不同类型的绘图取决于数据可视化的目的。下面我们就来看一些示例。
直方图
这类图有助于我们查看数值数据的分布，这是平均值和中位数所无法体现的。我们将使用hist()方法来创建一个简单的直方图。下面来看一个创建简单直方图的示例。为此创建一个名为histogram_example.py的脚本，并在其中编写如下内容：
|
1 2 3 4 5 6 |
import matplotlib.pyplot as plt import numpy as np x = np.random.randn(500) plt.hist(x) plt.show() |
运行脚本如下：
|
1 |
$ python3 histogram_example.py |
得到的输出结果如下：
上例中，我们使用numpy创建了一个随机数数组。然后使用plt.hist()方法对这一数值数据进行绘图。
散点图
这类图以一个点状集合展示数据。它提供了一种便捷地视觉查看数值关联的方式。它还有助于理解多个变量之间的关系。我们将使用scatter()方法来将数据绘制到散点图中。在散点图中，点的位置取决于x和y轴的值，即二维数据值，因此数据集中的每个值都是横向或纵向维度上的一个位置。我们来看一个散点图的示例。创建一个名为scatterplot_example.py的脚本，并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 |
import matplotlib.pyplot as plt import numpy as np x = np.linspace(-2,2,100) y = np.random.randn(100) colors = np.random.rand(100) plt.scatter(x,y,c=colors) plt.show() |
运行脚本如下：
|
1 |
$ python3 scatterplot_example.py |
我们将得到如下输出：
上例中，我们获取了x和y的值。然后使用plt.scatter()方法绘制这些值来获取x和y值的散点图。
柱状图
柱状图是将数据展现为矩形状态的图表。我们可以进行纵向或横向的绘制。创建一个名为bar_chart.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import matplotlib.pyplot as plt from matplotlib import style style.use('ggplot') x1 = [4,8,12] y1 = [12,16,6] x2 = [5,9,11] y2 = [6,16,8] plt.bar(x1,y1,color='g',linewidth=3) plt.bar(x2,y2,color='r',linewidth=3) plt.title('Bar plot') plt.xlabel('x axis') plt.ylabel('y axis') plt.show() |
运行脚本如下：
|
1 |
$ vi bar_chart.py |
运行结果如下：
上例中，我们有两组值：x1, y1和x2, y2。在获取了数值数据之后，我们使用了plt.bar()方法来对现有数据进行了柱状图绘制。
对数据绘图有很多种技术。其中，有一些技术或数据可视化的方法使用matplotlib，我们已经看到了。我们还可以使用其它的数据可视化工具来执行这类操作：如plotly。
Plotly
Plotly是Python中的一个交互的开源图形库。这一绘图库提供了30多种图表类型，包含科学图表、3D图、数据分析图、金融图表等等。
在Python中使用plotly，首先要在系统中安装它。在Terminal中运行如下命令来安装plotly：
|
1 |
$ pip3 install plotly |
我们可以在线及离线使用plotly。在线使用的话需要有一个plotly账号，然后可以在Python中设置账号信息：
|
1 |
plotly.tools.set_credentials_file(username='Username', api_key='APIkey') |
要离线使用plotly，我们应使用plotly函数：plotly.offline.plot()。
这一部分中我们将离线使用plotly。下面我们来看一个简单的示例。为此创建一个名为sample_plotly.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 |
import plotly from plotly.graph_objs import Scatter, Layout plotly.offline.plot({ "data": [Scatter(x=[1, 4, 3, 4], y=[4, 3, 2, 1])], "layout": Layout(title="plotly_sample_plot") }) |
运行以上脚本sample_plotly.py如下：
|
1 |
$ python3 sample_plotly.py |
我们将得到如下结果：
上例中，我们导入了plotly模块，然后设置了离线使用plotly。在其中传入了参数来进行绘图。在例子中，我们使用了一些参数：data和layout。在data参数中，我们为scatter函数定义了数组x和y，来使用值分别在x轴和y轴上绘图。然后我们使用了layout参数，在其中定义了layout函数来传入了图形的标题。以上程序执行的输出被保存为HTML文件，并在默认浏览器中打开。这一HTML文件和我们的脚本在同一目录。
下面我们来看一些可视化数据的不同类型的图表。首先从散点图开始。
散点图
创建一个名为scatter_plot_plotly.py的脚本并在其中编写如下的内容：
|
1 2 3 4 5 6 7 8 9 10 |
import plotly import plotly.graph_objs as go import numpy as np x_axis = np.random.randn(100) y_axis = np.random.randn(100) trace = go.Scatter(x=x_axis, y=y_axis, mode='markers') data_set = [trace] plotly.offline.plot(data_set, filename='scatter_plot.html') |
运行脚本如下：
|
1 |
$ python3 scatter_plot_plotly.py |
我们将得到如下输出：
上例中，我们导入了plotly，然后使用numpy创建了随机数据，因此在脚本中导入了numpy模块。在生成数据集后，我们创建了一个名为trace的对象并将数值数据插入该对象来绘制散点图。最后，我们将trace对象中的数据放到plotly.offline.plot()函数中，来获取数据的散点图。和第一个示例图一样，这个示例的输出也以HTML格式保存并在默认的浏览器中显示。
线状散点图
我们还可以创建信息量列大的绘图，如线状散点图。下面来看一个示例。创建一个名为line_scatter_plot.py 的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import plotly import plotly.graph_objs as go import numpy as np x_axis = np.linspace(0, 1, 50) y0_axis = np.random.randn(50)+5 y1_axis = np.random.randn(50) y2_axis = np.random.randn(50)-5 trace0 = go.Scatter(x=x_axis, y=y0_axis, mode='markers', name='markers') trace1 = go.Scatter(x=x_axis, y=y1_axis, mode='lines+markers', name='line+markers') trace2 = go.Scatter(x=x_axis, y=y2_axis, mode='lines', name='lines') data_sets = [trace0, trace1, trace2] plotly.offline.plot(data_sets, filename='line_scatter_plot.hmtl') |
运行脚本如下：
|
1 |
$ python3 line_scatter_plot.py |
我们将得到如下输出：
上例中，我们导入了plotly以及numpy模块。然后为x轴以及三个不同的y轴生成了一些随机值。然后，我们将该数据放到了创建的trace对象中，最后将数据集放入plotly的离线函数中。接着我们获取了散点及线状格式的输出。该示例的输出被保存到当前目录的line_scatter_plot.html文件中。
箱形图
箱形图有益于传递信息量，尤其是在数据很少又想显示很多时，我们来看一个示例。创建一个名为plotly_box_plot.py的脚本并在其中编写如下内容：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import random, plotly from numpy import * N = 50 c = ['hsl('+str(h)+',50%'+',50%)' for h in linspace(0, 360, N)] data_set = [{ 'y': 3.5*sin(pi*i/N) + i/N + (1.5+0.5*cos(pi*i/N))*random.rand(20), 'type':'box', 'marker':{'color': c[i]} } for i in range(int(N))] layout = {'xaxis': {'showgrid':False, 'zeroline':False, 'tickangle':45, 'showticklabels':False}, 'yaxis': {'zeroline':False, 'gridcolor':'white'}, 'paper_bgcolor': 'rgb(233,233,233)', 'plot_bgcolor':'rgb(233,233,233)', } plotly.offline.plot(data_set) |
运行脚本如下：
|
1 |
$ python3 plotly_box_plot.py |
得到的结果如下：
上例中，我们导入了plotly以及numpy模块。然后我们声明了箱体内的总箱体数N，并通过调整HSL展示的饱和度和亮度以及在色调的变化生成了一组彩虹色。每个箱体由包含数据、类型和颜色的字典来体现。我们使用了列表推导式来描述N个箱体，每个箱体的颜色不同并带有随机生成的数据。接着我们格式化了输出的布局并通过离线plotly函数对数据绘图。
等高线图
等高线图是科学绘图时最常用的，也在显示热力图数据时经常使用。我们来看一个等高线图的示例。创建一个名为contour_plotly.py的脚本并在其中编写如下内容：
|
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 |
from plotly import tools import plotly import plotly.graph_objs as go trace0 = go.Contour( z=[[1, 2, 3, 4, 5, 6, 7, 8], [2, 4, 7, 12, 13, 14, 15, 16], [3, 1, 6, 11, 12, 13, 16, 17], [4, 2, 7, 7, 11, 14, 17, 18], [5, 3, 8, 8, 13, 15, 18, 19], [7, 4, 10, 9, 16, 18, 20, 19], [9, 10, 5, 27, 23, 21, 21, 21]], line=dict(smoothing=0), ) trace1 = go.Contour( z=[[1, 2, 3, 4, 5, 6, 7, 8], [2, 4, 7, 12, 13, 14, 15, 16], [3, 1, 6, 11, 12, 13, 16, 17], [4, 2, 7, 7, 11, 14, 17, 18], [5, 3, 8, 8, 13, 15, 18, 19], [7, 4, 10, 9, 16, 18, 20, 19], [9, 10, 5, 27, 23, 21, 21, 21]], line=dict(smoothing=0.95), ) data = tools.make_subplots(rows=1, cols=2, subplot_titles=('Smoothing_not_applied', 'smoothing_applied')) data.append_trace(trace0, 1, 1) data.append_trace(trace1, 1, 2) plotly.offline.plot(data) |
运行脚本如下：
|
1 2 3 |
$ python3 contour_plotly.py This is the format of your plot grid: [ (1,1) x1,y1 ] [ (1,2) x2,y2 ] |
我们将得到如下输出：
上例中，我们传入了数据集并对其应用了contour()函数。然后我将等高线数据添加到了data_set中，最后对数据应用了plotly函数来获取输出。这些是plotly中以可视化方式绘制数据的一些技术。
总结
本章中，我们学习了NumPy 和Pandas模块，以及数据可视化技术。在NumPy模块一节，我们学习了对数组索引和切片，以及通用数组函数。在pandas模块一节中，我们学习了序列和数据帧。我们还学习了如何将csv文件读取到数据帧中。对于数据可视化，我们学习了Python中用于数据可视化的库：matplotlib和plotly。
下一章中，我们将学习MySQL和SQLite数据库管理。
课后问题
- 什么是NumPy数组？
- 以下代码片断的输出是什么？
123456789import numpy as np# input arrayin_arr1 = np.array([[ 1, 2, 3], [ -1, -2, -3]] )print ("1st Input array : \n", in_arr1)in_arr2 = np.array([[ 4, 5, 6], [ -4, -5, -6]] )print ("2nd Input array : \n", in_arr2)# Stacking the two arrays horizontallyout_arr = np.hstack((in_arr1, in_arr2))print ("Output stacked array :\n ", out_arr) - 如何以比np.sum更快速的方式对小数组求和？
- 如何从Pandas数据帧删除索引、行或列？
- 如何将Pandas数据帧写入到文件中？
- Pandas中的NaN是什么？
- 如何从Pandas数据帧中删除重复内容？
- 如何改变Matplotlib中绘制的图形的大小？
- 使用Python绘图的替代方案有哪些？
扩展阅读
- 10分钟pandas文档：http://pandas.pydata.org/pandas-docs/stable/
- NumPy教程: https://docs.scipy.org/doc/numpy/user/quickstart.html
- 使用plotly绘图：https://plot.ly/d3-js-for-python-and-pandas-charts/
