Python项目——数据可视化

发表于 更新于 分类于 阅读次数：

生成数据

  • 数据可视化：通过可视化表示来探索数据
  • 数据挖掘：使用代码来探索数据集的规律和关联

安装 matplotlib

pip

pip是一个以Python写成的软件包管理系统，它可以安装和管理软件包。

大多数较新的Python版本都自带pip，因此首先可检查系统是否已经安装了pip。

  • 在Windows系统中检查是否安装了pip

    打开一个终端窗口，并执行如下命令：

    1
    2
    > python -m pip --version
    pip 20.1.1 from C:\Users\Hunter\AppData\Local\Programs\Python\Python38-32\lib\site-packages\pip (python 3.8)

在 Windows 系统中安装 matplotlib

在Windows系统中，首先需要安装Visual Studio。接下来，访问matplotlib · PyPI，查找与使用的Python版本、操作系统相匹配的.whl文件。

将这个.whl文件复制到项目所在文件夹，打开命令窗口，使用pip来安装matplotlib:

1
python -m pip install --user matplotlib-3.2.2-cp38-cp38-win32.whl

测试 matplotlib

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

1
2
$ python3
>>> import matplotlib

如果没有出现任何错误消息，就说明成功安装了 matplotlib。

绘制简单的折线图

我们将使用平方数序列1、4、9、16和25来绘制这个图表。

1
2
3
4
5
6
7
import matplotlib.pyplot as plt

%matplotlib inline # 让生成的图形嵌入jupyter notebook中

    squares = [1, 4, 9, 16, 25]
    plt.plot(squares)
    plt.show()

  • 模块pyplot包含很多用于生成图表的函数。

  • plt.show()打开matplotlib查看器，并显示绘制的图形。查看器能够缩放和导航图形，另外，单击磁盘图表可将图形保存起来。

修改标签文字和线条粗细

上述代码通过matplotlib查看器显示的图形，标签文字太小、线条太细。下面通过一些定制来改善这个图形的可读性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import matplotlib.pyplot as plt

squares = [1, 4, 9, 16, 25]
plt.plot(squares, linewidth=5)

# 设置图表标题，并给坐标轴加上标签
plt.title("Square Numbers", fontsize=24)
plt.xlabel("Value", fontsize=14)
plt.ylabel("Square of Value", fontsize=14)

# 设置刻度标记的大小
plt.tick_params(axis='both', labelsize=14)

plt.show()
  • 参数linewidth决定了plot()绘制的线条的粗细
  • 函数title()给图表指定标题
  • 参数fontsize指定了图表中文字的大小
  • 函数xlabel()和ylabel()
  • 函数tick_params()设置刻度的样式

校正图形

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import matplotlib.pyplot as plt

input_values = [1, 2, 3, 4, 5]
squares = [1, 4, 9, 16, 25]
plt.plot(input_values, squares, linewidth=5)

# 设置图表标题，并给坐标轴加上标签
plt.title("Square Numbers", fontsize=24)
plt.xlabel("Value", fontsize=14)
plt.ylabel("Square of Value", fontsize=14)

# 设置刻度标记的大小
plt.tick_params(axis='both', labelsize=14)

plt.show()

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

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

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

1
2
3
4
import matplotlib.pyplot as plt

plt.scatter(2, 4)
plt.show()

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import matplotlib.pyplot as plt

plt.scatter(2, 4, s=200)

# 设置图表标题并给坐标轴加上标签
plt.title("Square Numbers", fontsize=24)
plt.xlabel("Value", fontsize=14)
plt.ylabel("Square of Value", fontsize=14)

# 设置刻度标记的大小
plt.tick_params(axis='both', which='major', labelsize=14)
# 显示图例
plt.legend()

plt.show()
  • plt.scatter(2, 4, s=200)：实参s设置了绘制图形时使用的点的尺寸

使用 scatter() 绘制一系列点

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

1
2
3
4
5
6
7
8
9
import matplotlib.pyplot as plt

x_values = [1, 2, 3, 4, 5]
y_values = [1, 4, 9, 16, 25]

plt.scatter(x_values, y_values, s=100)

# 设置图表标题并给坐标轴加上标签
--snip--
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
--snip--

# 绘制一个展示 船票Fare 与 乘客年龄和性别 之间关系的散点图


# 方式一
# 利用query对性别和年龄进行筛选
x_values_1 = titanic.query("Sex == 'male' & Age != 'NaN'")['Age']
y_values_1 = titanic.query("Sex == 'male' & Age != 'NaN'")['Fare']

x_values_2 = titanic.query("Sex == 'female' & Age != 'NaN'")['Age']
y_values_2 = titanic.query("Sex == 'female' & Age != 'NaN'")['Fare']

plt.scatter(x_values_1, y_values_1, s=10, c='b', label='Male')
plt.scatter(x_values_2, y_values_2, s=10, c='r', label='Female')

# 方式二
titanic.loc[titanic['Sex'] == 'male', 'color'] = 'b' # 该处loc[]的用法为：指出 符合条件的行的列值 和 列标签
titanic.loc[~(titanic['Sex'] == 'male'), 'color'] = 'r'
plt.scatter(titanic['Age'].dropna(), titanic['Fare'].dropna(), s=10, c=titanic[color])



plt.title("船票与年龄", fontsize=24)
plt.xlabel("Age", fontsize=14)
plt.ylabel("Fare", fontsize=14)
# 显示图例
plt.legend()

plt.show()

可利用query()排除一些极端值的干扰

1
2
3
# 可视化 消费金额和购买数量的关系散点图
gu = grouped_user.sum().query('order_amount < 6000')
plt.scatter(gu['order_amount'], gu['order_products'])

自动计算数据

下面是绘制1000个点的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import matplotlib.pyplot as plt

x_values = list(range(1, 1001))
y_values = [x**2 for x in x_values]

plt.scatter(x_values, y_values, s=40)

# 设置图表标题并给坐标轴加上标签
plt.title("Square Numbers", fontsize=24)
plt.xlabel("Value", fontsize=14)
plt.ylabel("Square of Value", fontsize=14)

# 设置每个坐标轴的取值范围
plt.axis([0, 1100, 0, 1100000])

plt.show()

由于这个数据集较大，我们将点设置得较小，并使用函数axis()指定了每个坐标轴的取值范围。

删除数据点的轮廓

matplotlib允许你给散点图中的各个点指定颜色，默认为蓝色点和黑色轮廓。在散点图包含的数据点不多时效果很好，但绘制很多点时，黑色轮廓可能会粘连在一起。

要删除数据点的轮廓，可在调用scatter()时传递实参edgecolor='none'：

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

注意：matplotlib 2.0.0版本之后，scatter()函数的实参edgecolor默认为’none'。

自定义颜色

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

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

还可以使用RGB颜色模式自定义颜色：

plt.scatter(x_values, y_values, c=(0, 0, 0.8), s=40)

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

使用颜色映射

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

模块pyplot内置了一组颜色映射：

1
2
3
4
5
6
7
8
9
10
import matplotlib.pyplot as plt

x_values = list(range(1, 1001))
y_values = [x**2 for x in x_values]

plt.scatter(x_values, y_values, c=y_values, cmap=plt.cm.Blues,
           s=40)

# 设置图表标题并给坐标轴加上标签
--snip--

我们将参数c设置成了一个y值列表，并使用参数cmap告诉pyplot使用哪个颜色映射。y值较小的点显示为浅蓝色，y值较大的点显示为深蓝色。

注意：要了解pyplot中所有的颜色映射，访问Colormap reference

自动保存图表

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

plt.savefig('suqares_plot.png', bbox_inches='tight')

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

绘制饼图

matplotlib可视化饼图 - 知乎

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
# 绘制一个展示男女乘客比例的扇形图
males = (titanic['Sex'] == 'male').sum()
females = (titanic['Sex'] == 'female').sum()

proportions = [males, females]

# 绘制饼图
plt.pie(
    proportions,
    
    labels = ['Males', 'Females'],
    
    #是否 添加阴影效果
    shadow = False,
    
    # 指定填充色
    colors = ['blue', 'red'],
    
    # 每一块偏移中心的距离
    explode = (0.15 , 0.3),

    # 饼图的初始摆放角度，默认图是从x轴正方向逆时针画起,如设定=90则从y轴正方向画起
    startangle = 90,
    
    # 显示百分比, 小数点前后表示最少的位数 末尾两个%%是输出%自身
    autopct = '%1.1f%%'
    
)


# x，y轴刻度设置一致，保证饼图为圆形
plt.axis('equal')

# 设置图表标题
plt.title("男女乘客比例")

# tight_layout会自动调整子图参数，使之填充整个图像区域
plt.tight_layout()

plt.show()

随机漫步

随机漫步是这样行走得到的路径：每次行走都完全是随机的，没有明确的方向，结果是由一系列随机决策决定的。在自然界、物理学、生物学、化学和经济领域，随机漫步都有其实际用途。例如，漂浮在水滴上的花粉因不断受到水分子的挤压而在水面上移动。水滴中的分子运动是随机的，因此花粉在水面上的运动路径犹如随机漫步。

创建 RandomWalk() 类

创建一个RandomWalk()类，这个类需要三个属性：

  1. 存储随机漫步次数的变量
  2. 随机漫步经过的每个点的x坐标
  3. 随机漫步经过的每个点的y坐标

RandomWalk()类只包含两个方法：

  1. __init__()
  2. fill_walk()：计算随机漫步经过的所有点

先来看看__init__():

1
2
3
4
5
6
7
8
9
10
11
12
from random import choice

class RandomWalk():
    """一个生成随机漫步数据的类"""
    
    def __init__(self, num_points=5000):
        """初始化随机漫步的属性"""
        self.num_points = num_points
        
        # 所有随机漫步都始于(0, 0)
        self.x_values = [0]
        self.y_values = [0]

为做出随机决策，我们将所有可能的选择都存储在一个列表中，并在每次做决策时都使用choice()来决定使用哪种选择。

选择方向

我们将使用fill_walk()来生成漫步包含的点，并决定每次漫步的方向，如下所示：

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

绘制随机漫步图

rw_visual.py：

1
2
3
4
5
6
7
8
9
import matplotlib.pyplot as plt

from random_walk import RandomWalk

# 创建一个RandomWalk实例，并将其包含的点都绘制出来
rw = RandomWalk()
rw.fill_walk()
plt.scatter(rw.x_values, rw.y_values, s=15)
plt.show()

模拟多次随机漫步

要在不多次运行程序的情况下模拟多次随机漫步，一种办法是将这些代码放在一个while循环中，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import matplotlib.pyplot as plt

from random_walk import RandomWalk

# 只要程序处于活动状态，就不断地模拟随机漫步
while True:
    # 创建一个RandomWalk实例，并将其包含的点都绘制出来
	rw = RandomWalk()
	rw.fill_walk()
	plt.scatter(rw.x_values, rw.y_values, s=15)
	plt.show()
	
	keep_running = input("Make another walk? (y/n): ")
	if keep_running == 'n':
		break

给点着色

我们将使用颜色映射来指出漫步中各点的先后顺序。为根据漫步中各点的先后顺序进行着色，我们传递参数c，并将其设置为一个列表，其中包含各点的先后顺序。

由于这些点是按顺序绘制的，因此给参数c指定的列表只需包含数字1~5000：

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

重新绘制起点和终点

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

隐藏坐标轴

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

为修改坐标轴，使用了函数plt.axes()来将每条坐标轴的可见性设置为False。

增加点数

在创建RandomWalk实例时增大num_points的值，并在绘图时调整每个点的大小，如下所示：

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

调整尺寸以适合屏幕

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

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

函数figure()用于指定图表的宽度、高度、分辨率和背景色：

需要给形参figsize指定一个元组，向matplotlib指出绘图窗口的尺寸，单位为英寸。

Python假定屏幕分辨率为80像素/英寸，如果知道自己系统的分辨率，可使用形参dpi向figure()传递该分辨率，以有效利用可用的屏幕空间：

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

使用 Pygal 模拟掷骰子

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

在这个项目中，我们将对掷骰子的结果进行分析。为确定哪些点数出现的可能性最大，我们将生成一个表示掷骰子结果的数据集，并根据结果绘制出一个图形。

安装 Pygal

在 Windows 系统中，命令：

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

Paygal 画廊

要了解使用Pygal可创建什么样的图表，可以查看Chart types — pygal documentation

创建 Die 类

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

1
2
3
4
5
6
7
8
9
10
11
12
from random import randint

class Die():
    """表示一个骰子的类"""
    
    def __init__(self, num_sides=6):
        """骰子默认为6面"""
        self.num_sides = num_sides
        
    def roll(self):
        """返回一个位于1和骰子面数之间的随机数"""
        return randint(1, self.num_sides)
  • 方法roll()使用函数randint()来返回一个1和面数之间的随机整数(包括起始值1和终止值num_sides)

骰子根据面数命名，6面的骰子命名为D6，8面的骰子命名为D8。

掷骰子

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

1
2
3
4
5
6
7
8
9
10
11
12
from die import Die

# 创建一个D6
die = Die()

# 掷几次骰子，并将结果存储在一个列表中
results = []
for roll_num in range(100):
    result = die.roll()
    results.append(result)
    
print(results)

分析结果

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
--snip--
# 掷几次骰子，并将结果存储在一个列表中
results = []
for roll_num in range(1000):
    result = die.roll()
    results.append(result)
    
# 分析结果
frequencies = []
for value in range(1, die.num_sides+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
print(frequencies)
  • 为分析结果，我们创建了空列表frequencies，用于存储每种点数出现的次数

绘制条形图(bar chart)

有了频率列表后，我们就可以绘制一个表示结果的条形图(bar chart)，指出各种结果出现的频率。

  1. 利用pygal绘制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pygal
--snip--

# 分析结果
frequencies = []
for value in range(1, die.num_sides+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
# 对结果进行可视化
bar = pygal.Bar()

bar.title = "Results of rolling one D6 1000 times."
bar.x_labels = ['1', '2', '3', '4', '5', '6']
bar.x_title = "Result"
bar.y_title = "Frequency of Result"

bar.add('D6', frequencies)
bar.render_to_file('die_visual.svg')
  • 为创建**条形图(bar diagram)**，创建了一个pygal.Bar()实例
  • 将D6骰子的可能结果用作x轴的标签
  • 使用add()将一系列值添加到图表中(传递给添加的值指定的标签、将出现在图表中的值的列表)
  • 将图表渲染为一个SVG文件(Scalable Vector Graphics，可缩放的矢量图形，是一种基于XML的图像文件格式)

要查看生成的直方图，最简单的方式是使用Web浏览器。为此，在任意浏览器中新建一个标签页，再打开文件die_visual.svg，将看到对应的图表。

注意：Python让这个图表具有交互性：如果将鼠标指向该图表中的任何条形，将看到与之相关联的数据(若无效果，刷新)。

绘制直方图(histogram)

  1. 利用pyplot绘制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pandas as pd
import matplotlib.pyplot as plt
# 绘制一个展示船票价格的直方图

# 创建直方图
# 参数：需要计算的series ，bins可以是直方图个数(默认为10)，也可以是自定义的序列
plt.hist(titanic['Fare'], bins = range(0,600,10))

# Set the title and labels
plt.xlabel('Fare')
plt.ylabel('Frequency')
plt.title('船票价格分布')

# show the plot
plt.show()


# 用户消费金额的分布图，利用query消除极值对可视化呈现效果的干扰
plt.hist(grouped_user.sum().query('order_amount < 1000')['order_amount'], bins = 20)
plt.show()

同时掷两个骰子

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
import pygal

from die import Die

# 创建两个D6骰子
die_1 = Die()
die_2 = Die()

# 掷骰子多次，并将结果存储到一个列表中
results = []
for roll_num in range(1000):
    result = die_1.roll() + die_2.roll()
    results.append(result)
    
# 分析结果
frequencies = []
max_result = die_1.num_sides + die_2.num_sides
for value in range(2, max_result+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
# 可视化结果
bar = pygal.Bar()

bar.title = "Results of rolling two D6 dice 1000 times."
bar.x_labels = ['2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12']
bar.x_title = "Result"
bar.y_title = "Frequency of Result"

bar.add('D6 + D6', frequencies)
bar.render_to_file('dice_visual.svg')

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

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

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 die import Die

import pygal

# 创建一个D6和一个D10
die_1 = Die()
die_2 = Die(10)

# 掷骰子多次，并将结果存储到一个列表中
results = []
for roll_num in range(50000):
    result = die_1.roll() + die_2.roll()
    results.append(result)
    
# 分析结果
frequencies = []
max_result = die_1.num_sides + die_2.num_sides
for value in range(2, max_result+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
# 可视化结果
bar = pygal.Bar()

bar.title = "Results of rolling a D6 and a D10 50,000 times."
bar.x_labels = [str(value) for value in range(2, 17)]
bar.x_title = "Result"
bar.y_title = "Frequency of Result"

bar.add('D6 + D10', frequencies)
bar.render_to_file('dice_visual.svg')
  • 通过列表解析调整x轴标签

下载数据

网上的数据多得难以置信，且大多未经过仔细检查。如果能够对这些数据进行分析，你就能发现别人没有发现的规律和关联。

CSV 文件格式

要在文本文件中存储数据，最简单的方式是将数据作为一系列以逗号分隔的值(CSV, Comma-Separated Values)写入文件，这样的文件称为CSV文件。

例如，下面是一行CSV格式的天气数据：

2014-1-5,61,44,26,18,7,-1,56,30,9,30.34,30.27,30.15,,,,10,4,,0.00,0,,195

CSV文件对人来说阅读起来比较麻烦，但程序可轻松地提取并处理其中的值，这有助于加快数据分析过程。

  • 最好使用用文字编辑器打开csv文件查看，Excel可能会更改显示格式

分析 CSV 文件头

csv模块包含在Python标准库中，可用于分析CSV文件中的数据行，让我们能够快速提取感兴趣的值。下面先来看一下sitka_weather_07-2014.csv文件的第一行，其中包含一系列有关数据的描述：

1
2
3
4
5
6
7
import csv

filename = 'sitka_weather_07-2014.csv'
with open(filename) as f:
    reader = csv.reader(f)
    header_row = next(reader)
    print(header_row)
  • 调用csv.reader()，并将前面存储的文件对象作为实参传入，从而创建一个与该文件相关联的阅读器对象
  • 模块csv的reader类包含next()方法，调用内置函数next()并将一个阅读器对象作为参数传入，将调用阅读器对象的next()方法，从而返回文件中的下一行。
  • reader处理文件中以逗号分隔的第一行数据，并将每项数据都作为一个元素存储在列表中。

注意：文件头的格式并非总是一致的， 空格和单位可能出现在奇怪的地方，但不会带来任何问题。

打印文件头及其位置

为让文件头数据更容易理解，将列表中的每个文件头及其位置打印出来：

1
2
3
4
5
6
7
--snip--
with open(filename) as f:
    reader = csv.reader(f)
    header_row = next(reader)
    
    for index, column_header in enumerate(header_row):
        print(index, column_header)
  • 对列表调用了enumerate()(枚举)来获取每个元素的索引及其值。

提取并读取数据

首先读取每天的最高气温：

1
2
3
4
5
6
7
8
9
10
11
12
13
import csv

# 从文件中获取最高气温
filename = 'sitka_weather_07-2014.csv'
with open(filename) as f:
    reader = csv.reader(f)
    header_row = next(reader)
    
    highs = []
    for row in reader:
        highs.append(row[1])
        
    print(highs)

  • for row in reader：遍历文件中余下的各行

    每次执行上述循环，我们都将索引1处(第2列)的数据附加到highs末尾。

下面使用int()将这些字符串转换为数字，让matplotlib能够读取它们：

1
2
3
4
5
6
7
--snip--
	highs = []
    for row in reader:
        high = int(row[1])
        highs.append(high)
        
    print(highs)

绘制气温图表

为可视化这些气温数据，我们首先使用matplotlib创建一个显示每日最高气温的简单图形：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import csv

from matplotlib import pyplot as plt

# 从文件中获取最高气温
--snip--

# 根据数据绘制图形
plt.figure(dpi=128, figsize=(10, 6))
plt.plot(highs, c='red')

# 设置图形的格式
plt.title("Daily high temperatures, July 2014", fontsize=24)
plt.xlabel('', fontsize=16)
plt.ylabel("Temperature (F)", fontsize=16)
plt.tick_params(axis='both', which='major', labelsize=16)

plt.show()

  • 鉴于还没有添加日期，因此没有给x轴添加标签

  • tick_params()：

    which一共3个参数：[‘major’ , ‘minor’. ‘both’]
    默认是major，表示主刻度，后面分布为次刻度及主次刻度都显示.

  • 调整x轴日期的显示间隔

    1
    plt.xticks(pd.date_range('1997-01-01', '1997-04-01', freq='10d'))

模块 datetime

下面在图表中添加日期。在天气数据文件中，第一个日期在第二行：

获取日期数据时，获得的是一个字符串，因此需要将字符串'2014-7-1'转换为一个表示相应日期的对象。可使用模块datetime中的方法strptime()：

1
2
3
4
>>> from datetime import datetime
>>> first_date = datetime.strptime('2014-7-1', '%Y-%m-%d')
>>> print(first_date)
2014-07-01 00:00:00

  • 传入方法strptime()的第2个实参告诉Python如何设置日期的格式。

    • %Y-让Python将字符串中第一个连字符前面的部分视为4位的年份
    • %m-让Python将第二个连字符前面的部分视为表示月份的数字
    • %d让Python将最后一部分视为月份中的一天

  • 方法strptime()可接受各种实参，并根据它们来决定如何解读日期：

    实参 含义
    %A 星期的名称，如Monday
    %B 月份名，如January
    %m 用数字表示的月份 (01~12)
    %d 用数字表示月份中的一天 (01~31)
    %Y 四位的年份，如2015
    %y 两位的年份，如15
    %H 24小时制的小时数 (00-23)
    %I 12小时制的小时数 (01~12)
    %p am或pm
    %M 分钟数 (00~59)
    %S 秒数 (00~61)

在图表中添加日期

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
import csv
from datetime import datetime

from matplotlib import pyplot as plt

# 从文件中获取日期和最高气温
filename = 'sitka_weather_07-2014.csv'
with open(filename) as f:
    reader = csv.reader(f)
    header_row = next(reader)
        
    dates, highs = [], []
    for row in reader:
        current_date = datetime.strptime(row[0], "%Y-%m-%d")
        dates.append(current_date)
        
        high = int(row[1])
        highs.append(high)

# 根据数据绘制图形
plt.figure(dpi=128, figsize=(10, 6))
plt.plot(dates, highs, c='red')

# 设置图形的格式
plt.title("Daily high temperatures, July 2014", fontsize=24)
plt.xlabel('', fontsize=16)
plt.gcf().autofmt_xdate() # 绘制斜的日期标签，以免它们彼此重叠
plt.ylabel("Temperature (F)", fontsize=16)
plt.tick_params(axis='both', which='major', labelsize=16)

plt.show()
  • 创建了两个空列表：dates, highs = [], []
  • 将包含日期信息的数据转换为datetime对象：datetime.strptime(row[0], "%Y-%m-%d")
  • 将日期和最高气温值传给plot()：plt.plot(dates, highs, c='red')

涵盖更长的时间

创建覆盖整年的天气图：

1
2
3
4
5
6
7
8
9
--snip--
# 从文件中获取日期和最高气温
filename = 'stika_weather_2014.csv'
with open(filename) as f:
--snip--
# 设置图形的格式
plt.title("Daily high temperatures - 2014", fontsize=24)
plt.xlabel('', fontsize=16)
--snip--

再绘制一个数据系列

从数据文件中提取最低气温，并添加到图表中：

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
--snip--
# 从文件中获取日期、最高气温和最低气温
filename = 'sitka_weather_2014.csv'
with open(filename) as f:
    reader = csv.reader(f)
    header_row = next(reader)
    
    dates, highs, lows = [], [], []
    for row in reader:
        current_date = datetime.strptime(row[0], "%Y-%m-%d")
        dates.append(current_date)
        
        high = int(row[1])
        highs.append(high)
        
        low = int(rpw[3])
        lows.append(low)
        
# 根据数据绘制图形
plt.figure(dpi=128, figsize=(10, 6))
plt.plot(dates, highs, c='red')
plt.plot(dates, lows, c='blue')

# 设置图形的格式
plt.title("Daily high and low temperatures - 2014", fontsize=24)
--snip--

给图表区域着色

通过着色来呈现每天的气温范围，为此使用方法fill_between()，它接受一个x值系列和两个y值系列，并填充两个y值系列之间的空间：

1
2
3
4
5
6
--snip--
# 根据数据绘制图形
fig = plt.figure(dpi=128, figsize=(10, 6))
plt.plot(dates, highs, c='red'. alpha=0.5)
plt.plot(dates, lows, c='blue'. alpha=0.5)
plt.fill_between(dates, highs, lows, facecolor='blue', alpha=0.1)
  • 实参alpha指定颜色的透明度
    • 0表示完全透明
    • 1(默认)表示完全不透明
  • fill_between()
    • 实参facecolor指定了填充区域的颜色

错误检查

我们应该能够使用有关任何地方的天气数据来运行highs_lows.py中的代码，但有些气象站会偶尔出现故障，未能收集部分或全部其应该收集的数据。缺失数据可能会引发异常，如果不妥善地处理，还可能导致程序崩溃。

例如，我们来看看生成加利福尼亚死亡谷的气温图时出现的情况：

1
2
3
4
5
--snip--
# 从文件中获取日期、最高气温和最低气温
filename = 'death_valley_2014.csv'
withj open(filename) as f:
--snip--

运行结果：

1
2
3
4
Traceback (most recent call last):
  File "highs_lows.py", line 17, in <module>
    high = int(row[1])
ValueError: invalid literal for int() with base 10: ''

查看文件可知，没有记录2014年2月16日的数据，表示最高温度的字符串为空。为解决这种问题，我们从CSV文件中读取值时执行错误检查代码，对分析数据集时可能出现的异常进行处理：

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
--snip--
# 从文件中获取日期、最高气温和最低气温
filename = 'death_valley_2014.csv'
with open(filename) as f:
    reader = csv.reader(f)
    header_row = next(reader)
        
    dates, highs, lows = [], [], []
    for row in reader:
        try:
	        current_date = datetime.strptime(row[0], "%Y-%m-%d")
        	high = int(row[1])
            low = int(row[3])
        except ValueError:
            print(current_date, 'missing data')
        else:
            dates.append(current_date)
	        highs.append(high)
            lows.append(low)
            
# 根据数据绘制图形
--snip--

# 设置图形的格式
title = "Daily high and low temperatures - 2014\nDeath Valley, CA"
plt.title(title, fontsize=20)
--snip--

在有些情况下，需要使用continue来跳过一些数据，或者使用remove()(删除列表值)或del(删除 键-值 对)将已提取的数据删除。可采用任何管用的方法，只要能进行精确而有意义的可视化就好。

16-2 比较锡特卡和死亡谷的气温：

为准确地比较锡特卡和死亡谷的气温范围，在y轴上使用相同的刻度，对两地的气温范围进行直接比较：

  • pyplot的方法ylim()可以对y轴的刻度做限制；xlim()则可以对x轴的刻度做限制。
1
2
3
4
5
# 设置图形的格式
--snip--
plt.ylim(10, 120)

plt.show()

尝试在一个图表中呈现这两个数据集：

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
import csv
from datetime import datetime

from matplotlib import pyplot as plt

def get_weather_data(filename, dates, highs, lows):
    """从文件中获取日期、最高气温和最低气温"""
    with open(filename) as f:
        reader = csv.reader(f)
        header_row = next(reader)
        
        for row in reader:
            try:
                current_date = datetime.strptime(row[0], "%Y-%m-%d")
                high = int(row[1])
                low = int(row[3])
            except ValueError:
                print(current_date, 'missing data')
            else:
                dates.append(current_date)
                highs.append(high)
                lows.append(low)

# 获取锡特卡的气温数据
dates, highs, lows = [], [], []
get_weather_data('stika_weather_2014.csv', dates, highs, lows)

# 根据锡特卡数据绘制图形
plt.figure(dpi=128, figsize=(10, 6))
plt.plot(dates, highs, c='red', alpha=0.6)
plt.plot(dates, lows, c='blue', alpha=0.6)
plt.fill_between(dates, highs, lows, facecolor='blue', alpha=0.15)

# 获取死亡谷的气温数据
dates, highs, lows = [], [], []
get_weather_data('death_valley_2014.csv', dates, highs, lows)

# 将死亡谷数据的图形 添加到当前的绘制中
plt.plot(dates, highs, c='red', alpha=0.3)
plt.plot(dates, lows, c='blue', alpha=0.3)
plt.fill_between(dates, highs, lows, facecolor='blue', alpha=0.05)

# 设置图形的格式
title = "Daily high and low temperatures - 2014"
title += "\nSitka, AK and Death Valley, CA"
plt.title(title, fontsize=20)
plt.xlabel('', fontsize=16)
plt.gcf().autofmt_xdate()
plt.ylabel("Temperature (F)", fontsize=16)
plt.tick_params(axis='both', which='major', labelsize=16)
plt.ylim(10, 120)

plt.show()

制作交易收盘价走势图： JSON 格式

下载收盘价数据

btc_close_2017.json实际是一个很长的Python列表，其中每个元素都是一个包含五个键的字典：统计日期、月份、周数、周几以及收盘价。由于2017年1月1日是周日，作为2017年的第一周实在太短，。因此被计入2016年的第52周。于是2017年的第一周是从1月2日开始的。

可以将收盘价数据文件直接下载到程序所在的文件夹中，也可以用Python 2.x标准库中模块urllib2(Python 3.x版本使用urllib)的函数urlopen()来做，还可以通过Python的第三方模块requests下载数据。

如果采用函数urlopen()来下载数据，可以使用如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from __future__ import (absolute_import, division, print_function, unicode_literals)

try:
    # Python 2.x 版本
    from urllib2 import urlopen
except ImportError:
    # Python 3.x 版本
    from urllib.request import urlopen
import json

json_url = 'https://raw.githubusercontent.com/muxuezi/btc/master/btc_close_2017.json'
response = urlopen(json_url)
# 读取数据
req = response.read()
# 将数据写入文件
with open('btc_close_2017_urllib.json', 'wb') as f:
    f.write(req)
# 加载json格式
file_urllib = json.loads(req)
print(file_urllib)

  • python打开文件时w与wb的区别,r与rb的区别

    在Windows中的换行符是\r\n。

    • 以文本方式('w')写入，遇到\n会自动替换为\r\n
    • 以二进制文本方式('wb')写入，遇到\n仍然按\n记录

  • json

    • load()

      载入json文件

    • loads()

      载入JSON格式的字符串

函数urlopen的代码稍微复杂一些，第三方模块requests封装了许多常用的方法，让数据下载和读取方式变得非常简单：

1
2
3
4
5
6
7
8
import requests

json_url = 'https://raw.githubusercontent.com/muxuezi/btc/master/btc_close_2017.json'
req = requests.get(json_url)
# 将数据写入文件
with open('btc_close_2017_request.json', 'w') as f:
    f.write(req.text)
file_requests = req.json()
  • req.text属性可以直接读取文件数据，返回格式是字符串
  • req.json()可以将json文件的数据转换为Python列表，与之前的file_urllib内容相同

提取相关的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import json

# 将数据加载到一个列表中
filename = 'btc_close_2017.json'
with open(filename) as f:
    btc_data = json.load(f)
# 打印每一天的信息
for btc_dict in btc_data:
    date = btc_dict['date']
    month = btc_dict['month']
    week = btc_dict['week']
    weekday = btc_dict['weekday']
    close = btc_dict['close']
    print("{} is month {} week {}, {}, the close price is {} RMB".format(date, month, week, weekday, close))

将字符串转换为数字值

btc_close_2017.json中的每个键和值都是字符串。为了能在后边的内容中对交易数据进行计算，需要先将表示周数和收盘价的字符串转换为数值，因此使用函数int()：

1
2
3
4
5
6
7
8
9
10
--snip--

# 打印每一天的信息
for btc_dict in btc_data:
    date = btc_dict['date']
    month = int(btc_dict['month'])
    week = int(btc_dict['week'])
    weekday = btc_dict['weekday']
    close = int(float(btc_dict['close']))
    print("{} is month {} week {}, {}, the close price is {} RMB".format(date, month, week, weekday, close))
  • 在实际工作中，原始数据的格式经常是不统一的。此类数值类型转换造成的ValueError异常十分普遍。该例子中，无法将包含小数点的字符串转换为整数，因此需要先转换为浮点数再转换为整数：int(float(btc_dict['close']))

有了这些数据之后，可以结合Pygal的可视化功能来探索一些有趣的信息。

绘制收盘价折线图

之前章节介绍过用Pygal绘制条形图(bar chart)的方法，也介绍了用matplotlib绘制折线图(line chart)的方法。下面用Pygal来实现收盘价的折线图。

绘制折线图之前，需要获取x轴与y轴数据，因此我们创建了几个列表来存储数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
--snip--

# 创建5个列表，分别存储日期和收盘价
dates = []
months = []
weeks = []
weekdays = []
close = []
# 每一天的信息
for btc_dict in btc_data:
    dates.append(btc_dict['date'])
    months.append(int(btc_dict['month']))
    weeks.append(int(btc_dict['week']))
    weekdays.append(btc_dict['weekday'])
    close.append(int(float(btc_dict['close'])))

由于数据点比较多，x轴要显示346个日期，因此需要利用Pygal的配置参数，对图形进行适当的调整：

1
2
3
4
5
6
7
8
9
10
11
--snip--

import pygal

line_chart = pygal.Line(x_label_rotation=20, show_mirror_x_labels=False)
line_chart.title = '收盘价（￥）'
line_chart.x_labels = dates
N = 20 # x轴坐标每隔20天显示一次
line_chart.x_labels_major = dates[::N]
line_chart.add('收盘价', close)
line_chart.render_to_file('收盘价折线图（￥）.svg')
  • pygal.Line()创建Line实例
    • x_label_rotation=20：让x轴上的标签顺时针旋转20°
    • show_mirror_x_labels=False：告诉图形不用显示所有的x轴标签
  • line_chart.x_labels_major = dates[:20]：x轴坐标每隔20天显示一次

下面对价格做一些简单的探索

时间序列特征初探

进行时间序列分析总是期望发现趋势(trend)、周期性(seasonality)和噪声(noise)，从而能够描述事实、预测未来、做出决策。

从收盘价的折线图可以看出，2017年的总体趋势时非线性的，而且增长幅度不断增大，似乎呈指数分布。但是，在每个季度末(3月、6月、9月)似乎有一些相似的波动，为了验证周期性的假设，需要先将非线性的趋势(指数增长部分)消除。**对数变换(log transformation)**是常用的处理方法之一。

用Python标准库的数学模块math来解决这个问题。math里有许多常用的数学函数，这里以10为底的对数函数math.log10计算收盘价，日期仍然保持不变——这种方式称为半对数(semi-logarithmic)变换。

1
2
3
4
5
6
7
8
9
10
11
12
13
--snip--

import pygal
import math

line_chart = pygal.Line(x_label_rotation=20, show_mirror_x_labels=False)
line_chart.title = '收盘价对数变换（￥）'
line_chart.x_labels = dates
N = 20 # x轴坐标每隔20天显示一次
line_chart.x_labels_major = dates[::N]
close_log = [math.log10(_) for _ in close]
line_chart.add('log收盘价', close_log)
line_chart.render_to_file('收盘价对数变换折线图（￥）.svg')

剔除非线性趋势之后，整体的趋势更接近线性增长，且收盘价在每个季度末似乎有显著的周期性。那么，12月会不会再现这一场景？下面来看看收盘价的月日均值与周日均值的表现。

收盘价均值

再利用btc_close_2017.json文件中的数据，绘制2017年前11个月的日均值、前49周(01-02~12-10)的日均值，以及每周各天的日均值。虽然这些日均值的数值不同，但都是一段时间的均值，计算方法都是一样的。因此，可以将绘图代码封装成函数，以便重复使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
--snip--

from itertools import groupby

def draw_line(x_data, y_data, title, y_legend):
    xy_map = []
    for x, y in groupby(sorted(zip(x_data, y_data)), key=lambda _: _[0]):
    y_list = [v for _, v in y]
    xy_map.append([x, sum(y_list) / len(y_list)])
x_unique, y_mean = [*zip(*xy_map)]
line_chart = pygal.Line()
line_chart.title = title
line_chart.x_labels = x_unique
line_chart.add(y_legend, y_mean)
line_chart.render_to_file(title+'.svg')
return line_chart
  • 由于需要将数据按月份、周数、周几分组，再计算每组的均值，因此导入Python标准库中模块itertools的函数groupby。
  • 将x轴与y轴的数据合并、排序，再用函数groupby分组
  • 分组之后，求出每组的平均值，存储到xy_map中
  • 最后，将xy_map中存储的x轴与y轴数据分离，就可以像之前一样用Pygal画图了

下面画出收盘价月日均值，由于12月的数据不完整，只取1月到11月的数据。通过dates查找2017-12-01索引的位置，确定周数和收盘价的取值范围：

1
2
3
4
idx_month = dates.index('2017-12-01')
line_chart_month = draw_line(months[:idx_month], close[:idx_month], '收盘价月日均值（￥）',
                            '月日均值')
line_chart_month

收盘价数据仪表盘

每个SVG文件打开之后都是独立的页面，如果能整合在一起，就可以方便地进行长期管理、监测和分析。另外，新的图表也可以方便地加入进来，这样就形成了一个数据仪表盘(dashboard)。下面，将之前绘制的图整合起来，做一个收盘价数据仪表盘：

1
2
3
4
5
6
7
8
9
10
11
12
--snip--

with open('收盘价Dashboard.html', 'w', encoding='utf8') as html_file:
    html_file.write(
        '<html><head><title>收盘价Dashboard</title><meta charset="utf-8"></head><body>\n')
    for svg in [
        '收盘价折线图（¥）.svg', '收盘价对数变换折线图（¥）.svg', '收盘价月日均值（¥）.svg',
        '收盘价周日均值（¥）.svg', '收盘价星期均值（¥）.svg'
    ]:
        html_file.write(
            '    <object type="image/svg+xml" data="{0}" height=500></object>\n'.format(svg))
    html_file.write('</body></html>')

和常见网络应用的数据仪表盘一样，这个数据仪表盘也是一个完整的网页。

使用 API

使用 Web API

Web API是网站的一部分，用于 与使用非常具体的URL请求特定信息的程序 交互。这种请求称为API调用。请求的数据将以易于处理的格式(如JSON或CSV)返回。

依赖于外部数据源的大多数应用程序都依赖于API调用，如集成社交媒体网站的应用程序。

Git 和 GitHub

本章的可视化将基于来自GitHub的信息。我们将使用GitHub的API来请求有关该网站中Python项目的信息，然后使用Pygal生成交互式可视化，以呈现这些项目的受欢迎程度。

本章将编写一个程序，它自动下载GitHub上星级最高的Python项目的信息，并对这些信息进行可视化。

使用 API 调用请求数据

GitHub的API让你能够通过API调用来请求各种信息。要知道API调用是什么样的，在浏览器中访问如下地址：

1
https://api.github.com/search/repositories?q=language:python&sort=starshttps://api.github.com/
  • 第一部分https://api.github.com/：将请求发送到GitHub网站中响应API调用的部分
  • 接下来的部分search/repositories：让API搜索GitHub上的所有仓库
  • repositories后面的问号指出我们要传递一个实参。
    • q=：q表示查询，等号让我们能够开始指定查询
    • 通过使用language:python，我们指出只想获取主要语言为Python的仓库的信息
  • 最后一部分&sort=stars：指定将项目按其获得的星级排序

安装 requests

requests包让Python程序能够轻松地向网站请求信息以及检查返回的响应。要安装requests，执行：

1
pip install --user requests

处理 API 响应

下面来编写一个程序，它执行API调用并处理结果，找出GitHub上星级最高的Python项目：

1
2
3
4
5
6
7
8
9
10
11
12
import requests

# 执行API调用并存储响应
url = 'https://api.github.com/search/repositories?=language:python&sort=stars'
r = requests.get(url)
print("Status code:", r.status_code)

# 将API响应存储在一个变量中
response_dict = r.json()

# 处理结果
print(response_dict.keys())

  • 使用requests.get()执行API调用

    响应对象包含一个名为status_code的属性

    • 状态码200表示请求成功

  • 这个API返回JSON格式的信息。因此我们使用方法json()将这些信息转换为一个Python字典

处理响应字典

下面来生成一些概述API调用返回的信息的输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import requests

# 执行API调用并存储响应
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
r = requests.get(url)
print("Status code:", r.status_code)

# 将API响应存储在一个变量中
response_dict = r.json()
print("Total repositories:", response_dict['total_count'])

# 探索有关仓库的信息
repo_dicts = response_dict['items']
print("Repositories returned:", len(repo_dicts))

# 研究第一个仓库
repo_dict = repo_dicts[0]
print("\nKeys:", len(repo_dict))
for key in sorted(repo_dict.keys()):
    print(key)
  • 与'items'关联的值是一个列表，其中包含很多字典，每个字典都包含有关一个Python仓库的信息。

下面来提取repo_dict中与一些键相关联的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
--snip--

# 研究第一个仓库
repo_dict = repo_dicts[0]

print("\nSelected information about first repository:")
print('Name:', repo_dict['name'])
print('Owner:', repo_dict['owner']['login'])
print('Stars:', repo_dict['stargazers_count'])
print('Reposiory:', repo_dict['html_url'])
print('Created:', repo_dict['created_at'])
print('Updated:', repo_dict['updated_at'])
print('Description:', repo_dict['description'])

概述最受欢迎的仓库

对这些数据进行可视化时，我们需要涵盖多个仓库。下面就来编写一个循环，打印API调用返回的每个仓库的特定信息，以便能够在可视化中包含所有这些信息：

1
2
3
4
5
6
7
8
9
10
11
12
--snip--
# 研究有关仓库的信息
repo_dicts = response_dict['items']
print("Repositories returned:", len(repo_dicts))

print("\nSelected information about each repository:")
for repo_dict in repo_dicts:
    print('\nName:', repo_dict['name'])
    print('Owner:', repo_dict['owner']['login'])
    print('Stars:', repo_dict['stargazers_count'])
    print('Reposiory:', repo_dict['html_url'])
    print('Description:', repo_dict['description'])

监视 API 的速率限制

大多数API都存在速率限制，即你在特定时间内可执行的请求数存在限制。要获悉你是否接近了GitHub的限制，在浏览器中输入https://api.github.com/rate_limit，将得到类似于下面的响应：

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
{
    "resources":{
        "core":{
            "limit":60,
            "remaining":0,
            "reset":1593698255
        },
        "graphql":{
            "limit":0,
            "remaining":0,
            "reset":1593700880
        },
        "integration_manifest":{
            "limit":5000,
            "remaining":5000,
            "reset":1593700880
        },
        "search":{
            "limit":10,
            "remaining":10,
            "reset":1593697340
        }
    },
    "rate":{
        "limit":60,
        "remaining":0,
        "reset":1593698255
    }
}

我们关心的信息是搜索API的速率限制。从18~22行可知，极限为每分钟10个请求；当前这一分钟内，还可执行10个请求；reset值指的是配额将重置的Unix时间或新纪元时间(1970-01-01午夜后多少秒)。用完配额后，将收到一条简单的响应，由此知道已到达API极限。到达极限后，必须等待配额重置。

注意：很多API都要求你注册获得密钥后才能执行API调用。GitHub没有这样的要求，但获得API密钥后，配额将高得多。

使用 Pygal 可视化仓库

我们来进行可视化，呈现GitHub上Python项目的受欢迎程度。创建一个交互式条形图，条形的高度表示项目获得了多少颗星。单击条形将进入项目在GitHub上的主页。

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
import requests
import pygal
from pygal.style import LightColorizedStyle as LCS, LightenStyle as LS

# 执行API调用并存储响应
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
r = requests.get(url)
print("Status code:", r.status_code)

# 将API响应存储在一个变量中
response_dict = r.json()
print("Total repositories:", response_dict['total_count'])

# 研究有关仓库的信息
repo_dicts = response_dict['items']

names, stars = [], []
for repo_dict in repo_dicts:
    names.append(repo_dict['name'])
    stars.append(repo_dict['stargazers_count'])
    
# 可视化
my_style = LS('#333366', base_style=LCS)
chart = pygal.Bar(style=my_style, x_label_rotation=45, show_legend=False)
chart.title = 'Most-Starred Python Projects on GitHub'
chart.x_labels = names

chart.add('', stars)
chart.render_to_file('python_repos.svg')
  • LS('#333366', base_style=LCS)：使用LightenStyle(别名LS)定义了一种样式，并将基色设置为深蓝色；还传递了实参base_style，以使用LightColorizedStyle类(别名LCS)
  • show_legend=False隐藏了图例，因为只在图表中绘制一个数据系列
  • 由于不需要给这个数据系列添加标签，因此添加数据时，将标签设置成了空字符串。

改进 Pygal 图表

我们将进行多个方面的定制，因此先来稍微调整代码结构，创建一个配置对象，其中包含要传递给Bar()的所有定制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
--snip--

# 可视化
my_style = LS('#333366', base_style=LCS)

my_config = pygal.Config()
my_config.x_label_rotation = 45
my_config.show_legend = False
my_config.title_font_size = 24
my_config.label_font_size = 14
my_config.major_label_font_size = 18
my_config.truncate_label = 15
my_config.show_y_guides = False
my_config.width = 1000

chart = pygal.Bar(my_config, style=my_style)
chart.title = 'Most-Starred Python Projects on GitHub'
chart.x_labels = names

chart.add('', stars)
chart.render_to_file('python_repos.svg')

  • 9~11行设置了图表标题、副标签和主标签的字体大小。

    在这个图表中，副标签是x轴上的项目名和y轴上的大部分数字；主标签是y轴上为5000整数倍的刻度，这些标签更大，以与副标签区分开。

  • truncate_label=15将较长的项目缩短为15个字符(将鼠标指向被截短的项目名，将显示完整的项目名)

  • show_y_guides=False：隐藏图表中的水平线。

  • width=1000：自定义的宽度，让图表更充分地利用浏览器中的可用空间

添加自定义工具提示

在Python中，将鼠标指向条形将显示它表示的信息，这通常称为工具提示。下面来创建一个自定义工具提示，以同时显示项目的描述。

来看一个简单的示例，它可视化前三个项目，并给每个项目对应的条形都指定自定义标签。为此，我们向add()传递一个字典列表，而不是值列表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pygal
from pygal.style import LightColorizedStyle as LCS, LightenStyle as LS

my_style = LS('#333366', base_style=LCS)
chart = pygal.Bar(style=my_style, x_label_rotation=45, show_legend=False)

chart.title = 'Python Projects'
chart.x_labels = ['httpie', 'django', 'flask']

plot_dicts = [
    {'value': 16101， 'label': 'Description of httpie.'},
    {'value': 15028, 'label': 'Description of django.'},
    {'value': 14798, 'label': 'Description of flask.'},
]

chart.add('', plot_dicts)
chart.render_to_file('bar_descriptions.svg')
  • plot_dicts列表包含三个字典，'value'对应的值确定条形高度；'label'对应的值给条形创建工具提示。

根据数据绘图

为根据数据绘图，我们将自动生成plot_dicts。其中包含API调用返回的30个项目的信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
--snip--
# 研究有关仓库的信息
repo_dicts = response_dict['items']
print("Number of items:", len(repo_dicts))

names, plot_dicts = [], []
for repo_dict in repo_dicts:
    names.append(repo_dict['name'])
    
    plot_dict = {
        'value': repo_dict['stargazers_count'],
        'label': repo_dict['description'],
    }
    plot_dicts.append(plot_dict)
    
# 可视化
my_style = LS('#333366', base_style=LCS)
--snip--

chart.add('', plot_dicts)
chart.render_to_file('python_repos.svg')

在图表中添加可单击的链接

Pygal还允许将图表中的每个条形用作网站的链接。为此，在为每个项目创建的字典中，添加一个键为'xlink'的 键-值 对：

1
2
3
4
5
6
7
8
9
10
11
12
--snip--
names, plot_dicts = [], []
for repo_dict in repo_dicts:
    names.append(repo_dict['name'])
    
    plot_dict = {
        'value': repo_dict['stargazers_count'],
        'label': repo_dict['description'],
        'xlink': repo_dict['html_url'],
    }
    plot_dicts.append(plot_dict)
--snip--

单击图表中的任何条形，都将在浏览器中打开一个新的标签页，并在其中显示相应项目的GitHub页面。

Hacker News API

为探索如何使用其他网站的API调用，我们来看看

Hacker News网站，用户分享编程和技术方面的文章，并就这些文章展开积极的讨论。Hacker News的API让你能够访问有关该网站所有文章和评论的信息，且不要求通过注册获得密钥。

已被墙。

问题

Jupyter Notebook 用matplotlib作图显示中文乱码

1
plt.rc('font', family='SimHei', size=7)  ##显示中文，字体大小根据需要调整

存在极端值干扰

  • 使用query()做范围的筛选

  • 根据切比雪夫定理做筛选：

    • 所有数据中，至少有75%的数据位于平均数2个标准差范围内

  • 所有数据中，至少有88.9%的数据位于平均数3个标准差范围内

    • 所有数据中，至少有96%的数据位于平均数5个标准差范围内

条形图和直方图的区别

  • 条形图(bar chart)

    1. 用条形的高度表示各类别频数的多少，其宽度(表示类别)则是固定的；
    2. 条形图各矩形分开排列(有间隙)
    3. 主要用于展示分类数据

  • 直方图(Histogram)

    1. 用面积表示各组频数的多少，矩形的高度表示每一组的频数或频率，宽度则表示各组的组距
    2. 分组数据具有连续性，直方图各矩形通常是连续排列
    3. 主要用于展示数值型数据

绘图时x轴/y轴的刻度标签重叠

Matplotlib绘图时x轴标签重叠的解决办法 - 云+社区 - 腾讯云

  • 方法一：

    拉长画布

  • 方法二：

    调整刻度标签的字体大小：plt.tick_params(axis='x', labelsize=8)

  • 方法三：

    将纵向图改为横向，如条形图：plt.barh()

  • 方法四：

    旋转刻度标签的角度：plt.xticks(rotation=30)

Pandas常用图表简介

箱线图(箱型图/盒型图)

直方图用于显示一组数据的分布情况，而箱线图用于显示一组数据内部的分散情况。例如： 最大值、最小值，中位数，4分位数、异常值等等。

  • 箱线图各部位的含义

    箱线图各部位的含义

    • 上四分位数(QU)：第75%位数

    • 下四分位数(QL)：第25%位数

    • 异常值的标准：

      • IQR(Inter-Quatile range)：四分位距

        IQR = QU - QL，IQR包含了全部观察值的一半

      • 过小的异常值为 $<$ QL-1.5IQR的值

      • 过大的异常值 $>$ QU+1.5IQR的值

    Matplotlib中绘制箱线图的函数为DataFrame.boxplot()

一文学会matplotlib绘图