生成数据
- 数据可视化：通过可视化表示来探索数据
- 数据挖掘：使用代码来探索数据集的规律和关联
安装 matplotlib
pip
pip是一个以Python写成的软件包管理系统，它可以安装和管理软件包。
大多数较新的Python版本都自带pip，因此首先可检查系统是否已经安装了pip。
在 Windows 系统中安装 matplotlib
在Windows系统中，首先需要安装Visual Studio。接下来，访问matplotlib · PyPI，查找与使用的Python版本、操作系统相匹配的.whl文件。
将这个.whl文件复制到项目所在文件夹，打开命令窗口，使用pip来安装matplotlib:
python -m pip install --user matplotlib-3.2.2-cp38-cp38-win32.whl
测试 matplotlib
安装必要的包后，对安装进行测试。为此，首先使用命令python或python3启动一个终端会话，再尝试导入matplotlib:
$ python3
>>> import matplotlib
如果没有出现任何错误消息，就说明成功安装了 matplotlib。
绘制简单的折线图
我们将使用平方数序列1、4、9、16和25来绘制这个图表。
import matplotlib.pyplot as plt
%matplotlib inline
squares = [1, 4, 9, 16, 25]
plt.plot(squares)
plt.show()
修改标签文字和线条粗细
上述代码通过matplotlib查看器显示的图形，标签文字太小、线条太细。下面通过一些定制来改善这个图形的可读性：
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()同时提供输入值和输出值：
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坐标，它将在指定位置绘制一个点。
import matplotlib.pyplot as plt
plt.scatter(2, 4)
plt.show()
下面来设置输出的样式，使其更有趣：添加标题，给轴加上标签，并确保所有文本都大到能够看清：
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值的列表，如下所示：
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--
--snip--
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'
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()排除一些极端值的干扰
gu = grouped_user.sum().query('order_amount < 6000')
plt.scatter(gu['order_amount'], gu['order_products'])
自动计算数据
下面是绘制1000个点的代码：
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内置了一组颜色映射：
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可视化饼图 - 知乎
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),
startangle = 90,
autopct = '%1.1f%%'
)
plt.axis('equal')
plt.title("男女乘客比例")
plt.tight_layout()
plt.show()
随机漫步
随机漫步是这样行走得到的路径：每次行走都完全是随机的，没有明确的方向，结果是由一系列随机决策决定的。在自然界、物理学、生物学、化学和经济领域，随机漫步都有其实际用途。例如，漂浮在水滴上的花粉因不断受到水分子的挤压而在水面上移动。水滴中的分子运动是随机的，因此花粉在水面上的运动路径犹如随机漫步。
创建 RandomWalk() 类
创建一个RandomWalk()类，这个类需要三个属性：
- 存储随机漫步次数的变量
- 随机漫步经过的每个点的x坐标
- 随机漫步经过的每个点的y坐标
RandomWalk()类只包含两个方法：
__init__()fill_walk()：计算随机漫步经过的所有点
先来看看__init__():
from random import choice
class RandomWalk():
"""一个生成随机漫步数据的类"""
def __init__(self, num_points=5000):
"""初始化随机漫步的属性"""
self.num_points = num_points
self.x_values = [0]
self.y_values = [0]
为做出随机决策，我们将所有可能的选择都存储在一个列表中，并在每次做决策时都使用choice()来决定使用哪种选择。
选择方向
我们将使用fill_walk()来生成漫步包含的点，并决定每次漫步的方向，如下所示：
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
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：
import matplotlib.pyplot as plt
from random_walk import RandomWalk
rw = RandomWalk()
rw.fill_walk()
plt.scatter(rw.x_values, rw.y_values, s=15)
plt.show()
模拟多次随机漫步
要在不多次运行程序的情况下模拟多次随机漫步，一种办法是将这些代码放在一个while循环中，如下所示：
import matplotlib.pyplot as plt
from random_walk import RandomWalk
while True:
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：
--snip--
while True:
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--
重新绘制起点和终点
--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--
隐藏坐标轴
--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的值，并在绘图时调整每个点的大小，如下所示：
--snip--
while True:
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输出的尺寸：
--snip--
while True:
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 类
下面的类模拟掷一个骰子：
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骰子，将结果打印出来，并检查结果是否合理：
from die import Die
die = Die()
results = []
for roll_num in range(100):
result = die.roll()
results.append(result)
print(results)
分析结果
为分析掷一个D6骰子的结果，我们计算每个点数出现的次数：
--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)，指出各种结果出现的频率。
- 利用pygal绘制
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)
- 利用pyplot绘制
import pandas as pd
import matplotlib.pyplot as plt
plt.hist(titanic['Fare'], bins = range(0,600,10))
plt.xlabel('Fare')
plt.ylabel('Frequency')
plt.title('船票价格分布')
plt.show()
plt.hist(grouped_user.sum().query('order_amount < 1000')['order_amount'], bins = 20)
plt.show()
同时掷两个骰子
import pygal
from die import Die
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次的结果：
from die import Die
import pygal
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')
下载数据
网上的数据多得难以置信，且大多未经过仔细检查。如果能够对这些数据进行分析，你就能发现别人没有发现的规律和关联。
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文件的第一行，其中包含一系列有关数据的描述：
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处理文件中以逗号分隔的第一行数据，并将每项数据都作为一个元素存储在列表中。
注意：文件头的格式并非总是一致的， 空格和单位可能出现在奇怪的地方，但不会带来任何问题。
打印文件头及其位置
为让文件头数据更容易理解，将列表中的每个文件头及其位置打印出来：
--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()(枚举)来获取每个元素的索引及其值。
提取并读取数据
首先读取每天的最高气温：
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)
下面使用int()将这些字符串转换为数字，让matplotlib能够读取它们：
--snip--
highs = []
for row in reader:
high = int(row[1])
highs.append(high)
print(highs)
绘制气温图表
为可视化这些气温数据，我们首先使用matplotlib创建一个显示每日最高气温的简单图形：
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轴日期的显示间隔
plt.xticks(pd.date_range('1997-01-01', '1997-04-01', freq='10d'))
模块 datetime
下面在图表中添加日期。在天气数据文件中，第一个日期在第二行：
获取日期数据时，获得的是一个字符串，因此需要将字符串'2014-7-1'转换为一个表示相应日期的对象。可使用模块datetime中的方法strptime()：
>>> from datetime import datetime
>>> first_date = datetime.strptime('2014-7-1', '%Y-%m-%d')
>>> print(first_date)
2014-07-01 00:00:00
在图表中添加日期
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')
涵盖更长的时间
创建覆盖整年的天气图：
--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--
再绘制一个数据系列
从数据文件中提取最低气温，并添加到图表中：
--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值系列之间的空间：
--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指定颜色的透明度
fill_between()
错误检查
我们应该能够使用有关任何地方的天气数据来运行highs_lows.py中的代码，但有些气象站会偶尔出现故障，未能收集部分或全部其应该收集的数据。缺失数据可能会引发异常，如果不妥善地处理，还可能导致程序崩溃。
例如，我们来看看生成加利福尼亚死亡谷的气温图时出现的情况：
--snip--
filename = 'death_valley_2014.csv'
withj open(filename) as f:
--snip--
运行结果：
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文件中读取值时执行错误检查代码，对分析数据集时可能出现的异常进行处理：
--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轴的刻度做限制。
--snip--
plt.ylim(10, 120)
plt.show()
尝试在一个图表中呈现这两个数据集：
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()来下载数据，可以使用如下代码：
from __future__ import (absolute_import, division, print_function, unicode_literals)
try:
from urllib2 import urlopen
except ImportError:
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)
file_urllib = json.loads(req)
print(file_urllib)
函数urlopen的代码稍微复杂一些，第三方模块requests封装了许多常用的方法，让数据下载和读取方式变得非常简单：
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内容相同
提取相关的数据
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()：
--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轴数据，因此我们创建了几个列表来存储数据：
--snip--
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的配置参数，对图形进行适当的调整：
--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
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)变换。
--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
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)的日均值，以及每周各天的日均值。虽然这些日均值的数值不同，但都是一段时间的均值，计算方法都是一样的。因此，可以将绘图代码封装成函数，以便重复使用。
--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索引的位置，确定周数和收盘价的取值范围：
idx_month = dates.index('2017-12-01')
line_chart_month = draw_line(months[:idx_month], close[:idx_month], '收盘价月日均值（￥）',
'月日均值')
line_chart_month
收盘价数据仪表盘
每个SVG文件打开之后都是独立的页面，如果能整合在一起，就可以方便地进行长期管理、监测和分析。另外，新的图表也可以方便地加入进来，这样就形成了一个数据仪表盘(dashboard)。下面，将之前绘制的图整合起来，做一个收盘价数据仪表盘：
--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调用是什么样的，在浏览器中访问如下地址：
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，执行：
pip install --user requests
处理 API 响应
下面来编写一个程序，它执行API调用并处理结果，找出GitHub上星级最高的Python项目：
import requests
url = 'https://api.github.com/search/repositories?=language:python&sort=stars'
r = requests.get(url)
print("Status code:", r.status_code)
response_dict = r.json()
print(response_dict.keys())
处理响应字典
下面来生成一些概述API调用返回的信息的输出：
import requests
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
r = requests.get(url)
print("Status code:", r.status_code)
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中与一些键相关联的值：
--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调用返回的每个仓库的特定信息，以便能够在可视化中包含所有这些信息：
--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，将得到类似于下面的响应：
{
"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上的主页。
import requests
import pygal
from pygal.style import LightColorizedStyle as LCS, LightenStyle as LS
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
r = requests.get(url)
print("Status code:", r.status_code)
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()的所有定制：
--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()传递一个字典列表，而不是值列表：
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个项目的信息：
--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'的 键-值 对：
--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作图显示中文乱码
plt.rc('font', family='SimHei', size=7)
存在极端值干扰
条形图和直方图的区别
条形图(bar chart)
- 用条形的高度表示各类别频数的多少，其宽度(表示类别)则是固定的；
- 条形图各矩形分开排列(有间隙)
- 主要用于展示分类数据
直方图(Histogram)
- 用面积表示各组频数的多少，矩形的高度表示每一组的频数或频率，宽度则表示各组的组距
- 分组数据具有连续性，直方图各矩形通常是连续排列
- 主要用于展示数值型数据
绘图时x轴/y轴的刻度标签重叠
Matplotlib绘图时x轴标签重叠的解决办法 - 云+社区 - 腾讯云
箱线图(箱型图/盒型图)
直方图用于显示一组数据的分布情况，而箱线图用于显示一组数据内部的分散情况。例如： 最大值、最小值，中位数，4分位数、异常值等等。
