数据可视化 matplotlib

数据可视化

数据可视化指的是通过可视化表示来探索的数据，它与数据挖掘紧密相关，而数据挖掘指的是使用代码来探索数据集的规律和关联。

在基因研究、天气研究、政治经济分析等众多领域，大家都使用python来完成数据秘密集型工作。数据科学家使用python编写了一系列令人印象深刻的可视化和分析工具。最流行的工具之一是matplotlib，他是一个数学绘图库。我们将使用它来制作简单的图表。

1.安装matplotlib

在Linux环境安装matplotlib

yum install python3-matplotlib

在Windows环境安装matplotlib

win + r
 
进入cmd框
 
python -m pip install matplotlib
 

pychmon安装matplotlib

参考
https://blog.csdn.net/Lemostic/article/details/81676603

测试matplotlib

首先使用python或或者python3启动一个终端，再尝试导入matplotlib

C:\Users\86153>python
>>> import matplotlib
>>>
 

如果没有出现任何错误消息，就说明你的系统安装了matplotlib。

matplotlib画廊

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

2.绘制简单的折线图

参数

.plot(squ)	#该函数尝试根据这些数据绘制出有意义的图形。
.show()	#打开matplotlib查看器，并显示绘制的图形。
.title()	#给图表指定标签题
 
//为每条轴设置标题，fontsize指定图表中文字的大小
.xlabel()	
.ylabel()
 
.tick_params()	#设置刻度标记样式大小
 
.scatter() 要绘制单个点，并向它传递一对x和y坐标，他将在指定位置绘制一个点。
 
.savefig()	#要让程序自动将图表保存到文件中

1.绘制简单的折线图

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

import matplotlib.pyplot as pyplot  #先导入pyplot模块，并给他指定pyplot。
 
 
squ = [1,4,9,16,25]		#创建列表存放平均数
pyplot.plot(squ)	#该函数尝试根据这些数据绘制出有意义的图形。
pyplot.show()	#打开matplotlib查看器，并显示绘制的图形。

2.修改标签文字和线条粗细

import matplotlib.pyplot as plt
 
squ = [1,4,9,16,25]
plt.plot(squ,linewidth=5)	#参数linewidth决定了plot()绘制的线条的粗细
 
#设置图表标题，并给坐标轴加上标签
plt.title("square",fontsize=24)	#给图表指定标签题，fontsize指定图表中文字的大小
 
#为每条轴设置标题，fontsize指定图表中文字的大小
plt.xlabel("value",fontsize=24)	
plt.ylabel("square of value",fontsize=24)
 
#设置刻度标记样式大小（其中指定的实参将影响x轴与y轴上的刻度（axis='both'），并将刻度标记的字号设置成14.）
plt.tick_params(axis='both',labelsize=14)
 
plt.show()

3.校正数据

图形更容易阅读后，我们发现没有正确的绘制数据：折线图的终点指出4.0的平方为25！

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

import matplotlib.pyplot as plt
 
input_values = [1,2,3,4,5]		#提供输入值
squ = [1,4,9,16,25]
 
 
plt.plot(input_values,squ,linewidth=5)	#使用输入值
 
#设置图表标题，并给坐标轴加上标签
plt.title("square",fontsize=24)
plt.xlabel("value",fontsize=24)
plt.ylabel("square of value",fontsize=24)
 
#设置刻度标记大小
plt.tick_params(axis='both',labelsize=14)
 
plt.show()
 

现在plot()将正确的绘制数据，因为我们同时提供了输入值和输出值，它无需对输出值的生成方式作出假设。

使用plot()时可指定各种实参，还可以使用众多函数对图形进行定制。

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

有时候，需要绘制散点图并设置各个数据点的样式。绘制大型数据集时，你还可以对每个点都设置同样的样式，再使用不同的样式选择重新绘制某些点，以突出他们。

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

import matplotlib.pyplot as plt
 
plt.scatter(2,4,s=200)  #s：使用实参s设置了绘制图形时使用的点的尺寸。
 
#设置图表标题并给坐标轴机上标签
plt.title("square",fontsize=24)
plt.xlabel("value",fontsize=24)
plt.ylabel("square of value",fontsize=24)
 
#设置刻度标记大小
plt.tick_params(axis='both',which='major',labelsize=14)
plt.show()

5.使用scatter()绘制一系列点

要绘制一系列点，可想scatter()传递两个分别包含x值和y值的列表。

import matplotlib.pyplot as plt
 
x_value = [1,2,3,4,5]   #要计算其平方值的数字
y_vlaue = [1,4,9,16,25] #包含x列每个数字的平方值
#将这些列表传递给scatter()时，，matplotlib一次从每个列表中读取一个值来绘制一个点。
#要绘制的点的坐标分别为（1，1）（2,4）（3,9）等。
plt.scatter(x_value,y_vlaue,s=100)  #s：使用实参s设置了绘制图形时使用的点的尺寸。
 
#设置图表标题并给坐标轴机上标签
plt.title("square",fontsize=24)
plt.xlabel("value",fontsize=24)
plt.ylabel("square of value",fontsize=24)
 
#设置刻度标记大小
plt.tick_params(axis='both',which='major',labelsize=14)
plt.show()

6.自动计算数据

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

绘制1000个点

import matplotlib.pyplot as plt
 
x_value = list(range(1,1001))
y_value = [x**2 for x in x_value]
print(y_value[-1])
plt.scatter(x_value,y_value,s=10)
#设置图表标题并给坐标轴机上标签
plt.title("square",fontsize=24)
plt.xlabel("value",fontsize=14)
plt.ylabel("square of value",fontsize=14)
 
#设置每个坐标轴的取值范围
plt.axis([0,1100,0,1100000])
plt.show()
 

我们先创建一个包含x值的列表，其中包含数字1-1000。使用列表生成式计算y的列表，它遍历x值（for x in x_value），计算其平方值（x**2），并将结果存储到列表y_value中，然后,将输入列表和输出列表传递给scatter()。
由于这个数据集比较大，我们将点设置得较小，并使用函数axis()指定了每一个坐标轴的取值范围。函数axis()要求提供四个值：x和y坐标轴的最小值和最大值。

7.删除数据点的轮廓

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

plt.scatter(x_value,y_value,edgecolors='none',s=200)

测试没看出来区别

8.自定义颜色

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

plt.scatter(x_value,y_value,c='red',s=200)

还可以使用RGB颜色模式自定义颜色。要指定自定义颜色，可传递参数c，并将其设置为一个元组，将其包含三个0~1之间的小数值，他们分别代表红色、绿色和蓝色分量。

创建一个淡蓝点组成的散图

plt.scatter(x_value,y_value,c=(0,0,0.8),s=200)

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

9.使用颜色映射

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

模块pyplot内置了一组颜色映射。要使用这些颜色映射，你需要告诉python该如何设置数据集汇中每个点的颜色。

根据Y值来设置其颜色

import matplotlib.pyplot as plt
x_value = list(range(1,1001))
y_value = [x**2 for x in x_value]
plt.scatter(x_value,y_value,c=y_value,cmap=plt.cm.Reds,s=40)
#设置图表标题并给坐标轴机上标签
plt.title("square",fontsize=14)
plt.xlabel("value",fontsize=14)
plt.ylabel("square of value",fontsize=14)
 
#设置每个坐标轴的取值范围
plt.axis([0,1100,0,1100000])
plt.show()

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

注意：要了解python中所有的颜色映射，请访问http://matplotlib.org ，单击Examples,找到color，再找到colormap

官方文档颜色

https://matplotlib.org/stable/gallery/color/colormap_reference.html#sphx-glr-gallery-color-colormap-reference-py
 
import numpy as np
import matplotlib.pyplot as plt
 
 
cmaps = [('Perceptually Uniform Sequential', [
            'viridis', 'plasma', 'inferno', 'magma', 'cividis']),
         ('Sequential', [
            'Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds',
            'YlOrBr', 'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu',
            'GnBu', 'PuBu', 'YlGnBu', 'PuBuGn', 'BuGn', 'YlGn']),
         ('Sequential (2)', [
            'binary', 'gist_yarg', 'gist_gray', 'gray', 'bone', 'pink',
            'spring', 'summer', 'autumn', 'winter', 'cool', 'Wistia',
            'hot', 'afmhot', 'gist_heat', 'copper']),
         ('Diverging', [
            'PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu',
            'RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr', 'seismic']),
         ('Cyclic', ['twilight', 'twilight_shifted', 'hsv']),
         ('Qualitative', [
            'Pastel1', 'Pastel2', 'Paired', 'Accent',
            'Dark2', 'Set1', 'Set2', 'Set3',
            'tab10', 'tab20', 'tab20b', 'tab20c']),
         ('Miscellaneous', [
            'flag', 'prism', 'ocean', 'gist_earth', 'terrain', 'gist_stern',
            'gnuplot', 'gnuplot2', 'CMRmap', 'cubehelix', 'brg',
            'gist_rainbow', 'rainbow', 'jet', 'turbo', 'nipy_spectral',
            'gist_ncar'])]
 
 
gradient = np.linspace(0, 1, 256)
gradient = np.vstack((gradient, gradient))
 
 
def plot_color_gradients(cmap_category, cmap_list):
    # Create figure and adjust figure height to number of colormaps
    nrows = len(cmap_list)
    figh = 0.35 + 0.15 + (nrows + (nrows-1)*0.1)*0.22
    fig, axs = plt.subplots(nrows=nrows, figsize=(6.4, figh))
    fig.subplots_adjust(top=1-.35/figh, bottom=.15/figh, left=0.2, right=0.99)
 
    axs[0].set_title(cmap_category + ' colormaps', fontsize=14)
 
    for ax, name in zip(axs, cmap_list):
        ax.imshow(gradient, aspect='auto', cmap=plt.get_cmap(name))
        ax.text(-.01, .5, name, va='center', ha='right', fontsize=10,
                transform=ax.transAxes)
 
    # Turn off *all* ticks & spines, not just the ones with colormaps.
    for ax in axs:
        ax.set_axis_off()
 
 
for cmap_category, cmap_list in cmaps:
    plot_color_gradients(cmap_category, cmap_list)
 
plt.show()

10.自动保存图表

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

plt.savefig('C:\\Users\86153\Desktop\MEG.png',bbox_inches='tight')

第一个实参指定要以什么样的文件保存文件，以及文件路径，如果不写文件路径，泽保存在py文件所在的文件的目录中；
第二个参数指定将图表多余的空白区域裁减掉。如果要保留图表周围多余的空白区域，可省略这个实参。

练习

数字的三次方成为立方，绘制一个图形，显示前五个数的立方

import matplotlib.pyplot as plt
 
x_value = [1,2,3,4,5]
y_value = [x*x*x for x in x_value]
 
plt.plot(x_value,y_value,linewidth=5,color='m')
# plt.scatter(x_value,y_value,c=y_value,cmap=plt.cm.Reds)
 
plt.title("biaoti",fontsize=24)
plt.xlabel("value",fontsize=19)
plt.ylabel("y-value",fontsize=19)
 
plt.axis([1,6,0,150])
plt.show()

数字的三次方成为立方，绘制一个图形，显示前5000个整数的立方值。

import matplotlib.pyplot as plt
 
x_value = list(range(1,5001))
y_value = [x*x*x for x in x_value]
 
plt.scatter(x_value,y_value,s=40,c=y_value,cmap=plt.cm.Reds)
# plt.scatter(x_value,y_value,c=y_value,cmap=plt.cm.Reds)
 
plt.title("biaoti",fontsize=24)
plt.xlabel("value",fontsize=19)
plt.ylabel("y-value",fontsize=19)
 
# plt.axis([1,6,0,150])
plt.show()

模拟骰子出现的次数

模拟摇骰子

from random import randint
 
class Die():
    """表示一个骰子的类"""
 
    def __init__(self,num=6):
        self.num = num
 
    def roll(self):
        """返回一个位于1和骰子面数之间的随机值"""
        return randint(1,self.num)

数据可视化

#使用matplotlib模拟掷骰子
 
import matplotlib.pyplot as plt
from pygalwww import Die
from matplotlib.pyplot import MultipleLocator as mult
#创建一个6面骰子和一个10面骰子
die_1 = Die(8)
die_2 = Die(10)
#掷几次骰子，并将掷出来的点数存储在一个列表中
results = [ die_1.roll() + die_2.roll() for i in range(500)]       #每次产生的点数相加
 
#会出现的点数
max_result = die_1.num + die_2.num
x_freq = [i for i in range(2,max_result+1)]     #结果分析，计算都会有哪些值出现
y_freq = [results.count(i) for i in range(2,max_result+1)]      #结果分析，统计每个点数出现的次数
 
#数据可视化
plt.plot(x_freq,y_freq,linewidth=4,c='green')
print(x_freq)
plt.xlabel("value")
plt.ylabel("value of")
 
#把x轴间隔设置为1,并存在变量里面
x_major = mult(1)
#ax为两条坐标轴的实例
ax = plt.gca()
#把x轴的主刻度设置为1的倍数
ax.xaxis.set_major_locator(x_major)
 
plt.xlim(0,20)
# plt.ylim(0,100)
 
plt.show()

3.随机漫步

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

参数

 
 
.figure() #用于指定图表的宽度、高度、分辨率和背景色。
	figsize=(x,y)	#绘图窗口的尺寸，单位是英寸
	dpi=xxx		#分辨率
	
//隐藏坐标轴
.xticks([])  #去掉x轴
.yticks([])  #去掉y轴
.axis('off') #去掉坐标轴

随机漫步scatter()

1.1创建rand()类

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

rand类只包含两个方法：init()和fill_walk(),其后者计算随机漫步经过的所有点。

//创建类，选择方向
from random import choice	#调用随机数模块
 
#创建类
class Rand():
    """一个生成随机漫步数据的类"""
 
    def __init__(self,num=50000):
        """初始化随机漫步的属性"""
        self.num = num		#漫步的次数
 
        #所有随机漫步都始于（0,0）
        self.x_value = [0]
        self.y_value = [0]
 
#选择方向
    def fill_walk(self):
        """计算随机漫步包含的所有点"""
 
        #不断漫步，直到列表达到指定的长度，退出漫步
        while len(self.x_value) < self.num:
 
            #决定前进方向以及沿这个方向前进的距离
            x_dir = choice([1,-1])	#向左-1 向右1
            x_dis = choice([0,1,2,3,4])	#移动几个距离
            x_step = x_dir * x_dis
 
 
            y_dir = choice([1,-1])
            y_dis = choice([0,1,2,3,4])
            y_step = y_dir * y_dis
 
            #拒绝原地踏步
            if x_step == 0 and y_step == 0:
                continue
 
            #计算下一个点的x和y值
            next_x = self.x_value[-1] + x_step
            next_y = self.y_value[-1] + y_step
 
            self.x_value.append(next_x)
            self.y_value.append(next_y)
			#为获得漫步中下一个点x值，我们将x_step和y_value中的最后一个值相加，与y值也是同理。获得下一个点的x值和y值，我们将他们分别附加到列表的末尾。
 
//绘制图表
import matplotlib.pyplot as plt
 
#创建一个rand实例，并将其包含的点都绘制出来
rw = Rand()
rw.fill_walk()
 
#设置绘图窗口的尺寸
plt.figure(figsize=(10,6))
 
#给点着色
point = list(range(rw.num))
plt.scatter(rw.x_value,rw.y_value,c=point,cmap=plt.cm.Blues,s=1)
 
#突出起点和终点
plt.scatter(0,0,c='green',s=100)
plt.scatter(rw.x_value[-1],rw.y_value[-1],c='red',s=100)
 
#隐藏坐标轴
plt.xticks([])  #去掉x轴
plt.yticks([])  #去掉y轴
plt.axis('off') #去掉坐标轴
plt.show()
 

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

分子运动 plot()

分子运动：模拟花粉在水滴表面的运动轨迹。

重构了随机漫步代码

from random import choice
 
#创建类
class Rand():
    """一个生成随机漫步数据的类"""
 
    def __init__(self,num=5000):
        """初始化随机漫步的属性"""
        self.num = num
        
    def get_step(self):
        """用于确定漫步的距离和方向"""
 
        # 所有随机漫步都始于（0,0）
        value = [0]
        while len(value) < self.num:
            # 决定前进方向以及沿这个方向前进的距离
            dir = choice([1, -1])
            dis = choice([0, 1, 2, 3, 4, 5, 6, 7, 8])
            step = dir * dis
 
            # 计算下一个点的x和y值
            next_x = value[-1] + step
            value.append(next_x)
        return value
 
    def fill_walk(self):
        """计算随机漫步包含的所有点"""
        x_step = self.get_step()
        y_step = self.get_step()
 
        self.x_step = x_step
        self.y_step = y_step
 
 
import matplotlib.pyplot as plt
 
#创建一个rand实例，并将其包含的点都绘制出来
rw = Rand()
rw.fill_walk()
 
#设置绘图窗口的尺寸
plt.figure(figsize=(10,6))
 
#给点着色
point = list(range(rw.num))
# plt.scatter(rw.x_value,rw.y_value,c=point,cmap=plt.cm.Blues,s=1)
plt.plot(rw.x_step,rw.y_step,linewidth=3)
 
#突出起点和终点
plt.scatter(0,0,c='green',s=100)
plt.scatter(rw.x_step[-1],rw.y_step[-1],c='red',s=100)
 
#隐藏坐标轴
plt.xticks([])  #去掉x轴
plt.yticks([])  #去掉y轴
plt.axis('off') #去掉坐标轴
plt.show()

4.1.使用pygal模拟掷骰子

本节，我们将使用python可视化包pygal来生成可缩放的矢量图形文件。对于需要在尺寸不同的屏幕上显示的图表，这很有用，因为他们将自动缩放，以适合观看者屏幕。

我们将对掷骰子的结果进行分析。掷6面的常规骰子时，可能会出现的结果为1-6点，且出现每种结果的可能性相同。为确定哪些点数出现的可能性最大，我们将生成一个表示掷骰子结果的数据集，并根据结果绘制出一个图形。

在数学领域，常常利用掷骰子来解释各个数据分析，但他在赌场和其他博弈场景中也得到了

2.安装pygal

Linux和OS x系统中，应执行

pip install --user pygal

在Windows系统中

python -m pip install --user pygal

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

2.1pygal画廊

要了解使用pygal可创建什么样的图表，请查看图表类型画廊，访问：http://www.pygal.org/ ,单击documentation，再单击chart types。每个实例都包含源代码。

2.2 模拟一个掷骰子

创建Die类,模拟骰子出点数

from random import randint
 
class Die():
    """表示一个骰子的类"""
 
    def __init__(self,num=6):
        self.num = num
 
    def roll(self):
        """返回一个位于1和骰子面数之间的随机值"""
        return randint(1,self.num)

数据处理

import pygal
from pygalwww import Die
 
#创建一个D6
die = Die()
 
#掷几次骰子，并将结果存储在一个列表中
results = []        #存放每次掷骰子的点数
for i in range(1000):       #掷N次骰子
    result = die.roll()     #每次产生的点数
    results.append(result)  #将产生的点数存入列表
# print(results)
 
#结果分析
freq = []       #统计每个点数出现的次数
for  value in range(1,die.num+1):   #range出会出现的点数
    fre = results.count(value)      #count：统计在列表中出现的次数
    freq.append(fre)        #将统计出来的次数存入列表中。
# print(freq)
 
#对比结果可视化
hist = pygal.Bar()      #创建条形图，创建的一个实例
 
hist.title = "Results of rolling."      #用于标示直方图的字符串
hist.x_labels = ['1','2','3','4','5','6']   #轴x的值
hist.x_title = 'Result'     #轴x的标题
hist.y_title = "Frequency of Result"    #轴y的标题
 
hist.add('D6',freq)     #将一系列值添加到图标中（向它传递要给添加的值指定的标签，还有一个列表，其中包含将出现在图标中的值。）
hist.render_to_file('die_visual.svg')   #将这个图表渲染为一个SVG文件，这种文件名称必须为.svg。

要查看生成的直方图，最简单的方式就是使用web浏览器。

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

2.3同时掷两个骰子

同时掷两个骰子时，得到的点数更多，结果分布也不同。下面修改代码，创建两个D6骰子，以模拟同时掷两个骰子的情况。每次掷骰子时，我们都将两个骰子的点数相加，并将结果存储。

创建Die类,模拟骰子出点数

from random import randint
 
class Die():
    """表示一个骰子的类"""
 
    def __init__(self,num=6):
        self.num = num
 
    def roll(self):
        """返回一个位于1和骰子面数之间的随机值"""
        return randint(1,self.num)

数据处理

import pygal
from pygalwww import Die
 
 
#创建两个D6骰子
die_1 = Die()
die_2 = Die()
 
#掷几次骰子，并将结果存储在一个列表中
results = []        #存放每次掷骰子的点数
for i in range(1000):       #掷N次骰子
    result = die_1.roll() + die_2.roll()     #每次产生的点数相加
    results.append(result)  #将产生的点数存入列表
 
# print(results)
print(len(results))
 
#结果分析
freq = []       #统计每个点数出现的次数
max_result = die_1.num + die_2.num      #会出现的点数
for  value in range(2,max_result+1):   #range出会出现的点数
    fre = results.count(value)      #count：统计在列表中出现的次数
    freq.append(fre)        #将统计出来的次数存入列表中。
 
print(freq)
 
#对比结果可视化
hist = pygal.Bar()      #创建条形图，创建的一个实例
 
hist.title = "Results of rolling."      #用于标示直方图的字符串
hist.x_labels = ['2','3','4','5','6','7','8','9','10','11','12']   #轴x的值
hist.x_title = 'Result'     #轴x的标题
hist.y_title = "Frequency of Result"    #轴y的标题
 
hist.add('D6 + D6',freq)     #将一系列值添加到图标中（向它传递要给添加的值指定的标签，还有一个列表，其中包含将出现在图标中的值。）
hist.render_to_file('die_visual.svg')   #将这个图表渲染为一个SVG文件，这种文件名称必须为.svg。

两个骰子买7看来不是没有道理的~~

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

创建一个6面骰子和一个10面骰子，看掷出结果如何

创建骰子

数据生成

import pygal
from pygalwww import Die
 
 
#创建一个6面骰子和一个10面骰子
die_1 = Die()
die_2 = Die(10)
 
#掷几次骰子，并将结果存储在一个列表中
results = []        #存放每次掷骰子的点数
for i in range(5000):       #掷N次骰子
    result = die_1.roll() + die_2.roll()     #每次产生的点数相加
    results.append(result)  #将产生的点数存入列表
 
# print(results)
print(len(results))
 
#结果分析
freq = []       #统计每个点数出现的次数
max_result = die_1.num + die_2.num      #会出现的点数
for  value in range(2,max_result+1):   #range出会出现的点数
    fre = results.count(value)      #count：统计在列表中出现的次数
    freq.append(fre)        #将统计出来的次数存入列表中。
 
print(freq)
 
#对比结果可视化
hist = pygal.Bar()      #创建条形图，创建的一个实例
 
hist.title = "Results of rolling."      #用于标示直方图的字符串
hist.x_labels = ['2','3','4','5','6','7','8','9','10','11','12','13','14','15','16']   #轴x的值
hist.x_title = 'Result'     #轴x的标题
hist.y_title = "Frequency of Result"    #轴y的标题
 
hist.add('D6 + D10',freq)     #将一系列值添加到图标中（向它传递要给添加的值指定的标签，还有一个列表，其中包含将出现在图标中的值。）
hist.render_to_file('die_visual.svg')   #将这个图表渲染为一个SVG文件，这种文件名称必须为.svg。

为创建D10骰子，我们在创建第二个die实例时传递了实参10，将循环次数从1000次修改为了5000次。

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

将for循环优化为列表解析，优化hist.x_labels值的为自动生成。优化hist.add的名称自动生成

import pygal
from pygalwww import Die
#创建一个6面骰子和一个10面骰子
die_1 = Die(8)
die_2 = Die(8)
#掷几次骰子，并将掷出来的点数存储在一个列表中
results = [ die_1.roll() + die_2.roll() for i in range(500)]       #每次产生的点数相加
 
#结果分析，统计每个点数出现的次数
max_result = die_1.num + die_2.num      #会出现的点数
freq = [results.count(i) for i in range(2,max_result+1)]
 
#对比结果可视化
hist = pygal.Bar()      #创建条形图，创建的一个实例
 
hist.title = "Results of rolling."      #用于标示直方图的字符串
hist.x_labels = [i for i in range(2,max_result+1)]   #轴x的值
hist.x_title = 'Result'     #轴x的标题
hist.y_title = "Frequency of Result"    #轴y的标题
 
hist.add(f'D{die_1.num} + D{die_2.num}',freq)     #将一系列值添加到图标中（向它传递要给添加的值指定的标签，还有一个列表，其中包含将出现在图标中的值。）
hist.render_to_file('die_visual.svg')   #将这个图表渲染为一个SVG文件，这种文件名称必须为.svg。

模拟随机漫步

from random import choice
 
#创建类
class Rand():
    """一个生成随机漫步数据的类"""
 
    def __init__(self,num=5000):
        """初始化随机漫步的属性"""
        self.num = num
 
    def get_step(self):
        """用于确定漫步的距离和方向"""
 
        # 所有随机漫步都始于（0,0）
        value = [0]
        while len(value) < self.num:
            # 决定前进方向以及沿这个方向前进的距离
            dir = choice([1, -1])
            dis = choice([0, 1, 2, 3, 4, 5, 6, 7, 8])
            step = dir * dis
 
            # 计算下一个点的x和y值
            next_x = value[-1] + step
            value.append(next_x)
        return value
 
    def fill_walk(self):
        """计算随机漫步包含的所有点"""
        x_step = self.get_step()
        y_step = self.get_step()
 
        self.x_step = x_step
        self.y_step = y_step
 
 
#初始化数据
import pygal
 
#生成漫步类
py = Rand()
py.fill_walk()
 
#x轴和y轴生成元组
add_all = [(0,0)]
for i in range(1,py.num):
	add_all.append((py.x_step[i],py.y_step[i]))
 
#实例化XY类，参数stroke=False说明我们不需要绘制折线，只要点
xy_chart = pygal.XY(stroke=False)
#把我们图表的标题设置好
xy_chart.title = 'suijimanbu'
#把点的标签，横纵坐标设置好
xy_chart.add('A', add_all)
xy_chart.render_to_file('C:\\Users\\MEG\\Desktop\\Python\\bar_chart.svg')
 

5.下载数据

本章将从网上下载数据，并对这些数据进行可视化。我们将访问并可视化的数据以常见格式存储的数据：CSV和JSON。

5.1 JSON格式

下载json格式的交易收盘价数据，并使用模块json来处理他们。使用pygal对收盘价格数据进行可视化，以探索价格变化的周期性。

1.1 下载收盘价数据

附件

1.2 提取相关数据

import json
 
#将数据加载到一个列表中
filename = 'btc_close_2017.json'
with open(filename) as f:
    f = f.read()
    btc_data = json.loads(f)
 
#打印每一天的信息
for btc in btc_data:
    date = btc['date']		#日期
    month = btc['month']	#月份
    week = btc['week']		#周数
    weekday = btc['weekday']	#周几
    close = btc['close']		#收盘价格
    print(f"{date} {month}月 {week}周 星期：{weekday},收盘价格 {close}元")
 
结果：
2017-01-01 01月 52周 星期：Sunday,收盘价格 6928.6492元
2017-01-02 01月 1周 星期：Monday,收盘价格 7070.2554元
....
2017-12-11 12月 50周 星期：Monday,收盘价格 110642.88元
2017-12-12 12月 50周 星期：Tuesday,收盘价格 113732.6745元

1.3 绘制收盘价折线图

import json
 
#将数据加载到一个列表中
filename = 'btc_close_2017.json'
with open(filename) as f:
    f = f.read()
    btc_data = json.loads(f)
 
#创建5个列表，分别存储日期和收盘价
dates = []
months = []
weeks = []
weekdays = []
close = []
 
#打印每一天的信息,并转换为int()类型
for btc in btc_data:
    dates.append(btc['date'])   #日期
    months.append(int(btc['month']))	#月份
    weeks.append(int(btc['week']))		#周数
    weekdays.append(btc['weekday']) 	#周几
    close.append(int(float(btc['close'])	)) 	#收盘价格,python不能直接将包含小数点的字符串'22.332'转换为整数。为消除这种错误需要先将字符串转换为浮点数（float），再将浮点数转换为整数（int）
# print(len(months))
 
#绘制收盘折线图
import pygal
 
line_chart = pygal.Line(x_label_rotation=20,show_minor_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('D:\\python资料\\30s\\代码\\数据可视化\\收盘价折线图(￥).svg')

在创建line实例时，分别设置了x_label_rotation与show_minor_x_labels作为初始化参数。x_label_rotation=20让x轴上的日期标签顺时针旋转20°，show_minor_x_labels=false则告诉图形不用显示所有的x轴标签。设置了图形的标题和x轴标签之后，我们配置x_lable_major属性，让x轴坐标每隔20天显示一次，这样x轴就不会显得非常拥挤了

1.4 时间序列特征初探

进行时间序列分析总是期望发展趋势、周期性和噪声，从而能够描述事实、预测未来、做出决策。从收盘价的折线图可以看出，2017年的总体趋势是非线性的，而且增长幅度不断增大。不过，在每个季度末似乎有一些相似的波动。尽管这些波动被增长的趋势掩盖了，不过其中也许有周期性。未来验证周期性的假设，需要首先将非线性的趋势消除。

对数变换是常用的处理方法之一。用python标准库的数学模块math来处理。，math中有许多常用的数学函数，这里用以10为底的对数函数math.log10计算收盘价，日期仍然保持不变。这种方式成为半对数变换。

import json
 
#将数据加载到一个列表中
filename = 'btc_close_2017.json'
with open(filename) as f:
    f = f.read()
    btc_data = json.loads(f)
 
#创建5个列表，分别存储日期和收盘价
dates = []
months = []
weeks = []
weekdays = []
close = []
 
#打印每一天的信息,并转换为int()类型
for btc in btc_data:
    dates.append(btc['date'])   #日期
    months.append(int(btc['month']))	#月份
    weeks.append(int(btc['week']))		#周数
    weekdays.append(btc['weekday']) 	#周几
    close.append(int(float(btc['close'])	)) 	#收盘价格,python不能直接将包含小数点的字符串'22.332'转换为整数。为消除这种错误需要先将字符串转换为浮点数（float），再将浮点数转换为整数（int）
# print(len(months))
 
#绘制收盘折线图
import pygal
import math
 
line_chart = pygal.Line(x_label_rotation=20,show_minor_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('收盘价',close_log)
line_chart.render_to_file('D:\\python资料\\30s\\代码\\数据可视化\\收盘价折线图(￥).svg')
 

使用对数变换剔除非线性趋势之后，整体上涨的趋势更接近线性增长。收盘价在每个季度末似乎有显著的周期性，都出现了剧烈的波动。

1.5 收盘价均值

绘制2017年前11个月的日均值，前49周的日均值，以及每周中隔天的日均值。

代码详细解析文档
https://blog.csdn.net/pythonxiaohei/article/details/100101290

import json
 
#将数据加载到一个列表中
filename = 'btc_close_2017.json'
with open(filename) as f:
    f = f.read()
    btc_data = json.loads(f)
 
#创建5个列表，分别存储日期和收盘价
dates = []
months = []
weeks = []
weekdays = []
close = []
 
#打印每一天的信息,并转换为int()类型
for btc in btc_data:
    dates.append(btc['date'])   #日期
    months.append(int(btc['month']))	#月份
    weeks.append(int(btc['week']))		#周数
    weekdays.append(btc['weekday']) 	#周几
    close.append(int(float(btc['close'])	)) 	#收盘价格,python不能直接将包含小数点的字符串'22.332'转换为整数。为消除这种错误需要先将字符串转换为浮点数（float），再将浮点数转换为整数（int）
# print(len(months))
 
#绘制收盘折线图
import pygal
import math
from itertools import groupby
 
line_chart = pygal.Line(x_label_rotation=20,show_minor_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('收盘价',close_log)
line_chart.render_to_file('D:\\python资料\\30s\\代码\\数据可视化\\收盘价折线图(￥).svg')
 
def draw(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)])    #xy_map=[[1, 6285.870967741936], [2, 7315.714285714285]]类似于这样的值
    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
 
#收盘价月日均值
idx_month = dates.index('2017-12-01')
line_chart_month = draw(months[:idx_month],close[:idx_month],'收盘价月日均值','月日均值')
line_chart_month
 
#收盘价周日均值
idx_week = dates.index('2017-12-11')
line_chart_week = draw(weeks[1:idx_week],close[1:idx_week],'收盘价周日均值','周日均值')
line_chart_week
 
#收盘价星期均值
idx_weeks = dates.index('2017-12-11')
wd = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
weekdays_int = [ wd.index(w) +1 for w in weekdays[1:idx_weeks]]
print(weekdays_int)
line_chart_weekday = draw(weekdays_int,close[1:idx_weeks],'收盘价星期均值','星期均值')

1.6 收盘价数据仪表盘

 
with open('收盘价.html','w',encoding='utf8') as file:
    file.write('<html><head><title>收盘价</title><metacharset="utf8"></head><boby>\n')
    for svg in ['收盘价折线图(￥).svg','收盘价月日均值.svg','收盘价星期均值.svg','收盘价周日均值.svg']:
        file.write('    <object type="image/svg+xml" data="{0}" height=500></object>\n'.format(svg))
        file.write('</boby></html>')
 

5.2.CSV文件格式

要在文件文件中存储数据，最简单的方式时将数据作为一系列以逗号分隔的值（CSV）写入文件。这样的文件称为CSV文件。

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

其文件以纯文本形式存储表格数据（数字和文本），文件的每一行都是一个数据记录。

1.1分析CSV文件头

CSV模块包含在python标准库中，可用于分析CSV文件中的数据行。

filename = 'sitka_weather_07-2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
    print(header_row)       #打印出next（）拿出来的第一行数据 
	
结果：['AKDT', 'Max TemperatureF', ......', ' CloudCover', ' Events', ' WindDirDegrees']
 

注意：文件头的格式并非总是一致的，空格和单位可能出现在奇怪的地方。这些在原始数据文件中很常见，但不会带来任何问题。

1.2打印文件头及其位置

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

import csv
 
filename = 'sitka_weather_07-2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    for index,column in enumerate(header_row):  #对列表调用了enumerate()来获取每个元素的索引及其值。
        print(index,column)
 
结果：
0 AKDT
1 Max TemperatureF
2 Mean TemperatureF
....
21  Events
22  WindDirDegrees
 

1.3提取数据并读取数据

知道需要那些列中的数据后，首先读取每天的最高气温

import csv
 
#从文件中获取最高气温
filename = 'sitka_weather_07-2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    highs = []		#创建一个列表，存放文件第二列的数据
    for row in reader:
        high = int(row[1])	#取出每个循环的第二列的数据，并将转换为int类型
        highs.append(high)	#将数据存放highs列表。
 
    print(highs)
 
结果：
[64, 71, 64, 59, 69, 62, 61, 55, 57, 61, 57, 59, 57, 61, 64, 61, 59, 63, 60, 57, 69, 63, 62, 59, 57, 57, 61, 59, 61, 61, 66]

阅读器对象从起停留的地方继续往下读取CSV文件，每次都自动返回当前所处位置的下一行。由于我们已经读取了文件头行，这个循环将从第二行开始--从这行开始包含的是实际数据。

1.4 绘制气温图表

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

import csv
 
#从文件中获取最高气温
filename = 'sitka_weather_07-2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    highs = [int(row[1]) for row in reader]     #从文件中获取最高气温
 
from matplotlib import pyplot as plt
 
#根据数据绘制图形
fig = plt.figure(dpi=128,figsize=(10,6))
plt.plot(highs,c='red')		#将最高气温传递给plot，plot生成图，并设置颜色（红色为最高气温）
 
#设置图形的格式
plt.title("Daily high july 2014",fontsize=24)	#设置标题
plt.xlabel('date',fontsize=16)		#设置X轴
plt.ylabel('Temperature(F)',fontsize=16)
plt.tick_params(axis='both',which='major',labelsize=15)
 
plt.show()

1.5 在图表中添加日期

提取日期和最高气温

import csv
from matplotlib import pyplot as plt
from datetime import datetime
 
#从文件中获取日期和最高气温
filename = 'sitka_weather_07-2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    #存储日期和最高气温
    dates,highs = [],[]
    for row in reader:
        current_date = datetime.strptime(row[0],"%Y-%m-%d")
        dates.append(current_date)  #获取日期
        highs.append(int(row[1]))   #获取最高气温
 
#根据数据绘制图形
fig = plt.figure(dpi=128,figsize=(10,6))
plt.plot(dates,highs,c='red')   #将最高气温传递给plot，plot生成图，并设置颜色（红色为最高气温）
 
 
#设置图形的格式
plt.title("Daily high july 2014",fontsize=24)  #设置标题
plt.xlabel('date',fontsize=16)   #设置X轴
fig.autofmt_xdate()     #绘制斜的日期标签
plt.ylabel('Temperature(F)',fontsize=16)
plt.tick_params(axis='both',which='major',labelsize=15)
 
plt.show()

1.6 覆盖更长时间

添加更多数据，生成一副更复杂的天气图

import csv
from matplotlib import pyplot as plt
from datetime import datetime
 
#从文件中获取日期和最高气温
filename = 'sitka_weather_2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    #存储日期和最高气温
    dates,highs = [],[]
    for row in reader:
        current_date = datetime.strptime(row[0],"%Y-%m-%d")
        dates.append(current_date)  #获取日期
        highs.append(int(row[1]))   #获取最高气温
 
#根据数据绘制图形
fig = plt.figure(dpi=128,figsize=(10,6))
plt.plot(dates,highs,c='red')   #将最高气温传递给plot，plot生成图，并设置颜色（红色为最高气温）
 
 
#设置图形的格式
plt.title("Daily high - 2014",fontsize=24)  #设置标题
plt.xlabel('date',fontsize=16)   #设置X轴
fig.autofmt_xdate()     #绘制斜的日期标签
plt.ylabel('Temperature(F)',fontsize=16)
plt.tick_params(axis='both',which='major',labelsize=15)
 
plt.show()

1.7 再绘制一个数据系列

从文件中获取最低气温，并给图表区着色

import csv
from matplotlib import pyplot as plt
from datetime import datetime
 
#从文件中获取日期和最高气温，最低气温
filename = 'sitka_weather_2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    #存储日期和最高气温
    dates,highs,lows = [],[],[]
    for row in reader:
        current_date = datetime.strptime(row[0],"%Y-%m-%d")
        dates.append(current_date)  #获取日期
        highs.append(int(row[1]))   #获取最高气温
        lows.append(int(row[3]))    #获取最低气温
 
#根据数据绘制图形
fig = plt.figure(dpi=128,figsize=(10,6))
plt.plot(dates,highs,c='red',alpha=0.5)   #将最高气温传递给plot，
plt.plot(dates,lows,c='blue',alpha=0.5)   #将最低气温传递给plot，alpha指定颜色的透明度
plt.fill_between(dates,highs,lows,facecolor='blue',alpha=0.1)  #区域填充色
 
#设置图形的格式
plt.title("Daily high - 2014",fontsize=24)  #设置标题
plt.xlabel('date',fontsize=16)   #设置X轴
fig.autofmt_xdate()     #绘制斜的日期标签
plt.ylabel('Temperature(F)',fontsize=16)
plt.tick_params(axis='both',which='major',labelsize=15)
 
plt.show()

alpha：指定颜色透明度，alpha值为0表示完全透明，1（默认值）表示完全不透明	
fill_between()：传递给一个x值系列，还需要传递两个y值。实参facecolor制定了填充区域的颜色

1.8 错误检查

收集的数据信息，可能会出现丢失，未能收集部分或者全部其应该收集的数据。缺失数据可能会引发异常，如果不妥善处理，可能会导致程序崩溃。

import csv
from matplotlib import pyplot as plt
from datetime import datetime
 
#从文件中获取日期和最高气温，最低气温
filename = 'death_valley_2014.csv'  #存储文件变量名
with open(filename) as f:   #将结果文件对象存储在f中
    reader = csv.reader(f)         #使用csv读取文件对象
    header_row = next(reader)       #使用next()获取文件第一行，运行一次next()调用一行数据
 
    #存储日期和最高气温
    dates,highs,lows = [],[],[]
    for row in reader:
		#try数据正常，则运行else，去添加数据。try捕获到异常，执行except，打印错误消息后，循环将接着处理下一行数据。
        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)    #获取最低气温
 
#根据数据绘制图形
fig = plt.figure(dpi=128,figsize=(10,6))
plt.plot(dates,highs,c='red',alpha=0.5)   #将最高气温传递给plot，
plt.plot(dates,lows,c='blue',alpha=0.5)   #将最低气温传递给plot，alpha指定颜色的透明度
plt.fill_between(dates,highs,lows,facecolor='blue',alpha=0.1)  #区域填充色
 
#设置图形的格式
plt.title("Daily high - 2014",fontsize=24)  #设置标题
plt.xlabel('date',fontsize=16)   #设置X轴
fig.autofmt_xdate()     #绘制斜的日期标签
plt.ylabel('Temperature(F)',fontsize=16)
plt.tick_params(axis='both',which='major',labelsize=15)
 
plt.show()
 
打印：
2014-02-16 00:00:00 missing data   #捕获出来的异常数据

使用的很多数据集都可能缺失数据、数据格式不正确或者数据本身不正确。对于这样的情形，可以使用try-exceot-else代码来处理数据缺失的问题。有些情况下需要使用continue来跳过一些数据，或者使用remove()或del将已提取的数据删除。可采取任何管用的方法，只要能进行精确而有意义的可视化就好。

6.使用API

使用web应用编程接口（API）自动请求网站的特定信息而不是整个网页，在对这些信息进行可视化。由于这样编写的程序始终使用最新的数据来生成可视化，因此即便数据瞬息万变，它呈现出来的信息也都是最新的。

1.1 web API

web API是网站的一部分，用于与使用非常具体的URL请求特定信息的程序交互。这种请求称为API调用。请求的数据将以易于处理的格式（JSON或CSV）返回。依赖于外部数据源的大多数应用程序都依赖于API调用，如集成社交媒体网站的应用程序。

1.2 使用API调用请求数据

GitHub的API让你能够通过API调用来请求各种信息。

API样式

https://api.github.com/search/repositories?q=language:python&sort=stars
 
{
  "total_count": 6740320,		#GitHub中python项目个数
  "incomplete_results": false,	#false表示请求是成功的（并非完整的），倘若GitHub无法全面处理该API，它返回的值将为True
  "items": [	#包含GitHub上最受欢迎的python项目的详细信息
    {
      "id": 83222441,
      "node_id": "MDEwOlJlcG9zaXRvcnk4MzIyMjQ0MQ==",
      "name": "system-design-primer",
      "full_name": "donnemartin/system-design-primer",
      "private": false,
      "owner": {
        "login": "donnemartin",
        "id": 5458997,
        "node_id": "MDQ6VXNlcjU0NTg5OTc=",

这个调用返回GitHub当前托管了多少个python项目，还有有关最受欢迎的python仓库信息。
api.github.com：将请求发送到GitHub网站中响应API调用的部分
search/repositories：让API搜索GitHub上所有的仓库。
? 支出我们要传递的一个实参
q：表示查询，等号让我们能够指定查询。
language:python： 指出只想获取主要语言为python的仓库信息。
&sort=stars ：将项目按其获得的星级进行排序。

6.2.安装requests

requests包让程序能够轻松的向网站请求信息以及检查返回的响应。

1.1 安装requests

pip install --user requests

2 处理API响应

执行API 嗲用并处理结果，找出GITHUB上星级最高的python项目

import requests
 
#执行API调用并存储响应
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'   #API调用的URL
r = requests.get(url)       #使用requests.get()执行调用，将响应数据存储在r中，为JSON格式
print("status code:",r.status_code)     #返回网站调用状态码（200表示响应成功）
 
#将API响应存储在一个变量中
respnse = r.json()      #将返回数据反序列化，为一个python字典类型。
print(respnse.keys())       #处理结果
 
 
结果：
status code: 200
dict_keys(['total_count', 'incomplete_results', 'items'])	#响应字典包含的三个键

3 处理响应字典

import requests
 
#执行API调用并存储响应
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'   #API调用的URL
r = requests.get(url)       #使用requests.get()执行调用，将响应数据存储在r中，为JSON格式
print("status code:",r.status_code)     #返回网站调用状态码（200表示响应成功）
 
#将API响应存储在一个变量中
respnse = r.json()      #将返回数据反序列化，为一个python字典类型。
print(respnse.keys())       #处理结果
print("python项目数量：",respnse['total_count'])     #打印GitHub中共包含多少个python个仓库
 
#探索有关仓库信息
repo_dicts = respnse['items']   
print("返回的仓库数量",len(repo_dicts))    #打印GitHub返回的仓库数量
 
#研究第一个仓库
repo_dict = repo_dicts[0]       #获取第一个仓库数据
print("\nkes:",len(repo_dict))  #键值数量
for key in sorted(repo_dict.keys()):    #按字母排序打印仓库中key的名称
    print(key)
	
 
结果：
status code: 200
dict_keys(['total_count', 'incomplete_results', 'items'])
python项目数量： 6740525
python仓库数量 30
 
kes: 74
archive_url
archived

4.概述最受欢迎的仓库

打印API调用返回的每个仓库的特定信息。

import requests
 
#执行API调用并存储响应
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'   #API调用的URL
r = requests.get(url)       #使用requests.get()执行调用，将响应数据存储在r中，为JSON格式
print("status code:",r.status_code)     #返回网站调用状态码（200表示响应成功）
 
#将API响应存储在一个变量中
respnse = r.json()      #将返回数据反序列化，为一个python字典类型。
print(respnse.keys())       #处理结果
print("python项目数量：",respnse['total_count'])     #打印GitHub中共包含多少个python个仓库
 
#探索有关仓库信息
repo_dicts = respnse['items']
print("最受欢迎的仓库",len(repo_dicts))    #打印GitHub最受欢迎的仓库
 
print("\n概述最受欢迎的仓库")
for repo in repo_dicts:
    print("\n名称:",repo['name'])
    print('所有者：',repo['owner']['login'])
		print('星级：',repo['stargazers_count'])
    print('URL：',repo['html_url'])
    print('描述：',repo['description'])

打印每个项目的名称，所有者，星级，在GitHub上的URL以及描述

结果

status code: 200
dict_keys(['total_count', 'incomplete_results', 'items'])
python项目数量： 6740774
最受欢迎的仓库 30
 
概述最受欢迎的仓库
 
名称: system-design-primer
所有者： donnemartin
星级： 121718
URL： https://github.com/donnemartin/system-design-primer
描述： Learn how to design large-scale systems. Prep for the system design interview.  Includes Anki flashcards.
 
名称: public-apis
所有者： public-apis
星级： 111036
URL： https://github.com/public-apis/public-apis
描述： A collective list of free APIs for use in software and web development.
 
名称: Python
所有者： TheAlgorithms
星级： 100179
URL： https://github.com/TheAlgorithms/Python
描述： All Algorithms implemented in Python
 
名称: Python-100-Days
所有者： jackfrued
星级： 99704
URL： https://github.com/jackfrued/Python-100-Days
描述： Python - 100天从新手到大师
....

监视API的速率限制

#大多数API都存在速率限制，既你在特定时间内可执行的请求数存在限制。github限制
 
https://api.github.com/rate_limit
 
//访问结果
{
	"resources": {
		"core": {
			"limit": 60,
			"remaining": 60,
			"reset": 1613921532,
			"used": 0
		},
		"graphql": {
			"limit": 0,
			"remaining": 0,
			"reset": 1613921532,
			"used": 0
		},
		"integration_manifest": {
			"limit": 5000,
			"remaining": 5000,
			"reset": 1613921532,
			"used": 0
		},
		"search": {			#API速率限制
			"limit": 10,		#每分钟请求数
			"remaining": 9,		#剩余请求数
			"reset": 1613917986,	#配额将重置的Unix时间或新纪元时间
			"used": 1
		}
	},
	"rate": {
		"limit": 60,
		"remaining": 60,
		"reset": 1613921532,
		"used": 0
	}
}

5.使用pygal可视化仓库

创建一个交互式条线图：线条的盖度表示项目获得了多少颗星。单机条形将进入项目在GitHub上的主页。

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'   #API调用的URL
r = requests.get(url)       #使用requests.get()执行调用，将响应数据存储在r中，为JSON格式
print("status code:",r.status_code)     #返回网站调用状态码（200表示响应成功）
 
#将API响应存储在一个变量中
respnse = r.json()      #将返回数据反序列化，为一个python字典类型。
print(respnse.keys())       #处理结果
print("python项目数量：",respnse['total_count'])     #打印GitHub中共包含多少个python个仓库
 
#探索有关仓库信息
repo_dicts = respnse['items']
 
names,plot_stars = [],[]     #存储项目名称及星级
for repo in repo_dicts:
    names.append(repo['name'])
 
    # value存放星数，label存放项目描述
    plot_dict = {
        'value':repo['stargazers_count'],
        'label':str(repo['description']),      #转换为str原因：取到的数据有一处None，chart.add无法使用空值，所以将控制转换为字符串'None',表示有值
        'xlink':repo['html_url'],        #pygal根据xlink相关的URL将每个条形都转换为活跃的连接。单机图标中的任何条形时，都将在浏览器中打开一个新的标签页
    }
    plot_stars.append(plot_dict)
 
 
print(plot_stars)
#可视化
my_style = LS('#333366',base_style=LCS)     #使用LightenStyle定义一种样式，并将其基色设置成深蓝色，传递实参base_style,以使用LightColorizedStyle类
 
#创建一个配置对象
my_config = pygal.Config()      #创建config类，定制其属性
my_config.x_label_rotation = 45     #让标签绕X轴旋转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       #将较长的项目名称缩短为15个字符
my_config.show_y_guides = False     #隐藏图标中的水平线
my_config.width = 1000      #设置自定义宽度，让图表更充分的抵用浏览器中的可用空间
 
 
chart = pygal.Bar(my_config,style=my_style) #创建条形图，通过my_config作为第一个实参，传递进去所有设置属性
chart.title = 'most-starred python projects on github'
chart.x_labels = names  #x轴属性名称
 
chart.add('',plot_stars) #标签，接收列表【星数和描述】
chart.render_to_file('D:\\python资料\\30s\\代码\\数据可视化\\API\\python_repos.svg')

点击图标就会跳转到GitHub上相应的仓库中