1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings(action='once')
"""
#绘图参数设置
large=22;med=16;small=12
params={'axes.titlesize':large,
        'legend.fontsize':med,
        'figure.figsize':(16,10),
        'axes.labelsize':med,
        'axes.titlesize':med,
        'xtick.labelsize':med,
        'ytick.labelsize':med,
        'figure.figsize':large}
plt.rcParams.update(params) """
plt.style.use('seaborn-whitegrid')
sns.set_style('white')
%matplotlib inline

1
2
3
#版本信息
print(mpl.__version__)
print(sns.__version__)

1
2
3
4
midwest = pd.read_csv(
  "https://raw.githubusercontent.com/" + 
  "selva86/datasets/master/midwest_filter.csv")
midwest.head()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
categories=np.unique(midwest['category'])
colors=[
    plt.cm.tab10(i/float(len(categories)-1)) for i in range(len(categories))
]

plt.figure(figsize=(16,10), dpi=80, facecolor='w', edgecolor='K')
for i,category in enumerate(categories):
    plt.scatter(
        'area', 'poptotal',
        data=midwest.loc[midwest.category==category,:],
        s=20, cmap=colors[i], label=str(category)
    )
plt.gca().set(
    xlim=(0.0,0.1), ylim=(0,90000), 
    xlabel='Area', ylabel='Population')
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.title("Scatterplot of Midwest Area vs Population",fontsize=22)
plt.legend(fontsize=12)
plt.show()

1
2
3
4
5
from matplotlib import patches
from scipy.spatial import ConvexHull
import warnings
warnings.simplefilter('ignore')
sns.set_style('white')

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
# Step 1: 数据准备，上一例散点图已经完成
# Step 2: Draw Scatterplot with unique color for each category
fig = plt.figure(figsize=(16, 10), dpi= 80, facecolor='w', edgecolor='k')
for i, category in enumerate(categories):
    plt.scatter(
        'area', 'poptotal', 
        data=midwest.loc[midwest.category==category, :],
        s='dot_size', edgecolors='black', 
        cmap=colors[i], label=str(category), linewidths=.5)

# Step 3: Encircling
# https://stackoverflow.com/questions/44575681/
# how-do-i-encircle-different-data-sets-in-scatter-plot
def encircle(x,y, ax=None, **kw):
    if not ax: ax=plt.gca()
    p = np.c_[x,y]
    hull = ConvexHull(p)
    poly = plt.Polygon(p[hull.vertices,:], **kw)
    ax.add_patch(poly)

# Select data to be encircled
midwest_encircle_data = midwest.loc[midwest.state=='IN', :]
# Draw polygon surrounding vertices
encircle(
    midwest_encircle_data.area, midwest_encircle_data.poptotal, 
    ec="k", fc="gold", alpha=0.1)
encircle(
    midwest_encircle_data.area, midwest_encircle_data.poptotal, 
    ec="firebrick", fc="none", linewidth=1.5)

# Step 4: Decorations
plt.gca().set(
    xlim=(0.0, 0.1), ylim=(0, 90000), xlabel='Area', ylabel='Population')
plt.xticks(fontsize=12); plt.yticks(fontsize=12)
plt.title("Bubble Plot with Encircling", fontsize=22)
plt.legend(fontsize=12)
plt.show()

1
2
3
4
5
#导入数据
df = pd.read_csv(
    "https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv"
)
df.info()

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
#数据预处理
df_select = df.loc[df.cyl.isin([4,8]), :]
print(df_select.head())

#绘图
sns.set_style("white")
#主要参数，x，y，分类变量hue，数据data
grid_obj = sns.lmplot(
    x='displ', y='hwy', hue='cyl', 
    data=df_select,
    height=7, aspect=1.6, robust=True, palette='tab10',
    scatter_kws=dict(
        s=60, linewidths=0.7, edgecolors='black'
    )
)
#修饰图片
grid_obj.set(xlim=(0.5, 7.5), ylim=(0, 50))
#解决中文显示问题
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
#添加标题
plt.title(
    "Scatterplot with line of best fit grouped by number of cylinders" + 
    "\n带线性回归最佳拟合的散点图", 
    fontsize=20)
plt.show()

1
2
3
4
5
6
7
8
9
10
#针对每类绘制带回归拟合的散点图(上图的拆分显示)
grid_obj = sns.lmplot(
    x='displ', y='hwy',col='cyl', data=df_select,
    height=7, aspect=1.6, robust=True, palette='Set1',
    scatter_kws=dict(s=60, linewidths=0.7, edgecolors='black')
    )
#主要修改了palette参数，以及把hue改为col参数
grid_obj.set(xlim=(0.5, 7.5), ylim=(0, 50))
#省略了修饰图片
plt.show()

1
2
3
4
5
# 当多个数据点x和y值相等，绘图时会重叠，为了直观地看到所有数据点，使其稍微抖动
# 导入数据 >>
# https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv
df = pd.read_csv("mpg_ggplot2.csv")  #直接读取网页csv报连接超时
print(df.head())

1
2
3
4
5
6
7
#绘制抖动图
fig, ax = plt.subplots(figsize=(16,10), dpi=80)
sns.stripplot(df.cty, df.hwy, jitter=0.25, size=8, ax=ax, linewidth=0.5)
#先使用subplot得到图像对象和ax参数，在用stripplot完成绘图
#修饰图片
plt.title('使用抖动图避免数据点重叠', fontsize=22)
plt.show()

1
2
3
4
'''避免重叠的另一个方法是用点的大小表示重叠的点数量，体现某一点上的集中度'''
#导入数据
df = pd.read_csv('mpg_ggplot2.csv')
df.info()

1
2
3
4
5
6
7
#数据准备：生成counts数据框
df_counts = df.groupby(['hwy', 'cty']).size().reset_index(name='counts')
#绘图：跟上例一样使用stripplot函数，但是改为使用size参数控制点的大小
fig, ax = plt.subplots(figsize=(16,10), dpi=80)
sns.stripplot(df_counts.cty, df_counts.hwy, size=df_counts.counts*2, ax=ax)
plt.title('计数图')
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
'''沿X和Y轴变量的直方图'''
#导入数据
df = pd.read_csv('mpg_ggplot2.csv')
#创建图像和网格
fig = plt.figure(figsize=(16,10), dpi=80)
grid = plt.GridSpec(4, 4, hspace=0.5, wspace=0.2)
#定义axes
ax_main = fig.add_subplot(grid[:-1, :-1])
ax_right = fig.add_subplot(grid[:-1, -1], xticklabels=[], yticklabels=[])
ax_bottom = fig.add_subplot(grid[-1, 0:-1], xticklabels=[], yticklabels=[])

#main axe上画散点图
ax_main.scatter(
    'displ', 'hwy', data=df, 
    c=df.manufacturer.astype('category').cat.codes,
    s=df.cty*4, alpha=0.9, cmap='tab10', edgecolors='gray', linewidths=0.5
)
#右方的直方图
ax_right.hist(
    df.hwy, 40, histtype='stepfilled', orientation='horizontal', color='orange'
)
#下方的直方图
ax_bottom.hist(
    df.displ, 40, histtype='stepfilled', orientation='vertical', color='orange'
)
ax_bottom.invert_yaxis()

#修饰图片
ax_main.set(title='边缘直方图--displ vs hwy', xlabel='displ', ylabel='hwy')
ax_main.title.set_fontsize(20)
for item in (
    [ax_main.xaxis.label, ax_main.yaxis.label] + 
    ax_main.get_xticklabels() + 
    ax_main.get_yticklabels()
    ):
    item.set_fontsize(14)

xlabels = ax_main.get_xticks().tolist()
ax_main.set_xticklabels(xlabels)

plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'''构建图片主要内容的过程与上图一样'''
df = pd.read_csv('mpg_ggplot2.csv')
#创建图像和网格
fig = plt.figure(figsize=(16,10), dpi=80)
grid = plt.GridSpec(4, 4, hspace=0.5, wspace=0.2)
#定义axes
ax_main = fig.add_subplot(grid[:-1, :-1])
ax_right = fig.add_subplot(grid[:-1, -1], xticklabels=[], yticklabels=[])
ax_bottom = fig.add_subplot(grid[-1, 0:-1], xticklabels=[], yticklabels=[])
#main axe上画散点图
ax_main.scatter(
    'displ', 'hwy', data=df, 
    c=df.manufacturer.astype('category').cat.codes,
    s=df.cty*4, alpha=0.9, cmap='tab10',edgecolors='gray',linewidths=0.5
)

#添加边缘箱形图
sns.boxplot(df.hwy, ax=ax_right, orient='v')
sns.boxplot(df.displ, ax=ax_bottom, orient='h')

#修饰图片与上图一样，略
plt.show()

1
2
3
4
5
6
'''相关图用于直观地查看给定二维数组中所有的变量对之间的两两相关度量'''
#导入数据
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/mtcars.csv')
print(df.head())
#两两相关系数：
print(df.corr())

1
2
3
4
5
6
7
8
9
10
11
12
#绘图
plt.figure(figsize=(12,10), dpi=80)
sns.heatmap(
    df.corr(), 
    xticklabels=df.corr().columns, yticklabels=df.corr().columns, 
    cmap='RdYlGn', center=0, annot=True
)
#修饰图片
plt.title('Correlogram of mtcars', fontsize=20)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.show()

1
2
3
4
'''双变量分析常用绘图，给出两两的关联图，相当于R中的pairs函数'''
#导入数据
df = sns.load_dataset('iris')
df.info()

1
2
3
4
5
#绘图
plt.figure(figsize=(10,8), dpi=80)
sns.pairplot(df, kind='scatter', hue='species',#可以加入分类变量
             plot_kws=dict(s=80, edgecolor='white', linewidth=2.5))
plt.show()

1
2
3
4
#图例2
plt.figure(figsize=(10,8), dpi=80)
sns.pairplot(df, kind='reg', hue='species')
plt.show()

1
2
#默认参数设置
sns.pairplot(df)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''可以根据单个指标查看项目的变化情况，并可视化此差异的顺序和数量'''
#导入数据
df = pd.read_csv('mtcars.csv')
#数据准备
# 抽取一列
x = df.loc[:, ['mpg']]
# 计算每个数据点相对于标准差的离散程度
df['mpg_z'] = (x - x.mean())/x.std()
# 分配颜色，增加颜色变量
df['colors'] = ['red' if i<0 else 'green' for i in df['mpg_z']]
# 按计算所得的 离散程度 重排数据
df.sort_values('mpg_z', inplace=True)
# 重排后 更新index
df.reset_index(inplace=True)
print(df.head())

1
2
3
4
5
6
7
8
9
10
11
12
13
#绘图
plt.figure(figsize=(14,10), dpi=80)
plt.hlines(
    y=df.index, 
    xmin=0, xmax=df.mpg_z, color=df.colors, alpha=0.5, linewidth=5
)
#主要参数：数据y，bar的长度xmin和xmax，colors，等
#修饰图片
plt.gca().set(ylabel='$Model$', xlabel='$Mileage$') # $号代表外层的新一级的标签
plt.yticks(df.index, df.cars, fontsize=12)
plt.title('Diverging Bars of Car Mileage', fontdict={'size':20}) # 使用字典的写法
plt.grid(linestyle='--', alpha=0.5)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'''与上图类似，另外可以在图中加入文本强调一些内容'''
#数据准备与上例相同，直接绘图：
plt.figure(figsize=(14,14), dpi=80)
plt.hlines(y=df.index, xmin=0, xmax=df.mpg_z)
#增加文本
for x, y, tex in zip(df.mpg_z, df.index, df.mpg_z):
    t = plt.text(
        x, y, round(tex, 2), 
        horizontalalignment='right' if x<0 else 'left', 
        verticalalignment='center', 
        fontdict={'color': 'red' if x<0 else 'green', 'size': 14}
    )
#修饰图片
plt.yticks(df.index, df.cars, fontsize=12)
plt.title('Diverging Text Bars of Car Mileage', fontsize=20)
plt.grid(linestyle='--', alpha=0.5)
plt.xlim(-2.5, 2.5)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#数据准备同上，直接绘图
plt.figure(figsize=(14,16), dpi=80)
plt.scatter(df.mpg_z, df.index, s=450, alpha=0.6, color=df.colors)
for x, y, tex in zip(df.mpg_z, df.index, df.mpg_z):
    t = plt.text(x, y, round(tex, 1), horizontalalignment='center',
                verticalalignment='center', fontdict={'color': 'white'})

#修饰图片
plt.gca().spines['top'].set_alpha(0.3)
plt.gca().spines['bottom'].set_alpha(0.3)
plt.gca().spines['right'].set_alpha(0.3)
plt.gca().spines['left'].set_alpha(0.3)

plt.yticks(df.index, df.cars)
plt.title('Diverging Dotplot of Car Mileage', fontsize=20)
plt.xlabel('$Mileage$')
plt.grid(linestyle='--', alpha=0.5)
plt.xlim(-2.5, 2.5)
plt.show()

1
2
3
4
5
6
7
8
9
10
#数据准备
df = pd.read_csv('mtcars.csv')
x = df.loc[:, ['mpg']]
df['mpg_z'] = (x - x.mean())/x.std()
df['colors'] = 'black'

df.loc[df.cars == 'Fiat X1-9', 'colors'] = 'dackorange'
df.sort_values('mpg_z', inplace=True)
df.reset_index(inplace=True)
df.head()

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
#绘图
plt.figure(figsize=(14,16), dpi=80)
plt.hlines(
    y=df.index, xmin=0, xmax=df.mpg_z, color=df.colors, alpha=0.4, linewidth=1
)
plt.scatter(
    df.mpg_z, df.index, color=df.colors, alpha=0.6,
    s=[600 if x == 'Fiat X1-9' else 300 for x in df.cars]
)
plt.yticks(df.index, df.cars)
plt.xticks(fontsize=12)

#添加注释
plt.annotate(
    'Mercedes Models', xy=(0.0, 11.0), xytext=(1.0, 11), 
    xycoords='data',
    fontsize=15, color='white', ha='center', va='center', 
    bbox=dict(boxstyle='square', fc='firebrick'),
    arrowprops=dict(
        arrowstyle='-[, widthB=2.0, lengthB=1.5', lw=2.0, color='steelblue'
    ),
)

#添加补丁（框框）
from matplotlib import patches
p1 = patches.Rectangle(
    (-0.2, -1), width=0.3, height=3, alpha=0.2, facecolor='red'
)
p2 = patches.Rectangle(
    (1.5, 27), width=.8, height=5, alpha=0.2, facecolor='green'
)
plt.gca().add_patch(p1)
plt.gca().add_patch(p2)

#修饰图片
plt.title('Diverging Bars of Car Mileage', fontsize=20)
plt.grid(linestyle='--', alpha=0.5)
plt.show()

1
2
3
4
5
6
'''通过填充颜色，面积图不仅强调峰和谷，还强调了其累积效应'''
#数据准备
df = pd.read_csv('economics.csv', parse_dates=['date']).head(100)
x = np.arange(df.shape[0])
y_returns = (df.psavert.diff().fillna(0)/df.psavert.shift(1)).fillna(0)*100
df.head()

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
#绘图
plt.figure(figsize=(16,10), dpi=80)
plt.fill_between(
    x[1:], y_returns[1:], 0, where=y_returns[1:] >= 0, 
    facecolor='red', alpha=0.7, interpolate=True
)
plt.fill_between(
    x[1:], y_returns[1:], 0, where=y_returns[1:] <= 0,
    facecolor='green', alpha=0.7, interpolate=True
)

#添加注释
plt.annotate(
    'Peak\n1975', xy=(94,21), xytext=(80,18), fontsize=15, color='white',
    bbox={'boxstyle': 'square', 'fc': 'firebrick'},
    arrowprops={'facecolor': 'steelblue', 'shrink': 0.05}
)

#修饰图片
xtickvals = [ 
    str(m)[:3].upper() + '-'+str(y) for y,m in \
    zip(df.date.dt.year, df.date.dt.month_name())
]
plt.gca().set_xticks(x[::6])
plt.gca().set_xticklabels(
    xtickvals[::6], rotation=90, 
    fontdict={
        'horizontalalignment':'center', 'verticalalignment':'center_baseline'
    }
)
plt.ylim(-35, 35), plt.xlim(1, 100)
plt.title("Month Economics Return %", fontsize=22)
plt.ylabel("Monthly returns %")
plt.grid(alpha=0.5)
plt.show()

1
2
3
4
5
6
7
8
'''传达项目的排序信息，并可以添加度量值以提供更精确的信息'''
#数据准备
df_raw = pd.read_csv('mpg_ggplot2.csv')
#抽取两列，进行排序，并按照排序求均值
df = df_raw[['cty', 'manufacturer']].groupby('manufacturer').mean()
df.sort_values('cty', inplace=True)
df.reset_index(inplace=True)
print(df.head())

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
from matplotlib import patches
#绘图
fig, ax = plt.subplots(figsize=(16,10), facecolor='white', dpi=80)
ax.vlines(
    x=df.index, ymin=0, ymax=df.cty, color='firebrick', alpha=0.7, linewidth=20
)
#添加注释
for i, cty in enumerate(df.cty):
    ax.text(i, cty+0.5, round(cty, 1), horizontalalignment='center')
#修饰图片
ax.set_title('Bar Chart for Highway Mileage', fontsize=22)
ax.set(ylabel='Miles Per Gallon', ylim=(0,30))
plt.xticks(
    df.index, df.manufacturer.str.upper(), 
    rotation=60, fontsize=12, horizontalalignment='right'
)
#添加补丁
p1 = patches.Rectangle(
    (0.57, -0.005), width=0.33, height=0.13, alpha=0.1, 
    facecolor='green', transform=fig.transFigure
)
p2 = patches.Rectangle(
    (0.124, -0.005), width=0.446, height=0.13, alpha=0.1,
    facecolor='red', transform=fig.transFigure
)
fig.add_artist(p1)
fig.add_artist(p2)
fig.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'''与有序条形图内容类似，风格更好看'''
#数据准备同上，绘图
fig, ax = plt.subplots(figsize=(16,10), dpi=80)
ax.vlines(
    x=df.index, ymin=0, ymax=df.cty, color='firebrick', alpha=0.7, linewidth=2
)
ax.scatter(x=df.index, y=df.cty, s=75, color='firebrick', alpha=0.7)
#修饰图片
ax.set_title('Lollipop  Chart for Highway Mileage', fontsize=22)
ax.set_ylabel('Mileage Per Gallon')
ax.set_xticks(df.index)
ax.set_xticklabels(
    df.manufacturer.str.upper(), rotation=60, 
    fontdict={'horizontalalignment': 'right', "size": 12}
)
ax.set_ylim(0, 30)
#添加注释
for row in df.itertuples():
    ax.text(
        row.Index, row.cty+0.5, s=round(row.cty, 2), 
        horizontalalignment='center', verticalalignment='bottom', fontsize=14
    )
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#数据准备同上，绘图
fig, ax = plt.subplots(figsize=(16,10), dpi=80)
ax.hlines(
    y=df.index, xmin=11, xmax=26, 
    color='gray', alpha=0.7, linewidth=1, linestyles='dashdot'
)
ax.scatter(y=df.index, x=df.cty, s=75, color='firebrick', alpha=0.7)
#图片修饰
ax.set_title('Dot Plot for Highway Mileage', fontsize=22)
ax.set_xlabel('Miles Per Gallon')
ax.set_yticks(df.index)
ax.set_yticklabels(
    df.manufacturer.str.title(), fontdict={'horizontalalignment': 'right'}
)
ax.set_xlim(10, 27)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
'''坡度图适合用来比较给定项目的前后位置'''
from matplotlib import lines
#数据准备
df = pd.read_csv('gdppercap.csv')
left_label = [
    str(c) + ',' + str(round(y)) for c, y in zip(df.continent, df['1952'])
]
right_label = [
    str(c) + ',' + str(round(y)) for c, y in zip(df.continent, df['1957'])
]
klass = [
    'red' if (y1-y2) < 0 else 'green' for y1, y2 in zip(df['1952'], df['1957'])
]

1
2
3
4
5
6
7
8
9
10
#定义函数draw line
def newline(p1, p2, color='black'):
    ax = plt.gca()
    line = lines.Line2D(
        [p1[0], p2[0]], [p1[1], p2[1]], 
        marker='o', markersize=6, 
        color='red' if p1[1] - p2[1] > 0 else 'green'
    )
    ax.add_line(line)
    return line

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
54
55
56
57
#绘图
fig, ax = plt.subplots(1, 1, figsize=(14,14), dpi=80)
#画垂线
ax.vlines(
    x=1, ymin=500, ymax=13000, 
    color='black', alpha=0.7, linewidth=1, linestyles='dotted'
)
ax.vlines(
    x=3, ymin=500, ymax=13000, 
    color='black', alpha=0.7, linewidth=1, linestyles='dotted'
)
#散点
ax.scatter(
    y=df['1952'], x=np.repeat(1, df.shape[0]), 
    s=10, color='black', alpha=0.7
)
ax.scatter(
    y=df['1957'], x=np.repeat(3, df.shape[0]),
    s=10, color='black', alpha=0.7
)
#注释
for p1, p2, c in zip(df['1952'], df['1957'], df['continent']):
    newline([1, p1], [3, p2])
    ax.text(
        1 - 0.05, p1, c + ',' + str(round(p1)), 
        fontsize=14, horizontalalignment='right', verticalalignment='center'
    )
    ax.text(
        3 + 0.05, p2, c + ',' + str(round(p2)), 
        fontsize=14, horizontalalignment='left', verticalalignment='center'
    )
#前后的注释
ax.text(
    1 - 0.05, 13000, 'BEFORE', 
    fontdict={'size': 18, 'weight': 700}, 
    horizontalalignment='right', verticalalignment='center'
)
ax.text(
    3 + 0.05, 13000, 'AFTER', 
    fontdict={'size': 18, 'weight': 700},
    horizontalalignment='left', verticalalignment='center'
)
#修饰图片
ax.set_title(
    "SlopeChart: Compairing GDP Per Capita between 1952 and 1957",
    fontsize=22
)
ax.set(xlim=(0,4), ylim=(0,14000), ylabel='Mean GDP Per Capita')
ax.set_xticks([1,3])
ax.set_xticklabels(['1952', '1957'])
plt.yticks(np.arange(500, 13000, 2000), fontsize=12)
#高亮边界
plt.gca().spines['top'].set_alpha(0)
plt.gca().spines['bottom'].set_alpha(0)
plt.gca().spines['right'].set_alpha(0)
plt.gca().spines['left'].set_alpha(0)
plt.show()

1
2
3
4
5
6
"""哑铃图传达了各个项目的前后位置，以及项目的等级排序"""
from matplotlib import lines
#准备数据
df = pd.read_csv('health.csv')
df.sort_values('pct_2014', inplace=True)
df.reset_index(inplace=True)

1
2
3
4
5
6
#定义函数（类似上例）
def newline(p1, p2, color='black'):
    ax = plt.gca()
    line = mlines.Line2D([p1[0],p2[0]], [p1[1],p2[1]], color='skyblue')
    ax.add_line(line)
    return line

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#绘图
fig, ax = plt.subplots(1, 1, figsize=(14,14), facecolor='#f7f7f7', dpi=80)
#垂线部分
ax.vlines(x=0.05, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, 
          linestyle='dotted')
ax.vlines(x=0.10, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, 
          linestyle='dotted')
ax.vlines(x=0.15, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, 
          linestyle='dotted')
ax.vlines(x=0.20, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, 
          linestyle='dotted')
#散点部分
ax.scatter(y=df['index'], x=df['pct_2013'], s=50, color='#0e668b', alpha=0.7)
ax.scatter(y=df['index'], x=df['pct_2014'], s=50, color='#a3c4dc', alpha=0.7)
#修饰图片
ax.set_facecolor('#f7f7f7')
ax.set_title("Dumbbell Chart: Pct Change -- 2013 vs 2014", fontsize=22)
ax.set(xlim=(0,0.25), ylim=(-1,27), ylabel='Mean GDP Per Capita')
ax.set_xticks([0.05, 0.10, 0.15, 0.20])
ax.set_xticklabels(['5%', '10%', '15%', '20%'])
plt.show()

1
2
3
4
5
6
7
"""区别连续变量和分类变量"""
#数据准备
df = pd.read_csv("mpg_ggplot2.csv")
x_var = 'displ'
groupby_var = 'class'
df_agg = df.loc[:, [x_var, groupby_var]].groupby(groupby_var)
vals = [df[x_var].values.tolist() for i,df in df_agg]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#绘图
plt.figure(figsize=(16,9), dpi=80)
colors = [plt.cm.Spectral(i/float(len(vals)-1)) for i in range(len(vals))]
n, bins, patches = plt.hist(
    vals, 30, stacked=True, density=False, color=colors[:len(vals)]
)
#修饰图片
plt.legend(
    {group:col for group,col in \
    zip(np.unique(df[groupby_var]).tolist(), colors[:len(vals)])}
)
plt.title(
    f'Stacked Histogram of ${x_var}$ colored by ${groupby_var}$', 
    fontsize=22
)
plt.xlabel(x_var)
plt.ylabel('Frequency')
plt.ylim(0, 25)
plt.xticks(ticks=bins[::3], labels=[round(b,1) for b in bins[::3]])
plt.show()

1
2
3
4
5
6
7
"""通过对条形图进行着色，可以将分布与表示颜色的另一个类型变量相关联"""
#数据准备
df = pd.read_csv("mpg_ggplot2.csv")
x_var = 'manufacturer'
groupby_var = 'class'
df_agg = df.loc[:, [x_var, groupby_var]].groupby(groupby_var)
vals = [df[x_var].values.tolist() for i,df in df_agg]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#绘图
plt.figure(figsize=(16,9), dpi=80)
colors = [plt.cm.Spectral(i/float(len(vals)-1)) for i in range(len(vals))]
n, bins, patches = plt.hist(
    vals, df[x_var].unique().__len__(), 
    stacked=True, density=False, color=colors[:len(vals)]
)
#图片修饰
plt.legend(
    {group: col for group,col in \
    zip(np.unique(df[groupby_var]).tolist(), colors[:len(vals)])}
)
plt.title(
    f'Stacked Histogram of ${x_var}$ colored by ${groupby_var}$', 
    fontsize=22
)
plt.xlabel(x_var)
plt.ylabel('Frequency')
plt.ylim(0, 40)
plt.xticks(
    ticks=bins, labels=np.unique(df[x_var]).tolist(), 
    rotation=90, horizontalalignment='left'
)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""密度图用于可视化连续变量，通过‘响应’变量对它们进行分组。"""
#下例描述城市里程的分布如何随汽车缸数而变化
#数据准备
df = pd.read_csv('mpg_ggplot2.csv')
#绘图
plt.figure(figsize=(16,10), dpi=80)
sns.kdeplot(df.loc[df['cyl']==4, 'cty'], color='green', alpha=0.7,
           label='cyl=4', shade=True)
sns.kdeplot(df.loc[df['cyl']==5, 'cty'], color='deeppink', alpha=0.7,
           label='cyl=5', shade=True)
sns.kdeplot(df.loc[df['cyl']==6, 'cty'], color='dodgerblue', alpha=0.7,
           label='cyl=6', shade=True)
sns.kdeplot(df.loc[df['cyl']==8, 'cty'], color='orange', alpha=0.7,
           label='cyl=8', shade=True)
#修饰图片
plt.title("Density Plot of City Mileage by n_Cylinders", fontsize=22)
plt.legend()
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
"""可以用一个图包含两个图所传达的集体信息"""
#数据准备
df = pd.read_csv('mpg_ggplot2.csv')
#绘图
plt.figure(figsize=(13,10), dpi=80)
sns.distplot(
    df.loc[df['class']=='compact', 'cty'], 
    color='dodgerblue', label='compact', 
    hist_kws={'alpha': 0.7}, kde_kws={'linewidth': 3}
)
sns.distplot(
    df.loc[df['class']=='suv', 'cty'], 
    color='orange', label='SUV', 
    hist_kws={'alpha': 0.7}, kde_kws={'linewidth': 3}
)
sns.distplot(
    df.loc[df['class']=='minivan', 'cty'], 
    color='g', label="minivan", 
    hist_kws={'alpha': 0.7}, kde_kws={'linewidth': 3}
)
plt.ylim(0, 0.35)
#修饰
plt.title("Density Plot of City Mileage by Vehicle Type", fontsize=22)
plt.legend()
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''
Joy Plot 允许不同组的密度曲线重叠，这是一种可视化大量分组数据的彼此关系的好方法。
并且看起来更加悦目，更清晰地传达正确的信息
'''
import joypy
#数据准备
mpg = pd.read_csv("mpg_ggplot2.csv")
#绘图
plt.figure(figsize=(16,10), dpi=80)
fig, axes = joypy.joyplot(
    mpg, column=['hwy', 'cty'], by='class', ylim='own', figsize=(14,10)
)
#修饰图片
plt.title("Joy Plot of City and Highway Mileage by Class", fontsize=22)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
"""显示按组分割的点的单变量分布，点数越暗，集中度越高"""
from matplotlib import patches
#数据准备
df_raw = pd.read_csv("mpg_ggplot2.csv")
#在原始数据上添加一个与cyl匹配的color变量
cyl_colors = {4:'tab:red', 5:'tab:green', 6:'tab:blue', 8:'tab:orange'}
df_raw['cyl_color'] = df_raw.cyl.map(cyl_colors)
#计算均值和中位数
df = df_raw[['cty', 'manufacturer']].groupby('manufacturer').mean()
df.sort_values('cty', ascending=False, inplace=True)
df.reset_index(inplace=True)
df_median = df_raw[['cty', 'manufacturer']].groupby('manufacturer').median()

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
#绘图
fig, ax = plt.subplots(figsize=(16,10), dpi=80)
ax.hlines(
    y=df.index, xmin=0, xmax=40, 
    color='gray', alpha=0.5, linewidth=0.5, linestyle='dashdot'
)
#画包点
for i,make in enumerate(df.manufacturer):
    df_make = df_raw.loc[df_raw.manufacturer==make, :]
    ax.scatter(
        y=np.repeat(i,df_make.shape[0]), x='cty', data=df_make, 
        s=75, edgecolors='gray', c='w', alpha=0.5
    )
    ax.scatter(
        y=i, x='cty', data=df_median.loc[df_median.index==make, :], 
        s=75, c='firebrick'
    )

#注释
ax.text(
    33, 13, "$red \; dots \; are \; the \: median$", 
    fontsize=12, color='firebrick'
)

#修饰图片
red_patch = plt.plot([], [], 
    marker='o', ms=10, ls='', mec=None, color='firebrick', label='Median')
plt.legend(handles=red_patch)
ax.set_title("Distribution of City Mileage by Make", fontsize=22)
ax.set_xlabel("Miles Per Gallon (city)", alpha=0.7)
ax.set_yticks(df.index)
ax.set_yticklabels(
    df.manufacturer.str.title(), alpha=0.7, 
    fontdict={'horizontalalignment': 'right'}
)
ax.set_xlim(1, 40)
plt.xticks(alpha=0.7)
plt.gca().spines['top'].set_visible(False)
plt.gca().spines['bottom'].set_visible(False)
plt.gca().spines['right'].set_visible(False)
plt.gca().spines['left'].set_visible(False)
plt.grid(axis='both', alpha=0.4, linewidth=0.1)
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
"""
绘制箱形图时需要注意解释可能会扭曲该组中包含的点数的框的大小
手动提供每个框中的观察数量，可以克服这个缺点
"""
#数据准备
df = pd.read_csv("mpg_ggplot2.csv")
#绘图
plt.figure(figsize=(13,10), dpi=80)
sns.boxplot(x='class', y='hwy', data=df, notch=False)
#在箱形图中添加N个obs（obtional）
def add_n_obs(df, group_var, y):
    medians_dict = {grp[0]:grp[1][y].median() for grp in df.groupby(group_var)}
    xticklabels = [x.get_text() for x in plt.gca().get_xticklabels()]
    n_obs = df.groupby(group_var)[y].size().values
    for (x, xticklabel),obs in zip(enumerate(xticklabels), n_obs):
        plt.text(
            x, medians_dict[xticklabel]*1.01, '#obs: '+str(obs), 
            horizontalalignment='center', fontsize=14, color='white'
        )
add_n_obs(df, group_var='class', y='hwy')
#修饰图片
plt.title("Box Plot of Highway Mileage by Vehicle Class", fontsize=22)
plt.ylim(10, 40)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
"""传达类似于分组的箱形图信息，此外还可以了解到每一组中的数据密度"""
#数据准备
df = pd.read_csv("mpg_ggplot2.csv")
#绘图
plt.figure(figsize=(13,10), dpi=80)
sns.boxplot(x='class', y='hwy', data=df, hue='cyl')
sns.stripplot(x='class', y='hwy', data=df, color='black', size=3, jitter=1)
for i in range(len(df["class"].unique())-1):
    plt.vlines(i+0.5, 10, 45, linestyle='solid', colors='gray', alpha=0.2)
#修饰图片
plt.title("Box Plot of Highway Mileage by Vehicle Class", fontsize=22)
plt.legend(title='Cylinders')
plt.show()

1
2
3
4
5
6
7
df = pd.read_csv("mpg_ggplot2.csv")
#绘图
plt.figure(figsize=(13,10), dpi=80)
sns.violinplot(x='class', y='hwy', data=df, scale='width', inner='quartile')
#修饰图片
plt.title("Violin Plot of Highway Mileage by Vehicle Class", fontsize=22)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
"""金字塔图可用于显示由数量排序的组的分布"""
df = pd.read_csv("email_campaign_funnel.csv")
#绘图
plt.figure(figsize=(13,10), dpi=80)
group_var = 'Gender'
order_of_bars = df.Stage.unique()[::-1]
colors = [plt.cm.Spectral(i/float(len(df[group_var].unique())-1)) for i in \
    range(len(df[group_var].unique()))]
for c,group in zip(colors, df[group_var].unique()):
    sns.barplot(
        x='Users', y='Stage', data=df.loc[df[group_var]==group,:], 
        order=order_of_bars, color=c, label=group
    )
#修饰图片
plt.xlabel("$Users$")
plt.ylabel('Stage of Purchase')
plt.yticks(fontsize=12)
plt.title("Population Pyramid of the Marketing Funnel", fontsize=22)
plt.legend()
plt.show()

1
2
3
4
5
6
7
8
9
10
"""由seaborn库提供的，可用于可视化彼此相关的两个或多个分类变量的计数分布"""
#数据准备
titanic = sns.load_dataset('titanic')
#绘图
g = sns.catplot(
    'alive', col='deck', col_wrap=4, kind='count', height=3.5, 
    aspect=0.8, palette='tab20', data=titanic[titanic.deck.notnull()]
)
fig.suptitle('sf')
plt.show()

1
2
3
4
5
6
#绘图例2
sns.catplot(
    x='age', y='embark_town', hue='sex', col='class', orient='h', height=5,
    aspect=1, palette='tab10', kind='violin', dodge=True, cut=0, bw=0.2,
    data=titanic[titanic.embark_town.notnull()]
)

1
2
3
4
5
6
7
"""用于显示更大群体中的组的组成"""
from pywaffle import Waffle
#数据准备
df_raw = pd.read_csv("mpg_ggplot2.csv")
df = df_raw.groupby("class").size().reset_index(name='counts')
n_categories = df.shape[0]
colors = [plt.cm.inferno_r(i/float(n_categories)) for i in range(n_categories)]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#绘图
fig = plt.figure(
    FigureClass=Waffle, rows=7, colors=colors, figsize=(16,9),
    plots={
        '111': {
            'values': df["counts"],
            'labels': ["{0} ({1})".format(n[0], n[1]) for n in \ 
                df[['class', 'counts']].itertuples()],
            'legend': {
                'loc':'upper left', 'bbox_to_anchor':(1.05, 1), 'fontsize':12
            },
            'title': {
                'label':'#Vehicles by Class', 'loc':'center', 'fontsize':18
            }
        }
    }
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#绘图例2----------------------------
#数据准备-------------
#By Class Data
df_class = df_raw.groupby("class").size().reset_index(name='counts_class')
cat_num = df_class.shape[0]
colors_class = [plt.cm.Set3(i/float(cat_num)) for i in range(cat_num)]
#By Cylinders Data
df_cyl = df_raw.groupby('cyl').size().reset_index(name='counts_cyl')
cat_num = df_cyl.shape[0]
colors_cyl = [plt.cm.Spectral(i/float(cat_num)) for i in range(cat_num)]
#By Make Data
df_make = df_raw.groupby('manufacturer').size().reset_index(name='counts_make')
cat_num = df_make.shape[0]
colors_make = [plt.cm.tab20b(i/float(cat_num)) for i in range(cat_num)]

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
#绘图
fig = plt.figure(
    FigureClass=Waffle,
    plots={
        '311': {
            'values': df_class['counts_class'],
            'labels': ["{1}".format(n[0], n[1]) for n in 
                       df_class[['class', 'counts_class']].itertuples()],
            'legend': {
                'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 
                'fontsize': 12, 'title':'Class'
            },
            'title': {
                'label':'# Vehicles by Class', 'loc':'center', 'fontsize':18
            },
            'colors': colors_class
        },
        '312': {
            'values': df_cyl['counts_cyl'],
            'labels': ["{1}".format(n[0], n[1]) for n in 
                       df_cyl[['cyl', 'counts_cyl']].itertuples()],
            'legend': {
                'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 
                'fontsize': 12, 'title':'Cyl'
            },
            'title': {
                'label':'# Vehicles by Cyl', 'loc':'center', 'fontsize':18
            },
            'colors': colors_cyl
        },
        '313': {
            'values': df_make['counts_make'],
            'labels': ["{1}".format(n[0], n[1]) for n in 
                       df_make[['manufacturer', 'counts_make']].itertuples()],
            'legend': {
                'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 
                'fontsize': 12, 'title':'Manufacturer'
            },
            'title': {
                'label':'# Vehicles by Make', 'loc':'center', 'fontsize':18
            },
            'colors': colors_make
        }
    },
    rows=9,
    figsize=(16, 14)
)