Python-Seaborn详解

Seaborn 简介

Seaborn 是一个基于 matplotlib 且数据结构与 pandas 统一的统计图制作库。

这里列出了一些 seaborn 的功能：

• 计算多变量间关系的面向数据集接口
• 可视化类别变量的观测与统计
• 可视化单变量或多变量分布并与其子数据集比较
• 控制线性回归的不同因变量并进行参数估计与作图
• 对复杂数据进行易行的整体结构可视化
• 对多表统计图的制作高度抽象并简化可视化过程
• 提供多个内建主题渲染 matplotlib 的图像样式
• 提供调色板工具生动再现数据

Seaborn 框架旨在以数据可视化为中心来挖掘与理解数据。它提供的面向数据集制图函数主要是对行列索引和数组的操作，包含对整个数据集进行内部的语义映射与统计整合，以此生成富于信息的图表。

下面是一些 ? 的喵：

import seaborn as sns
sns.set()
tips = sns.load_dataset("tips")
sns.relplot(x="total_bill", y="tip", col="time",
            hue="smoker", style="smoker", size="size",
            data=tips);

上面发生了什么呢？我们一步步分析：

1. 我们装载 seaborn，这是这个例子唯一需要的 python 库。

import seaborn as sns

此处，seaborn 实际调用了 matplotlib 作图。虽然很多任务都可以直接使用 seaborn 提供的函数来完成，不过一些更深层或者更加个性化的可能需要直接使用 matplotlib 来实现，下面会详细介绍这一点。如果需要获得交互式体验，推荐使用 Jupyter/IPython 工具并开启 matplotlib 模式。否则，在使用交互式工具时如果想要看到图片需要调用 matplotlib.pyplot.show 函数。

1. 我们设置并使用 seaborn 默认的主题、尺寸大小以及调色板。

sns.set()

这里改变了 matplotlib rcParam 系统 所以会影响所有 matplotlib 图像的显示，即使你没有显式的调用 seaborn 修改这些参数。除了缺省的主题，我们提供一些其他选项，你可以独立的控制图片风格与尺寸来将他们迅速应用到演讲当中（例如，在演讲投影中使用一个拥有可阅读字体的图表）。如果你倾向于使用默认 matplotlib 主题或者其他的内置样式，你可以跳过这一部分，只使用 seaborn 提供的制图函数。

1. 装载数据集

tips = sns.load_dataset("tips")

文档中的代码多数会使用 load_dataset() 去取得样例数据集。这些数据集没什么特殊，都是 pandas 的数据结构（dataframes），所以我们也可以使用 pandas.read_csv 或者手动输入创建数据集。在文档中，多数作图都使用 tips 数据集，非常无聊但是就说明状况的作用还是可以。tips 数据集提供了一种“整洁”的整合数据的方式，所以如果你使用这种方式来整合自己的数据，使用 seaborn 再好不过了。下面详细解释为什么。

1. 我们写一个多子图散点图，分配语义变量

sns.relplot(x="total_bill", y="tip", col="time",
            hue="smoker", style="smoker", size="size",
            data=tips)

这张图说明了 tips 数据集中五个变量的关系，三个是数值变量，另外两个是类别变量。其中 total_bill 和 tip 这两个数值变量决定了轴上每个点出现的位置，另外一个 size 变量影响着出现点的大小。第一个类别变量 time 将散点图分为两个子图，第二个类别变量 smoker 决定点的形状。

所有上述内容均由 relplot 一次调用生成。注意，在函数调用过程中，我们仅仅使用变量名来划分图像中的不同的语义。如果直接使用 matplotlib ，就必须将变量转换为可视化函数的参数（例如，指定颜色，指定每个类别的制图方式），这在 seaborn 中被自动执行了，以此让使用者将注意力放在他们要解决的问题上。

接口抽象

因为不存在可视化数据的最好方式，每一个制图所描述的问题都有自己最合适的可视化方法。seaborn 旨在让可视化方法间的切换变得更容易，有时仅仅需要改变同一个接口中的参数即可。

函数 relplot() 之所以这样命名是因为设计这个函数的初衷是想让他体现多个统计间的关系。散点图可以很好的体现统计数据间的关系，但是如果有一个变量具有时间意义，那线状图可能更好一点，因此，relplot() 函数提供了一个 kind 接口可以很方便的用作于改变图像的组织方式。

dots = sns.load_dataset("dots")
sns.relplot(x="time", y="firing_rate", col="align",
            hue="choice", size="coherence", style="choice",
            facet_kws=dict(sharex=False),
            kind="line", legend="full", data=dots);

参数 size 和 style 被散点图和线状图共享，但是他们对这些可视化结果产生的影响是不同的（例如，改变点大小和线的样式）。这些细节在实际使用中是无需被关注的，我们只需要将注意力放在组织图像的结构与我们想表达的信息中。

估计与误差

我们常常会想知道一个变量的均值函数以便在计算其他变量时作为可用参数。seaborn 的许多函数都可以自动的计算参数估计，这在解决一些问题中是十分必要的。

fmri = sns.load_dataset("fmri")
sns.relplot(x="timepoint", y="signal", col="region",
            hue="event", style="event",
            kind="line", data=fmri);

估计统计参数时，seaborn 使用了 bootstrap 方法计算置信区间和误差以表示估计的不确定性程度。

Seaborn 还能实现一些不是很好用语言描述统计估计。比如，使用 lmplot() 可以将一个线性回归模型放在散点图当中去：

sns.lmplot(x="total_bill", y="tip", col="time", hue="smoker",
           data=tips);

分类图

标准的散点图和线状图用来可视化数值型数据，但是可能有些变量含有分类信息，之前的做法不再合适。我们提供了一些可视化分类变量的函数，在 catplot() 中可以找到。和 relplot() 相似的地方是，写 catplot() 函数的目的是为了提供一个面向数据集的通用接口，不仅可以显示数值变量，同时展示一个或多个类别变量。

在下面这种图中，你可以改变观测的粒聚集度，最好的情况是，所有的观测值都被调整的恰好到不会重叠但是又是沿着类别轴的：

sns.catplot(x="day", y="total_bill", hue="smoker",
            kind="swarm", data=tips);

你也可以使用核密度估计来表示这些观测可能来源于的样本：

sns.catplot(x="day", y="total_bill", hue="smoker",
            kind="violin", split=True, data=tips);

或者你可以在每个嵌套类别变量中求其唯一均值与置信区间：

sns.catplot(x="day", y="total_bill", hue="smoker",
            kind="bar", data=tips);

图与轴的函数

了解 seaborn 提供的不同函数间的区别非常重要，到目前为止我们见到的函数都是基于 figure-level 的函数。由于直接创建包含子图的 matplotlib 图像，数据得以被沿着轴展开，挖掘数据得到了优化。这些函数还可以做一些比较有技巧性的事情，比如把图例放在轴外。我们可以使用 FacetGrid 来完成这些事情。

每一个 figure-level 的图像 kind （指传给 kind 参数位置的图类别变量）都包含着一个特殊的 axes-level 作为 FacetGrid 的对象。例如，散点图实际上使用的是 scatterplot() 函数，条形图使用的是 barplot() 函数，这些函数被称为 axes-level 因为他们只会作用一个独立 matplotlib 图像轴不会影响到其他剩余轴上的子图。

总之就是 figure-level 函数控制整个图像，axes-level 的函数可以和 matplotlib 图进行更复杂的结合，无论其他轴上的子图是否由 seaborn 作出。

import matplotlib.pyplot as plt
f, axes = plt.subplots(1, 2, sharey=True, figsize=(6, 4))
sns.boxplot(x="day", y="tip", data=tips, ax=axes[0])
sns.scatterplot(x="total_bill", y="tip", hue="day", data=tips, ax=axes[1]);

使用 figure-level 函数控制图像大小的方法和控制 matplotlib 图的方法有一点不同。figure-level 函数不会设置整个图的大小，而是调整每个组成图的子图的大小，并且对于子图设定高度与比例，不会去分别设定高度和宽度。这样的参数化形式使得控制图表大小更容易了，并不需要非得仔细计算到底结果图会包含多少行、多少列，即使这样容易让人比较晕：

sns.relplot(x="time", y="firing_rate", col="align",
            hue="choice", size="coherence", style="choice",
            height=4.5, aspect=2 / 3,
            facet_kws=dict(sharex=False),
            kind="line", legend="full", data=dots);

区别 figure-level 函数和 axes-level 函数的方法就是去看函数是否携带一个 ax= 参数。或者你可以查看他们的输出类型：axes-level 函数返回一个 matplotlib axes，figure-level 函数返回一个 FacetGrid。

数据集结构可视化

在 seaborn 中创建多子图的可视化结果有两种方法，两种方法都可以刻画数据集的结构。第一种jointplot() 方法注重单对单关系：

iris = sns.load_dataset("iris")
sns.jointplot(x="sepal_length", y="petal_length", data=iris);

另一种是 pairplot() ，提供对数据更为全面的可视化。对于每对数据间的关系以及边缘分布都有考察，你可以选择用哪里分类变量作为条件：

sns.pairplot(data=iris, hue="species");

这两种方法在数据可视化都提供一些自定义选项，他们都是对于两个高度可自定义的多图作图函数 JointGrid 和 PairGrid 再封装。

自定义样式

Seaborn 库选择尽可能美观的设计，并且添加富于信息的标签。如果需要设计更为精致的图片可能会需要多执行一些步骤，这有多种方法。

第一种方法是使用 seaborn 给你的其他的主题。设置了不同的主题或者调色板样式会让整个图的效果都不一样：

sns.set(style="ticks", palette="muted")
sns.relplot(x="total_bill", y="tip", col="time",
            hue="smoker", style="smoker", size="size",
            data=tips);

如果要仅针对图像设计，所有的 seaborn 函数都接受一系列的可选参数来改变默认的语义映射，比如颜色。（对颜色的恰当选择在数据可视化中非常关键，seaborn 提供了附加支持 来引导调色板的使用）。

最后，当 seaborn 的函数与 matploblib 函数具有显然一致性时（例如 scatterplot() 和 plt.scatter），多余的参数会被直接传给 matploblib 层：

sns.relplot(x="total_bill", y="tip", col="time",
            hue="size", style="smoker", size="size",
            palette="YlGnBu", markers=["D", "o"], sizes=(10, 125),
            edgecolor=".2", linewidth=.5, alpha=.75,
            data=tips);

注意 relplot() 或者其他 figure-level 函数，因为当 relplot() 函数传递一些额外的关键字参数到 seaborn 底层的 axes-level 函数时，相当于将这些参数直接传给了底层 matplotlib 函数，这会使得你寻找对应文档变得有些麻烦，不过原则上是可以做到很高的自定义程度的。

有些 figure-level 的函数自定义可以通过传递额外参数到 FacetGrid 来实现，你可以使用这个对象的方法来控制图像的属性。甚至可以修改需要被作图的 matploblib 对象的值达到效果：

g = sns.catplot(x="total_bill", y="day", hue="time",
                height=3.5, aspect=1.5,
                kind="box", legend=False, data=tips);
g.add_legend(title="Meal")
g.set_axis_labels("Total bill ($)", "")
g.set(xlim=(0, 60), yticklabels=["Thursday", "Friday", "Saturday", "Sunday"])
g.despine(trim=True)
g.fig.set_size_inches(6.5, 3.5)
g.ax.set_xticks([5, 15, 25, 35, 45, 55], minor=True);
plt.setp(g.ax.get_yticklabels(), rotation=30);

Figure-level 函数作用于需要高效显示数据的情况，所以如果要更精确的调整大小与组织形式，直接使用 matploblib 或者使用对应的 seaborn axes-level 函数。matploblib 具有易于理解和强大的接口，任何有关图像属性的值都可以通过接口来完成设置。最好是将高度抽象的 seaborn 接口和可深度自定义的 matplotlib 接口一起使用来制作达到出版质量的最终成果。

组织数据集

之前提到过，如果你的数据整合的比较好，seaborn 的表现也会很出众。这种能称为做“长型”或者“整洁”数据在这里被详细解释。这些方式可以大致概括为：

1. 每个变量占有一个列
2. 每个观测占有一个行

你的数据是否整洁了？一种比较好的思考方式是去想你要怎么画你的图，从这一点来讲，变量就是图中一种具有规律展现形式的元素。如果看看样例 tips 会比较好：

tips.head()

	total_bill	tip	sex	smoker	day	time	size
0	16.99	1.01	Female	No	Sun	Dinner	2
—-	—-	—-	—-	—-	—-	—-	—-
1	10.34	1.66	Male	No	Sun	Dinner	3
—-	—-	—-	—-	—-	—-	—-	—-
2	21.01	3.50	Male	No	Sun	Dinner	3
—-	—-	—-	—-	—-	—-	—-	—-
3	23.68	3.31	Male	No	Sun	Dinner	2
—-	—-	—-	—-	—-	—-	—-	—-
4	24.59	3.61	Female	No	Sun	Dinner	4
—-	—-	—-	—-	—-	—-	—-	—-

从某种意义上讲，使用这种组织方式开始可能会感觉尴尬，比如使用时间序列数据，将时间点作为观测值放在列中。我们之前使用的 fmri 数据集展示了一个整洁的时间点在不同行间的组织形式：

fmri.head()

	subject	timepoint	event	region	signal
0	s13	18	stim	parietal	-0.017552
—-	—-	—-	—-	—-	—-
1	s5	14	stim	parietal	-0.080883
—-	—-	—-	—-	—-	—-
2	s12	18	stim	parietal	-0.081033
—-	—-	—-	—-	—-	—-
3	s11	18	stim	parietal	-0.046134
—-	—-	—-	—-	—-	—-
4	s10	18	stim	parietal	-0.037970
—-	—-	—-	—-	—-	—-

许多 seaborn 函数都提供了画出大范围数据图的功能，虽然在函数性上有所限制。要利用好整合较好的数据集，你肯定会使用 pandas.melt 函数来解构一个大的数据集。

安装和入门

为了安装最新版本的seaborn, 可以 pip命令:

pip install seaborn

也可以使用 conda 命令安装:

conda install seaborn

或者，您可以使用 pip 直接从github安装开发版本:

pip install git+https://github.com/mwaskom/seaborn.git

另外的方法是从 github仓库 下载，从本地安装:

pip install .

依赖

• Python 2.7 or 3.5+

必须的依赖

• numpy (>= 1.9.3)
• scipy (>= 0.14.0)
• matplotlib (>= 1.4.3)
• pandas (>= 0.15.2)

推荐的依赖

• statsmodels (>= 0.5.0)

测试

为了测试 seaborn，请在源代码分发的根目录中运行 make test。 这会运行单元测试套件（使用 pytest，但许多旧测试使用 nose 断言）。 它还在函数 docstrings 中运行示例代码，以对更广泛和更现实的示例用法进行冒烟测试。

完整的测试集需要 Internet 连接才能下载示例数据集（如果以前没有缓存过），但单元测试应该可以离线运行。

错误

请通过 github issue tracker 报告您遇到的任何错误. 在其中一个示例数据集中包含可重现的示例（通过 load_dataset() 访问）将是最有帮助的。 如果不知道你正在使用的 seaborn 和 matplotlib 的版本，以及 用于绘图的 matplotlib backend，你很难调试任何问题，所以请在错误报告中包含这些内容。

可视化统计关系

统计分析是了解数据集中的变量如何相互关联以及这些关系如何依赖于其他变量的过程。可视化是此过程的核心组件，这是因为当数据被恰当地可视化时，人的视觉系统可以看到指示关系的趋势和模式。

我们将在本教程中讨论三个seaborn函数。我们最常用的是relplot()。这是一个figure-level的函数，可以用散点图和线图两种通用的方法来可视化统计关系。relplot()将FacetGrid 与两个axes-level函数组合在一起:

• scatterplot() (kind="scatter"; 默认值)
• lineplot()(kind="line")

正如我们将要看到的，这些函数可能非常有启发性，因为他们使用简单且易于理解的数据表示形式，且仍然能够表示复杂的数据集结构。之所以可以这样，是因为它们可以通过色调、大小和样式的语义映射最多三个额外的变量来增强绘制的二维图形。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="darkgrid")

用散点图关联变量

散点图是数据可视化的支柱，它通过点云描绘了两个变量的联合分布，其中每个点代表数据集中的一个观测值。这种描述能够使我们通过视觉推断出许多信息，他们之间是否存在任何有意义的关系。

在seaborn中有多种方式绘制散点图。当两个变量的是数值型时，最基本的是函数scatterplot()。在 类别可视化，我们将会看到使用散点图来显示类别数据的专用工具。scatterplot()是relplot()中kind的默认类型(也可以通过kind="scatter"来设置):

tips = sns.load_dataset("tips")
sns.relplot(x="total_bill", y="tip", data=tips);

虽然这些点是以二维绘制的，但可以通过根据第三个变量对点进行着色来将另一个维度添加到绘图中。在seaborn中，这被称为使用“色调语义”，因为该点的颜色获得了意义：

sns.relplot(x="total_bill", y="tip", hue="smoker", data=tips);

为了强调类别之间的差异并提高可访问性，可以为每个类别使用不同的标记样式：

sns.relplot(x="total_bill", y="tip", hue="smoker", style="smoker", data=tips);

也可以通过单独改变每个点的色调和样式来表示四个变量。但是这应该谨慎，因为眼睛对形状的敏感度远低于对颜色的敏感度:

sns.relplot(x="total_bill", y="tip", hue="smoker", style="time", data=tips);

在上面的例子中，色调语义表示类别，所以使用了默认的定性调色板。如果色调语义表示数值(特别是，如果它可以转换为浮点数)，默认的颜色切换到顺序调色板:

sns.relplot(x="total_bill", y="tip", hue="size", data=tips);

在这两种情况下，您都可以自定义调色板，有多种方式可以实现。在这里，我们使用cubehelix_palette()的字符串接口自定义一个顺序调色板:

sns.relplot(x="total_bill", y="tip", hue="size", palette="ch:r=-.5,l=.75", data=tips);

第三个语义变量改变每个点的大小:

sns.relplot(x="total_bill", y="tip", size="size", data=tips);

与matplotlib.pyplot.scatter()不同，变量的值不用于直接决定点的面积。数据单位中的值范围被规范化为面积单位的范围，这个范围可以自定义:

sns.relplot(x="total_bill", y="tip", size="size", sizes=(15, 200), data=tips);

在scatterplot()API示例中展示了更多如何通过自定义使用不同语义来显示统计关系的示例。

强调线图的连续性

散点图是非常有效的，但是没有通用的最优可视化类型。相反，可视表示应该适应数据集的细节以及您试图用图表回答的问题。

对于某些数据集，您可能希望了解一个变量中的变化关于时间的函数，或者类似的连续变量。在这种情况下，一个很好的选择是绘制线图。在seaborn中，这可以通过lineplot()函数直接实现，也可以通过设置relplot()的参数kind="line"来实现:

df = pd.DataFrame(dict(time=np.arange(500),
                       value=np.random.randn(500).cumsum()))
g = sns.relplot(x="time", y="value", kind="line", data=df)
g.fig.autofmt_xdate()

由于lineplot()假设您想要将y绘制为x的函数，默认行为是在绘制之前按数字x对数据进行排序。但是，这可以被禁用：

df = pd.DataFrame(np.random.randn(500, 2).cumsum(axis=0), columns=["x", "y"])
sns.relplot(x="x", y="y", sort=False, kind="line", data=df);

聚合和表示不确定性

更复杂的数据集将对x变量的相同值有多个观测值。seaborn的默认行为是通过绘制平均值及95%的置信区间，在每个x周围聚合多个测量值:

fmri = sns.load_dataset("fmri")
sns.relplot(x="timepoint", y="signal", kind="line", data=fmri);

置信区间是使用bootstrapping计算的，对于较大的数据集，它可能是时间密集型的。因此，可以禁用它们:

sns.relplot(x="timepoint", y="signal", ci=None, kind="line", data=fmri);

尤其是对于较大的数据，另一个不错的选择是通过绘制标准差，而不是置信区间来表示分布在每个时间点的分布范围:

sns.relplot(x="timepoint", y="signal", kind="line", ci="sd", data=fmri);

可以通过设置estimator参数为None，来完全停用聚合。当数据在每个点上有多个观察值时，这可能会产生奇怪的效果。

sns.relplot(x="timepoint", y="signal", estimator=None, kind="line", data=fmri);

Plotting subsets of data with semantic mappings

函数lineplot()与scatterplot()具有相同的灵活性：它可以通过修改绘图元素的色调，大小和样式来显示最多三个附加变量。它使用于scatterplot()相同的API，这意味着我们不需要停下来考虑控制matplotlib中线条与点外观的参数。

在lineplot()中使用语义也将决定数据的聚合方式。例如，添加具有两个级别的色调语义将绘图分成两行以及错误带，每个都着色以指示它们对应于哪个数据集。

sns.relplot(x="timepoint", y="signal", hue="event", kind="line", data=fmri);

在线条图中添加样式语义默认情况下会改变线条中的破折号模式：

sns.relplot(x="timepoint", y="signal", hue="region", style="event", kind="line", data=fmri);

但您可以通过每次观察时使用的标记识别子集，或者使用短划线或代替它们：

sns.relplot(x="timepoint", y="signal", hue="region", style="event",
            kind="line", data=fmri);

与散点图一样，要谨慎使用多个语义制作线图。虽然有时提供信息，但它们也很难解析和解释。但当您只检查一个附加变量的变化时，更改线条的颜色和样式也很有用。当打印成黑白或有色盲的人观看时，这可以使绘图更容易访问：

sns.relplot(x="timepoint", y="signal", hue="event", style="event", kind="line", data=fmri);

当您使用重复测量数据（即，您有多次采样的单位）时，您还可以单独绘制每个采样单位，而无需通过语义区分它们。这样可以避免使图例混乱：

sns.relplot(x="timepoint", y="signal", hue="region", style="event",
            dashes=False, markers=True, kind="line", data=fmri);

lineplot()中默认的色彩映射和图例的处理还取决于色调语义是类别还是数值：

dots = sns.load_dataset("dots").query("align == 'dots'")
sns.relplot(x="time", y="firing_rate",
            hue="coherence", style="choice",
            kind="line", data=dots);

可能会发生这样的情况：即使hue变量是数值，它也很难用线性色标表示。如下示例，其中hue变量的级别以对数方式缩放。您可以通过传递列表或字典为每一行提供特定的颜色值：

palette = sns.cubehelix_palette(light=.8, n_colors=6)
sns.relplot(x="time", y="firing_rate",
            hue="coherence", style="choice",
            palette=palette,
            kind="line", data=dots);

或者您可以更改色彩映射的规范化方式：

from matplotlib.colors import LogNorm
palette = sns.cubehelix_palette(light=.7, n_colors=6)
sns.relplot(x="time", y="firing_rate",
            hue="coherence", style="choice",
            hue_norm=LogNorm(),
            kind="line", data=dots);

第三个语义，size改变线的宽度：

sns.relplot(x="time", y="firing_rate",
            size="coherence", style="choice",
            kind="line", data=dots);

虽然size变量通常是数值型的，但是也可以用线宽映射为类别变量。在这样做的时候要小心，因为除了“粗”线和“细”线之外，很难区分更多。然而，当线具有高频变异性时，破折号很难被察觉，因此在这种情况下，使用不同的宽度可能更有效:

sns.relplot(x="time", y="firing_rate",
           hue="coherence", size="choice",
           palette=palette,
           kind="line", data=dots);

用日期数据绘图

线图通常用于可视化与实际日期和时间相关的数据。这些函数以原始格式将数据传递给底层的matplotlib函数，因此他们可以利用matplotlib在tick标签中设置日期格式的功能。但是所有这些格式化都必须在matplotlib层进行，您应该参考matplotlib文档来了解它是如何工作的：

df = pd.DataFrame(dict(time=pd.date_range("2017-1-1", periods=500),
                       value=np.random.randn(500).cumsum()))
g = sns.relplot(x="time", y="value", kind="line", data=df)
g.fig.autofmt_xdate()

显示与切面的多种关系

我们在本教程中强调，虽然这些函数可以同时显示几个语义变量，但这样做并不总是有效的。但是，当你想要了解两个变量之间的关系如何依赖于多个其他变量时呢？

最好的方法可能是多次绘制。因为relplot()基于FacetGrid，所以这很容易做到。要显示附加变量的影响，而不是将其分配给图中的一个语义角色，而是使用它来“切面”可视化。这意味着您可以创建多个轴并在每个轴上绘制数据的子集:

sns.relplot(x="total_bill", y="tip", hue="smoker", col="time", data=tips);

您还可以通过这种方式显示两个变量的影响：一个是通过在列上切面而另一个是在行上切面。当您开始向网格添加更多变量时，您可能希望减小图形大小。请记住，大小FacetGrid由每个切面的高度和长宽比参数化的：

sns.relplot(x="timepoint", y="signal", hue="subject",
            col="region", row="event", height=3,
            kind="line", estimator=None, data=fmri);

当您想要检查一个变量的多个级别的效果时，在列上对该变量进行切面处理，然后将切面“包装”到行中:

sns.relplot(x="timepoint", y="signal", hue="event", style="event",
            col="subject", col_wrap=5,
            height=3, aspect=.75, linewidth=2.5,
            kind="line", data=fmri.query("region == 'frontal'"));

这些可视化通常被称为格点图，它们非常有效，因为它们以总体模式和与这些模式的偏差的数据格式来呈现数据，便于眼睛观察。虽然你应该利用scatterplot()和relplot()提供的灵活性，但一定要记住，几个简单的图通常比一个复杂的图更有效。

可视化数据集的分布

在处理一组数据时，您通常想做的第一件事就是了解变量的分布情况。本教程的这一章将简要介绍seaborn中用于检查单变量和双变量分布的一些工具。

import seaborn as sns
import matplotlib.pyplot as plt
from scipy import stats
sns.set(color_codes=True)

绘制单变量分布

在seaborn中想要快速查看单变量分布的最方便的方法是使用distplot()函数。默认情况下，该方法将会绘制直方图histogram并拟合[内核密度估计] kernel density estimate (KDE).

x = np.random.normal(size=100)
sns.distplot(x);

直方图

对于直方图我们可能很熟悉，而且matplotlib中已经存在hist函数。 直方图首先确定数据区间，然后观察数据落入这些区间中的数量来绘制柱形图以此来表征数据的分布情况。为了说明这一点，让我们删除密度曲线并添加一个rug plot，它在每个观察值上画一个小的垂直刻度。您可以使用rugplot() 函数来创建rugplot本身，但是也可以在 distplot()中使用:

sns.distplot(x, kde=False, rug=True);

在绘制柱状图时，您的主要选择是要使用的“桶”的数量和放置它们的位置。 distplot() 使用一个简单的规则来很好地猜测默认情况下正确的数字是多少，但是尝试更多或更少的“桶”可能会揭示数据中的其他特性:

sns.distplot(x, bins=20, kde=False, rug=True);

核密度估计

可能你对核密度估计不太熟悉，但它可以是绘制分布形状的有力工具。和直方图一样，KDE图沿另一个轴的高度，编码一个轴上的观测密度：

sns.distplot(x, hist=False, rug=True);

绘制KDE比绘制直方图更需要计算。每个观测值首先被一个以该值为中心的正态(高斯)曲线所取代:

x = np.random.normal(0, 1, size=30)
bandwidth = 1.06 * x.std() * x.size ** (-1 / 5.)
support = np.linspace(-4, 4, 200)
kernels = []
for x_i in x:
    kernel = stats.norm(x_i, bandwidth).pdf(support)
    kernels.append(kernel)
    plt.plot(support, kernel, color="r")
sns.rugplot(x, color=".2", linewidth=3);

接下来，对这些曲线求和，计算支持网格(support grid)中每个点的密度值。然后对得到的曲线进行归一化，使曲线下的面积等于1:

from scipy.integrate import trapz
density = np.sum(kernels, axis=0)
density /= trapz(density, support)
plt.plot(support, density);

我们可以看到，如果在seaborn中使用kdeplot() 函数， 我们可以得到相同的曲线。这个函数也被distplot()所使用, 但是当您只想要密度估计时，它提供了一个更直接的接口，可以更容易地访问其他选项:

sns.kdeplot(x, shade=True);

KDE的带宽（bw）参数控制估计与数据的拟合程度，就像直方图中的bin大小一样。 它对应于我们在上面绘制的内核的宽度。 默认行为尝试使用常用参考规则猜测一个好的值，但尝试更大或更小的值可能会有所帮助：

sns.kdeplot(x)
sns.kdeplot(x, bw=.2, label="bw: 0.2")
sns.kdeplot(x, bw=2, label="bw: 2")
plt.legend();

正如您在上面所看到的，高斯KDE过程的本质意味着估计超出了数据集中最大和最小的值。有可能控制超过极值多远的曲线是由’cut’参数绘制的;然而，这只影响曲线的绘制方式，而不影响曲线的拟合方式:

sns.kdeplot(x, shade=True, cut=0)
sns.rugplot(x);

拟合参数分布

您还可以使用 distplot()

将参数分布拟合到数据集上，并直观地评估其与观测数据的对应程度:

x = np.random.gamma(6, size=200)
sns.distplot(x, kde=False, fit=stats.gamma);

绘制二元分布

它对于可视化两个变量的二元分布也很有用。在seaborn中，最简单的方法就是使用jointplot()函数，它创建了一个多面板图形，显示了两个变量之间的二元(或联合)关系，以及每个变量在单独轴上的一元(或边际)分布。

mean, cov = [0, 1], [(1, .5), (.5, 1)]
data = np.random.multivariate_normal(mean, cov, 200)
df = pd.DataFrame(data, columns=["x", "y"])

散点图

可视化二元分布最常见的方法是散点图，其中每个观察点都以x和y值表示。 这类似于二维rug plot。 您可以使用matplotlib的plt.scatter 函数绘制散点图, 它也是 jointplot()函数显示的默认类型的图:

sns.jointplot(x="x", y="y", data=df);

六边形“桶”(Hexbin)图

类似于单变量的直方图，用于描绘二元变量关系的图称为 “hexbin” 图,因为它显示了落入六边形“桶”内的观察计数。 此图对于相对较大的数据集最有效。它可以通过调用matplotlib中的 plt.hexbin函数获得并且在jointplot()作为一种样式。当使用白色作为背景色时效果最佳。

x, y = np.random.multivariate_normal(mean, cov, 1000).T
with sns.axes_style("white"):
    sns.jointplot(x=x, y=y, kind="hex", color="k");

核密度估计

也可以使用上面描述的核密度估计过程来可视化二元分布。在seaborn中，这种图用等高线图表示， 在jointplot()中被当作一种样式:

sns.jointplot(x="x", y="y", data=df, kind="kde");

您还可以使用kdeplot()函数绘制二维核密度图。这允许您在一个特定的(可能已经存在的)matplotlib轴上绘制这种图，而 jointplot() 函数能够管理它自己的图:

f, ax = plt.subplots(figsize=(6, 6))
sns.kdeplot(df.x, df.y, ax=ax)
sns.rugplot(df.x, color="g", ax=ax)
sns.rugplot(df.y, vertical=True, ax=ax);

如果希望更连续地显示双变量密度，可以简单地增加轮廓层的数量:

f, ax = plt.subplots(figsize=(6, 6))
cmap = sns.cubehelix_palette(as_cmap=True, dark=0, light=1, reverse=True)
sns.kdeplot(df.x, df.y, cmap=cmap, n_levels=60, shade=True);

jointplot()函数使用JointGrid来管理图形。为了获得更大的灵活性，您可能想直接使用JointGrid来绘制图形。jointplot()在绘图后返回JointGrid对象，您可以使用它添加更多图层或调整可视化的其他方面：

g = sns.jointplot(x="x", y="y", data=df, kind="kde", color="m")
g.plot_joint(plt.scatter, c="w", s=30, linewidth=1, marker="+")
g.ax_joint.collections[0].set_alpha(0)
g.set_axis_labels("$X$", "$Y$");

可视化数据集中的成对关系

要在数据集中绘制多个成对的双变量分布，您可以使用pairplot()函数。 这将创建一个轴矩阵并显示DataFrame中每对列的关系，默认情况下，它还绘制对角轴上每个变量的单变量分布：

iris = sns.load_dataset("iris")
sns.pairplot(iris);

与jointplot()和JointGrid之间的关系非常类似， pairplot()函数构建在PairGrid对象之上, 可以直接使用它来获得更大的灵活性：

g = sns.PairGrid(iris)
g.map_diag(sns.kdeplot)
g.map_offdiag(sns.kdeplot, n_levels=6);

Visualizing linear relationships

Many datasets contain multiple quantitative variables, and the goal of an analysis is often to relate those variables to each other. We previously discussed functions that can accomplish this by showing the joint distribution of two variables. It can be very helpful, though, to use statistical models to estimate a simple relationship between two noisy sets of observations. The functions discussed in this chapter will do so through the common framework of linear regression.

In the spirit of Tukey, the regression plots in seaborn are primarily intended to add a visual guide that helps to emphasize patterns in a dataset during exploratory data analyses. That is to say that seaborn is not itself a package for statistical analysis. To obtain quantitative measures related to the fit of regression models, you should use statsmodels. The goal of seaborn, however, is to make exploring a dataset through visualization quick and easy, as doing so is just as (if not more) important than exploring a dataset through tables of statistics.

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

sns.set(color_codes=True)
tips = sns.load_dataset("tips")

Functions to draw linear regression models

Two main functions in seaborn are used to visualize a linear relationship as determined through regression. These functions, regplot() and lmplot() are closely related, and share much of their core functionality. It is important to understand the ways they differ, however, so that you can quickly choose the correct tool for particular job.

In the simplest invocation, both functions draw a scatterplot of two variables, x and y, and then fit the regression model y ~ x and plot the resulting regression line and a 95% confidence interval for that regression:

sns.regplot(x="total_bill", y="tip", data=tips);

sns.lmplot(x="total_bill", y="tip", data=tips);

You should note that the resulting plots are identical, except that the figure shapes are different. We will explain why this is shortly. For now, the other main difference to know about is that regplot() accepts the x and y variables in a variety of formats including simple numpy arrays, pandas Series objects, or as references to variables in a pandas DataFrame object passed to data. In contrast, lmplot() has data as a required parameter and the x and y variables must be specified as strings. This data format is called “long-form” or “tidy” data. Other than this input flexibility, regplot() possesses a subset of lmplot()’s features, so we will demonstrate them using the latter.

It’s possible to fit a linear regression when one of the variables takes discrete values, however, the simple scatterplot produced by this kind of dataset is often not optimal:

sns.lmplot(x="size", y="tip", data=tips);

One option is to add some random noise (“jitter”) to the discrete values to make the distribution of those values more clear. Note that jitter is applied only to the scatterplot data and does not influence the regression line fit itself:

sns.lmplot(x="size", y="tip", data=tips, x_jitter=.05);

A second option is to collapse over the observations in each discrete bin to plot an estimate of central tendency along with a confidence interval:

sns.lmplot(x="size", y="tip", data=tips, x_estimator=np.mean);

Fitting different kinds of models

The simple linear regression model used above is very simple to fit, however, it is not appropriate for some kinds of datasets. The Anscombe’s quartet dataset shows a few examples where simple linear regression provides an identical estimate of a relationship where simple visual inspection clearly shows differences. For example, in the first case, the linear regression is a good model:

anscombe = sns.load_dataset("anscombe")
sns.lmplot(x="x", y="y", data=anscombe.query("dataset == 'I'"),
           ci=None, scatter_kws={"s": 80});

The linear relationship in the second dataset is the same, but the plot clearly shows that this is not a good model:

sns.lmplot(x="x", y="y", data=anscombe.query("dataset == 'II'"),
           ci=None, scatter_kws={"s": 80});

In the presence of these kind of higher-order relationships, lmplot() and regplot() can fit a polynomial regression model to explore simple kinds of nonlinear trends in the dataset:

sns.lmplot(x="x", y="y", data=anscombe.query("dataset == 'II'"),
           order=2, ci=None, scatter_kws={"s": 80});

A different problem is posed by “outlier” observations that deviate for some reason other than the main relationship under study:

sns.lmplot(x="x", y="y", data=anscombe.query("dataset == 'III'"),
           ci=None, scatter_kws={"s": 80});

In the presence of outliers, it can be useful to fit a robust regression, which uses a different loss function to downweight relatively large residuals:

sns.lmplot(x="x", y="y", data=anscombe.query("dataset == 'III'"),
           robust=True, ci=None, scatter_kws={"s": 80});

When the y variable is binary, simple linear regression also “works” but provides implausible predictions:

tips["big_tip"] = (tips.tip / tips.total_bill) > .15
sns.lmplot(x="total_bill", y="big_tip", data=tips,
           y_jitter=.03);

The solution in this case is to fit a logistic regression, such that the regression line shows the estimated probability of y = 1 for a given value of x:

sns.lmplot(x="total_bill", y="big_tip", data=tips,
           logistic=True, y_jitter=.03);

Note that the logistic regression estimate is considerably more computationally intensive (this is true of robust regression as well) than simple regression, and as the confidence interval around the regression line is computed using a bootstrap procedure, you may wish to turn this off for faster iteration (using ci=None).

An altogether different approach is to fit a nonparametric regression using a lowess smoother. This approach has the fewest assumptions, although it is computationally intensive and so currently confidence intervals are not computed at all:

sns.lmplot(x="total_bill", y="tip", data=tips,
           lowess=True);

The residplot() function can be a useful tool for checking whether the simple regression model is appropriate for a dataset. It fits and removes a simple linear regression and then plots the residual values for each observation. Ideally, these values should be randomly scattered around y = 0:

sns.residplot(x="x", y="y", data=anscombe.query("dataset == 'I'"),
              scatter_kws={"s": 80});

If there is structure in the residuals, it suggests that simple linear regression is not appropriate:

sns.residplot(x="x", y="y", data=anscombe.query("dataset == 'II'"),
              scatter_kws={"s": 80});

Conditioning on other variables

The plots above show many ways to explore the relationship between a pair of variables. Often, however, a more interesting question is “how does the relationship between these two variables change as a function of a third variable?” This is where the difference between regplot() and lmplot() appears. While regplot() always shows a single relationship, lmplot() combines regplot() with FacetGrid to provide an easy interface to show a linear regression on “faceted” plots that allow you to explore interactions with up to three additional categorical variables.

The best way to separate out a relationship is to plot both levels on the same axes and to use color to distinguish them:

sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips);

In addition to color, it’s possible to use different scatterplot markers to make plots the reproduce to black and white better. You also have full control over the colors used:

sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips,
           markers=["o", "x"], palette="Set1");

To add another variable, you can draw multiple “facets” which each level of the variable appearing in the rows or columns of the grid:

sns.lmplot(x="total_bill", y="tip", hue="smoker", col="time", data=tips);

sns.lmplot(x="total_bill", y="tip", hue="smoker", col="time", row="sex", data=tips);

Controlling the size and shape of the plot

Before we noted that the default plots made by regplot() and lmplot() look the same but on axes that have a different size and shape. This is because regplot() is an “axes-level” function draws onto a specific axes. This means that you can make multi-panel figures yourself and control exactly where the regression plot goes. If no axes object is explicitly provided, it simply uses the “currently active” axes, which is why the default plot has the same size and shape as most other matplotlib functions. To control the size, you need to create a figure object yourself.

f, ax = plt.subplots(figsize=(5, 6))
sns.regplot(x="total_bill", y="tip", data=tips, ax=ax);

In contrast, the size and shape of the lmplot() figure is controlled through the FacetGrid interface using the size and aspect parameters, which apply to each facet in the plot, not to the overall figure itself:

sns.lmplot(x="total_bill", y="tip", col="day", data=tips,
           col_wrap=2, height=3);

sns.lmplot(x="total_bill", y="tip", col="day", data=tips,
           aspect=.5);

Plotting a regression in other contexts

A few other seaborn functions use regplot() in the context of a larger, more complex plot. The first is the jointplot() function that we introduced in the distributions tutorial. In addition to the plot styles previously discussed, jointplot() can use regplot() to show the linear regression fit on the joint axes by passing kind="reg":

sns.jointplot(x="total_bill", y="tip", data=tips, kind="reg");

Using the pairplot() function with kind="reg" combines regplot() and PairGrid to show the linear relationship between variables in a dataset. Take care to note how this is different from lmplot(). In the figure below, the two axes don’t show the same relationship conditioned on two levels of a third variable; rather, PairGrid() is used to show multiple relationships between different pairings of the variables in a dataset:

sns.pairplot(tips, x_vars=["total_bill", "size"], y_vars=["tip"],
             height=5, aspect=.8, kind="reg");

Like lmplot(), but unlike jointplot(), conditioning on an additional categorical variable is built into pairplot() using the hue parameter:

sns.pairplot(tips, x_vars=["total_bill", "size"], y_vars=["tip"],
             hue="smoker", height=5, aspect=.8, kind="reg");

构建结构化多图网格

在探索中等维度数据时，经常需要在数据集的不同子集上绘制同一类型图的多个实例。这种技术有时被称为“网格”或“格子”绘图，它与“多重小图”的概念有关。这种技术使查看者从复杂数据中快速提取大量信息。 Matplotlib为绘制这种多轴图提供了很好的支持; seaborn构建于此之上，可直接将绘图结构和数据集结构关系起来。

要使用网格图功能，数据必须在Pandas数据框中，并且必须采用 Hadley Whickam所谓的 “整洁”数据的形式。简言之，用来画图的数据框应该构造成每列一个变量，每一行一个观察的形式。

至于高级用法，可以直接使用本教程中讨论的对象，以提供最大的灵活性。一些seaborn函数（例如lmplot()，catplot()和pairplot()）也在后台使用它们。与其他在没有操纵图形的情况下绘制到特定的（可能已经存在的）matplotlib Axes上的“Axes-level” seaborn函数不同，这些更高级别的函数在调用时会创建一个图形，并且通常对图形的设置方式更加严格。在某些情况下，这些函数或它们所依赖的类构造函数的参数将提供不同的接口属性，如lmplot()中的图形大小，你可以设置每个子图的高和宽高比。但是，使用这些对象的函数在绘图后都会返回它，并且这些对象大多都有方便简单的方法来改变图的绘制方式。

import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style="ticks")

基于一定条件的多重小图

当你想在数据集的不同子集中分别可视化变量分布或多个变量之间的关系时，FacetGrid类非常有用。 FacetGrid最多有三个维：row，col和hue。前两个与轴(axes)阵列有明显的对应关系;将色调变量hue视为沿深度轴的第三个维度，不同的级别用不同的颜色绘制。

首先，使用数据框初始化FacetGrid对象并指定将形成网格的行，列或色调维度的变量名称。这些变量应是离散的，然后对应于变量的不同取值的数据将用于沿该轴的不同小平面的绘制。例如，假设我们想要在tips数据集中检查午餐和晚餐小费分布的差异。

此外，relplot()，catplot()和lmplot()都在内部使用此对象，并且它们在完成时返回该对象，以便进一步调整。

tips = sns.load_dataset("tips")
g = sns.FacetGrid(tips, col="time")

如上初始化网格会设置matplotlib图形和轴，但不会在其上绘制任何内容。

在网格上可视化数据的主要方法是FacetGrid.map()。为此方法提供绘图函数以及要绘制的数据框变量名作为参数。我们使用直方图绘制每个子集中小费金额的分布。

g = sns.FacetGrid(tips, col="time")
g.map(plt.hist, "tip");

map函数绘制图形并注释轴，生成图。要绘制关系图，只需传递多个变量名称。还可以提供关键字参数，这些参数将传递给绘图函数：

g = sns.FacetGrid(tips, col="sex", hue="smoker")
g.map(plt.scatter, "total_bill", "tip", alpha=.7)
g.add_legend();

有几个传递给类构造函数的选项可用于控制网格外观。

g = sns.FacetGrid(tips, row="smoker", col="time", margin_titles=True)
g.map(sns.regplot, "size", "total_bill", color=".3", fit_reg=False, x_jitter=.1);

注意，matplotlib API并未正式支持margin_titles，此选项在一些情况下可能无法正常工作。特别是，它目前不能与图之外的图例同时使用。

通过提供每个面的高度以及纵横比来设置图形的大小：

g = sns.FacetGrid(tips, col="day", height=4, aspect=.5)
g.map(sns.barplot, "sex", "total_bill");

/Users/mwaskom/code/seaborn/seaborn/axisgrid.py:715: UserWarning: Using the barplot function without specifying order is likely to produce an incorrect plot.
  warnings.warn(warning)

小图的默认排序由DataFrame中的信息确定的。如果用于定义小图的变量是类别变量，则使用类别的顺序。否则，小图将按照各类的出现顺序排列。但是，可以使用适当的* _order参数指定任意构面维度的顺序：

ordered_days = tips.day.value_counts().index
g = sns.FacetGrid(tips, row="day", row_order=ordered_days,
                  height=1.7, aspect=4,)
g.map(sns.distplot, "total_bill", hist=False, rug=True);

可以用seaborn调色板（即可以传递给color_palette()的东西。）还可以用字典将hue变量中的值映射到matplotlib颜色：

pal = dict(Lunch="seagreen", Dinner="gray")
g = sns.FacetGrid(tips, hue="time", palette=pal, height=5)
g.map(plt.scatter, "total_bill", "tip", s=50, alpha=.7, linewidth=.5, edgecolor="white")
g.add_legend();

还可以让图的其他方面（如点的形状）在色调变量的各个级别之间变化，这在以黑白方式打印时使图易于理解。为此，只需将一个字典传递给hue_kws，其中键是绘图函数关键字参数的名称，值是关键字值列表，每个级别为一个色调变量。

g = sns.FacetGrid(tips, hue="sex", palette="Set1", height=5, hue_kws={"marker": ["^", "v"]})
g.map(plt.scatter, "total_bill", "tip", s=100, linewidth=.5, edgecolor="white")
g.add_legend();

如果一个变量的水平数过多，除了可以沿着列绘制之外，也可以“包装”它们以便它们跨越多行。执行此wrap操作时，不能使用row变量。

attend = sns.load_dataset("attention").query("subject <= 12")
g = sns.FacetGrid(attend, col="subject", col_wrap=4, height=2, ylim=(0, 10))
g.map(sns.pointplot, "solutions", "score", color=".3", ci=None);

/Users/mwaskom/code/seaborn/seaborn/axisgrid.py:715: UserWarning: Using the pointplot function without specifying order is likely to produce an incorrect plot.
  warnings.warn(warning)

使用FacetGrid.map() （可以多次调用）绘图后，你可以调整绘图的外观。 FacetGrid对象有许多方法可以在更高的抽象层次上操作图形。最一般的是FacetGrid.set()，还有其他更专业的方法，如FacetGrid.set_axis_labels()，它们都遵循内部构面没有轴标签的约定。例如：

with sns.axes_style("white"):
    g = sns.FacetGrid(tips, row="sex", col="smoker", margin_titles=True, height=2.5)
g.map(plt.scatter, "total_bill", "tip", color="#334488", edgecolor="white", lw=.5);
g.set_axis_labels("Total bill (US Dollars)", "Tip");
g.set(xticks=[10, 30, 50], yticks=[2, 6, 10]);
g.fig.subplots_adjust(wspace=.02, hspace=.02);

对于需要更多自定义的情形，你可以直接使用底层matplotlib图形Figure和轴Axes对象，它们分别作为成员属性存储在Figure和轴Axes（一个二维数组）中。在制作没有行或列刻面的图形时，你还可以使用ax属性直接访问单个轴。

g = sns.FacetGrid(tips, col="smoker", margin_titles=True, height=4)
g.map(plt.scatter, "total_bill", "tip", color="#338844", edgecolor="white", s=50, lw=1)
for ax in g.axes.flat:
    ax.plot((0, 50), (0, .2 * 50), c=".2", ls="--")
g.set(xlim=(0, 60), ylim=(0, 14));

使用自定义函数

使用FacetGrid时，你除了可以使用现有的matplotlib和seaborn函数，还可以使用自定义函数。但是，这些函数必须遵循一些规则：

1. 它必须绘制到“当前活动的”matplotlib轴Axes上。 matplotlib.pyplot命名空间中的函数就是如此。如果要直接使用当前轴的方法，可以调用plt.gca来获取对当前Axes的引用。
2. 它必须接受它在位置参数中绘制的数据。在内部，FacetGrid将为传递给FacetGrid.map()的每个命名位置参数传递一Series数据。
3. 它必须能接受color和label关键字参数，理想情况下，它会用它们做一些有用的事情。在大多数情况下，最简单的方法是捕获** kwargs的通用字典并将其传递给底层绘图函数。

让我们看一下自定义绘图函数的最小示例。这个函数在每个构面采用一个数据向量：

from scipy import stats
def quantile_plot(x, **kwargs):
    qntls, xr = stats.probplot(x, fit=False)
    plt.scatter(xr, qntls, **kwargs)
g = sns.FacetGrid(tips, col="sex", height=4)
g.map(quantile_plot, "total_bill");

如果你想要制作一个双变量图，编写函数则应该有分别接受x轴变量，y轴变量的参数：

def qqplot(x, y, **kwargs):
    _, xr = stats.probplot(x, fit=False)
    _, yr = stats.probplot(y, fit=False)
    plt.scatter(xr, yr, **kwargs)
g = sns.FacetGrid(tips, col="smoker", height=4)
g.map(qqplot, "total_bill", "tip");

因为plt.scatter接受颜色和标签关键字参数并做相应的处理，所以我们可以毫无困难地添加一个色调构面：

g = sns.FacetGrid(tips, hue="time", col="sex", height=4)
g.map(qqplot, "total_bill", "tip")
g.add_legend();

这种方法还允许我们使用额外的美学元素来区分色调变量的级别，以及不依赖于分面变量的关键字参数：

g = sns.FacetGrid(tips, hue="time", col="sex", height=4,
                  hue_kws={"marker": ["s", "D"]})
g.map(qqplot, "total_bill", "tip", s=40, edgecolor="w")
g.add_legend();

有时候，你需要使用color和label关键字参数映射不能按预期方式工作的函数。在这种情况下，你需要显式捕获它们并在自定义函数的逻辑中处理它们。例如，这种方法可用于映射plt.hexbin，使它与FacetGrid API匹配：

def hexbin(x, y, color, **kwargs):
    cmap = sns.light_palette(color, as_cmap=True)
    plt.hexbin(x, y, gridsize=15, cmap=cmap, **kwargs)
with sns.axes_style("dark"):
    g = sns.FacetGrid(tips, hue="time", col="time", height=4)
g.map(hexbin, "total_bill", "tip", extent=[0, 50, 0, 10]);

绘制成对数据关系

PairGrid允许你使用相同的绘图类型快速绘制小子图的网格。在PairGrid中，每个行和列都分配给一个不同的变量，结果图显示数据集中的每个对变量的关系。这种图有时被称为“散点图矩阵”，这是显示成对关系的最常见方式，但是PairGrid不仅限于散点图。

了解FacetGrid和PairGrid之间的差异非常重要。前者每个构面显示以不同级别的变量为条件的相同关系。后者显示不同的关系（尽管上三角和下三角组成镜像图）。使用PairGrid可为你提供数据集中有趣关系的快速，高级的摘要。

该类的基本用法与FacetGrid非常相似。首先初始化网格，然后将绘图函数传递给map方法，并在每个子图上调用它。还有一个伴侣函数， pairplot() ，可以更快的绘图。

iris = sns.load_dataset("iris")
g = sns.PairGrid(iris)
g.map(plt.scatter);

可以在对角线上绘制不同的函数，以显示每列中变量的单变量分布。但请注意，轴刻度与该绘图的计数或密度轴不对应。

g = sns.PairGrid(iris)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);

此图的一种常见用法是通过单独的分类变量对观察结果进行着色。例如，iris数据集三种不同种类的鸢尾花都有四种测量值，因此你可以看到不同花在这些取值上的差异。

g = sns.PairGrid(iris, hue="species")
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter)
g.add_legend();

默认情况下，使用数据集中的每个数值列，但如果需要，你可以专注于特定列。

g = sns.PairGrid(iris, vars=["sepal_length", "sepal_width"], hue="species")
g.map(plt.scatter);

也可以在上三角和下三角中使用不同的函数来强调关系的不同方面。

g = sns.PairGrid(iris)
g.map_upper(plt.scatter)
g.map_lower(sns.kdeplot)
g.map_diag(sns.kdeplot, lw=3, legend=False);

对角线上具有单位关系的方形网格实际上只是一种特殊情况，你也可以在行和列中使用不同的变量进行绘图。

g = sns.PairGrid(tips, y_vars=["tip"], x_vars=["total_bill", "size"], height=4)
g.map(sns.regplot, color=".3")
g.set(ylim=(-1, 11), yticks=[0, 5, 10]);

当然，美学属性是可配置的。例如，你可以使用不同的调色板（例如，显示色调变量的顺序）并将关键字参数传递到绘图函数中。

g = sns.PairGrid(tips, hue="size", palette="GnBu_d")
g.map(plt.scatter, s=50, edgecolor="white")
g.add_legend();

PairGrid很灵活，但要快速查看数据集，使用pairplot()更容易。此函数默认使用散点图和直方图，但会添加一些其他类型（目前，你还可以绘制非对角线上的回归图和对角线上的KDE）。

sns.pairplot(iris, hue="species", height=2.5);

还可以使用关键字参数控制绘图的美观，函数会返回PairGrid实例以便进一步调整。

g = sns.pairplot(iris, hue="species", palette="Set2", diag_kind="kde", height=2.5)

控制图像的美学样式(aesthetics)

绘制有吸引力的图像很十分重要的。当你在探索一个数据集并为你自己做图的时候，制作一些让人看了心情愉悦的图像是很好的。可视化对向观众传达量化的简介也是很重要的，在这种情况下制作能够抓住查看者的注意力并牢牢吸引住他们的图像就更有必要了。

Matplotlib是高度可定制的，但是很难知道要如何设置图像才能使得图像更加吸引人。Seaborn提供了许多定制好的主题和高级的接口，用于控制Matplotlib所做图像的外观。

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

让我们定义一个简单的函数来绘制一些偏移正弦波，这将帮助我们看到我们可以调整的能够影响图像风格的不同参数。

def sinplot(flip=1):
    x = np.linspace(0, 14, 100)
    for i in range(1, 7):
        plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)

这是Matplotlib默认情况下的绘图外观：

sinplot()

为了将图像的风格转变为seaborn的默认样式，我们可以 set() 函数。

sns.set()
sinplot()

（注意，在0.8之前的seaborn版本中， set() 已经在使用impory语句导入的时候就被调用了。但在以后的版本中，必须要显式调用它）。

Seaborn将matplotlib参数分成两个独立的组。第一组设置了图像的美术风格，第二组则对图像中不同的元素进行了控制，使得图像可以很容易地融入不同的环境中。

操作这些参数的接口是两对函数。要控制样式，请使用 axes_style() 和 set_style() 函数。要对图像中元素的样式进行修改，请使用 plotting_context() 和 set_context() 函数。在这两种情况下（控制图像样式与修改元素样式），第一个函数会返回一个参数字典，第二个函数设置matplotlib中相关参数的默认值。

Seaborn图像参数

有五个预设的Seaborn主题： darkgrid，whitegrid，dark，white以及 ticks。它们分别适用于不同的应用程序和个人偏好。默认主题为 darkgrid。如上所述，坐标方格有助于将制出的图像用作定量信息的查阅表，灰色背景上的白色有助于防止网格与表示数据的行发生竞争。 whitegrid 主题类似，但它更适用于包含大量数据元素的绘图：

sns.set_style("whitegrid")
data = np.random.normal(size=(20, 6)) + np.arange(6) / 2
sns.boxplot(data=data);

对许多的图像而言，（尤其是在你只是想通过图像来提供给人们一个对数据模式的印象时，比如说作报告时）坐标网格都是不必要的。

sns.set_style("dark")
sinplot()

sns.set_style("white")
sinplot()

有时，您可能希望为绘图提供一点额外的结构，这正是tick样式的用武之地：

sns.set_style("ticks")
sinplot()

移除坐标轴

white 样式与 ticks 样式的好处是都能删除所不需要的顶部与右部坐标轴。使用seaborn中的函数 despine() 可以来移除它们：

sinplot()
sns.despine()

有些图的好处在于，可以让坐标的主轴随着数据进行偏移，这可以使用 despine()函数来完成。当刻度无法覆盖轴的整个范围时，trim参数将限制不受影响的坐标轴的范围。

f, ax = plt.subplots()
sns.violinplot(data=data)
sns.despine(offset=10, trim=True);

你也可以通过控制 despine()的额外参数来删除坐标轴：

sns.set_style("whitegrid")
sns.boxplot(data=data, palette="deep")
sns.despine(left=True)

设置临时图像格式

虽然来回切换很容易，但你也可以在with语句中使用 axes_style() 函数来临时设置绘图参数。 这也允许您使用不同风格的坐标轴制作图形：

f = plt.figure()
with sns.axes_style("darkgrid"):
    ax = f.add_subplot(1, 2, 1)
    sinplot()
ax = f.add_subplot(1, 2, 2)
sinplot(-1)

覆盖控制seaborn样式的元素

如果你想要自己定制seaborn的样式，你可以通过给 axes_style() 与set_style()函数中的 rc 参数传递一个参数字典来实现。请注意，您只能通过此方法覆盖作为样式定义一部分的参数。（但是，更高级别的 set() 函数会获取任何matplotlib参数的字典）。

如果你想看看包含哪些参数，你可以只调用没有参数的函数，这将返回当前设置：

sns.axes_style()
{'axes.axisbelow': True,
 'axes.edgecolor': '.8',
 'axes.facecolor': 'white',
 'axes.grid': True,
 'axes.labelcolor': '.15',
 'axes.spines.bottom': True,
 'axes.spines.left': True,
 'axes.spines.right': True,
 'axes.spines.top': True,
 'figure.facecolor': 'white',
 'font.family': ['sans-serif'],
 'font.sans-serif': ['Arial',
  'DejaVu Sans',
  'Liberation Sans',
  'Bitstream Vera Sans',
  'sans-serif'],
 'grid.color': '.8',
 'grid.linestyle': '-',
 'image.cmap': 'rocket',
 'lines.solid_capstyle': 'round',
 'patch.edgecolor': 'w',
 'patch.force_edgecolor': True,
 'text.color': '.15',
 'xtick.bottom': False,
 'xtick.color': '.15',
 'xtick.direction': 'out',
 'xtick.top': False,
 'ytick.color': '.15',
 'ytick.direction': 'out',
 'ytick.left': False,
 'ytick.right': False}

然后，您可以设置这些参数的不同版本：

sns.set_style("darkgrid", {"axes.facecolor": ".9"})
sinplot()

缩放图像元素

一组独立的参数控制绘图元素的比例，这允许您使用相同的代码来制作在适合使用不同大小图片场景下的图片。

首先，让我们通过调用 set()来重置默认的参数：

sns.set()

按照相对大小的顺序排序，四个预设环境是 paper， notebook， talk与 poster。 notebook样式是默认样式，上文中的图就是使用该样式绘制的。

sns.set_context("paper")
sinplot()

sns.set_context("talk")
sinplot()

sns.set_context("poster")
sinplot()

您现在知道的关于样式函数的大部分内容应该转移到环境函数中。

你可以通过在调用 set_context() 时指定环境的名字来设置参数，你也可以通过提供一个参数字典来覆盖原有的参数值。

你也在转换环境的时候独立地对字符元素的大小进行缩放。（这个操作也能够顶层的 set() 函数来实现）。

sns.set_context("notebook", font_scale=1.5, rc={"lines.linewidth": 2.5})
sinplot()

同样的，你也可以暂时的通过嵌套在 with 语句下的语句来实现图像的缩放。

样式和环境都可以使用 set() 函数快速配置。

选择调色板

颜色在图像风格中比起其他元素显得更为重要。当合理有效地使用颜色时，数据模式会被凸显出来；反之，则会被掩盖。这里有很多数据可视化中关于颜色使用的优秀资源，我推荐阅读这些 Rob Simmon 的博客文章以及这篇更加学术性的论文。 此外，matplotlib 文档也提供了一篇很好的教程来说明一些内置Colormap的感知属性。

seaborn让您在选择与您处理的数据类型和可视化过程中搭配的配色方案变得简单。

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
sns.set()

创建调色板

使用离散调色板过程中最重要函数是color_palette()。这个函数为许多(但不是全部)可以在seaborn中生成颜色的方式提供了一个接口，并且在任何具有palette参数的函数的内部都可以使用(以及某些需要多种颜色时具有color参数的情况)。

color_palette() 会接受所有的seaborn调色板或者matplotlib Colormap (除了 jet, 您永远都不应该使用它). 它还可以获取以任何有效matplotlib格式(RGB元组、十六进制颜色代码或HTML颜色名字)指定的颜色列表。返回值始终是RGB元组的列表。

最后，在没有参数的情况下调用color_palette()函数将会返回当前默认的颜色循环。

函数set_palette()接受相同的参数，并将为所有图像设置默认的颜色循环。您也可以在with语句中调用color_palette()来临时改变调色板。

在不了解数据特征的情况下，通常也不可能知道哪种调色板或Colormap最适合一组数据。接下来，我们将通过三种常见的调色板 定性调色板, 顺序调色板, 和 发散调色板 来拆分介绍color_palette()函数的使用方法以及其他seaborn函数。

定性调色板

当您想要区分不具有内在顺序的离散数据块时，定性(分类)调色板是最佳方案。

导入seaborn的同时，会引入默认的颜色循环，由6种颜色构成。并将调用标准matplotlib颜色循环，看起来也更加赏心悦目。

current_palette = sns.color_palette()
sns.palplot(current_palette)

默认主题有六种变体，分别为deep, muted, pastel, bright, dark, and colorblind。

使用循环颜色系统

当您要区分任意数量的类别而不强调任何类别时，最简单的方法是在循环颜色空间中绘制间距相等的颜色(在此颜色空间中，色调会发生变化，同时保持亮度和饱和度不变)。这是大多数seaborn函数在处理当需要区分的数据集超过颜色循环中的6种颜色时时所使用的默认方法。

最为常用的方法是使用hls颜色空间——一种简单的RGB值变体。

sns.palplot(sns.color_palette("hls", 8))

hls_palette()函数允许您控制颜色的亮度(lightness)和饱和度(saturation)。

sns.palplot(sns.hls_palette(8, l=.3, s=.8))

然而，由于人类视觉系统的工作方式，RGB强度很高的颜色也不一定看起来同样强烈。我们认为黄色和绿色是相对较亮的，蓝色是相对较暗的，当目标是与hls系统保持一致性时可能会带来一些问题。

为了解决这一问题，seaborn提供了一个husl系统(后来更名为HSLuv)的接口，这也使选择间隔均匀的色调变得容易，同时使亮度和饱和度都更加均匀。

sns.palplot(sns.color_palette("husl", 8))

类似地，husl_palette()函数也为这个系统提供了一个更灵活的接口。

使用Color Brewer调色板

Color Brewer为定性调色板提供了另一种美观的配色方案(同样包含顺序调色板包括和发散调色板，详情见下文)。这些也作为matplotlib Colormap存在，但并没有得到很好的处理。在seaborn中，当您需要定性(qualitative)的Color Brewer方案时，你总是会得到离散的颜色，但这意味着在某些情况下颜色会循环重复。

Color Brewer的一个很好的特点是它对色盲比较友好。色盲有很多种，最为常见的是红绿色盲。通常，对于需要根据颜色进行元素区分时，应该尽量避免使用这两种颜色。

sns.palplot(sns.color_palette("Paired"))

sns.palplot(sns.color_palette("Set2"))

为了帮助您从Color Brewer库中选取配色方案，seaborn提供了choose_colorbrewer_palette()函数。这个函数能够启动交互式组件来帮助您浏览各种选项，修改不同的参数。但是只能在Jupyter notebook中使用。

当然，您可能只希望手动指定一组您喜欢的颜色。color_palette()函数会接受一个颜色列表，操作起来也很简单。

flatui = ["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e", "#2ecc71"]
sns.palplot(sns.color_palette(flatui))

使用来自xkcd color survey的颜色名字

不久前，xkcd开展了一项众包工作来为随机RGB颜色命名。产生了954个颜色名字，您现在可以在seaborn中使用xkcd_rgb字典来引用它们：

plt.plot([0, 1], [0, 1], sns.xkcd_rgb["pale red"], lw=3)
plt.plot([0, 1], [0, 2], sns.xkcd_rgb["medium green"], lw=3)
plt.plot([0, 1], [0, 3], sns.xkcd_rgb["denim blue"], lw=3);

除了从xkcd_rgb字典中提取单一颜色外，您也可以向xkcd_palette()函数传递一个颜色名字列表。

colors = ["windows blue", "amber", "greyish", "faded green", "dusty purple"]
sns.palplot(sns.xkcd_palette(colors))

顺序调色板

第二类主要的调色板被称为“顺序调色板”(sequential)，当数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时，最好使用顺序调色板，尽管在某些情况下您可能需要顺序调色板中的离散颜色。在kdeplot()和heatmap()函数中使用它们来作为Colormap则更为常见(以及类似的matplotlib函数)。

在这种情况下使用jet（或其他彩虹调色板）等Colormap是很常见的，因为色调范围给人的印象是提供有关数据的额外信息。然而，具有较大色调变化的Colormap往往会引入数据中不存在的不连续性，并且我们的视觉系统无法自然地将彩虹光谱映射到诸如“高”或“低”的定量区分。导致来这些可视化的结果更加令人困惑，因为它们掩盖了数据中的模式，而不是揭示它们。jet 调色板使用了最亮的颜色(黄色和青色)的中间数据值，导致效果是强调无趣的(和任意的)值，而不是强调极端的值。

对于连续性的数据，最好使用色调变化幅度较小，而亮度和饱和度变化幅度较大的配色方案。这种方法会很自然地吸引人们注意数据中相对重要的部分。

Color Brewer库有大量这样的配色方案，它们以调色板中主要的一种或多种颜色命名。

sns.palplot(sns.color_palette("Blues"))

与matplotlib类似，您可以通过添加加后缀_r来倒置顺序调色板的顺序。

sns.palplot(sns.color_palette("BuGn_r"))

seaborn同样添加了一个小窍门来帮助您创建“深色”调色板，它没有一个很宽的动态范围。在当您需要按顺序映射直线或点时这可能会很有用，因为颜色较亮的线条会比较难以区分。

sns.palplot(sns.color_palette("GnBu_d"))

您可能想要使用choose_colorbrewer_palette()函数来尝试多种选项，当您希望传递给seaborn或者matplotlib的返回值为Colormap对象时，您可以将as_cmap对象设置为True。

顺序 “cubehelix” 调色板

cubehelix调色板系统使顺序调色板的亮度产生线性变化，色调也会产生一些变化。这意味着您的Colormap在转换为黑白模式时(用于打印)的信息将得到保留，且对色盲友好。

Matplotlib内置了默认的cubehelix版本：

sns.palplot(sns.color_palette("cubehelix", 8))

Seborn为cubehelix系统提供了一个接口，以便您可以制作各种调色板，这些调色板都具有良好的线性亮度渐变。

由seborn cubehelix_palette() 函数返回的默认调色板与matplotlib的默认值稍有不同，因为它不会围绕色轮旋转很远，也不会覆盖很宽的强度范围。它还反转顺序，以便让更重要的值的颜色更暗：

sns.palplot(sns.cubehelix_palette(8))

cubehelix_palette() 函数的其他参数控制调色板的外观。您将更改的两个主要参数为 start (介于0到3之间的值)和 rot —— 旋转次数(任意值，但可能在-1和1之间)。

sns.palplot(sns.cubehelix_palette(8, start=.5, rot=-.75))

您还可以控制端点的亮度，甚至反转渐变：

sns.palplot(sns.cubehelix_palette(8, start=2, rot=0, dark=0, light=.95, reverse=True))

如同其他seaborn函数，您将默认得到一个颜色列表。但您也可以通过修改 as_cmap=True 将调色板作为Colormap对象的返回值来传递给seaborn或matplotlib函数。

x, y = np.random.multivariate_normal([0, 0], [[1, -.5], [-.5, 1]], size=300).T
cmap = sns.cubehelix_palette(light=1, as_cmap=True)
sns.kdeplot(x, y, cmap=cmap, shade=True);

为了帮助您选择更好的调色板或者Colormap，您可以在Jupyter notebook中使用 choose_cubehelix_palette() 函数来启动互动界面帮助您测试、修改不同的参数。如果您希望函数返回一个Colormap(而不是列表)，则在例如像 hexbin 这样的函数中设置 as_Cmap=True。

自定义调色板

为了更简单地生成自定义顺序调色板，您可以使用 light_palette() 或 dark_palette() 函数。它们都是以某个颜色为种子，从明向暗或从暗向明渐变，产生顺序调色板。与这些函数相搭配的还有 choose_light_palette() 和 choose_dark_palette() 来提供交互式组件便于创建调色板。

sns.palplot(sns.light_palette("green"))

sns.palplot(sns.dark_palette("purple"))

这些调色板同样可以被反转。

sns.palplot(sns.light_palette("navy", reverse=True))

这些调色板同样可以被用来创建Colormap对象而不是颜色列表。

pal = sns.dark_palette("palegreen", as_cmap=True)
sns.kdeplot(x, y, cmap=pal);

默认情况下，输入可以是任何有效的matplotlib颜色。替代解释由 input 参数控制。现在，您可以在 hls 或 husl 空间中提供元组以及默认的 rgb，您也可以使用任何有效的 xkcd 颜色来生成调色板。

sns.palplot(sns.light_palette((210, 90, 60), input="husl"))

sns.palplot(sns.dark_palette("muted purple", input="xkcd"))

注意，交互式调色板小部件的默认输入空间是 husl，它不同于函数本身的默认设置，但是在这种情况下更有用。

发散调色板

第三类调色板称为“发散调色板”(diverging)。当数据集的低值和高值都很重要，且数据集中有明确定义的中点时，这会是您的最佳选择。例如，绘制温度相对于基准时间点的变化图时，最好使用发散Colormap来同时显示温度相对于基准值的上升和下降

选择良好分散调色板的规则类似于良好的顺序调色板。不过在这种情况时需要注意两端颜色向中间颜色渐变时中间点的颜色不应该喧宾夺主，两端的颜色也应该具有相似的亮度和饱和度。

这里还需要强调的是，应该避免使用红色和绿色，因为需要考虑到红绿色盲患者的观感。

不出所料，Color Brewer库也同样提供了一些精心挑选的发散调色板。

sns.palplot(sns.color_palette("BrBG", 7))

sns.palplot(sns.color_palette("RdBu_r", 7))

matplotlib库中内置的 coolwarm 调色板也是一个很好的选择。请注意，这个Colormap的中间值和极值之间的对比度较小。

sns.palplot(sns.color_palette("coolwarm", 7))

自定义发散调色板

您可以使用seaborn的diverging_palette()函数来创建自定义colormap来描述发散数据(搭配有交互式组件choose_diverging_palette())。此函数使用 husl 颜色系统来创建发散调色板，您需要在函数中设置两个色调参数(用度表示)，也可以选择设置两端颜色的亮度和饱和度。 使用 husl 意味着两端到中间点的色调变化将是平衡的。

sns.palplot(sns.diverging_palette(220, 20, n=7))

sns.palplot(sns.diverging_palette(145, 280, s=85, l=25, n=7))

sep 参数控制两端到中间点色调变化的间隔。

sns.palplot(sns.diverging_palette(10, 220, sep=80, n=7))

也可以将中间点的颜色设置成暗色而非亮色。

sns.palplot(sns.diverging_palette(255, 133, l=60, n=7, center="dark"))

设置默认调色板

与color_palette()函数相伴随的有set_palette()。 两者之间的关系与美学教程中介绍的set_palette()函数和color_palette()函数接受相同参数的关系相类似。但它会更改默认的matplotlib参数，以便调色板应用于所有图像。

def sinplot(flip=1):
    x = np.linspace(0, 14, 100)
    for i in range(1, 7):
        plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)

您可以在 with 语句中通过 color_palette() 函数来临时改变调色板。

with sns.color_palette("PuBuGn_d"):
    sinplot()

Seaborn API

seaborn.relplot

seaborn.relplot(x=None, y=None, hue=None, size=None, style=None, data=None, row=None, col=None, col_wrap=None, row_order=None, col_order=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, markers=None, dashes=None, style_order=None, legend='brief', kind='scatter', height=5, aspect=1, facet_kws=None, **kwargs)

Figure-level interface for drawing relational plots onto a FacetGrid.

This function provides access to several different axes-level functions that show the relationship between two variables with semantic mappings of subsets. The kind parameter selects the underlying axes-level function to use:

• scatterplot() (with kind="scatter"; the default)
• lineplot() (with kind="line")

Extra keyword arguments are passed to the underlying function, so you should refer to the documentation for each to see kind-specific options.

The relationship between x and y can be shown for different subsets of the data using the hue, size, and style parameters. These parameters control what visual semantics are used to identify the different subsets. It is possible to show up to three dimensions independently by using all three semantic types, but this style of plot can be hard to interpret and is often ineffective. Using redundant semantics (i.e. both hue and style for the same variable) can be helpful for making graphics more accessible.

After plotting, the FacetGrid with the plot is returned and can be used directly to tweak supporting plot details or add other layers.

Note that, unlike when using the underlying plotting functions directly, data must be passed in a long-form DataFrame with variables specified by passing strings to x, y, and other parameters.

参数：x, y：names of variables in data

Input data variables; must be numeric.

hue：name in data, optional

Grouping variable that will produce elements with different colors. Can be either categorical or numeric, although color mapping will behave differently in latter case.

size：name in data, optional

Grouping variable that will produce elements with different sizes. Can be either categorical or numeric, although size mapping will behave differently in latter case.

style：name in data, optional

Grouping variable that will produce elements with different styles. Can have a numeric dtype but will always be treated as categorical.

data：DataFrame

Tidy (“long-form”) dataframe where each column is a variable and each row is an observation.

row, col：names of variables in data, optional

Categorical variables that will determine the faceting of the grid.

col_wrap：int, optional

“Wrap” the column variable at this width, so that the column facets span multiple rows. Incompatible with a row facet.

row_order, col_order：lists of strings, optional

Order to organize the rows and/or columns of the grid in, otherwise the orders are inferred from the data objects.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

hue_order：list, optional

Specified order for the appearance of the hue variable levels, otherwise they are determined from the data. Not relevant when the hue variable is numeric.

hue_norm：tuple or Normalize object, optional

Normalization in data units for colormap applied to the hue variable when it is numeric. Not relevant if it is categorical.

sizes：list, dict, or tuple, optional

An object that determines how sizes are chosen when size is used. It can always be a list of size values or a dict mapping levels of the size variable to sizes. When size is numeric, it can also be a tuple specifying the minimum and maximum size to use such that other values are normalized within this range.

size_order：list, optional

Specified order for appearance of the size variable levels, otherwise they are determined from the data. Not relevant when the size variable is numeric.

size_norm：tuple or Normalize object, optional

Normalization in data units for scaling plot objects when the size variable is numeric.

legend：“brief”, “full”, or False, optional

How to draw the legend. If “brief”, numeric hue and size variables will be represented with a sample of evenly spaced values. If “full”, every group will get an entry in the legend. If False, no legend data is added and no legend is drawn.

kind：string, optional

Kind of plot to draw, corresponding to a seaborn relational plot. Options are {scatter and line}.

height：scalar, optional

Height (in inches) of each facet. See also: aspect.

aspect：scalar, optional

Aspect ratio of each facet, so that aspect * height gives the width of each facet in inches.

facet_kws：dict, optional

Dictionary of other keyword arguments to pass to FacetGrid.

kwargs：key, value pairings

Other keyword arguments are passed through to the underlying plotting function.

返回值：g：FacetGrid

Returns the FacetGrid object with the plot on it for further tweaking.

Examples

Draw a single facet to use the FacetGrid legend placement:

>>> import seaborn as sns
>>> sns.set(style="ticks")
>>> tips = sns.load_dataset("tips")
>>> g = sns.relplot(x="total_bill", y="tip", hue="day", data=tips)

Facet on the columns with another variable:

>>> g = sns.relplot(x="total_bill", y="tip",
...                 hue="day", col="time", data=tips)

Facet on the columns and rows:

>>> g = sns.relplot(x="total_bill", y="tip", hue="day",
...                 col="time", row="sex", data=tips)

“Wrap” many column facets into multiple rows:

>>> g = sns.relplot(x="total_bill", y="tip", hue="time",
...                 col="day", col_wrap=2, data=tips)

Use multiple semantic variables on each facet with specified attributes:

>>> g = sns.relplot(x="total_bill", y="tip", hue="time", size="size",
...                 palette=["b", "r"], sizes=(10, 100),
...                 col="time", data=tips)

Use a different kind of plot:

>>> fmri = sns.load_dataset("fmri")
>>> g = sns.relplot(x="timepoint", y="signal",
...                 hue="event", style="event", col="region",
...                 kind="line", data=fmri)

Change the size of each facet:

>>> g = sns.relplot(x="timepoint", y="signal",
...                 hue="event", style="event", col="region",
...                 height=5, aspect=.7, kind="line", data=fmri)

seaborn.scatterplot

seaborn.scatterplot(x=None, y=None, hue=None, style=None, size=None, data=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, markers=True, style_order=None, x_bins=None, y_bins=None, units=None, estimator=None, ci=95, n_boot=1000, alpha='auto', x_jitter=None, y_jitter=None, legend='brief', ax=None, **kwargs)

Draw a scatter plot with possibility of several semantic groupings.

The relationship between x and y can be shown for different subsets of the data using the hue, size, and style parameters. These parameters control what visual semantics are used to identify the different subsets. It is possible to show up to three dimensions independently by using all three semantic types, but this style of plot can be hard to interpret and is often ineffective. Using redundant semantics (i.e. both hue and style for the same variable) can be helpful for making graphics more accessible.

参数：x, y：names of variables in data or vector data, optional

Input data variables; must be numeric. Can pass data directly or reference columns in data.

hue：name of variables in data or vector data, optional

Grouping variable that will produce points with different colors. Can be either categorical or numeric, although color mapping will behave differently in latter case.

size：name of variables in data or vector data, optional

Grouping variable that will produce points with different sizes. Can be either categorical or numeric, although size mapping will behave differently in latter case.

style：name of variables in data or vector data, optional

Grouping variable that will produce points with different markers. Can have a numeric dtype but will always be treated as categorical.

data：DataFrame

Tidy (“long-form”) dataframe where each column is a variable and each row is an observation.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

hue_order：list, optional

Specified order for the appearance of the hue variable levels, otherwise they are determined from the data. Not relevant when the hue variable is numeric.

hue_norm：tuple or Normalize object, optional

Normalization in data units for colormap applied to the hue variable when it is numeric. Not relevant if it is categorical.

sizes：list, dict, or tuple, optional

An object that determines how sizes are chosen when size is used. It can always be a list of size values or a dict mapping levels of the size variable to sizes. When size is numeric, it can also be a tuple specifying the minimum and maximum size to use such that other values are normalized within this range.

size_order：list, optional

Specified order for appearance of the size variable levels, otherwise they are determined from the data. Not relevant when the size variable is numeric.

size_norm：tuple or Normalize object, optional

Normalization in data units for scaling plot objects when the size variable is numeric.

markers：boolean, list, or dictionary, optional

Object determining how to draw the markers for different levels of the style variable. Setting to True will use default markers, or you can pass a list of markers or a dictionary mapping levels of the style variable to markers. Setting to False will draw marker-less lines. Markers are specified as in matplotlib.

style_order：list, optional

Specified order for appearance of the style variable levels otherwise they are determined from the data. Not relevant when the style variable is numeric.

{x,y}_bins：lists or arrays or functions

Currently non-functional.

units：{long_form_var}

Grouping variable identifying sampling units. When used, a separate line will be drawn for each unit with appropriate semantics, but no legend entry will be added. Useful for showing distribution of experimental replicates when exact identities are not needed.

Currently non-functional.

estimator：name of pandas method or callable or None, optional

Method for aggregating across multiple observations of the y variable at the same x level. If None, all observations will be drawn. Currently non-functional.

ci：int or “sd” or None, optional

Size of the confidence interval to draw when aggregating with an estimator. “sd” means to draw the standard deviation of the data. Setting to None will skip bootstrapping. Currently non-functional.

n_boot：int, optional

Number of bootstraps to use for computing the confidence interval. Currently non-functional.

alpha：float

Proportional opacity of the points.

{x,y}_jitter：booleans or floats

Currently non-functional.

legend：“brief”, “full”, or False, optional

How to draw the legend. If “brief”, numeric hue and size variables will be represented with a sample of evenly spaced values. If “full”, every group will get an entry in the legend. If False, no legend data is added and no legend is drawn.

ax：matplotlib Axes, optional

Axes object to draw the plot onto, otherwise uses the current Axes.

kwargs：key, value mappings

Other keyword arguments are passed down to plt.scatter at draw time.

返回值：ax：matplotlib Axes

Returns the Axes object with the plot drawn onto it.

See also

Show the relationship between two variables connected with lines to emphasize continuity.Draw a scatter plot with one categorical variable, arranging the points to show the distribution of values.

Examples

Draw a simple scatter plot between two variables:

>>> import seaborn as sns; sns.set()
>>> import matplotlib.pyplot as plt
>>> tips = sns.load_dataset("tips")
>>> ax = sns.scatterplot(x="total_bill", y="tip", data=tips)

Group by another variable and show the groups with different colors:

>>> ax = sns.scatterplot(x="total_bill", y="tip", hue="time",
...                      data=tips)

Show the grouping variable by varying both color and marker:

>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="time", style="time", data=tips)

Vary colors and markers to show two different grouping variables:

>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="day", style="time", data=tips)

Show a quantitative variable by varying the size of the points:

>>> ax = sns.scatterplot(x="total_bill", y="tip", size="size",
...                      data=tips)

Also show the quantitative variable by also using continuous colors:

>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="size", size="size",
...                      data=tips)

Use a different continuous color map:

>>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True)
>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="size", size="size",
...                      palette=cmap,
...                      data=tips)

Change the minimum and maximum point size and show all sizes in legend:

>>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True)
>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="size", size="size",
...                      sizes=(20, 200), palette=cmap,
...                      legend="full", data=tips)

Use a narrower range of color map intensities:

>>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True)
>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="size", size="size",
...                      sizes=(20, 200), hue_norm=(0, 7),
...                      legend="full", data=tips)

Vary the size with a categorical variable, and use a different palette:

>>> cmap = sns.cubehelix_palette(dark=.3, light=.8, as_cmap=True)
>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      hue="day", size="smoker",
...                      palette="Set2",
...                      data=tips)

Use a specific set of markers:

>>> markers = {"Lunch": "s", "Dinner": "X"}
>>> ax = sns.scatterplot(x="total_bill", y="tip", style="time",
...                      markers=markers,
...                      data=tips)

Control plot attributes using matplotlib parameters:

>>> ax = sns.scatterplot(x="total_bill", y="tip",
...                      s=100, color=".2", marker="+",
...                      data=tips)

Pass data vectors instead of names in a data frame:

>>> iris = sns.load_dataset("iris")
>>> ax = sns.scatterplot(x=iris.sepal_length, y=iris.sepal_width,
...                      hue=iris.species, style=iris.species)

Pass a wide-form dataset and plot against its index:

>>> import numpy as np, pandas as pd; plt.close("all")
>>> index = pd.date_range("1 1 2000", periods=100,
...                       freq="m", name="date")
>>> data = np.random.randn(100, 4).cumsum(axis=0)
>>> wide_df = pd.DataFrame(data, index, ["a", "b", "c", "d"])
>>> ax = sns.scatterplot(data=wide_df)

seaborn.lineplot

seaborn.lineplot(x=None, y=None, hue=None, size=None, style=None, data=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, dashes=True, markers=None, style_order=None, units=None, estimator='mean', ci=95, n_boot=1000, sort=True, err_style='band', err_kws=None, legend='brief', ax=None, **kwargs)

Draw a line plot with possibility of several semantic groupings.

The relationship between x and y can be shown for different subsets of the data using the hue, size, and style parameters. These parameters control what visual semantics are used to identify the different subsets. It is possible to show up to three dimensions independently by using all three semantic types, but this style of plot can be hard to interpret and is often ineffective. Using redundant semantics (i.e. both hue and style for the same variable) can be helpful for making graphics more accessible.

By default, the plot aggregates over multiple y values at each value of x and shows an estimate of the central tendency and a confidence interval for that estimate.

参数：x, y：names of variables in data or vector data, optional

Input data variables; must be numeric. Can pass data directly or reference columns in data.

hue：name of variables in data or vector data, optional

Grouping variable that will produce lines with different colors. Can be either categorical or numeric, although color mapping will behave differently in latter case.

size：name of variables in data or vector data, optional

Grouping variable that will produce lines with different widths. Can be either categorical or numeric, although size mapping will behave differently in latter case.

style：name of variables in data or vector data, optional

Grouping variable that will produce lines with different dashes and/or markers. Can have a numeric dtype but will always be treated as categorical.

data：DataFrame

Tidy (“long-form”) dataframe where each column is a variable and each row is an observation.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

hue_order：list, optional

Specified order for the appearance of the hue variable levels, otherwise they are determined from the data. Not relevant when the hue variable is numeric.

hue_norm：tuple or Normalize object, optional

Normalization in data units for colormap applied to the hue variable when it is numeric. Not relevant if it is categorical.

sizes：list, dict, or tuple, optional

An object that determines how sizes are chosen when size is used. It can always be a list of size values or a dict mapping levels of the size variable to sizes. When size is numeric, it can also be a tuple specifying the minimum and maximum size to use such that other values are normalized within this range.

size_order：list, optional

Specified order for appearance of the size variable levels, otherwise they are determined from the data. Not relevant when the size variable is numeric.

size_norm：tuple or Normalize object, optional

Normalization in data units for scaling plot objects when the size variable is numeric.

dashes：boolean, list, or dictionary, optional

Object determining how to draw the lines for different levels of the style variable. Setting to True will use default dash codes, or you can pass a list of dash codes or a dictionary mapping levels of the style variable to dash codes. Setting to False will use solid lines for all subsets. Dashes are specified as in matplotlib: a tuple of (segment, gap) lengths, or an empty string to draw a solid line.

markers：boolean, list, or dictionary, optional

Object determining how to draw the markers for different levels of the style variable. Setting to True will use default markers, or you can pass a list of markers or a dictionary mapping levels of the style variable to markers. Setting to False will draw marker-less lines. Markers are specified as in matplotlib.

style_order：list, optional

Specified order for appearance of the style variable levels otherwise they are determined from the data. Not relevant when the style variable is numeric.

units：{long_form_var}

Grouping variable identifying sampling units. When used, a separate line will be drawn for each unit with appropriate semantics, but no legend entry will be added. Useful for showing distribution of experimental replicates when exact identities are not needed.

estimator：name of pandas method or callable or None, optional

Method for aggregating across multiple observations of the y variable at the same x level. If None, all observations will be drawn.

ci：int or “sd” or None, optional

Size of the confidence interval to draw when aggregating with an estimator. “sd” means to draw the standard deviation of the data. Setting to None will skip bootstrapping.

n_boot：int, optional

Number of bootstraps to use for computing the confidence interval.

sort：boolean, optional

If True, the data will be sorted by the x and y variables, otherwise lines will connect points in the order they appear in the dataset.

err_style：“band” or “bars”, optional

Whether to draw the confidence intervals with translucent error bands or discrete error bars.

err_band：dict of keyword arguments

Additional paramters to control the aesthetics of the error bars. The kwargs are passed either to ax.fill_between or ax.errorbar, depending on the err_style.

legend：“brief”, “full”, or False, optional

How to draw the legend. If “brief”, numeric hue and size variables will be represented with a sample of evenly spaced values. If “full”, every group will get an entry in the legend. If False, no legend data is added and no legend is drawn.

ax：matplotlib Axes, optional

Axes object to draw the plot onto, otherwise uses the current Axes.

kwargs：key, value mappings

Other keyword arguments are passed down to plt.plot at draw time.

返回值：ax：matplotlib Axes

Returns the Axes object with the plot drawn onto it.

See also

Show the relationship between two variables without emphasizing continuity of the x variable.Show the relationship between two variables when one is categorical.

Examples

Draw a single line plot with error bands showing a confidence interval:

>>> import seaborn as sns; sns.set()
>>> import matplotlib.pyplot as plt
>>> fmri = sns.load_dataset("fmri")
>>> ax = sns.lineplot(x="timepoint", y="signal", data=fmri)

Group by another variable and show the groups with different colors:

>>> ax = sns.lineplot(x="timepoint", y="signal", hue="event",
...                   data=fmri)

Show the grouping variable with both color and line dashing:

>>> ax = sns.lineplot(x="timepoint", y="signal",
...                   hue="event", style="event", data=fmri)

Use color and line dashing to represent two different grouping variables:

>>> ax = sns.lineplot(x="timepoint", y="signal",
...                   hue="region", style="event", data=fmri)

Use markers instead of the dashes to identify groups:

>>> ax = sns.lineplot(x="timepoint", y="signal",
...                   hue="event", style="event",
...                   markers=True, dashes=False, data=fmri)

Show error bars instead of error bands and plot the standard error:

>>> ax = sns.lineplot(x="timepoint", y="signal", hue="event",
...                   err_style="bars", ci=68, data=fmri)

Show experimental replicates instead of aggregating:

>>> ax = sns.lineplot(x="timepoint", y="signal", hue="event",
...                   units="subject", estimator=None, lw=1,
...                   data=fmri.query("region == 'frontal'"))

Use a quantitative color mapping:

>>> dots = sns.load_dataset("dots").query("align == 'dots'")
>>> ax = sns.lineplot(x="time", y="firing_rate",
...                   hue="coherence", style="choice",
...                   data=dots)

Use a different normalization for the colormap:

>>> from matplotlib.colors import LogNorm
>>> ax = sns.lineplot(x="time", y="firing_rate",
...                   hue="coherence", style="choice",
...                   hue_norm=LogNorm(), data=dots)

Use a different color palette:

>>> ax = sns.lineplot(x="time", y="firing_rate",
...                   hue="coherence", style="choice",
...                   palette="ch:2.5,.25", data=dots)

Use specific color values, treating the hue variable as categorical:

>>> palette = sns.color_palette("mako_r", 6)
>>> ax = sns.lineplot(x="time", y="firing_rate",
...                   hue="coherence", style="choice",
...                   palette=palette, data=dots)

Change the width of the lines with a quantitative variable:

>>> ax = sns.lineplot(x="time", y="firing_rate",
...                   size="coherence", hue="choice",
...                   legend="full", data=dots)

Change the range of line widths used to normalize the size variable:

>>> ax = sns.lineplot(x="time", y="firing_rate",
...                   size="coherence", hue="choice",
...                   sizes=(.25, 2.5), data=dots)

Plot from a wide-form DataFrame:

>>> import numpy as np, pandas as pd; plt.close("all")
>>> index = pd.date_range("1 1 2000", periods=100,
...                       freq="m", name="date")
>>> data = np.random.randn(100, 4).cumsum(axis=0)
>>> wide_df = pd.DataFrame(data, index, ["a", "b", "c", "d"])
>>> ax = sns.lineplot(data=wide_df)

Plot from a list of Series:

>>> list_data = [wide_df.loc[:"2005", "a"], wide_df.loc["2003":, "b"]]
>>> ax = sns.lineplot(data=list_data)

Plot a single Series, pass kwargs to plt.plot:

>>> ax = sns.lineplot(data=wide_df["a"], color="coral", label="line")

Draw lines at points as they appear in the dataset:

>>> x, y = np.random.randn(2, 5000).cumsum(axis=1)
>>> ax = sns.lineplot(x=x, y=y, sort=False, lw=1)

seaborn.catplot

seaborn.catplot(x=None, y=None, hue=None, data=None, row=None, col=None, col_wrap=None, estimator=<function mean>, ci=95, n_boot=1000, units=None, order=None, hue_order=None, row_order=None, col_order=None, kind='strip', height=5, aspect=1, orient=None, color=None, palette=None, legend=True, legend_out=True, sharex=True, sharey=True, margin_titles=False, facet_kws=None, **kwargs)

seaborn.catplot 是一个将分类图绘制到FacetGrid上图级别接口。

这个函数可以访问多个轴级功能，这些轴级功能通过不同的可视化图表展示数字和一个或多个分类变量的关系。kind 参数可以选择的轴级基础函数有：

分类散点图:

• stripplot() (with kind="strip"; the default)
• swarmplot() (with kind="swarm")

分类分布图:

• boxplot() (with kind="box")
• violinplot() (with kind="violin")
• boxenplot() (with kind="boxen")

分类估计图:

• pointplot() (with kind="point")
• barplot() (with kind="bar")
• countplot() (with kind="count")

额外的关键字参数将传递给基础函数，因此，您应参阅每个文档，以查看特定类型的选项.

请注意，与直接使用轴级函数不同, 数据必须在长格式DataFrame中传递，并通过将字符串传递给 x, y, hue, 等指定的变量.

与基础绘图函数的情况一样, 如果变量有 categorical 数据类型, 则将从对象推断出分类变量的级别及其顺序。否则，您可能必须使用更改 dataframe 排序或使用函数参数(orient, order, hue_order, etc.) 来正确设置绘图。

此函数始终将其中一个变量视为分类，并在相关轴上的序数位置（0,1，… n）处绘制数据，即使数据具有数字或日期类型。

绘图后，返回带有绘图的 FacetGrid，可以直接用于调整绘图细节或添加其他图层。

参数：x, y, hue： data names 中的变量名称

用于绘制长格式数据的输入。查看解释示例

data：DataFrame

用于绘图的长形（整洁）数据集。每列应对应一个变量，每行应对应一个观察。

row, col：data 中的变量名称, 可选

分类变量将决定网格的分面。

col_wrap：int, 可选

以此宽度“包裹”列变量，以便列面跨越多行。 与行方面不兼容。

estimator：可调用的映射向量 -> 标量，可选

在每个分类箱内估计的统计函数。

ci：float或“sd”或None，可选

在估计值附近绘制置信区间的大小。如果是“sd”，则跳过自举(bootstrapping)并绘制观察的标准偏差。None,如果为None，则不执行自举，并且不会绘制错误条。

n_boot：int，可选

计算置信区间时使用的引导程序迭代次数。

units：数据或矢量数据中变量的名称,可选

采样单元的标识符，用于执行多级引导程序并考虑重复测量设计。

order, hue_order：字符串列表，可选

命令绘制分类级别，否则从数据对象推断级别。

row_order, col_order：字符串列表，可选

命令组织网格的行和/或列，否则从数据对象推断命令。

kind：字符串，可选

要绘制的绘图类型（对应于分类绘图功能的名称。选项包括：“点”，“条形”，“条形”，“群”，“框”，“小提琴”或“盒子”。

height：标量，可选

每个刻面的高度（以英寸为单位）。另见： aspect。

aspect：标量，可选

每个面的纵横比，因此aspect * height给出每个面的宽度，单位为英寸。

orient：“v” | “h”, 可选

图的方向（垂直或水平）。这通常是从输入变量的dtype推断出来的，但可用于指定“分类”变量何时是数字或何时绘制宽格式数据。

color：matplotlib颜色，可选

所有元素的颜色，或渐变调色板的种子。

palette：调色板名称，列表或字典，可选

用于色调变量的不同级别的颜色。应该是 color_palette(), 可以解释的东西，或者是将色调级别映射到matplotlib颜色的字典。

legend：bool, 可选

如果为 True 并且存在hue变量，则在图上绘制图例。t.

legend_out：bool, 可选

如果为True，则图形尺寸将被扩展，图例将绘制在中间右侧的图形之外。

share{x,y}：bool, ‘col’, 或 ‘row’ 可选

如果为true，则facet将跨行跨越列和/或x轴共享y轴。

margin_titles：bool, 可选

如果为True，则行变量的标题将绘制在最后一列的右侧。此选项是实验性的，可能无法在所有情况下使用。

facet_kws：dict, 可选

传递给FacetGrid的其他关键字参数的字典。

kwargs：key, value 配对

其他关键字参数将传递给基础绘图函数。

返回值：g：FacetGrid

返回FacetGrid对象及其上的绘图以进一步调整。

例子

绘制单个构面以使用FacetGrid图例放置：

>>> import seaborn as sns
>>> sns.set(style="ticks")
>>> exercise = sns.load_dataset("exercise")
>>> g = sns.catplot(x="time", y="pulse", hue="kind", data=exercise)

使用不同的绘图类型可视化相同的数据：

>>> g = sns.catplot(x="time", y="pulse", hue="kind",
...                data=exercise, kind="violin")

沿列的方面显示第三个分类变量：

>>> g = sns.catplot(x="time", y="pulse", hue="kind",
...                 col="diet", data=exercise)

为构面使用不同的高度和宽高比：

>>> g = sns.catplot(x="time", y="pulse", hue="kind",
...                 col="diet", data=exercise,
...                 height=5, aspect=.8)

创建许多列构面并将它们包装到网格的行中：

>>> titanic = sns.load_dataset("titanic")
>>> g = sns.catplot("alive", col="deck", col_wrap=4,
...                 data=titanic[titanic.deck.notnull()],
...                 kind="count", height=2.5, aspect=.8)

水平绘图并将其他关键字参数传递给绘图函数：

>>> g = sns.catplot(x="age", y="embark_town",
...                 hue="sex", row="class",
...                 data=titanic[titanic.embark_town.notnull()],
...                 orient="h", height=2, aspect=3, palette="Set3",
...                 kind="violin", dodge=True, cut=0, bw=.2)

使用返回的FacetGrid 上的方法来调整演示文稿：

>>> g = sns.catplot(x="who", y="survived", col="class",
...                 data=titanic, saturation=.5,
...                 kind="bar", ci=None, aspect=.6)
>>> (g.set_axis_labels("", "Survival Rate")
...   .set_xticklabels(["Men", "Women", "Children"])
...   .set_titles("{col_name}  {col_var}")
...   .set(ylim=(0, 1))
...   .despine(left=True))  
<seaborn.axisgrid.FacetGrid object at 0x...>

seaborn.stripplot

seaborn.stripplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, jitter=True, dodge=False, orient=None, color=None, palette=None, size=5, edgecolor='gray', linewidth=0, ax=None, **kwargs)

绘制一个散点图，其中一个变量是分类。

条形图可以单独绘制，但如果您想要显示所有观察结果以及底层分布的某些表示，它也是一个盒子或小提琴图的良好补充。

输入数据可以以多种格式传递，包括：

• 表示为列表，numpy数组或pandas Series对象的数据向量直接传递给x，y和hue参数
• 在这种情况下，x，y和hue变量将决定数据的绘制方式。
• “wide-form” DataFrame, 用于绘制每个数字列。
• 一个数组或向量列表。

在大多数情况下，可以使用numpy或Python对象，但最好使用pandas对象，因为关联的名称将用于注释轴。另外，您可以使用分组变量的分类类型来控制绘图元素的顺序。

此函数始终将其中一个变量视为分类，并在相关轴上的序数位置（0,1，… n）处绘制数据，即使数据具有数字或日期类型也是如此。

参数：x, y, hue： 数据或矢量数据中的变量名称，可选

用于绘制长格式数据的输入。查看解释示例。

data：DataFrame, 数组, 数组列表, 可选

用于绘图的数据集。如果 x 和 y 不存在，则将其解释为宽格式。否则预计它将是长格式的。

order, hue_order：字符串列表，可选

命令绘制分类级别，否则从数据对象推断级别。

jitter：float, True/1 是特殊的，可选

要应用的抖动量（仅沿分类轴）。 当您有许多点并且它们重叠时，这可能很有用，因此更容易看到分布。您可以指定抖动量（均匀随机变量支持的宽度的一半），或者仅使用True作为良好的默认值

dodge：bool, 可选

使用 hue 嵌套时，将其设置为 True 将沿着分类轴分离不同色调级别的条带。否则，每个级别的点将相互叠加。

orient：“v” | “h”, 可选

图的方向（垂直或水平）。这通常是从输入变量的dtype推断出来的，但可用于指定“分类”变量何时是数字或何时绘制宽格式数据。

color：matplotlib颜色，可选

所有元素的颜色，或渐变调色板的种子。

palette：调色板名称，列表或字典，可选

用于色调变量的不同级别的颜色。应该是 color_palette(), 可以解释的东西，或者是将色调级别映射到matplotlib颜色的字典。

size：float, 可选

标记的直径，以磅为单位。（虽然 plt.scatter 用于绘制点，但这里的 size 参数采用“普通”标记大小而不是大小^ 2，如 plt.scatter 。

edgecolor：matplotlib颜色，“灰色”是特殊的，可选的

每个点周围线条的颜色。如果传递"灰色"，则亮度由用于点体的调色板决定。

linewidth：float, 可选

构图元素的灰线宽度。

ax：matplotlib轴，可选

返回Axes对象，并在其上绘制绘图。

返回值：ax：matplotlib轴

返回Axes对象，并在其上绘制绘图。

也可参看

分类散点图，其中点不重叠。可以与其他图一起使用来显示每个观察结果。带有类似API的传统盒须图。箱形图和核密度估计的组合。

例子

绘制单个水平条形图：

>>> import seaborn as sns
>>> sns.set(style="whitegrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.stripplot(x=tips["total_bill"])

通过分类变量对条形图进行分组：

>>> ax = sns.stripplot(x="day", y="total_bill", data=tips)

添加抖动以显示值的分布：

>>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=True)

使用较少量的抖动：

>>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=0.05)

画水平条形图：

>>> ax = sns.stripplot(x="total_bill", y="day", data=tips,
...                    jitter=True)

围绕要点绘制轮廓：

>>> ax = sns.stripplot(x="total_bill", y="day", data=tips,
...                    jitter=True, linewidth=1)

将条带嵌套在第二个分类变量中：

>>> ax = sns.stripplot(x="sex", y="total_bill", hue="day",
...                    data=tips, jitter=True)

在主要分类轴上的不同位置绘制 hue 变量的每个级别：

>>> ax = sns.stripplot(x="day", y="total_bill", hue="smoker",
...                    data=tips, jitter=True,
...                    palette="Set2", dodge=True)

通过传递显式顺序来控制条带顺序：

>>> ax = sns.stripplot(x="time", y="tip", data=tips,
...                    order=["Dinner", "Lunch"])

绘制具有大点和不同美感的条带：

>>> ax =  sns.stripplot("day", "total_bill", "smoker", data=tips,
...                    palette="Set2", size=20, marker="D",
...                    edgecolor="gray", alpha=.25)

在箱形图上绘制观察条带：

>>> ax = sns.boxplot(x="tip", y="day", data=tips, whis=np.inf)
>>> ax = sns.stripplot(x="tip", y="day", data=tips,
...                    jitter=True, color=".3")

在小提琴情节的顶部绘制观察条带：

>>> ax = sns.violinplot(x="day", y="total_bill", data=tips,
...                     inner=None, color=".8")
>>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=True)

使用 catplot() 组合stripplot()和FacetGrid。这允许在其他分类变量中进行分组。使用catplot()比直接使用FacetGrid更安全，因为它确保了跨方面的变量顺序的同步

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="strip",
...                 jitter=True,
...                 height=4, aspect=.7);

seaborn.swarmplot

seaborn.swarmplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, dodge=False, orient=None, color=None, palette=None, size=5, edgecolor='gray', linewidth=0, ax=None, **kwargs)

Draw a categorical scatterplot with non-overlapping points.

This function is similar to stripplot(), but the points are adjusted (only along the categorical axis) so that they don’t overlap. This gives a better representation of the distribution of values, but it does not scale well to large numbers of observations. This style of plot is sometimes called a “beeswarm”.

A swarm plot can be drawn on its own, but it is also a good complement to a box or violin plot in cases where you want to show all observations along with some representation of the underlying distribution.

Arranging the points properly requires an accurate transformation between data and point coordinates. This means that non-default axis limits must be set before drawing the plot.

Input data can be passed in a variety of formats, including:

• Vectors of data represented as lists, numpy arrays, or pandas Series objects passed directly to the x, y, and/or hue parameters.
• A “long-form” DataFrame, in which case the x, y, and hue variables will determine how the data are plotted.
• A “wide-form” DataFrame, such that each numeric column will be plotted.
• An array or list of vectors.

In most cases, it is possible to use numpy or Python objects, but pandas objects are preferable because the associated names will be used to annotate the axes. Additionally, you can use Categorical types for the grouping variables to control the order of plot elements.

This function always treats one of the variables as categorical and draws data at ordinal positions (0, 1, … n) on the relevant axis, even when the data has a numeric or date type.

参数：x, y, hue：names of variables in data or vector data, optional

Inputs for plotting long-form data. See examples for interpretation.

data：DataFrame, array, or list of arrays, optional

Dataset for plotting. If x and y are absent, this is interpreted as wide-form. Otherwise it is expected to be long-form.

order, hue_order：lists of strings, optional

Order to plot the categorical levels in, otherwise the levels are inferred from the data objects.

dodge：bool, optional

When using hue nesting, setting this to True will separate the strips for different hue levels along the categorical axis. Otherwise, the points for each level will be plotted in one swarm.

orient：“v” | “h”, optional

Orientation of the plot (vertical or horizontal). This is usually inferred from the dtype of the input variables, but can be used to specify when the “categorical” variable is a numeric or when plotting wide-form data.

color：matplotlib color, optional

Color for all of the elements, or seed for a gradient palette.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

size：float, optional

Diameter of the markers, in points. (Although plt.scatter is used to draw the points, the size argument here takes a “normal” markersize and not size^2 like plt.scatter.

edgecolor：matplotlib color, “gray” is special-cased, optional

Color of the lines around each point. If you pass "gray", the brightness is determined by the color palette used for the body of the points.

linewidth：float, optional

Width of the gray lines that frame the plot elements.

ax：matplotlib Axes, optional

Axes object to draw the plot onto, otherwise uses the current Axes.

返回值：ax：matplotlib Axes

Returns the Axes object with the plot drawn onto it.

See also

A traditional box-and-whisker plot with a similar API.A combination of boxplot and kernel density estimation.A scatterplot where one variable is categorical. Can be used in conjunction with other plots to show each observation.Combine a categorical plot with a class:FacetGrid.

Examples

Draw a single horizontal swarm plot:

>>> import seaborn as sns
>>> sns.set(style="whitegrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.swarmplot(x=tips["total_bill"])

Group the swarms by a categorical variable:

>>> ax = sns.swarmplot(x="day", y="total_bill", data=tips)

Draw horizontal swarms:

>>> ax = sns.swarmplot(x="total_bill", y="day", data=tips)

Color the points using a second categorical variable:

>>> ax = sns.swarmplot(x="day", y="total_bill", hue="sex", data=tips)

Split each level of the hue variable along the categorical axis:

>>> ax = sns.swarmplot(x="day", y="total_bill", hue="smoker",
...                    data=tips, palette="Set2", dodge=True)

Control swarm order by passing an explicit order:

>>> ax = sns.swarmplot(x="time", y="tip", data=tips,
...                    order=["Dinner", "Lunch"])

Plot using larger points:

>>> ax = sns.swarmplot(x="time", y="tip", data=tips, size=6)

Draw swarms of observations on top of a box plot:

>>> ax = sns.boxplot(x="tip", y="day", data=tips, whis=np.inf)
>>> ax = sns.swarmplot(x="tip", y="day", data=tips, color=".2")

Draw swarms of observations on top of a violin plot:

>>> ax = sns.violinplot(x="day", y="total_bill", data=tips, inner=None)
>>> ax = sns.swarmplot(x="day", y="total_bill", data=tips,
...                    color="white", edgecolor="gray")

Use catplot() to combine a swarmplot() and a FacetGrid. This allows grouping within additional categorical variables. Using catplot() is safer than using FacetGrid directly, as it ensures synchronization of variable order across facets:

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="swarm",
...                 height=4, aspect=.7);

seaborn.boxplot

seaborn.boxplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, orient=None, color=None, palette=None, saturation=0.75, width=0.8, dodge=True, fliersize=5, linewidth=None, whis=1.5, notch=False, ax=None, **kwargs)

seaborn.boxplot 接口的作用是绘制箱形图以展现与类别相关的数据分布状况。

箱形图（或盒须图）以一种利于变量之间比较或不同分类变量层次之间比较的方式来展示定量数据的分布。图中矩形框显示数据集的上下四分位数，而矩形框中延伸出的线段（触须）则用于显示其余数据的分布位置，剩下超过上下四分位间距的数据点则被视为“异常值”。

输入数据可以通过多种格式传入，包括：

• 格式为列表，numpy数组或pandas Series对象的数据向量可以直接传递给x，y和hue参数。
• 对于长格式的DataFrame，x，y，和hue参数会决定如何绘制数据。
• 对于宽格式的DataFrame，每一列数值列都会被绘制。
• 一个数组或向量的列表。

在大多数情况下，可以使用numpy或Python对象，但更推荐使用pandas对象，因为与数据关联的列名/行名可以用于标注横轴/纵轴的名称。此外，您可以使用分类类型对变量进行分组以控制绘图元素的顺序。

此函数始终将其中一个变量视为分类，并在相关轴上的序数位置(0,1，… n)处绘制数据，即使数据属于数值类型或日期类型也是如此。

参数：x, y, hue：数据或向量数据中的变量名称，可选

用于绘制长格式数据的输入。查看样例以进一步理解。

data：DataFrame，数组，数组列表，可选

用于绘图的数据集。如果x和y都缺失，那么数据将被视为宽格式。否则数据被视为长格式。

order, hue_order：字符串列表，可选

控制分类变量（对应的条形图）的绘制顺序，若缺失则从数据中推断分类变量的顺序。

orient：“v” | “h”，可选

控制绘图的方向（垂直或水平）。这通常是从输入变量的dtype推断出来的，但是当“分类”变量为数值型或绘制宽格式数据时可用于指定绘图的方向。

color：matplotlib颜色，可选

所有元素的颜色，或渐变调色板的种子颜色。

palette：调色板名称，列表或字典，可选

用于hue变量的不同级别的颜色。可以从 color_palette() 得到一些解释，或者将色调级别映射到matplotlib颜色的字典。

saturation：float，可选

控制用于绘制颜色的原始饱和度的比例。通常大幅填充在轻微不饱和的颜色下看起来更好，如果您希望绘图颜色与输入颜色规格完美匹配可将其设置为1。

width：float，可选

不使用色调嵌套时完整元素的宽度，或主要分组变量一个级别的所有元素的宽度。

dodge：bool，可选

使用色调嵌套时，元素是否应沿分类轴移动。

fliersize：float，可选

用于表示异常值观察的标记的大小。

linewidth：float，可选

构图元素的灰线宽度。

whis：float，可选

控制在超过高低四分位数时IQR的比例，因此需要延长绘制的触须线段。超出此范围的点将被识别为异常值。

notch：boolean，可选

是否使矩形框“凹陷”以指示中位数的置信区间。还有其他几个参数可以控制凹槽的绘制方式；参见 plt.boxplot 以查看关于此问题的更多帮助信息。

ax：matplotlib轴，可选

绘图时使用的Axes轴对象，否则使用当前Axes轴对象。

kwargs：键，值映射

其他在绘图时传给 plt.boxplot 的参数。

返回值：ax：matplotlib轴

返回Axes对轴象，并在其上绘制绘图。

亦可参见

boxplot和核密度估计的结合。当一个变量是分类变量的散点图。可以与其他图表结合使用以展示各自的观测结果。分类散点图的特点是其中数据点互不重叠。可以与其他图表结合使用以展示各自的观测结果。

示例

绘制一个单独的横向箱型图：

>>> import seaborn as sns
>>> sns.set(style="whitegrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.boxplot(x=tips["total_bill"])

根据分类变量分组绘制一个纵向的箱型图：

>>> ax = sns.boxplot(x="day", y="total_bill", data=tips)

根据2个分类变量嵌套分组绘制一个箱型图：

>>> ax = sns.boxplot(x="day", y="total_bill", hue="smoker",
...                  data=tips, palette="Set3")

当一些数据为空时根据嵌套分组绘制一个箱型图：

>>> ax = sns.boxplot(x="day", y="total_bill", hue="time",
...                  data=tips, linewidth=2.5)

通过显式传入参数指定顺序控制箱型图的显示顺序：

>>> ax = sns.boxplot(x="time", y="tip", data=tips,
...                  order=["Dinner", "Lunch"])

针对DataFrame里每一个数值型变量绘制箱型图：

>>> iris = sns.load_dataset("iris")
>>> ax = sns.boxplot(data=iris, orient="h", palette="Set2")

使用 hue 参数无需改变箱型图的位置或宽度：

>>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"])
>>> ax = sns.boxplot(x="day", y="total_bill", hue="weekend",
...                  data=tips, dodge=False)

使用 swarmplot() 展示箱型图顶部的数据点：

>>> ax = sns.boxplot(x="day", y="total_bill", data=tips)
>>> ax = sns.swarmplot(x="day", y="total_bill", data=tips, color=".25")

把 catplot() 与 pointplot() 以及 FacetGrid 结合起来使用。这允许您通过额外的分类变量进行分组。使用 catplot() 比直接使用 FacetGrid 更为安全，因为它保证了不同切面上变量同步的顺序：

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="box",
...                 height=4, aspect=.7);

seaborn.violinplot

seaborn.violinplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, bw='scott', cut=2, scale='area', scale_hue=True, gridsize=100, width=0.8, inner='box', split=False, dodge=True, orient=None, linewidth=None, color=None, palette=None, saturation=0.75, ax=None, **kwargs)

结合箱型图与核密度估计绘图。

小提琴图的功能与箱型图类似。 它显示了一个（或多个）分类变量多个属性上的定量数据的分布，从而可以比较这些分布。与箱形图不同，其中所有绘图单元都与实际数据点对应，小提琴图描述了基础数据分布的核密度估计。

小提琴图可以是一种单次显示多个数据分布的有效且有吸引力的方式，但请记住，估计过程受样本大小的影响，相对较小样本的小提琴可能看起来非常平滑，这种平滑具有误导性。

输入数据可以通过多种格式传入，包括：

• 格式为列表，numpy数组或pandas Series对象的数据向量可以直接传递给x，y和hue参数。
• 对于长格式的DataFrame，x，y，和hue参数会决定如何绘制数据。
• 对于宽格式的DataFrame，每一列数值列都会被绘制。
• 一个数组或向量的列表。

在大多数情况下，可以使用numpy或Python对象，但更推荐使用pandas对象，因为与数据关联的列名/行名可以用于标注横轴/纵轴的名称。此外，您可以使用分类类型对变量进行分组以控制绘图元素的顺序。

此函数始终将其中一个变量视为分类，并在相关轴上的序数位置(0,1，… n)处绘制数据，即使数据属于数值类型或日期类型也是如此。

参数：x, y, hue：数据或向量数据中的变量名称，可选

用于绘制长格式数据的输入。查看样例以进一步理解。

data：DataFrame，数组，数组列表，可选

用于绘图的数据集。如果x和y都缺失，那么数据将被视为宽格式。否则数据被视为长格式。

order, hue_order：字符串列表，可选

控制分类变量（对应的条形图）的绘制顺序，若缺失则从数据中推断分类变量的顺序。

bw：{‘scott’, ‘silverman’, float}，可选

内置变量值或浮点数的比例因子都用来计算核密度的带宽。实际的核大小由比例因子乘以每个分箱内数据的标准差确定。

cut：float，可选

以带宽大小为单位的距离，以控制小提琴图外壳延伸超过内部极端数据点的密度。设置为0以将小提琴图范围限制在观察数据的范围内。（例如，在 ggplot 中具有与 trim=True 相同的效果）

scale：{“area”, “count”, “width”}，可选

该方法用于缩放每张小提琴图的宽度。若为 area ，每张小提琴图具有相同的面积。若为 count ，小提琴的宽度会根据分箱中观察点的数量进行缩放。若为 width ，每张小提琴图具有相同的宽度。

scale_hue：bool，可选

当使用色调参数 hue 变量绘制嵌套小提琴图时，该参数决定缩放比例是在主要分组变量（scale_hue=True）的每个级别内还是在图上的所有小提琴图（scale_hue=False）内计算出来的。

gridsize：int，可选

用于计算核密度估计的离散网格中的数据点数目。

width：float，可选

不使用色调嵌套时的完整元素的宽度，或主要分组变量的一个级别的所有元素的宽度。

inner：{“box”, “quartile”, “point”, “stick”, None}，可选

控制小提琴图内部数据点的表示。若为box，则绘制一个微型箱型图。若为quartiles，则显示四分位数线。若为point或stick，则显示具体数据点或数据线。使用None则绘制不加修饰的小提琴图。

split：bool，可选

当使用带有两种颜色的变量时，将split设置为True则会为每种颜色绘制对应半边小提琴。从而可以更容易直接的比较分布。

dodge：bool，可选

使用色调嵌套时，元素是否应沿分类轴移动。

orient：“v” | “h”，可选

控制绘图的方向（垂直或水平）。这通常是从输入变量的dtype推断出来的，但是当“分类”变量为数值型或绘制宽格式数据时可用于指定绘图的方向。

linewidth：float，可选

构图元素的灰线宽度。

color：matplotlib颜色，可选

所有元素的颜色，或渐变调色板的种子颜色。

palette：调色板名称，列表或字典，可选

用于hue变量的不同级别的颜色。可以从 color_palette() 得到一些解释，或者将色调级别映射到matplotlib颜色的字典。

saturation：float，可选

控制用于绘制颜色的原始饱和度的比例。通常大幅填充在轻微不饱和的颜色下看起来更好，如果您希望绘图颜色与输入颜色规格完美匹配可将其设置为1。

ax：matplotlib轴，可选

绘图时使用的Axes轴对象，否则使用当前Axes轴对象。

返回值：ax：matplotlib轴

返回Axes对轴象，并在其上绘制绘图。

亦可参见

一个传统的箱型图具有类似的API。当一个变量是分类变量的散点图。可以与其他图表结合使用以展示各自的观测结果。分类散点图的特点是其中数据点互不重叠。可以与其他图表结合使用以展示各自的观测结果。

示例

绘制一个单独的横向小提琴图：

>>> import seaborn as sns
>>> sns.set(style="whitegrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.violinplot(x=tips["total_bill"])

根据分类变量分组绘制一个纵向的小提琴图：

>>> ax = sns.violinplot(x="day", y="total_bill", data=tips)

根据2个分类变量嵌套分组绘制一个小提琴图：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="smoker",
...                     data=tips, palette="muted")

绘制分割的小提琴图以比较不同的色调变量：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="smoker",
...                     data=tips, palette="muted", split=True)

通过显式传入参数指定顺序控制小提琴图的显示顺序：

>>> ax = sns.violinplot(x="time", y="tip", data=tips,
...                     order=["Dinner", "Lunch"])

将小提琴宽度缩放为每个分箱中观察到的数据点数目：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="sex",
...                     data=tips, palette="Set2", split=True,
...                     scale="count")

将四分位数绘制为水平线而不是迷你箱型图：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="sex",
...                     data=tips, palette="Set2", split=True,
...                     scale="count", inner="quartile")

用小提琴图内部的横线显示每个观察到的数据点：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="sex",
...                     data=tips, palette="Set2", split=True,
...                     scale="count", inner="stick")

根据所有分箱的数据点数目对密度进行缩放：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="sex",
...                     data=tips, palette="Set2", split=True,
...                     scale="count", inner="stick", scale_hue=False)

使用窄带宽来减少平滑量：

>>> ax = sns.violinplot(x="day", y="total_bill", hue="sex",
...                     data=tips, palette="Set2", split=True,
...                     scale="count", inner="stick",
...                     scale_hue=False, bw=.2)

绘制横向小提琴图：

>>> planets = sns.load_dataset("planets")
>>> ax = sns.violinplot(x="orbital_period", y="method",
...                     data=planets[planets.orbital_period < 1000],
...                     scale="width", palette="Set3")

不要让密度超出数据中的极端数值：

>>> ax = sns.violinplot(x="orbital_period", y="method",
...                     data=planets[planets.orbital_period < 1000],
...                     cut=0, scale="width", palette="Set3")

使用 hue 而不改变小提琴图的位置或宽度：

>>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"])
>>> ax = sns.violinplot(x="day", y="total_bill", hue="weekend",
...                     data=tips, dodge=False)

把 catplot() 与 violinplot() 以及 FacetGrid 结合起来使用。这允许您通过额外的分类变量进行分组。使用 catplot() 比直接使用 FacetGrid 更为安全，因为它保证了不同切面上变量同步的顺序：

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="violin", split=True,
...                 height=4, aspect=.7);

seaborn.boxenplot

seaborn.boxenplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, orient=None, color=None, palette=None, saturation=0.75, width=0.8, dodge=True, k_depth='proportion', linewidth=None, scale='exponential', outlier_prop=None, ax=None, **kwargs)

Draw an enhanced box plot for larger datasets.

This style of plot was originally named a “letter value” plot because it shows a large number of quantiles that are defined as “letter values”. It is similar to a box plot in plotting a nonparametric representation of a distribution in which all features correspond to actual observations. By plotting more quantiles, it provides more information about the shape of the distribution, particularly in the tails. For a more extensive explanation, you can read the paper that introduced the plot:

https://vita.had.co.nz/papers/letter-value-plot.html

Input data can be passed in a variety of formats, including:

• Vectors of data represented as lists, numpy arrays, or pandas Series objects passed directly to the x, y, and/or hue parameters.
• A “long-form” DataFrame, in which case the x, y, and hue variables will determine how the data are plotted.
• A “wide-form” DataFrame, such that each numeric column will be plotted.
• An array or list of vectors.

In most cases, it is possible to use numpy or Python objects, but pandas objects are preferable because the associated names will be used to annotate the axes. Additionally, you can use Categorical types for the grouping variables to control the order of plot elements.

This function always treats one of the variables as categorical and draws data at ordinal positions (0, 1, … n) on the relevant axis, even when the data has a numeric or date type.

参数：x, y, hue：names of variables in data or vector data, optional

Inputs for plotting long-form data. See examples for interpretation.

data：DataFrame, array, or list of arrays, optional

Dataset for plotting. If x and y are absent, this is interpreted as wide-form. Otherwise it is expected to be long-form.

order, hue_order：lists of strings, optional

Order to plot the categorical levels in, otherwise the levels are inferred from the data objects.

orient：“v” | “h”, optional

Orientation of the plot (vertical or horizontal). This is usually inferred from the dtype of the input variables, but can be used to specify when the “categorical” variable is a numeric or when plotting wide-form data.

color：matplotlib color, optional

Color for all of the elements, or seed for a gradient palette.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

saturation：float, optional

Proportion of the original saturation to draw colors at. Large patches often look better with slightly desaturated colors, but set this to 1 if you want the plot colors to perfectly match the input color spec.

width：float, optional

Width of a full element when not using hue nesting, or width of all the elements for one level of the major grouping variable.

dodge：bool, optional

When hue nesting is used, whether elements should be shifted along the categorical axis.

k_depth：“proportion” | “tukey” | “trustworthy”, optional

The number of boxes, and by extension number of percentiles, to draw. All methods are detailed in Wickham’s paper. Each makes different assumptions about the number of outliers and leverages different statistical properties.

linewidth：float, optional

Width of the gray lines that frame the plot elements.

scale：“linear” | “exponential” | “area”

Method to use for the width of the letter value boxes. All give similar results visually. “linear” reduces the width by a constant linear factor, “exponential” uses the proportion of data not covered, “area” is proportional to the percentage of data covered.

outlier_prop：float, optional

Proportion of data believed to be outliers. Used in conjunction with k_depth to determine the number of percentiles to draw. Defaults to 0.007 as a proportion of outliers. Should be in range [0, 1].

ax：matplotlib Axes, optional

Axes object to draw the plot onto, otherwise uses the current Axes.

kwargs：key, value mappings

Other keyword arguments are passed through to plt.plot and plt.scatter at draw time.

返回值：ax：matplotlib Axes

Returns the Axes object with the plot drawn onto it.

See also

A combination of boxplot and kernel density estimation.A traditional box-and-whisker plot with a similar API.

Examples

Draw a single horizontal boxen plot:

>>> import seaborn as sns
>>> sns.set(style="whitegrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.boxenplot(x=tips["total_bill"])

Draw a vertical boxen plot grouped by a categorical variable:

>>> ax = sns.boxenplot(x="day", y="total_bill", data=tips)

Draw a letter value plot with nested grouping by two categorical variables:

>>> ax = sns.boxenplot(x="day", y="total_bill", hue="smoker",
...                    data=tips, palette="Set3")

Draw a boxen plot with nested grouping when some bins are empty:

>>> ax = sns.boxenplot(x="day", y="total_bill", hue="time",
...                    data=tips, linewidth=2.5)

Control box order by passing an explicit order:

>>> ax = sns.boxenplot(x="time", y="tip", data=tips,
...                    order=["Dinner", "Lunch"])

Draw a boxen plot for each numeric variable in a DataFrame:

>>> iris = sns.load_dataset("iris")
>>> ax = sns.boxenplot(data=iris, orient="h", palette="Set2")

Use stripplot() to show the datapoints on top of the boxes:

>>> ax = sns.boxenplot(x="day", y="total_bill", data=tips)
>>> ax = sns.stripplot(x="day", y="total_bill", data=tips,
...                    size=4, jitter=True, color="gray")

Use catplot() to combine boxenplot() and a FacetGrid. This allows grouping within additional categorical variables. Using catplot() is safer than using FacetGrid directly, as it ensures synchronization of variable order across facets:

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="boxen",
...                 height=4, aspect=.7);

seaborn.pointplot

seaborn.pointplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, estimator=<function mean>, ci=95, n_boot=1000, units=None, markers='o', linestyles='-', dodge=False, join=True, scale=1, orient=None, color=None, palette=None, errwidth=None, capsize=None, ax=None, **kwargs)

Show point estimates and confidence intervals using scatter plot glyphs.

A point plot represents an estimate of central tendency for a numeric variable by the position of scatter plot points and provides some indication of the uncertainty around that estimate using error bars.

Point plots can be more useful than bar plots for focusing comparisons between different levels of one or more categorical variables. They are particularly adept at showing interactions: how the relationship between levels of one categorical variable changes across levels of a second categorical variable. The lines that join each point from the same hue level allow interactions to be judged by differences in slope, which is easier for the eyes than comparing the heights of several groups of points or bars.

It is important to keep in mind that a point plot shows only the mean (or other estimator) value, but in many cases it may be more informative to show the distribution of values at each level of the categorical variables. In that case, other approaches such as a box or violin plot may be more appropriate.

Input data can be passed in a variety of formats, including:

• Vectors of data represented as lists, numpy arrays, or pandas Series objects passed directly to the x, y, and/or hue parameters.
• A “long-form” DataFrame, in which case the x, y, and hue variables will determine how the data are plotted.
• A “wide-form” DataFrame, such that each numeric column will be plotted.
• An array or list of vectors.

In most cases, it is possible to use numpy or Python objects, but pandas objects are preferable because the associated names will be used to annotate the axes. Additionally, you can use Categorical types for the grouping variables to control the order of plot elements.

This function always treats one of the variables as categorical and draws data at ordinal positions (0, 1, … n) on the relevant axis, even when the data has a numeric or date type.

参数：x, y, hue：names of variables in data or vector data, optional

Inputs for plotting long-form data. See examples for interpretation.

data：DataFrame, array, or list of arrays, optional

Dataset for plotting. If x and y are absent, this is interpreted as wide-form. Otherwise it is expected to be long-form.

order, hue_order：lists of strings, optional

Order to plot the categorical levels in, otherwise the levels are inferred from the data objects.

estimator：callable that maps vector -> scalar, optional

Statistical function to estimate within each categorical bin.

ci：float or “sd” or None, optional

Size of confidence intervals to draw around estimated values. If “sd”, skip bootstrapping and draw the standard deviation of the observations. If None, no bootstrapping will be performed, and error bars will not be drawn.

n_boot：int, optional

Number of bootstrap iterations to use when computing confidence intervals.

units：name of variable in data or vector data, optional

Identifier of sampling units, which will be used to perform a multilevel bootstrap and account for repeated measures design.

markers：string or list of strings, optional

Markers to use for each of the hue levels.

linestyles：string or list of strings, optional

Line styles to use for each of the hue levels.

dodge：bool or float, optional

Amount to separate the points for each level of the hue variable along the categorical axis.

join：bool, optional

If True, lines will be drawn between point estimates at the same hue level.

scale：float, optional

Scale factor for the plot elements.

orient：“v” | “h”, optional

Orientation of the plot (vertical or horizontal). This is usually inferred from the dtype of the input variables, but can be used to specify when the “categorical” variable is a numeric or when plotting wide-form data.

color：matplotlib color, optional

Color for all of the elements, or seed for a gradient palette.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

errwidth：float, optional

Thickness of error bar lines (and caps).

capsize：float, optional

Width of the “caps” on error bars.

ax：matplotlib Axes, optional

Axes object to draw the plot onto, otherwise uses the current Axes.

返回值：ax：matplotlib Axes

Returns the Axes object with the plot drawn onto it.

See also

Show point estimates and confidence intervals using bars.Combine a categorical plot with a class:FacetGrid.

Examples

Draw a set of vertical point plots grouped by a categorical variable:

>>> import seaborn as sns
>>> sns.set(style="darkgrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.pointplot(x="time", y="total_bill", data=tips)

!(../images/language/f5eb9519edb052868537ca9735f0f8df.jpg)

Draw a set of vertical points with nested grouping by a two variables:

>>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker",
...                    data=tips)

Separate the points for different hue levels along the categorical axis:

>>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker",
...                    data=tips, dodge=True)

Use a different marker and line style for the hue levels:

>>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker",
...                    data=tips,
...                    markers=["o", "x"],
...                    linestyles=["-", "--"])

Draw a set of horizontal points:

>>> ax = sns.pointplot(x="tip", y="day", data=tips)

Don’t draw a line connecting each point:

>>> ax = sns.pointplot(x="tip", y="day", data=tips, join=False)

Use a different color for a single-layer plot:

>>> ax = sns.pointplot("time", y="total_bill", data=tips,
...                    color="#bb3f3f")

Use a different color palette for the points:

>>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker",
...                    data=tips, palette="Set2")

Control point order by passing an explicit order:

>>> ax = sns.pointplot(x="time", y="tip", data=tips,
...                    order=["Dinner", "Lunch"])

Use median as the estimate of central tendency:

>>> from numpy import median
>>> ax = sns.pointplot(x="day", y="tip", data=tips, estimator=median)

Show the standard error of the mean with the error bars:

>>> ax = sns.pointplot(x="day", y="tip", data=tips, ci=68)

Show standard deviation of observations instead of a confidence interval:

>>> ax = sns.pointplot(x="day", y="tip", data=tips, ci="sd")

Add “caps” to the error bars:

>>> ax = sns.pointplot(x="day", y="tip", data=tips, capsize=.2)

Use catplot() to combine a barplot() and a FacetGrid. This allows grouping within additional categorical variables. Using catplot() is safer than using FacetGrid directly, as it ensures synchronization of variable order across facets:

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="point",
...                 dodge=True,
...                 height=4, aspect=.7);

seaborn.barplot

seaborn.barplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, estimator=<function mean>, ci=95, n_boot=1000, units=None, orient=None, color=None, palette=None, saturation=0.75, errcolor='.26', errwidth=None, capsize=None, dodge=True, ax=None, **kwargs)

Show point estimates and confidence intervals as rectangular bars.

A bar plot represents an estimate of central tendency for a numeric variable with the height of each rectangle and provides some indication of the uncertainty around that estimate using error bars. Bar plots include 0 in the quantitative axis range, and they are a good choice when 0 is a meaningful value for the quantitative variable, and you want to make comparisons against it.

For datasets where 0 is not a meaningful value, a point plot will allow you to focus on differences between levels of one or more categorical variables.

It is also important to keep in mind that a bar plot shows only the mean (or other estimator) value, but in many cases it may be more informative to show the distribution of values at each level of the categorical variables. In that case, other approaches such as a box or violin plot may be more appropriate.

Input data can be passed in a variety of formats, including:

• Vectors of data represented as lists, numpy arrays, or pandas Series objects passed directly to the x, y, and/or hue parameters.
• A “long-form” DataFrame, in which case the x, y, and hue variables will determine how the data are plotted.
• A “wide-form” DataFrame, such that each numeric column will be plotted.
• An array or list of vectors.

In most cases, it is possible to use numpy or Python objects, but pandas objects are preferable because the associated names will be used to annotate the axes. Additionally, you can use Categorical types for the grouping variables to control the order of plot elements.

This function always treats one of the variables as categorical and draws data at ordinal positions (0, 1, … n) on the relevant axis, even when the data has a numeric or date type.

参数：x, y, hue：names of variables in data or vector data, optional

Inputs for plotting long-form data. See examples for interpretation.

data：DataFrame, array, or list of arrays, optional

Dataset for plotting. If x and y are absent, this is interpreted as wide-form. Otherwise it is expected to be long-form.

order, hue_order：lists of strings, optional

Order to plot the categorical levels in, otherwise the levels are inferred from the data objects.

estimator：callable that maps vector -> scalar, optional

Statistical function to estimate within each categorical bin.

ci：float or “sd” or None, optional

Size of confidence intervals to draw around estimated values. If “sd”, skip bootstrapping and draw the standard deviation of the observations. If None, no bootstrapping will be performed, and error bars will not be drawn.

n_boot：int, optional

Number of bootstrap iterations to use when computing confidence intervals.

units：name of variable in data or vector data, optional

Identifier of sampling units, which will be used to perform a multilevel bootstrap and account for repeated measures design.

orient：“v” | “h”, optional

Orientation of the plot (vertical or horizontal). This is usually inferred from the dtype of the input variables, but can be used to specify when the “categorical” variable is a numeric or when plotting wide-form data.

color：matplotlib color, optional

Color for all of the elements, or seed for a gradient palette.

palette：palette name, list, or dict, optional

Colors to use for the different levels of the hue variable. Should be something that can be interpreted by color_palette(), or a dictionary mapping hue levels to matplotlib colors.

saturation：float, optional

Proportion of the original saturation to draw colors at. Large patches often look better with slightly desaturated colors, but set this to 1 if you want the plot colors to perfectly match the input color spec.

errcolor：matplotlib color

Color for the lines that represent the confidence interval.

errwidth：float, optional

Thickness of error bar lines (and caps).

capsize：float, optional

Width of the “caps” on error bars.

dodge：bool, optional

When hue nesting is used, whether elements should be shifted along the categorical axis.

ax：matplotlib Axes, optional

Axes object to draw the plot onto, otherwise uses the current Axes.

kwargs：key, value mappings

Other keyword arguments are passed through to plt.bar at draw time.

返回值：ax：matplotlib Axes

Returns the Axes object with the plot drawn onto it.

See also

Show the counts of observations in each categorical bin.Show point estimates and confidence intervals using scatterplot glyphs.Combine a categorical plot with a class:FacetGrid.

Examples

Draw a set of vertical bar plots grouped by a categorical variable:

>>> import seaborn as sns
>>> sns.set(style="whitegrid")
>>> tips = sns.load_dataset("tips")
>>> ax = sns.barplot(x="day", y="total_bill", data=tips)

Draw a set of vertical bars with nested grouping by a two variables:

>>> ax = sns.barplot(x="day", y="total_bill", hue="sex", data=tips)

Draw a set of horizontal bars:

>>> ax = sns.barplot(x="tip", y="day", data=tips)

Control bar order by passing an explicit order:

>>> ax = sns.barplot(x="time", y="tip", data=tips,
...                  order=["Dinner", "Lunch"])

Use median as the estimate of central tendency:

>>> from numpy import median
>>> ax = sns.barplot(x="day", y="tip", data=tips, estimator=median)

Show the standard error of the mean with the error bars:

>>> ax = sns.barplot(x="day", y="tip", data=tips, ci=68)

Show standard deviation of observations instead of a confidence interval:

>>> ax = sns.barplot(x="day", y="tip", data=tips, ci="sd")

Add “caps” to the error bars:

>>> ax = sns.barplot(x="day", y="tip", data=tips, capsize=.2)

Use a different color palette for the bars:

>>> ax = sns.barplot("size", y="total_bill", data=tips,
...                  palette="Blues_d")

Use hue without changing bar position or width:

>>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"])
>>> ax = sns.barplot(x="day", y="total_bill", hue="weekend",
...                  data=tips, dodge=False)

Plot all bars in a single color:

>>> ax = sns.barplot("size", y="total_bill", data=tips,
...                  color="salmon", saturation=.5)

Use plt.bar keyword arguments to further change the aesthetic:

>>> ax = sns.barplot("day", "total_bill", data=tips,
...                  linewidth=2.5, facecolor=(1, 1, 1, 0),
...                  errcolor=".2", edgecolor=".2")

Use catplot() to combine a barplot() and a FacetGrid. This allows grouping within additional categorical variables. Using catplot() is safer than using FacetGrid directly, as it ensures synchronization of variable order across facets:

>>> g = sns.catplot(x="sex", y="total_bill",
...                 hue="smoker", col="time",
...                 data=tips, kind="bar",
...                 height=4, aspect=.7);

seaborn.countplot

seaborn.countplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, orient=None, color=None, palette=None, saturation=0.75, dodge=True, ax=None, **kwargs)

seaborn.countplot使用条形图显示每个类别中观测值的数量。

这个函数可以被认为是针对类别变量的直方图。基本的API和选项与barplot()完全相同，因此可以对比学习。

可以通过多种格式传入数据，包括：

• 通过列表、numpy数组、或者pandas Series对象表示的向量数据，数据直接传给x, y, 和/或hue参数。
• 长格式的DataFrame，此时会通过x, y以及hue变量决定如何绘制数据。
• 宽格式的DataFrame，此时每个数值型的column都会被绘制。
• 数组或者列表形式的向量

在绝大多数情况下，数据格式都可以使用numpy或者Python对象，但是推荐使用pandas对象，因为pandas对象中相关的名称会被用于注释坐标轴。此外，可以通过设置分组变量为使用Categorical类型来控制绘制元素的顺序。

这个函数总会将变量作为类别变量进行处理，按顺序(0, 1, … n)在相应坐标轴绘制数据，即使数据为数值或者日期类型。

参数：x, y, hue: data或者向量数据中的变量名，可选

用于绘制长格式数据的输入。查看解释示例

data：DataFrame, 数组，或者包含数组的列表，可选

用于绘制的数据集。如果x和y不存在，那么会将数据按宽格式进行处理，否则应当为长格式。

order, hue_order：包含字符串的列表，可选

类别层级绘制的顺序，否则层级会从数据对象中推测。

orient: “v” | “h”, 可选

绘制的朝向（竖直或者水平）。通过从输入变量的dtype进行推断。当类别变量是数值型或者绘制宽格式数据时，可以进行指定。

color: matplotlib颜色，可选

所有元素的颜色，或者渐变调色盘的种子。

palette: 调色盘名称，列表或字典，可选

用于hue变量的不同级别的颜色。应当是color_palette()可以解释的东西，或者将色调级别映射到matplotlib颜色的字典。

saturation: float, 可选

在原有饱和度的比例下绘制颜色。大片的图块通常在略微不饱和的颜色下看起来更好，而如果想要绘制的颜色与输入颜色规格完全匹配，应当设置此值为1。

dodge: bool, 可选

当使用色调嵌套时，决定是否沿着类别轴对元素进行移位。

ax: matplotlib轴，可选

绘制图像的轴对象，不指定时使用当前轴。

kwargs: 键值映射

其他关键字参数会被传递给plt.bar.

返回值：ax: matplotlib轴

返回带有绘图的轴对象。

另请参阅

barplot(): 使用条形图显示点估计和置信区间。

factorplot(): 结合类别图与FacetGrid类。

示例

显示单个类别变量的计数值：

>>> import seaborn as sns
>>> sns.set(style="darkgrid")
>>> titanic = sns.load_dataset("titanic")
>>> ax = sns.countplot(x="class", data=titanic)

显示两个类别变量的计数值：

>>> ax = sns.countplot(x="class", hue="who", data=titanic)

水平绘制条形图：

>>> ax = sns.countplot(y="class", hue="who", data=titanic)

使用不同的颜色色盘：

>>> ax = sns.countplot(x="who", data=titanic, palette="Set3")

使用plt.bar的关键字参数获得不同的显示效果：

>>> ax = sns.countplot(x="who", data=titanic,
...                    facecolor=(0, 0, 0, 0),
...                    linewidth=5,
...                    edgecolor=sns.color_palette("dark", 3))

使用catplot()实现结合countplot()以及FacetGrid的效果。这样做可以在额外的类别变量中进行分组。使用catplot()比直接使用FacetGrid更加安全，因为这样做可以确保跨分面的变量顺序同步：

>>> g = sns.catplot(x="class", hue="who", col="survived",
...                 data=titanic, kind="count",
...                 height=4, aspect=.7);

seaborn.jointplot

seaborn.jointplot(x, y, data=None, kind='scatter', stat_func=None, color=None, height=6, ratio=5, space=0.2, dropna=True, xlim=None, ylim=None, joint_kws=None, marginal_kws=None, annot_kws=None, **kwargs)

Draw a plot of two variables with bivariate and univariate graphs.

This function provides a convenient interface to the JointGrid class, with several canned plot kinds. This is intended to be a fairly lightweight wrapper; if you need more flexibility, you should use JointGrid directly.

参数：x, y：strings or vectors

Data or names of variables in data.

data：DataFrame, optional

DataFrame when x and y are variable names.

kind：{ “scatter” | “reg” | “resid” | “kde” | “hex” }, optional

Kind of plot to draw.

stat_func：callable or None, optional

Deprecated

color：matplotlib color, optional

Color used for the plot elements.

height：numeric, optional

Size of the figure (it will be square).

ratio：numeric, optional

Ratio of joint axes height to marginal axes height.

space：numeric, optional

Space between the joint and marginal axes

dropna：bool, optional

If True, remove observations that are missing from x and y.

{x, y}lim：two-tuples, optional

Axis limits to set before plotting.

{joint, marginal, annot}_kws：dicts, optional

Additional keyword arguments for the plot components.

kwargs：key, value pairings

Additional keyword arguments are passed to the function used to draw the plot on the joint Axes, superseding items in the joint_kws dictionary.

返回值：grid：JointGrid

JointGrid object with the plot on it.

See also

The Grid class used for drawing this plot. Use it directly if you need more flexibility.

Examples

Draw a scatterplot with marginal histograms:

>>> import numpy as np, pandas as pd; np.random.seed(0)
>>> import seaborn as sns; sns.set(style="white", color_codes=True)
>>> tips = sns.load_dataset("tips")
>>> g = sns.jointplot(x="total_bill", y="tip", data=tips)

Add regression and kernel density fits:

>>> g = sns.jointplot("total_bill", "tip", data=tips, kind="reg")

Replace the scatterplot with a joint histogram using hexagonal bins:

>>> g = sns.jointplot("total_bill", "tip", data=tips, kind="hex")

Replace the scatterplots and histograms with density estimates and align the marginal Axes tightly with the joint Axes:

>>> iris = sns.load_dataset("iris")
>>> g = sns.jointplot("sepal_width", "petal_length", data=iris,
...                   kind="kde", space=0, color="g")

Draw a scatterplot, then add a joint density estimate:

>>> g = (sns.jointplot("sepal_length", "sepal_width",
...                    data=iris, color="k")
...         .plot_joint(sns.kdeplot, zorder=0, n_levels=6))

Pass vectors in directly without using Pandas, then name the axes:

>>> x, y = np.random.randn(2, 300)
>>> g = (sns.jointplot(x, y, kind="hex")
...         .set_axis_labels("x", "y"))

Draw a smaller figure with more space devoted to the marginal plots:

>>> g = sns.jointplot("total_bill", "tip", data=tips,
...                   height=5, ratio=3, color="g")

Pass keyword arguments down to the underlying plots:

>>> g = sns.jointplot("petal_length", "sepal_length", data=iris,...                   marginal_kws=dict(bins=15, rug=True),...                   annot_kws=dict(stat="r"),...                   s=40, edgecolor="w", linewidth=1)

seaborn.pairplot

seaborn.pairplot(data, hue=None, hue_order=None, palette=None, vars=None, x_vars=None, y_vars=None, kind='scatter', diag_kind='auto', markers=None, height=2.5, aspect=1, dropna=True, plot_kws=None, diag_kws=None, grid_kws=None, size=None)

Plot pairwise relationships in a dataset.

By default, this function will create a grid of Axes such that each variable in data will by shared in the y-axis across a single row and in the x-axis across a single column. The diagonal Axes are treated differently, drawing a plot to show the univariate distribution of the data for the variable in that column.

It is also possible to show a subset of variables or plot different variables on the rows and columns.

This is a high-level interface for PairGrid that is intended to make it easy to draw a few common styles. You should use PairGrid directly if you need more flexibility.

参数：data：DataFrame

Tidy (long-form) dataframe where each column is a variable and each row is an observation.

hue：string (variable name), optional

Variable in data to map plot aspects to different colors.

hue_order：list of strings

Order for the levels of the hue variable in the palette

palette：dict or seaborn color palette

Set of colors for mapping the hue variable. If a dict, keys should be values in the hue variable.

vars：list of variable names, optional

Variables within data to use, otherwise use every column with a numeric datatype.

{x, y}_vars：lists of variable names, optional

Variables within data to use separately for the rows and columns of the figure; i.e. to make a non-square plot.

kind：{‘scatter’, ‘reg’}, optional

Kind of plot for the non-identity relationships.

diag_kind：{‘auto’, ‘hist’, ‘kde’}, optional

Kind of plot for the diagonal subplots. The default depends on whether "hue" is used or not.

markers：single matplotlib marker code or list, optional

Either the marker to use for all datapoints or a list of markers with a length the same as the number of levels in the hue variable so that differently colored points will also have different scatterplot markers.

height：scalar, optional

Height (in inches) of each facet.

aspect：scalar, optional

Aspect * height gives the width (in inches) of each facet.

dropna：boolean, optional

Drop missing values from the data before plotting.

{plot, diag, grid}_kws：dicts, optional

Dictionaries of keyword arguments.

返回值：grid：PairGrid

Returns the underlying PairGrid instance for further tweaking.

See also

Subplot grid for more flexible plotting of pairwise relationships.

Examples

Draw scatterplots for joint relationships and histograms for univariate distributions:

>>> import seaborn as sns; sns.set(style="ticks", color_codes=True)
>>> iris = sns.load_dataset("iris")
>>> g = sns.pairplot(iris)

Show different levels of a categorical variable by the color of plot elements:

>>> g = sns.pairplot(iris, hue="species")

Use a different color palette:

>>> g = sns.pairplot(iris, hue="species", palette="husl")

Use different markers for each level of the hue variable:

>>> g = sns.pairplot(iris, hue="species", markers=["o", "s", "D"])

Plot a subset of variables:

>>> g = sns.pairplot(iris, vars=["sepal_width", "sepal_length"])

Draw larger plots:

>>> g = sns.pairplot(iris, height=3,
...                  vars=["sepal_width", "sepal_length"])

Plot different variables in the rows and columns:

>>> g = sns.pairplot(iris,
...                  x_vars=["sepal_width", "sepal_length"],
...                  y_vars=["petal_width", "petal_length"])

Use kernel density estimates for univariate plots:

>>> g = sns.pairplot(iris, diag_kind="kde")

Fit linear regression models to the scatter plots:

>>> g = sns.pairplot(iris, kind="reg")

Pass keyword arguments down to the underlying functions (it may be easier to use PairGrid directly):

>>> g = sns.pairplot(iris, diag_kind="kde", markers="+",
...                  plot_kws=dict(s=50, edgecolor="b", linewidth=1),
...                  diag_kws=dict(shade=True))

seaborn.distplot

seaborn.distplot(a, bins=None, hist=True, kde=True, rug=False, fit=None, hist_kws=None, kde_kws=None, rug_kws=None, fit_kws=None, color=None, vertical=False, norm_hist=False, axlabel=None, label=None, ax=None)

灵活绘制单变量观测值分布图。

该函数结合了matplotlib中的 hist函数（自动计算一个默认的合适的bin大小）、seaborn的kdeplot()和rugplot()函数。它还可以拟合scipy.stats分布并在数据上绘制估计的PDF（概率分布函数）。

参数：a：Series、1维数组或者列表。

观察数据。如果是具有name属性的Series对象，则该名称将用于标记数据轴。

bins：matplotlib hist()的参数，或None。可选参数。

直方图bins（柱）的数目，若填None，则默认使用Freedman-Diaconis规则指定柱的数目。

hist：布尔值，可选参数。

是否绘制（标准化）直方图。

kde：布尔值，可选参数。

是否绘制高斯核密度估计图。

rug：布尔值，可选参数。

是否在横轴上绘制观测值竖线。

fit：随机变量对象，可选参数。

一个带有fit方法的对象，返回一个元组，该元组可以传递给pdf方法一个位置参数，该位置参数遵循一个值的网格用于评估pdf。

{hist, kde, rug, fit}_kws：字典，可选参数。

底层绘图函数的关键字参数。

color：matplotlib color，可选参数。

可以绘制除了拟合曲线之外所有内容的颜色。

vertical：布尔值，可选参数。

如果为True，则观测值在y轴显示。

norm_hist：布尔值，可选参数。

如果为True，则直方图的高度显示密度而不是计数。如果绘制KDE图或拟合密度，则默认为True。

axlabel：字符串，False或者None，可选参数。

横轴的名称。如果为None，将尝试从a.name获取它；如果为False，则不设置标签。

label：字符串，可选参数。

图形相关组成部分的图例标签。

ax：matplotlib axis，可选参数。

若提供该参数，则在参数设定的轴上绘图。

返回值：ax：matplotlib Axes

返回Axes对象以及用于进一步调整的绘图。

另请参见

kdeplot

显示具有核密度估计图的单变量或双变量分布。

rugplot

绘制小的垂直线以显示分布中的每个观测值。

范例

显示具有核密度估计的默认图和使用参考规则自动确定bin大小的直方图：

>>> import seaborn as sns, numpy as np
>>> sns.set(); np.random.seed(0)
>>> x = np.random.randn(100)
>>> ax = sns.distplot(x)

使用Pandas对象获取信息轴标签：

>>> import pandas as pd
>>> x = pd.Series(x, name="x variable")
>>> ax = sns.distplot(x)

使用核密度估计和小的垂直线绘制分布图：

>>> ax = sns.distplot(x, rug=True, hist=False)

使用直方图和最大似然高斯分布拟合绘制分布图：

>>> from scipy.stats import norm
>>> ax = sns.distplot(x, fit=norm, kde=False)

在垂直轴上绘制分布图：

>>> ax = sns.distplot(x, vertical=True)

更改所有绘图元素的颜色：

>>> sns.set_color_codes()
>>> ax = sns.distplot(x, color="y")

将特定参数传递给基础绘图函数：

>>> ax = sns.distplot(x, rug=True, rug_kws={"color": "g"},
...                   kde_kws={"color": "k", "lw": 3, "label": "KDE"},
...                   hist_kws={"histtype": "step", "linewidth": 3,
...                             "alpha": 1, "color": "g"})

seaborn.kdeplot

seaborn.kdeplot(data, data2=None, shade=False, vertical=False, kernel='gau', bw='scott', gridsize=100, cut=3, clip=None, legend=True, cumulative=False, shade_lowest=True, cbar=False, cbar_ax=None, cbar_kws=None, ax=None, **kwargs)

拟合并绘制单变量或双变量核密度估计图。

参数：data：一维阵列

输入数据

**data2：一维阵列，可选。

第二输入数据。如果存在，将估计双变量KDE。

shade：布尔值，可选参数。

如果为True，则在KDE曲线下方的区域中增加阴影（或者在数据为双变量时使用填充的轮廓绘制）。

vertical：布尔值，可选参数。

如果为True，密度图将显示在x轴。

kernel：{‘gau’ | ‘cos’ | ‘biw’ | ‘epa’ | ‘tri’ | ‘triw’ }，可选参数

要拟合的核的形状代码，双变量KDE只能使用高斯核。

bw：{‘scott’ | ‘silverman’ | scalar | pair of scalars }，可选参数

用于确定双变量图的每个维的核大小、标量因子或标量的参考方法的名称。需要注意的是底层的计算库对此参数有不同的交互：statsmodels直接使用它，而scipy将其视为数据标准差的缩放因子。

gridsize：整型数据，可选参数。

评估网格中的离散点数。

cut：标量，可选参数。

绘制估计值以从极端数据点切割* bw。

clip：一对标量，可选参数。

用于拟合KDE图的数据点的上下限值。可以为双变量图提供一对（上，下）边界。

legend：布尔值，可选参数。

如果为True，为绘制的图像添加图例或者标记坐标轴。

cumulative：布尔值，可选参数。

如果为True，则绘制kde估计图的累积分布。

shade_lowest：布尔值，可选参数。

如果为True，则屏蔽双变量KDE图的最低轮廓。绘制单变量图或“shade = False”时无影响。当你想要在同一轴上绘制多个密度时，可将此参数设置为“False”。

cbar：布尔值，可选参数。

如果为True并绘制双变量KDE图，为绘制的图像添加颜色条。

cbar_ax：matplotlib axes，可选参数。

用于绘制颜色条的坐标轴，若为空，就在主轴绘制颜色条。

cbar_kws：字典，可选参数。

fig.colorbar（）的关键字参数。

ax：matplotlib axes，可选参数。

要绘图的坐标轴，若为空，则使用当前轴。

kwargs：键值对

其他传递给plt.plot（）或plt.contour {f}的关键字参数，具体取决于是绘制单变量还是双变量图。

返回值：ax：matplotlib Axes

绘图的坐标轴。

另请参见

distplot

灵活绘制单变量观测值分布图。

jointplot

绘制一个具有双变量和边缘分布的联合数据集。

范例

绘制一个简单的单变量分布：

>>> import numpy as np; np.random.seed(10)
>>> import seaborn as sns; sns.set(color_codes=True)
>>> mean, cov = [0, 2], [(1, .5), (.5, 1)]
>>> x, y = np.random.multivariate_normal(mean, cov, size=50).T
>>> ax = sns.kdeplot(x)

在密度曲线下使用不同的颜色着色：

>>> ax = sns.kdeplot(x, shade=True, color="r")

绘制一个双变量分布：

>>> ax = sns.kdeplot(x, y)

使用填充轮廓：

>>> ax = sns.kdeplot(x, y, shade=True)

使用更多的轮廓级别和不同的调色板：

>>> ax = sns.kdeplot(x, y, n_levels=30, cmap="Purples_d")

使用窄带宽：

>>> ax = sns.kdeplot(x, bw=.15)

在纵轴上绘制密度分布：

>>> ax = sns.kdeplot(y, vertical=True)

将密度曲线限制在数据范围内:

>>> ax = sns.kdeplot(x, cut=0)

为轮廓添加一个颜色条:

>>> ax = sns.kdeplot(x, y, cbar=True)

为双变量密度图绘制两个阴影：

>>> iris = sns.load_dataset("iris")
>>> setosa = iris.loc[iris.species == "setosa"]
>>> virginica = iris.loc[iris.species == "virginica"]
>>> ax = sns.kdeplot(setosa.sepal_width, setosa.sepal_length,
...                  cmap="Reds", shade=True, shade_lowest=False)
>>> ax = sns.kdeplot(virginica.sepal_width, virginica.sepal_length,
...                  cmap="Blues", shade=True, shade_lowest=False)

seaborn.rugplot

seaborn.rugplot(a, height=0.05, axis='x', ax=None, **kwargs)

将数组中的数据点绘制为轴上的棒状标识。

参数：a：向量

1维的观察数组。

height：标量, 可选

以比例形式表示的坐标轴上棒状标识的高度。

axis：{‘x’ | ‘y’}, 可选

需要画rugplot的坐标轴

ax：matplotlib 轴, 可选

进行绘制的坐标轴; 未指定的话设定为当前轴。

kwargs：键值对

被传递给LineCollection的其他关键字参数。

返回值：ax：matplotlib Axex对象

在其上进行绘图的Axex对象。

seaborn.lmplot

seaborn.lmplot(x, y, data, hue=None, col=None, row=None, palette=None, col_wrap=None, height=5, aspect=1, markers='o', sharex=True, sharey=True, hue_order=None, col_order=None, row_order=None, legend=True, legend_out=True, x_estimator=None, x_bins=None, x_ci='ci', scatter=True, fit_reg=True, ci=95, n_boot=1000, units=None, order=1, logistic=False, lowess=False, robust=False, logx=False, x_partial=None, y_partial=None, truncate=False, x_jitter=None, y_jitter=None, scatter_kws=None, line_kws=None, size=None)

在FacetGrid对象上绘制数据和回归模型。

这个函数结合了 regplot() 和 FacetGrid。 它预期作为一个能够将回归模型运用在数据集处于不同条件下的子数据集的方便的接口

在考虑如何将变量分配到不同方面时，一般规则是使用 hue 进行最重要的比较，然后使用 col 和 row。 但是，请始终考虑您的特定数据集以及您正在创建的可视化目标。

估算回归模型有许多互斥的选项。

此函数的参数涵盖了 FacetGrid中的大多数选项，尽管这样，偶尔还是会出现您需要直接使用该类和 regplot() 的情况。

参数：x, y：字符串，可选

输入变量; 这些应该是data中的列名。

data：DataFrame

Tidy (“long-form”)格式的DataFrame，其中每列为一个变量，每行为一个观测样本。

hue, col, row：字符串

定义数据子集的变量，将在网格中的不同构面上绘制。 请参阅* _order参数以控制此变量的级别顺序。

palette： 调色板名称，列表或字典，可选

用于hue变量的不同级别的颜色。 应该是 color_palette()可以解释的东西，或者是将色调级别映射到matplotlib颜色的字典。

col_wrap：整数，可选

以此宽度“包裹”列变量，以便列分面（facet）跨越多行。 与row 分面（facet）不兼容。

height： 标量，可选

每个分面（facet）的高度（以英寸为单位）。 另见：aspect。

aspect：标量，可选

每个分面（facet）的纵横比，因此aspect * height给出每个分面（facet）的宽度，单位为英寸。

markers：matplotlib标记代码或标记代码列表，可选

散点图的标记。如果是列表，列表中的每个标记将用于hue变量的每个级别。

share{x,y}：布尔值，‘col’,或 ‘row’ ，可选

如果为true，则分面（facet）之间将跨列共享y轴和/或跨行共享x轴。

{hue,col,row}_order：列表，可选

分面变量的级别顺序。在默认情况下，这将是级别在“data”中出现的顺序，或者，如果变量是pandas的分类类别变量，则为类别的顺序。

legend：布尔值，可选

如果为“True”并且有一个hue变量，则添加一个图例。

legend_out：布尔值，可选

如果为“True”，图形尺寸将被扩展，图例将被绘制在图像中部右侧之外。

x_estimator：可调用的映射向量->标量，可选

将此函数应用于x的每个唯一值并绘制结果的估计值。当x是离散变量时，这是十分有用的。如果给出x_ci，则该估计将被引导并且将绘制置信区间。

x_bins：整数或向量，可选

将x变量加入离散区间，然后估计中心趋势和置信区间。 此分箱仅影响散点图的绘制方式; 回归仍然适合原始数据。该参数被解释为均匀大小（不必要间隔）的箱的数量或箱中心的位置。使用此参数时，它意味着x_estimator的默认值为numpy.mean。

x_ci：“ci”。“sd”， 在[0,100]间的整数或None，可选

绘制“x”离散值的集中趋势时使用的置信区间的大小。 如果为“ci”，遵循ci参数的值。 如果是“sd”，则跳过bootstrapping并显示每个bin中观察值的标准偏差。

scatter：布尔值，可选

如果为 True，则绘制带有基础观测值（或x_estimator 值）的散点图。

fit_reg：布尔值，可选

如果为 True，则估计并绘制与 x 和 y 变量相关的回归模型。

ci：在[0,100]间的整数或None，可选

回归估计的置信区间的大小。这将使用回归线周围的半透明带绘制。 使用自助法（bootstrap）估计置信区间; 对于大型数据集，建议通过将此参数设置为None来避免该计算。

n_boot：整数，可选

用于估计ci的自助法（bootstrap）重采样数。 默认值试图在时间和稳定性之间找到平衡; 你可能希望为“最终”版本的图像增加此值。

units：data中的变量名，可选

如果x和y观察结果嵌套在采样单元中，则可以在此处指定。在通过对所有的单元和观察样本（在单元内）执行重新采样的多级自助法（multilevel bootstrap）来计算置信区间时将考虑这一点。 否则，这不会影响估计或绘制回归的方式。

order：整数，可选

如果order大于1，使用numpy.polyfit来估计多项式回归。

logistic：布尔值，可选

如果为“True”，则假设y是二元变量并使用statsmodels来估计逻辑回归模型。 请注意，这比线性回归的计算密集程度要大得多，因此您可能希望减少引导程序重新采样（n_boot）的数量或将 ci设置为“无”。

lowess：布尔值，可选

如果为“True”，则使用statsmodels来估计非参数lowess模型（局部加权线性回归）。 请注意，目前无法为此类模型绘制置信区间。

robust：布尔值，可选

如果为“True”，则使用statsmodels来估计稳健回归。 这将削弱异常值。 请注意，这比标准线性回归的计算密集程度要大得多，因此您可能希望减少引导程序重新采样（n_boot）的数量或将 ci设置为“无”。

logx：布尔值，可选

如果为 True，则估计形式y~log（x）的线性回归，但在输入空间中绘制散点图和回归模型。 请注意，x必须为正才能正常工作。

{x,y}_partial： data中的字符串或矩阵

混淆（Confounding）变量以在绘图之前退回x或y变量。

truncate：布尔值，可选

默认情况下，绘制回归线以在绘制散点图后填充x轴限制。 如果truncate是True，它将改为受到数据本身限制的限制。

{x,y}_jitter：浮点数，可选

将此大小的均匀随机噪声添加到“x”或“y”变量中。 在拟合回归之后，噪声被添加到数据的副本中，并且仅影响散点图的外观。 在绘制采用离散值的变量时，这会很有用。

{scatter,line}_kws：字典

传递给plt.scatter和plt.plot的附加关键字参数。

也可以查看

绘制数据和条件模型fit.Subplot网格用于绘制条件关系。合并 regplot() 和 PairGrid （与kind =“reg”一起使用时）。

注意

regplot() 与 lmplot() 函数是紧密关联的，但是前者是一个坐标轴级别的函数，而后者则是一个联合了regplot() 与 FacetGrid的图像级别的函数。

示例

绘制两个变量之间的简单线性关系：

>>> import seaborn as sns; sns.set(color_codes=True)
>>> tips = sns.load_dataset("tips")
>>> g = sns.lmplot(x="total_bill", y="tip", data=tips)

条件在第三个变量上并绘制不同颜色的水平：

>>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips)

使用不同的标记和颜色，以便绘图更容易再现为黑白：

>>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips,
...                markers=["o", "x"])

使用不同的调色板：

>>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips,
...                palette="Set1")

使用字典将hue级别映射到颜色：

>>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips,
...                palette=dict(Yes="g", No="m"))

绘制不同列中第三个变量的级别：

>>> g = sns.lmplot(x="total_bill", y="tip", col="smoker", data=tips)

更改构面的高度和纵横比：

>>> g = sns.lmplot(x="size", y="total_bill", hue="day", col="day",
...                data=tips, height=6, aspect=.4, x_jitter=.1)

将列变量的级别换行为多行：

>>> g = sns.lmplot(x="total_bill", y="tip", col="day", hue="day",
...                data=tips, col_wrap=2, height=3)

两个变量上的条件形成一个完整的网格：

>>> g = sns.lmplot(x="total_bill", y="tip", row="sex", col="time",
...                data=tips, height=3)

在返回的 FacetGrid 实例上使用方法来进一步调整图像：

>>> g = sns.lmplot(x="total_bill", y="tip", row="sex", col="time",
...                data=tips, height=3)
>>> g = (g.set_axis_labels("Total bill (US Dollars)", "Tip")
...       .set(xlim=(0, 60), ylim=(0, 12),
...            xticks=[10, 30, 50], yticks=[2, 6, 10])
...       .fig.subplots_adjust(wspace=.02))

seaborn.regplot

seaborn.regplot(x, y, data=None, x_estimator=None, x_bins=None, x_ci='ci', scatter=True, fit_reg=True, ci=95, n_boot=1000, units=None, order=1, logistic=False, lowess=False, robust=False, logx=False, x_partial=None, y_partial=None, truncate=False, dropna=True, x_jitter=None, y_jitter=None, label=None, color=None, marker='o', scatter_kws=None, line_kws=None, ax=None)

绘制数据和线性回归模型拟合。

估算回归模型有许多互斥的选项。

参数：x，y：字符串，序列（series）或者是向量数组（vector array）

输入变量。 如果是字符串，应该与data中的列名相对应。 使用pandas对象时，轴将被Series的名字标记。

data：DataFrame

Tidy (“long-form”)格式的DataFrame，其中每列为一个变量，每行为一个观测样本。

x_estimator：可调用的映射向量 ->标量，可选

将此函数应用于x的每个唯一值并绘制结果的估计值。当x是离散变量时，这是十分有用的。如果给出x_ci，则该估计将被引导并且将绘制置信区间。

x_bins：整数或向量，可选

将x变量加入离散区间，然后估计中心趋势和置信区间。 此分箱仅影响散点图的绘制方式; 回归仍然适合原始数据。该参数被解释为均匀大小（不必要间隔）的箱的数量或箱中心的位置。使用此参数时，它意味着x_estimator的默认值为numpy.mean。

x_ci：”ci”，’sd’，位于 [0, 100]之间的整数或None，可选

绘制“x”离散值的集中趋势时使用的置信区间的大小。 如果为“ci”，遵循ci参数的值。 如果是“sd”，则跳过bootstrapping并显示每个bin中观察值的标准偏差。

scatter：布尔值，可选

如果为 True，则绘制带有基础观测值（或x_estimator 值）的散点图。

fit_reg：布尔值，可选

如果为 True，则估计并绘制与 x 和 y 变量相关的回归模型。

ci：位于 [0, 100]之间的整数或None，可选

回归估计的置信区间的大小。这将使用回归线周围的半透明带绘制。 使用自助法（bootstrap）估计置信区间; 对于大型数据集，建议通过将此参数设置为None来避免该计算。

n_boot：整数，可选

用于估计ci的自助法（bootstrap）重采样数。 默认值试图在时间和稳定性之间找到平衡; 你可能希望为“最终”版本的图像增加此值。

units： data,中的变量名，可选

如果x和y观察结果嵌套在采样单元中，则可以在此处指定。在通过对所有的单元和观察样本（在单元内）执行重新采样的多级自助法（multilevel bootstrap）来计算置信区间时将考虑这一点。 否则，这不会影响估计或绘制回归的方式。

order：整数，可选

如果order大于1，使用numpy.polyfit来估计多项式回归。

logistic：布尔值，可选

如果为“True”，则假设y是二元变量并使用statsmodels来估计逻辑回归模型。 请注意，这比线性回归的计算密集程度要大得多，因此您可能希望减少引导程序重新采样（n_boot）的数量或将 ci设置为“无”。

lowess：布尔值，可选

如果为“True”，则使用statsmodels来估计非参数lowess模型（局部加权线性回归）。 请注意，目前无法为此类模型绘制置信区间。

robust：布尔值，可选

如果为“True”，则使用statsmodels来估计稳健回归。 这将削弱异常值。 请注意，这比标准线性回归的计算密集程度要大得多，因此您可能希望减少引导程序重新采样（n_boot）的数量或将 ci设置为“无”。

logx：布尔值，可选

如果为 True，则估计形式y~log（x）的线性回归，但在输入空间中绘制散点图和回归模型。 请注意，x必须为正才能正常工作。

{x,y}_partial： data 中的字符串或矩阵

混淆（Confounding）变量以在绘图之前退回x或y变量。

truncate：布尔值，可选

默认情况下，绘制回归线以在绘制散点图后填充x轴限制。 如果truncate是True，它将改为受到数据本身限制的限制。

{x,y}_jitter：浮点数，可选

将此大小的均匀随机噪声添加到“x”或“y”变量中。 在拟合回归之后，噪声被添加到数据的副本中，并且仅影响散点图的外观。 在绘制采用离散值的变量时，这会很有用。

label：字符串

要应用于散点图或回归线（如果scatter为’False`）的标签，以便在图例中使用。

color：matplotlib 颜色

适用于所有绘图元素的颜色; 将被scatter_kws或line_kws中传递的颜色取代。

marker：matplotlib标记代码或标记代码列表，可选

散点图的标记。

{scatter,line}_kws：字典

传递给plt.scatter和plt.plot的附加关键字参数。

ax：matplotlib Axes对象，可选

绘制到指定轴对象，否则在当前轴对象上绘图。

返回值：ax：matplotlib Axes对象

包含了图像的Axes对象。

也可以看看

结合 regplot() 和 FacetGrid 来绘制数据集中的多个线性关系。 结合 regplot() 和 JointGrid （与kind="reg"一起使用时）。结合 regplot() 和 PairGrid （当用于kind =“reg”）。绘制线性回归模型的残差。

注意

regplot() 和 lmplot() 函数密切相关，但是前者是坐标轴级别的函数，而后者是结合了regplot() 和 FacetGrid的图像级别的函数。

通过 jointplot() 和 pairplot() 函数来组合 regplot() 和 JointGrid 或 PairGrid 是十分容易的，虽然这些函数不直接接受所有 regplot()的参数。

例子

绘制DataFrame中两个变量之间的关系：

>>> import seaborn as sns; sns.set(color_codes=True)
>>> tips = sns.load_dataset("tips")
>>> ax = sns.regplot(x="total_bill", y="tip", data=tips)

利用两个定义为numpy数组的变量进行绘图; 使用不同的颜色：

>>> import numpy as np; np.random.seed(8)
>>> mean, cov = [4, 6], [(1.5, .7), (.7, 1)]
>>> x, y = np.random.multivariate_normal(mean, cov, 80).T
>>> ax = sns.regplot(x=x, y=y, color="g")

利用两个定义为pandas Series的变量来进行绘图; 使用不同的标记：

>>> import pandas as pd
>>> x, y = pd.Series(x, name="x_var"), pd.Series(y, name="y_var")
>>> ax = sns.regplot(x=x, y=y, marker="+")

使用68％置信区间，该区间对应于估计的标准误差：

>>> ax = sns.regplot(x=x, y=y, ci=68)

使用离散的x变量进行绘图并添加一些抖动：

>>> ax = sns.regplot(x="size", y="total_bill", data=tips, x_jitter=.1)

绘制一个离散的x变量，显示唯一值的均值和置信区间：

>>> ax = sns.regplot(x="size", y="total_bill", data=tips,
...                  x_estimator=np.mean)

将连续的变量划分为分离的区间并进行绘图：

>>> ax = sns.regplot(x=x, y=y, x_bins=4)

拟合高阶多项式回归并截断模型预测：

>>> ans = sns.load_dataset("anscombe")
>>> ax = sns.regplot(x="x", y="y", data=ans.loc[ans.dataset == "II"],
...                  scatter_kws={"s": 80},
...                  order=2, ci=None, truncate=True)

拟合稳健回归并且不绘制置信区间：

>>> ax = sns.regplot(x="x", y="y", data=ans.loc[ans.dataset == "III"],
...                  scatter_kws={"s": 80},
...                  robust=True, ci=None)

对数据运用逻辑回归; 抖动y变量并使用较少的bootstrap迭代：

>>> tips["big_tip"] = (tips.tip / tips.total_bill) > .175
>>> ax = sns.regplot(x="total_bill", y="big_tip", data=tips,
...                  logistic=True, n_boot=500, y_jitter=.03)

使用 log(x) 拟合回归模型并截断模型预测：

>>> ax = sns.regplot(x="size", y="total_bill", data=tips,
...                  x_estimator=np.mean, logx=True, truncate=True)

seaborn.residplot

seaborn.residplot(x, y, data=None, lowess=False, x_partial=None, y_partial=None, order=1, robust=False, dropna=True, label=None, color=None, scatter_kws=None, line_kws=None, ax=None)

绘制线性回归的残差。

此函数将在x上回归y（可能作为鲁棒或多项式回归），然后绘制残差的散点图。 你可以选择将局部加权回归散点平滑法（LOWESS）拟合到残差图，这有助于确定残差是否存在结构。

参数：x： 向量或字符串

预测变量数据中的数据或列名称。

y：向量或字符串

响应变量的数据中的数据或列名称。

data：DataFrame, 可选

如果 x 和 y 是列名，则指定使用的DataFrame

lowess： 布尔值, 可选

将局部加权回归散点平滑法（LOWESS）应用到残差散点图中。

{x, y}_partial：矩阵或字符串，可选

具有与x相同的第一维的矩阵或数据中的列名称。这些变量被视为有误的，并在绘制之前从x或y变量中删除。

order：整数，可选

计算残差时拟合多项式的阶数。

robust：布尔值，可选

在计算残差时拟合稳健的线性回归。

dropna：布尔值，可选

如果为True，则在拟合和绘图时忽略缺少的数据。

label：字符串，可选

将在任何图的图例中使用的标签。

color：matplotlib 颜色，可选

用于绘图的所有元素的颜色。

{scatter, line}_kws： 字典，可选

用于绘制图像的组件而传递给 scatter() 和 plot() 的其他关键字参数。

ax：matplotlib轴，可选

绘制到指定轴对象，否则在当前轴对象上绘图，如果轴不存在则创建一个新轴。

返回值：ax：matplotlib Axes对象

带有回归图像的轴对象

也可以看看

regplot

绘制一个简单的线性回归模型

jointplot

边际分布。

seaborn.heatmap

seaborn.heatmap(data, vmin=None, vmax=None, cmap=None, center=None, robust=False, annot=None, fmt='.2g', annot_kws=None, linewidths=0, linecolor='white', cbar=True, cbar_kws=None, cbar_ax=None, square=False, xticklabels='auto', yticklabels='auto', mask=None, ax=None, **kwargs)

将矩形数据绘制为颜色编码矩阵。

这是一个坐标轴级的函数，如果没有提供给ax参数，它会将热力图绘制到当前活动的轴中。除非cbar为False或为cbar_ax提供单独的Axes，否则将使用此轴空间的一部分绘制颜色图。

参数：data：矩形数据集

可以强制转换为ndarray格式数据的2维数据集。如果提供了Pandas DataFrame数据，索引/列信息将用于标记列和行。

vmin, vmax：浮点型数据，可选参数。

用于锚定色彩映射的值，否则它们是从数据和其他关键字参数推断出来的。

cmap：matplotlib 颜色条名称或者对象，或者是颜色列表，可选参数。

从数据值到颜色空间的映射。 如果没有提供，默认值将取决于是否设置了“center”。

center：浮点数，可选参数。

绘制有色数据时将色彩映射居中的值。 如果没有指定，则使用此参数将更改默认的cmap。

robust：布尔值，可选参数。

如果是True，并且vmin或vmax为空，则使用稳健分位数而不是极值来计算色彩映射范围。

annot:布尔值或者矩形数据，可选参数。

如果为True，则在每个热力图单元格中写入数据值。 如果数组的形状与data相同，则使用它来代替原始数据注释热力图。

fmt：字符串，可选参数。

添加注释时要使用的字符串格式代码。

annot_kws：字典或者键值对，可选参数。

当annot为True时，ax.text的关键字参数。

linewidths：浮点数，可选参数。

划分每个单元格的行的宽度。

linecolor：颜色，可选参数

划分每个单元的线条的颜色。

cbar：布尔值，可选参数。

描述是否绘制颜色条。

cbar_kws：字典或者键值对，可选参数。

fig.colorbar的关键字参数。

cbar_ax：matplotlib Axes，可选参数。

用于绘制颜色条的轴，否则从主轴获取。

square：布尔值，可选参数。

如果为True，则将坐标轴方向设置为“equal”，以使每个单元格为方形。

xticklabels, yticklabels：“auto”，布尔值，类列表值，或者整形数值，可选参数。

如果为True，则绘制数据框的列名称。如果为False，则不绘制列名称。如果是列表，则将这些替代标签绘制为xticklabels。如果是整数，则使用列名称，但仅绘制每个n标签。如果是“auto”，将尝试密集绘制不重叠的标签。

mask：布尔数组或者DataFrame数据，可选参数。

如果为空值，数据将不会显示在mask为True的单元格中。 具有缺失值的单元格将自动被屏蔽。

ax：matplotlib Axes，可选参数。

绘制图的坐标轴，否则使用当前活动的坐标轴。

kwargs：其他关键字参数。

所有其他关键字参数都传递给ax.pcolormesh。

返回值：ax：matplotlib Axes

热力图的轴对象。

另请参见

clustermap

使用分层聚类绘制矩阵以排列行和列。

范例

为numpy数组绘制热力图：

>>> import numpy as np; np.random.seed(0)
>>> import seaborn as sns; sns.set()
>>> uniform_data = np.random.rand(10, 12)
>>> ax = sns.heatmap(uniform_data)

更改默认的colormap范围：

>>> ax = sns.heatmap(uniform_data, vmin=0, vmax=1)

使用发散色图绘制以0为中心的数据的热力图：

>>> normal_data = np.random.randn(10, 12)
>>> ax = sns.heatmap(normal_data, center=0)

使用特定的行和列标签绘制dataframe：

>>> flights = sns.load_dataset("flights")
>>> flights = flights.pivot("month", "year", "passengers")
>>> ax = sns.heatmap(flights)

使用整数格式的数字值注释每个小单元格：

>>> ax = sns.heatmap(flights, annot=True, fmt="d")

在每个单元格之间添加线：

>>> ax = sns.heatmap(flights, linewidths=.5)

使用不同的colormap：

>>> ax = sns.heatmap(flights, cmap="YlGnBu")

将colormap置于特定值的中心：

>>> ax = sns.heatmap(flights, center=flights.loc["January", 1955])

绘制每个其他列标签，而不绘制行标签：

>>> data = np.random.randn(50, 20)
>>> ax = sns.heatmap(data, xticklabels=2, yticklabels=False)

不绘制颜色条：

>>> ax = sns.heatmap(flights, cbar=False)

在不同的坐标轴方向绘制颜色条：

>>> grid_kws = {"height_ratios": (.9, .05), "hspace": .3}
>>> f, (ax, cbar_ax) = plt.subplots(2, gridspec_kw=grid_kws)
>>> ax = sns.heatmap(flights, ax=ax,
...                  cbar_ax=cbar_ax,
...                  cbar_kws={"orientation": "horizontal"})

使用遮罩绘制矩阵中的一部分

>>> corr = np.corrcoef(np.random.randn(10, 200))
>>> mask = np.zeros_like(corr)
>>> mask[np.triu_indices_from(mask)] = True
>>> with sns.axes_style("white"):
...     ax = sns.heatmap(corr, mask=mask, vmax=.3, square=True)

seaborn.clustermap

seaborn.clustermap(data, pivot_kws=None, method='average', metric='euclidean', z_score=None, standard_scale=None, figsize=None, cbar_kws=None, row_cluster=True, col_cluster=True, row_linkage=None, col_linkage=None, row_colors=None, col_colors=None, mask=None, **kwargs)

Plot a matrix dataset as a hierarchically-clustered heatmap.

参数：data：2D array-like

Rectangular data for clustering. Cannot contain NAs.

pivot_kws：dict, optional

If data is a tidy dataframe, can provide keyword arguments for pivot to create a rectangular dataframe.

method：str, optional

Linkage method to use for calculating clusters. See scipy.cluster.hierarchy.linkage documentation for more information: https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.hierarchy.linkage.html

metric：str, optional

Distance metric to use for the data. See scipy.spatial.distance.pdist documentation for more options https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html To use different metrics (or methods) for rows and columns, you may construct each linkage matrix yourself and provide them as {row,col}_linkage.

z_score：int or None, optional

Either 0 (rows) or 1 (columns). Whether or not to calculate z-scores for the rows or the columns. Z scores are: z = (x - mean)/std, so values in each row (column) will get the mean of the row (column) subtracted, then divided by the standard deviation of the row (column). This ensures that each row (column) has mean of 0 and variance of 1.

standard_scale：int or None, optional

Either 0 (rows) or 1 (columns). Whether or not to standardize that dimension, meaning for each row or column, subtract the minimum and divide each by its maximum.

figsize: tuple of two ints, optional

Size of the figure to create.

cbar_kws：dict, optional

Keyword arguments to pass to cbar_kws in heatmap, e.g. to add a label to the colorbar.

{row,col}_cluster：bool, optional

If True, cluster the {rows, columns}.

{row,col}_linkage：numpy.array, optional

Precomputed linkage matrix for the rows or columns. See scipy.cluster.hierarchy.linkage for specific formats.

{row,col}_colors：list-like or pandas DataFrame/Series, optional

List of colors to label for either the rows or columns. Useful to evaluate whether samples within a group are clustered together. Can use nested lists or DataFrame for multiple color levels of labeling. If given as a DataFrame or Series, labels for the colors are extracted from the DataFrames column names or from the name of the Series. DataFrame/Series colors are also matched to the data by their index, ensuring colors are drawn in the correct order.

mask：boolean array or DataFrame, optional

If passed, data will not be shown in cells where mask is True. Cells with missing values are automatically masked. Only used for visualizing, not for calculating.

kwargs：other keyword arguments

All other keyword arguments are passed to sns.heatmap

返回值：clustergrid：ClusterGrid

A ClusterGrid instance.

Notes

The returned object has a savefig method that should be used if you want to save the figure object without clipping the dendrograms.

To access the reordered row indices, use: clustergrid.dendrogram_row.reordered_ind

Column indices, use: clustergrid.dendrogram_col.reordered_ind

Examples

Plot a clustered heatmap:

>>> import seaborn as sns; sns.set(color_codes=True)
>>> iris = sns.load_dataset("iris")
>>> species = iris.pop("species")
>>> g = sns.clustermap(iris)

Use a different similarity metric:

>>> g = sns.clustermap(iris, metric="correlation")

Use a different clustering method:

>>> g = sns.clustermap(iris, method="single")

Use a different colormap and ignore outliers in colormap limits:

>>> g = sns.clustermap(iris, cmap="mako", robust=True)

Change the size of the figure:

>>> g = sns.clustermap(iris, figsize=(6, 7))

Plot one of the axes in its original organization:

>>> g = sns.clustermap(iris, col_cluster=False)

Add colored labels:

>>> lut = dict(zip(species.unique(), "rbg"))
>>> row_colors = species.map(lut)
>>> g = sns.clustermap(iris, row_colors=row_colors)

Standardize the data within the columns:

>>> g = sns.clustermap(iris, standard_scale=1)

Normalize the data within the rows:

>>> g = sns.clustermap(iris, z_score=0)

seaborn.FacetGrid

pyclass seaborn.FacetGrid(data, row=None, col=None, hue=None, col_wrap=None, sharex=True, sharey=True, height=3, aspect=1, palette=None, row_order=None, col_order=None, hue_order=None, hue_kws=None, dropna=True, legend_out=True, despine=True, margin_titles=False, xlim=None, ylim=None, subplot_kws=None, gridspec_kws=None, size=None)

用于绘制条件关系的多图网格。

__init__(data, row=None, col=None, hue=None, col_wrap=None, sharex=True, sharey=True, height=3, aspect=1, palette=None, row_order=None, col_order=None, hue_order=None, hue_kws=None, dropna=True, legend_out=True, despine=True, margin_titles=False, xlim=None, ylim=None, subplot_kws=None, gridspec_kws=None, size=None)

初始化matplotlib画布和FacetGrid对象。

该类将数据集映射到由行和列组成的网格中的多个轴上，这些轴与数据集中变量的级别对应。它产生的图通常被称为“lattice”，“trellis”或“small-multiple”图形。

它还可以用hue参数表示第三个变量的级别，该参数绘制不同颜色的不同数据子集。它使用颜色来解析第三维度上的元素，但是只绘制相互重叠的子集，并且不会像接受“hue”的坐标轴级函数那样为特定的可视化定制“hue”参数。

当使用从数据集推断语义映射的seaborn函数时，必须注意在各个方面之间同步这些映射。在大多数情况下，使用图形级函数（例如relplot()或catplot()）比直接使用FacetGrid更好。

基本工作流程是使用数据集和用于构造网格的变量初始化FacetGrid对象。然后，通过调用FacetGrid.map()或FacetGrid.map_dataframe()，可以将一个或多个绘图函数应用于每个子集。最后，可以使用其他方法调整绘图，以执行更改轴标签、使用不同刻度或添加图例等操作。有关详细信息，请参阅下面的详细代码示例。

参数：data：DataFrame数据。

整洁的（“长形式”）dataframe数据，其中每一列是一个变量，每一行是一个观察实例。

row, col, hue：字符串。

定义数据子集的变量，这些变量将在网格的不同方面绘制。请参阅*_order参数以控制此变量的级别顺序。

col_wrap：整形数值，可选参数。

以此参数值来限制网格的列维度，以便列面跨越多行。与row面不兼容。

share{x,y}：布尔值，’col’ 或 ‘row’可选

如果为true，则跨列共享y轴或者跨行共享x轴。

height：标量，可选参数。

每个图片的高度设定（以英寸为单位）。另见：aspect

aspect：标量，可选参数。

每个图片的纵横比，因此aspect * height给出每个图片的宽度，单位为英寸。

palette：调色板名称，列表或字典，可选参数。

用于色调变量的不同级别的颜色。应为color_palette()可以解释的参数，或者是将色调级别映射到matplotlib颜色的字典。

{row,col,hue}_order：列表，可选参数。

对所给命令级别进行排序。默认情况下，这将是在数据中显示的级别，或者，如果变量是pandas分类，则为类别顺序。

hue_kws：参数-列表值的映射字典

插入到绘图调用中的其他关键字参数，使得其他绘图属性在色调变量的级别上有所不同（例如散点图中的标记）。

legend_out：布尔值，可选参数。

如果为True，则图形尺寸将被扩展，图例将绘制在中间右侧的图形之外。

despine：布尔值，可选参数。

从图中移除顶部和右侧边缘框架。

margin_titles：布尔值，可选参数。

如果为True，则行变量的标题将绘制在最后一列的右侧。此选项是实验性的，可能无法在所有情况下使用。

{x, y}lim：元组，可选参数。

每个图片上每个轴的限制（仅当share {x，y}为True时才相关）。

subplot_kws：字典，可选参数。

传递给matplotlib subplot（s）方法的关键字参数字典。

gridspec_kws：字典，可选参数。

传递给matplotlib的gridspec模块（通过plt.subplots）的关键字参数字典。需要matplotlib> = 1.4，如果col_wrap不是None，则忽略它。

另请参见

用于绘制成对关系的子图网格。

relplot

结合关系图和FacetGrid。

catplot

结合分类图和FacetGrid。

lmplot

结合回归图和FacetGrid。

范例

使用tips数据集初始化2x2网格图：

>>> import seaborn as sns; sns.set(style="ticks", color_codes=True)
>>> tips = sns.load_dataset("tips")
>>> g = sns.FacetGrid(tips, col="time", row="smoker")

在每个子图绘制一个单变量图：

>>> import matplotlib.pyplot as plt
>>> g = sns.FacetGrid(tips, col="time",  row="smoker")
>>> g = g.map(plt.hist, "total_bill")

（注意，没有必要重新捕获返回的变量;它是相同的对象，但在示例中这样做使得处理doctests更加方便）。

将其他关键字参数传递给映射函数：

>>> import numpy as np
>>> bins = np.arange(0, 65, 5)
>>> g = sns.FacetGrid(tips, col="time",  row="smoker")
>>> g = g.map(plt.hist, "total_bill", bins=bins, color="r")

在每个子图绘制一个双变量函数：

>>> g = sns.FacetGrid(tips, col="time",  row="smoker")
>>> g = g.map(plt.scatter, "total_bill", "tip", edgecolor="w")

将其中一个变量分配给绘图元素的颜色：

>>> g = sns.FacetGrid(tips, col="time",  hue="smoker")
>>> g = (g.map(plt.scatter, "total_bill", "tip", edgecolor="w")
...       .add_legend())

更改每个子图的高度和纵横比：

>>> g = sns.FacetGrid(tips, col="day", height=4, aspect=.5)
>>> g = g.map(plt.hist, "total_bill", bins=bins)

指定绘图元素的顺序：

>>> g = sns.FacetGrid(tips, col="smoker", col_order=["Yes", "No"])
>>> g = g.map(plt.hist, "total_bill", bins=bins, color="m")

使用不同的调色板：

>>> kws = dict(s=50, linewidth=.5, edgecolor="w")
>>> g = sns.FacetGrid(tips, col="sex", hue="time", palette="Set1",
...                   hue_order=["Dinner", "Lunch"])
>>> g = (g.map(plt.scatter, "total_bill", "tip", **kws)
...      .add_legend())

使用字典将色调级别映射到颜色：

>>> pal = dict(Lunch="seagreen", Dinner="gray")
>>> g = sns.FacetGrid(tips, col="sex", hue="time", palette=pal,
...                   hue_order=["Dinner", "Lunch"])
>>> g = (g.map(plt.scatter, "total_bill", "tip", **kws)
...      .add_legend())

另外，为色调级别使用不同的标记：

>>> g = sns.FacetGrid(tips, col="sex", hue="time", palette=pal,
...                   hue_order=["Dinner", "Lunch"],
...                   hue_kws=dict(marker=["^", "v"]))
>>> g = (g.map(plt.scatter, "total_bill", "tip", **kws)
...      .add_legend())

将包含多个级别的列变量“换行”到行中：

>>> att = sns.load_dataset("attention")
>>> g = sns.FacetGrid(att, col="subject", col_wrap=5, height=1.5)
>>> g = g.map(plt.plot, "solutions", "score", marker=".")

定义一个自定义双变量函数来映射到网格：

>>> from scipy import stats
>>> def qqplot(x, y, **kwargs):
...     _, xr = stats.probplot(x, fit=False)
...     _, yr = stats.probplot(y, fit=False)
...     plt.scatter(xr, yr, **kwargs)
>>> g = sns.FacetGrid(tips, col="smoker", hue="sex")
>>> g = (g.map(qqplot, "total_bill", "tip", **kws)
...       .add_legend())

定义一个使用DataFrame对象的自定义函数，并接受列名作为位置变量：

>>> import pandas as pd
>>> df = pd.DataFrame(
...     data=np.random.randn(90, 4),
...     columns=pd.Series(list("ABCD"), name="walk"),
...     index=pd.date_range("2015-01-01", "2015-03-31",
...                         name="date"))
>>> df = df.cumsum(axis=0).stack().reset_index(name="val")
>>> def dateplot(x, y, **kwargs):
...     ax = plt.gca()
...     data = kwargs.pop("data")
...     data.plot(x=x, y=y, ax=ax, grid=False, **kwargs)
>>> g = sns.FacetGrid(df, col="walk", col_wrap=2, height=3.5)
>>> g = g.map_dataframe(dateplot, "date", "val")

绘图后使用不同的轴标签：

>>> g = sns.FacetGrid(tips, col="smoker", row="sex")
>>> g = (g.map(plt.scatter, "total_bill", "tip", color="g", **kws)
...       .set_axis_labels("Total bill (US Dollars)", "Tip"))

设置每个子图共享的其他属性：

>>> g = sns.FacetGrid(tips, col="smoker", row="sex")
>>> g = (g.map(plt.scatter, "total_bill", "tip", color="r", **kws)
...       .set(xlim=(0, 60), ylim=(0, 12),
...            xticks=[10, 30, 50], yticks=[2, 6, 10]))

为子图标题使用不同的模板：

>>> g = sns.FacetGrid(tips, col="size", col_wrap=3)
>>> g = (g.map(plt.hist, "tip", bins=np.arange(0, 13), color="c")
...       .set_titles("{col_name} diners"))

收紧每个子图:

>>> g = sns.FacetGrid(tips, col="smoker", row="sex",
...                   margin_titles=True)
>>> g = (g.map(plt.scatter, "total_bill", "tip", color="m", **kws)
...       .set(xlim=(0, 60), ylim=(0, 12),
...            xticks=[10, 30, 50], yticks=[2, 6, 10])
...       .fig.subplots_adjust(wspace=.05, hspace=.05))

方法

| __init__(data[, row, col, hue, col_wrap, …]) | 初始化matplotlib画布和FacetGrid对象。 |

| add_legend([legend_data, title, label_order]) | 绘制一个图例，可能将其放在轴外并调整图形大小。|

| despine(**kwargs) | 从子图中移除轴的边缘框架。 |

| facet_axis(row_i, col_j) | 使这些索引识别的轴处于活动状态并返回。 |

| facet_data() | 用于每个子图的名称索引和数据子集的生成器。 |

| map(func, args, *kwargs) | 将绘图功能应用于每个子图的数据子集。 |

| map_dataframe(func, args, *kwargs) | 像.map一样，但是将args作为字符串传递并在kwargs中插入数据。 |

| savefig(args, *kwargs) | 保存图片。 |

| set(**kwargs) | 在每个子图集坐标轴上设置属性。|

| set_axis_labels([x_var, y_var]) | 在网格的左列和底行设置轴标签。 |

| set_titles([template, row_template, …]) | 在每个子图上方或网格边缘绘制标题。 |

| set_xlabels([label]) | 在网格的底行标记x轴。 |

| set_xticklabels([labels, step]) | 在网格的底行设置x轴刻度标签。 |

| set_ylabels([label]) | 在网格的左列标记y轴。 |

| set_yticklabels([labels]) | 在网格的左列上设置y轴刻度标签。 |

属性

| ax | 轻松访问单个坐标轴。 |

seaborn.FacetGrid.map

FacetGrid.map(func, *args, **kwargs)

Apply a plotting function to each facet’s subset of the data.

参数：func：callable

A plotting function that takes data and keyword arguments. It must plot to the currently active matplotlib Axes and take a color keyword argument. If faceting on the hue dimension, it must also take a label keyword argument.

args：strings

Column names in self.data that identify variables with data to plot. The data for each variable is passed to func in the order the variables are specified in the call.

kwargs：keyword arguments

All keyword arguments are passed to the plotting function.

返回值：self：object

Returns self.

seaborn.FacetGrid.map_dataframe

FacetGrid.map_dataframe(func, *args, **kwargs)

Like .map but passes args as strings and inserts data in kwargs.

This method is suitable for plotting with functions that accept a long-form DataFrame as a data keyword argument and access the data in that DataFrame using string variable names.

参数：func：callable

A plotting function that takes data and keyword arguments. Unlike the map method, a function used here must “understand” Pandas objects. It also must plot to the currently active matplotlib Axes and take a color keyword argument. If faceting on the hue dimension, it must also take a label keyword argument.

args：strings

Column names in self.data that identify variables with data to plot. The data for each variable is passed to func in the order the variables are specified in the call.

kwargs：keyword arguments

All keyword arguments are passed to the plotting function.

返回值：self：object

Returns self.

seaborn.PairGrid

class seaborn.PairGrid(data, hue=None, hue_order=None, palette=None, hue_kws=None, vars=None, x_vars=None, y_vars=None, diag_sharey=True, height=2.5, aspect=1, despine=True, dropna=True, size=None)

Subplot grid for plotting pairwise relationships in a dataset.

This class maps each variable in a dataset onto a column and row in a grid of multiple axes. Different axes-level plotting functions can be used to draw bivariate plots in the upper and lower triangles, and the the marginal distribution of each variable can be shown on the diagonal.

It can also represent an additional level of conditionalization with the hue parameter, which plots different subets of data in different colors. This uses color to resolve elements on a third dimension, but only draws subsets on top of each other and will not tailor the hue parameter for the specific visualization the way that axes-level functions that accept hue will.

__init__(data, hue=None, hue_order=None, palette=None, hue_kws=None, vars=None, x_vars=None, y_vars=None, diag_sharey=True, height=2.5, aspect=1, despine=True, dropna=True, size=None)

Initialize the plot figure and PairGrid object.

参数：data：DataFrame

Tidy (long-form) dataframe where each column is a variable and each row is an observation.

hue：string (variable name), optional

Variable in data to map plot aspects to different colors.

hue_order：list of strings

Order for the levels of the hue variable in the palette

palette：dict or seaborn color palette

Set of colors for mapping the hue variable. If a dict, keys should be values in the hue variable.

hue_kws：dictionary of param -> list of values mapping

Other keyword arguments to insert into the plotting call to let other plot attributes vary across levels of the hue variable (e.g. the markers in a scatterplot).

vars：list of variable names, optional

Variables within data to use, otherwise use every column with a numeric datatype.

{x, y}_vars：lists of variable names, optional

Variables within data to use separately for the rows and columns of the figure; i.e. to make a non-square plot.

height：scalar, optional

Height (in inches) of each facet.

aspect：scalar, optional

Aspect * height gives the width (in inches) of each facet.

despine：boolean, optional

Remove the top and right spines from the plots.

dropna：boolean, optional

Drop missing values from the data before plotting.

See also

Easily drawing common uses of PairGrid.Subplot grid for plotting conditional relationships.

Examples

Draw a scatterplot for each pairwise relationship:

>>> import matplotlib.pyplot as plt
>>> import seaborn as sns; sns.set()
>>> iris = sns.load_dataset("iris")
>>> g = sns.PairGrid(iris)
>>> g = g.map(plt.scatter)

Show a univariate distribution on the diagonal:

>>> g = sns.PairGrid(iris)
>>> g = g.map_diag(plt.hist)
>>> g = g.map_offdiag(plt.scatter)

(It’s not actually necessary to catch the return value every time, as it is the same object, but it makes it easier to deal with the doctests).

Color the points using a categorical variable:

>>> g = sns.PairGrid(iris, hue="species")
>>> g = g.map_diag(plt.hist)
>>> g = g.map_offdiag(plt.scatter)
>>> g = g.add_legend()

Use a different style to show multiple histograms:

>>> g = sns.PairGrid(iris, hue="species")
>>> g = g.map_diag(plt.hist, histtype="step", linewidth=3)
>>> g = g.map_offdiag(plt.scatter)
>>> g = g.add_legend()

Plot a subset of variables

>>> g = sns.PairGrid(iris, vars=["sepal_length", "sepal_width"])
>>> g = g.map(plt.scatter)

Pass additional keyword arguments to the functions

>>> g = sns.PairGrid(iris)
>>> g = g.map_diag(plt.hist, edgecolor="w")
>>> g = g.map_offdiag(plt.scatter, edgecolor="w", s=40)

Use different variables for the rows and columns:

>>> g = sns.PairGrid(iris,
...                  x_vars=["sepal_length", "sepal_width"],
...                  y_vars=["petal_length", "petal_width"])
>>> g = g.map(plt.scatter)

Use different functions on the upper and lower triangles:

>>> g = sns.PairGrid(iris)
>>> g = g.map_upper(plt.scatter)
>>> g = g.map_lower(sns.kdeplot, cmap="Blues_d")
>>> g = g.map_diag(sns.kdeplot, lw=3, legend=False)

Use different colors and markers for each categorical level:

>>> g = sns.PairGrid(iris, hue="species", palette="Set2",
...                  hue_kws={"marker": ["o", "s", "D"]})
>>> g = g.map(plt.scatter, linewidths=1, edgecolor="w", s=40)
>>> g = g.add_legend()

Methods

| __init__(data[, hue, hue_order, palette, …]) | Initialize the plot figure and PairGrid object. || add_legend([legend_data, title, label_order]) | Draw a legend, maybe placing it outside axes and resizing the figure. || map(func, kwargs) | Plot with the same function in every subplot. || map_diag(func, kwargs) | Plot with a univariate function on each diagonal subplot. || map_lower(func, kwargs) | Plot with a bivariate function on the lower diagonal subplots. || map_offdiag(func, kwargs) | Plot with a bivariate function on the off-diagonal subplots. || map_upper(func, kwargs) | Plot with a bivariate function on the upper diagonal subplots. || savefig(*args, kwargs) | Save the figure. || set(**kwargs) | Set attributes on each subplot Axes. |

seaborn.PairGrid.map

PairGrid.map(func, **kwargs)

Plot with the same function in every subplot.

参数：func：callable plotting function

Must take x, y arrays as positional arguments and draw onto the “currently active” matplotlib Axes. Also needs to accept kwargs called color and label

seaborn.PairGrid.map_diag

PairGrid.map_diag(func, **kwargs)

Plot with a univariate function on each diagonal subplot.

参数：func：callable plotting function

Must take an x array as a positional argument and draw onto the “currently active” matplotlib Axes. Also needs to accept kwargs called color and label.

seaborn.PairGrid.map_offdiag

PairGrid.map_offdiag(func, **kwargs)

Plot with a bivariate function on the off-diagonal subplots.

参数：func：callable plotting function

Must take x, y arrays as positional arguments and draw onto the “currently active” matplotlib Axes. Also needs to accept kwargs called color and label.

seaborn.PairGrid.map_lower

PairGrid.map_lower(func, **kwargs)

Plot with a bivariate function on the lower diagonal subplots.

参数：func：callable plotting function

Must take x, y arrays as positional arguments and draw onto the “currently active” matplotlib Axes. Also needs to accept kwargs called color and label.

seaborn.PairGrid.map_upper

PairGrid.map_upper(func, **kwargs)

Plot with a bivariate function on the upper diagonal subplots.

参数：func：callable plotting function

Must take x, y arrays as positional arguments and draw onto the “currently active” matplotlib Axes. Also needs to accept kwargs called color and label.

seaborn.JointGrid

class seaborn.JointGrid(x, y, data=None, height=6, ratio=5, space=0.2, dropna=True, xlim=None, ylim=None, size=None)

Grid for drawing a bivariate plot with marginal univariate plots.

__init__(x, y, data=None, height=6, ratio=5, space=0.2, dropna=True, xlim=None, ylim=None, size=None)

Set up the grid of subplots.

参数：x, y：strings or vectors

Data or names of variables in data.

data：DataFrame, optional

DataFrame when x and y are variable names.

height：numeric

Size of each side of the figure in inches (it will be square).

ratio：numeric

Ratio of joint axes size to marginal axes height.

space：numeric, optional

Space between the joint and marginal axes

dropna：bool, optional

If True, remove observations that are missing from x and y.

{x, y}lim：two-tuples, optional

Axis limits to set before plotting.

See also

High-level interface for drawing bivariate plots with several different default plot kinds.

Examples

Initialize the figure but don’t draw any plots onto it:

>>> import seaborn as sns; sns.set(style="ticks", color_codes=True)
>>> tips = sns.load_dataset("tips")
>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips)

Add plots using default parameters:

>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips)
>>> g = g.plot(sns.regplot, sns.distplot)

Draw the join and marginal plots separately, which allows finer-level control other parameters:

>>> import matplotlib.pyplot as plt
>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips)
>>> g = g.plot_joint(plt.scatter, color=".5", edgecolor="white")
>>> g = g.plot_marginals(sns.distplot, kde=False, color=".5")

Draw the two marginal plots separately:

>>> import numpy as np
>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips)
>>> g = g.plot_joint(plt.scatter, color="m", edgecolor="white")
>>> _ = g.ax_marg_x.hist(tips["total_bill"], color="b", alpha=.6,
...                      bins=np.arange(0, 60, 5))
>>> _ = g.ax_marg_y.hist(tips["tip"], color="r", alpha=.6,
...                      orientation="horizontal",
...                      bins=np.arange(0, 12, 1))

Add an annotation with a statistic summarizing the bivariate relationship:

>>> from scipy import stats
>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips)
>>> g = g.plot_joint(plt.scatter,
...                  color="g", s=40, edgecolor="white")
>>> g = g.plot_marginals(sns.distplot, kde=False, color="g")
>>> g = g.annotate(stats.pearsonr)

Use a custom function and formatting for the annotation

>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips)
>>> g = g.plot_joint(plt.scatter,
...                  color="g", s=40, edgecolor="white")
>>> g = g.plot_marginals(sns.distplot, kde=False, color="g")
>>> rsquare = lambda a, b: stats.pearsonr(a, b)[0] ** 2
>>> g = g.annotate(rsquare, template="{stat}: {val:.2f}",
...                stat="$R^2$", loc="upper left", fontsize=12)

Remove the space between the joint and marginal axes:

>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips, space=0)
>>> g = g.plot_joint(sns.kdeplot, cmap="Blues_d")
>>> g = g.plot_marginals(sns.kdeplot, shade=True)

Draw a smaller plot with relatively larger marginal axes:

>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips,
...                   height=5, ratio=2)
>>> g = g.plot_joint(sns.kdeplot, cmap="Reds_d")
>>> g = g.plot_marginals(sns.kdeplot, color="r", shade=True)

Set limits on the axes:

>>> g = sns.JointGrid(x="total_bill", y="tip", data=tips,
...                   xlim=(0, 50), ylim=(0, 8))
>>> g = g.plot_joint(sns.kdeplot, cmap="Purples_d")
>>> g = g.plot_marginals(sns.kdeplot, color="m", shade=True)

Methods

| __init__(x, y[, data, height, ratio, space, …]) | Set up the grid of subplots. || annotate(func[, template, stat, loc]) | Annotate the plot with a statistic about the relationship. || plot(joint_func, marginal_func[, annot_func]) | Shortcut to draw the full plot. || plot_joint(func, kwargs) | Draw a bivariate plot of x and y. || plot_marginals(func, kwargs) | Draw univariate plots for x and y separately. || savefig(args, *kwargs) | Wrap figure.savefig defaulting to tight bounding box. || set_axis_labels([xlabel, ylabel]) | Set the axis labels on the bivariate axes. |

seaborn.JointGrid.plot

JointGrid.plot(joint_func, marginal_func, annot_func=None)

Shortcut to draw the full plot.

Use plot_joint and plot_marginals directly for more control.

参数：joint_func, marginal_func：callables

Functions to draw the bivariate and univariate plots.

返回值：self：JointGrid instance

seaborn.JointGrid.plot_joint

JointGrid.plot_joint(func, **kwargs)

Draw a bivariate plot of x and y.

参数：func：plotting callable

This must take two 1d arrays of data as the first two positional arguments, and it must plot on the “current” axes.

kwargs：key, value mappings

Keyword argument are passed to the plotting function.

返回值：self：JointGrid instance

seaborn.JointGrid.plot_marginals

JointGrid.plot_marginals(func, **kwargs)

Draw univariate plots for x and y separately.

参数：func：plotting callable

This must take a 1d array of data as the first positional argument, it must plot on the “current” axes, and it must accept a “vertical” keyword argument to orient the measure dimension of the plot vertically.

kwargs：key, value mappings

Keyword argument are passed to the plotting function.

返回值：self：JointGrid instance

Returns self.

seaborn.set

seaborn.set(context='notebook', style='darkgrid', palette='deep', font='sans-serif', font_scale=1, color_codes=True, rc=None)

Set aesthetic parameters in one step.

Each set of parameters can be set directly or temporarily, see the referenced functions below for more information.

参数：context：string or dict

Plotting context parameters, see plotting_context()

style：string or dict

Axes style parameters, see axes_style()

palette：string or sequence

Color palette, see color_palette()

font：string

Font family, see matplotlib font manager.

font_scale：float, optional

Separate scaling factor to independently scale the size of the font elements.

color_codes：bool

If True and palette is a seaborn palette, remap the shorthand color codes (e.g. “b”, “g”, “r”, etc.) to the colors from this palette.

rc：dict or None

Dictionary of rc parameter mappings to override the above.

seaborn.axes_style

seaborn.axes_style(style=None, rc=None)

Return a parameter dict for the aesthetic style of the plots.

This affects things like the color of the axes, whether a grid is enabled by default, and other aesthetic elements.

This function returns an object that can be used in a with statement to temporarily change the style parameters.

参数：style：dict, None, or one of {darkgrid, whitegrid, dark, white, ticks}

A dictionary of parameters or the name of a preconfigured set.

rc：dict, optional

Parameter mappings to override the values in the preset seaborn style dictionaries. This only updates parameters that are considered part of the style definition.

See also

set the matplotlib parameters for a seaborn themereturn a parameter dict to to scale plot elementsdefine the color palette for a plot

Examples

>>> st = axes_style("whitegrid")

>>> set_style("ticks", {"xtick.major.size": 8, "ytick.major.size": 8})

>>> import matplotlib.pyplot as plt
>>> with axes_style("white"):
...     f, ax = plt.subplots()
...     ax.plot(x, y)

seaborn.set_style

seaborn.set_style(style=None, rc=None)

Set the aesthetic style of the plots.

This affects things like the color of the axes, whether a grid is enabled by default, and other aesthetic elements.

参数：style：dict, None, or one of {darkgrid, whitegrid, dark, white, ticks}

A dictionary of parameters or the name of a preconfigured set.

rc：dict, optional

Parameter mappings to override the values in the preset seaborn style dictionaries. This only updates parameters that are considered part of the style definition.

See also

return a dict of parameters or use in a with statement to temporarily set the style.set parameters to scale plot elementsset the default color palette for figures

Examples

>>> set_style("whitegrid")
>>> set_style("ticks", {"xtick.major.size": 8, "ytick.major.size": 8})

seaborn.plotting_context

seaborn.plotting_context(context=None, font_scale=1, rc=None)

Return a parameter dict to scale elements of the figure.

This affects things like the size of the labels, lines, and other elements of the plot, but not the overall style. The base context is “notebook”, and the other contexts are “paper”, “talk”, and “poster”, which are version of the notebook parameters scaled by .8, 1.3, and 1.6, respectively.

This function returns an object that can be used in a with statement to temporarily change the context parameters.

参数：context：dict, None, or one of {paper, notebook, talk, poster}

A dictionary of parameters or the name of a preconfigured set.

font_scale：float, optional

Separate scaling factor to independently scale the size of the font elements.

rc：dict, optional

Parameter mappings to override the values in the preset seaborn context dictionaries. This only updates parameters that are considered part of the context definition.

See also

set the matplotlib parameters to scale plot elementsreturn a dict of parameters defining a figure styledefine the color palette for a plot

Examples

>>> c = plotting_context("poster")
>>> c = plotting_context("notebook", font_scale=1.5)
>>> c = plotting_context("talk", rc={"lines.linewidth": 2})
>>> import matplotlib.pyplot as plt
>>> with plotting_context("paper"):
...     f, ax = plt.subplots()
...     ax.plot(x, y)

seaborn.set_context

seaborn.set_context(context=None, font_scale=1, rc=None)

Set the plotting context parameters.

This affects things like the size of the labels, lines, and other elements of the plot, but not the overall style. The base context is “notebook”, and the other contexts are “paper”, “talk”, and “poster”, which are version of the notebook parameters scaled by .8, 1.3, and 1.6, respectively.

参数：context：dict, None, or one of {paper, notebook, talk, poster}

A dictionary of parameters or the name of a preconfigured set.

font_scale：float, optional

Separate scaling factor to independently scale the size of the font elements.

rc：dict, optional

Parameter mappings to override the values in the preset seaborn context dictionaries. This only updates parameters that are considered part of the context definition.

See also

return a dictionary of rc parameters, or use in a with statement to temporarily set the context.set the default parameters for figure styleset the default color palette for figures

Examples

>>> set_context("paper")
>>> set_context("talk", font_scale=1.4)
>>> set_context("talk", rc={"lines.linewidth": 2})

seaborn.set_color_codes

seaborn.set_color_codes(palette='deep')

Change how matplotlib color shorthands are interpreted.

Calling this will change how shorthand codes like “b” or “g” are interpreted by matplotlib in subsequent plots.

参数：palette：{deep, muted, pastel, dark, bright, colorblind}

Named seaborn palette to use as the source of colors.

See also

Color codes can be set through the high-level seaborn style manager.Color codes can also be set through the function that sets the matplotlib color cycle.

Examples

Map matplotlib color codes to the default seaborn palette.

>>> import matplotlib.pyplot as plt
>>> import seaborn as sns; sns.set()
>>> sns.set_color_codes()
>>> _ = plt.plot([0, 1], color="r")

Use a different seaborn palette.

>>> sns.set_color_codes("dark")
>>> _ = plt.plot([0, 1], color="g")
>>> _ = plt.plot([0, 2], color="m")

seaborn.reset_defaults

seaborn.reset_defaults()

Restore all RC params to default settings.

seaborn.reset_orig

seaborn.reset_orig()

Restore all RC params to original settings (respects custom rc).

seaborn.set_palette

seaborn.set_palette(palette, n_colors=None, desat=None, color_codes=False)

通过searborn调色板设置matplotlib色彩循环

参数：palette：seaborn color paltte | matplotlib colormap | hls | husl

调色板参数。 应该可以被 color_palette() 函数处理。

n_colors：int

色彩循环中的颜色数量。默认数量与palette模式有关, 查看color_palette()文档了解更多内容。

desat：float

每种颜色去饱和的比例。

color_codes：bool

如果为True，并且palette是seaborn调色板, 则将颜色代码简写 (例如“b”, “g”, “r”等等)映射到当前调色板上。

另外

在with语句中临时设置调色板或色彩循环。设置参数以调整绘图元素的默认参数。

例子

>>> set_palette("Reds")
>>> set_palette("Set1", 8, .75)

seaborn.color_palette

seaborn.color_palette(palette=None, n_colors=None, desat=None)

返回一个颜色列表来定义一个调色板。

Available seaborn palette names:

有 deep, muted, bright, pastel, dark, colorblind 六种颜色模式

Other options:

matplotlib Colormap 的名字、‘ch:’, ‘hls’, ‘husl’，或任一 matplotlib 接受的不同格式颜色列表。

调用此函数并设置 palette=None 会返回当前 matplotlib 色彩循环。

matplotlib 调色板的顺序可以通过在调色板名称后添加 “_r” 来倒置，同样，添加 “_d” 可以将调色板设置为深色模式。（这些选项为互斥属性，返回的颜色列表同样可以被取反）

可以在 with 语句中使用此函数来为一个或多个点临时改变调色板。

参数：palette：None, string, or sequence, optional

调色板或者 None 值来返回给当前调色板。如果是序列，输入颜色会被使用，可能会被循环化并降低饱和度。

n_colors：int, 可选

调色板中的颜色数。如果为 None，则默认值将取决于调色板的指定方式。已命名调色板默认有 6 种颜色，抓取当前调色板或传递颜色列表不会更改颜色数，除非作出指定。要求比调色板中存在的颜色更多的颜色会导致调色板循环化。

desat：float, 可选

每种颜色的去饱和比例。

返回值：palette：RGB 元组序列。

调色板。操作类似于列表，但可以用作上下文管理器，并具有转换为十六进制颜色代码的 as_hex 方法。

另外

设置所有的默认颜色循环。重新分配颜色代码，如 “b”、“g” 等。从seaborn 调色板中选择颜色。

例子

不带参数的调用将返回当前默认颜色循环中的所有颜色：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.color_palette())

显示另一个 “seaborn 调色板”，具有与默认 matplotlib 颜色循环相同的基本色调顺序，但颜色更吸引人。默认情况下，使用调色板名称进行调用将返回6种颜色：

>>> sns.palplot(sns.color_palette("muted"))

使用一个内置 matplotlib clolormap 的离散值：

>>> sns.palplot(sns.color_palette("RdBu", n_colors=7))

创建自定义 cubehelix 调色板：

>>> sns.palplot(sns.color_palette("ch:2.5,-.2,dark=.3"))

使用一个明确的 matplotlib 调色板并降低一些饱和度：

>>> sns.palplot(sns.color_palette("Set1", n_colors=8, desat=.5))

创建 “dark”（深色）matplotlib 顺序调色板变体。(当对应于有序变量的多条线或点进行着色时，如果您不希望最轻的线不可见，则可以使用此选项)：

>>> sns.palplot(sns.color_palette("Blues_d"))

作为上下文管理器使用：

>>> import numpy as np, matplotlib.pyplot as plt
>>> with sns.color_palette("husl", 8):
...    _ = plt.plot(np.c_[np.zeros(8), np.arange(8)].T)

seaborn.husl_palette

seaborn.husl_palette(n_colors=6, h=0.01, s=0.9, l=0.65)

在 HUSL 色调空间中获得一组均匀间隔的颜色。

h, s, 和 l 值应该在 0 和 1 之间。

参数：n_colors：int

调色板中的颜色数

h：float

第一个色调

s：float

饱和度

l：float

亮度

返回值：palette：seaborn 调色板

类似列表的颜色对象的 RGB 元组。

另外

在 HSL 系统中使用等间距圆形色调创建一个调色板。

例子

使用默认参数创建一个有 10 种颜色的调色板：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.husl_palette(10))

创建一个以不同色调值开头的 10 种颜色的调色板：

>>> sns.palplot(sns.husl_palette(10, h=.5))

创建一个比默认颜色更暗的 10 种颜色的调色板：

>>> sns.palplot(sns.husl_palette(10, l=.4))

创建 10 种颜色的调色板，其饱和度低于默认值：

>>> sns.palplot(sns.husl_palette(10, s=.4))

seaborn.hls_palette

seaborn.hls_palette(n_colors=6, h=0.01, l=0.6, s=0.65)

在 HLS 色调空间中获取一组均匀间隔的颜色。

h, s, 和 l 值应该在 0 和 1 之间。

参数：n_colors：int

调色板中的颜色数

h：float

第一个色调

l：float

亮度

s：float

饱和度

返回值：palette：seaborn 调色板

类似列表的颜色对象的 RGB 元组。

另外

在 HUSL 系统中使用等间距圆形色调创建一个调色板。

例子

使用默认参数创建一个有 10 种颜色的调色板：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.hls_palette(10))

创建一个以不同色调值开头的 10 种颜色的调色板：

>>> sns.palplot(sns.hls_palette(10, h=.5))

创建一个比默认颜色更暗的 10 种颜色的调色板：

>>> sns.palplot(sns.hls_palette(10, l=.4))

创建 10 种颜色的调色板，其饱和度低于默认值：

>>> sns.palplot(sns.hls_palette(10, s=.4))

seaborn.cubehelix_palette

seaborn.cubehelix_palette(n_colors=6, start=0, rot=0.4, gamma=1.0, hue=0.8, light=0.85, dark=0.15, reverse=False, as_cmap=False)

用 cubehelix 系统制作顺序调色板。

生成亮度呈线性减小(或增大)的 colormap。这意味着 colormap在转换为黑白模式时(用于打印)的信息将得到保留，且对色盲友好。“cubehelix” 也可以作为基于 matplotlib 的调色板使用，但此函数使用户可以更好地控制调色板的外观，并且具有一组不同的默认值。

除了使用这个函数，还可以在 seaborn 中使用字符串速记生成 cubehelix 调色板。 请参见下面的示例。

参数：n_colors：int

调色板中的颜色数。

start：float, 0 <= start <= 3

第一个色调。

rot：float

围绕调色板范围内的色相控制盘旋转。

gamma：float 0 <= gamma

Gamma 系数用以强调较深 (Gamma < 1) 或较浅 (Gamma > 1) 的颜色。

hue：float, 0 <= hue <= 1

颜色的饱和度。

dark：float 0 <= dark <= 1

调色板中最暗颜色的强度。

light：float 0 <= light <= 1

调色板中最浅颜色的强度。

reverse：bool

如果为 True 值，则调色板将从暗到亮。

as_cmap：bool

如果为 True 值，则返回 matplotlib colormap 而不是颜色列表。

返回值：palette or cmap：seaborn 调色板或者 matplotlib colormap

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

另外

启动交互式小部件以调整 cubehelix 调色板参数。创建具有暗低值的连续调色板。创建具有亮低值的连续调色板。

参考

Green, D. A. (2011). “一种用于显示天文强度图像的配色方案”. Bulletin of the Astromical Society of India, Vol. 39, p. 289-295.

例子

生成默认调色板：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.cubehelix_palette())

从相同的起始位置向后旋转：

>>> sns.palplot(sns.cubehelix_palette(rot=-.4))

使用不同的起点和较短的旋转：

>>> sns.palplot(sns.cubehelix_palette(start=2.8, rot=.1))

反转亮度渐变方向：

>>> sns.palplot(sns.cubehelix_palette(reverse=True))

生成一个 colormap 对象：

>>> from numpy import arange
>>> x = arange(25).reshape(5, 5)
>>> cmap = sns.cubehelix_palette(as_cmap=True)
>>> ax = sns.heatmap(x, cmap=cmap)

使用完整的亮度范围：

>>> cmap = sns.cubehelix_palette(dark=0, light=1, as_cmap=True)
>>> ax = sns.heatmap(x, cmap=cmap)

使用 color_palette() 函数接口：

>>> sns.palplot(sns.color_palette("ch:2,r=.2,l=.6"))

seaborn.dark_palette

seaborn.dark_palette(color, n_colors=6, reverse=False, as_cmap=False, input='rgb')

制作一个混合深色和 color 模式的顺序调色板。

这种调色板适用于数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时。

可以通过多种方式指定 color 参数，包括用于在 matplotlib 中定义颜色的所有选项，以及由 seborn 处理的其他几个颜色空间。也可以使用 XKCD color survey 中的颜色名字数据库。

如果您在使用 IPython notebook，您还可以通过 choose_dark_palette() 函数交互式选择调色板。

参数：color：高值的基色

十六进制、RGB 元组或者颜色名字。

n_colors：int, 可选

调色板中的颜色数。

reverse：bool, 可选

如果为 True 值，则反转混合的方向。

as_cmap：bool, optional

如果为 True 值，则返回 matplotlib colormap 而不是列表。

input：{‘rgb’, ‘hls’, ‘husl’, xkcd’}

用于解释输入颜色的颜色空间。前三个选项适用于元组输入，后者适用于字符串输入。

返回值：palette or cmap：seaborn color palette or matplotlib colormap

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

另外

创建具有暗低值的连续调色板。创建有两种颜色的发散调色板。

例子

从一个 HTML 颜色生成一个调色板：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.dark_palette("purple"))

生成亮度降低的调色板：

>>> sns.palplot(sns.dark_palette("seagreen", reverse=True))

从 HUSL 空间种子生成选项板：

>>> sns.palplot(sns.dark_palette((260, 75, 60), input="husl"))

生成一个 colormap 对象：

>>> from numpy import arange
>>> x = arange(25).reshape(5, 5)
>>> cmap = sns.dark_palette("#2ecc71", as_cmap=True)
>>> ax = sns.heatmap(x, cmap=cmap)

seaborn.light_palette

seaborn.light_palette(color, n_colors=6, reverse=False, as_cmap=False, input='rgb')

制作一个混合浅色和 color 模式的顺序调色板。

这种调色板适用于数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时。

可以通过多种方式指定 color 参数，包括用于在 matplotlib 中定义颜色的所有选项，以及由 seborn 处理的其他几个颜色空间。也可以使用 XKCD color survey 中的颜色名字数据库。

如果您在使用 IPython notebook，您还可以通过 choose_light_palette() 函数交互式选择调色板。

参数：color：高值的基色

十六进制、input 中的元组或者颜色名字。

n_colors：int, 可选

调色板中的颜色数。

reverse：bool, 可选

如果为 True 值，则反转混合的方向。

as_cmap：bool, 可选

如果为 True 值，则返回 matplotlib colormap 而不是列表。

input：{‘rgb’, ‘hls’, ‘husl’, xkcd’}

用于解释输入颜色的颜色空间。前三个选项适用于元组输入，后者适用于字符串输入。

返回值：palette or cmap：seaborn color palette or matplotlib colormap

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

另外

创建具有暗低值的连续调色板。创建有两种颜色的发散调色板。

例子

从一个 HTML 颜色生成一个调色板：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.light_palette("purple"))

生成亮度降低的调色板：

>>> sns.palplot(sns.light_palette("seagreen", reverse=True))

从 HUSL 空间种子生成选项板：

>>> sns.palplot(sns.light_palette((260, 75, 60), input="husl"))

生成一个 colormap 对象：

>>> from numpy import arange
>>> x = arange(25).reshape(5, 5)
>>> cmap = sns.light_palette("#2ecc71", as_cmap=True)
>>> ax = sns.heatmap(x, cmap=cmap)

seaborn.diverging_palette

seaborn.diverging_palette(h_neg, h_pos, s=75, l=50, sep=10, n=6, center='light', as_cmap=False)

在两个 HUSL 颜色直接建立一个发散调色板。

如果您在使用 IPython notebook，您还可以通过 choose_diverging_palette() 函数交互式选择调色板。

参数：h_neg, h_pos：float in [0, 359]

图的正负范围的锚定色调

s：[0, 100] 范围内的浮点数，可选

图的两个范围的锚定饱和度

l：[0, 100] 范围内的浮点数，可选

图的两个范围的锚定亮度

n：int，可选

调色板中的颜色数（如果为not，返回一个colormap）

center：{“light”, “dark”}, 可选

调色板中心为亮或暗

as_cmap：bool, 可选

如果为 true，返回一个 matplotlib colormap 而不是一个颜色列表。

返回值：palette or cmap：seaborn color palette or matplotlib colormap

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

另外

创建具有暗值的连续调色板。创建具有亮值的连续调色板。

例子

生成一个蓝-白-红调色板：

>>> import seaborn as sns; sns.set()
>>> sns.palplot(sns.diverging_palette(240, 10, n=9))

生成一个更亮的绿-白-紫调色板：

>>> sns.palplot(sns.diverging_palette(150, 275, s=80, l=55, n=9))

生成一个蓝-黑-红调色板:

>>> sns.palplot(sns.diverging_palette(250, 15, s=75, l=40,
...                                   n=9, center="dark"))

生成一个 colormap 对象:

>>> from numpy import arange
>>> x = arange(25).reshape(5, 5)
>>> cmap = sns.diverging_palette(220, 20, sep=20, as_cmap=True)
>>> ax = sns.heatmap(x, cmap=cmap)

seaborn.blend_palette

seaborn.blend_palette(colors, n_colors=6, as_cmap=False, input='rgb')

创建在颜色列表之间混合的调色板。

参数：colors：由 input 解释的各种格式的颜色序列。

十六进制码，html 颜色名字，或者 input 空间中的元组。

n_colors：int, 可选

调色板中的颜色数。

as_cmap：bool, 可选

如果为 True 值，则返回 matplotlib colormap 而不是列表。

返回值：palette or cmap：seaborn 调色板或 matplotlib colormap

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

seaborn.xkcd_palette

seaborn.xkcd_palette(colors)

使用来自xkcd color survey的颜色名字生成调色板。

查看完整的 xkcd 颜色列表： https://xkcd.com/color/rgb/

这是一个简单的 seaborn.xkcd_rgb 字典的装饰器。

参数：colors：字符串列表

seaborn.xkcd_rgb 字典中的 key 的列表。

返回值：palette：seaborn 调色板

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

另外

使用 Crayola crayon colors 创建调色板。

seaborn.crayon_palette

seaborn.crayon_palette(colors)

通过 Crayola crayons 颜色名字生成调色板。

颜色列表在这里获取： https://en.wikipedia.org/wiki/List_of_Crayola_crayon_colors

这是一个简单的 seaborn.crayons 字典的装饰器。

参数：colors：字符串列表

List of keys in the seaborn.crayons dictionary.

返回值：palette：seaborn 调色板

Returns the list of colors as rgb tuples in an object that behaves like other seaborn color palettes.返回一个类似 serborn 调色板的对象，其中包括 RGB 元组构成的的颜色列表。

另外

使用来自xkcd color survey的颜色名字创建调色板。

seaborn.mpl_palette

seaborn.mpl_palette(name, n_colors=6)

从一个 matplotlib 调色板中返回离散颜色。

请注意，这会正确处理定性的 colorbrewer 调色板，但如果您要求的颜色多于特定的定性调色板，提供的颜色将会比您预期的少。相反，使用 color_palette() 函数请求一个定性 colorbrewer 调色板将会返回预期数目的颜色，但是是循环型的。

如果您在使用 IPython notebook，您还可以通过 choose_colorbrewer_palette() 函数交互式选择调色板。

参数：name：string

调色板名字，应该是一个被命名的 matplotlib colormap。

n_colors：int

调色板中离散颜色的个数。

返回值：palette or cmap：seaborn 调色板或者 matplotlib colormap

类似列表的颜色对象的 RGB 元组，或者可以将连续值映射到颜色的 colormap 对象，具体取决于 as_cmap 参数的值。

例子

生成一个含有 8 种颜色的定性 colorbrewer 调色板：

>>> import seaborn as sns; sns.set()>>> sns.palplot(sns.mpl_palette("Set2", 8))

生成一个连续的 colorbrewer 调色板：

>>> sns.palplot(sns.mpl_palette("Blues"))

生成一个发散调色板：

>>> sns.palplot(sns.mpl_palette("seismic", 8))

生成一个 “dark” 顺序调色板：

>>> sns.palplot(sns.mpl_palette("GnBu_d"))

seaborn.choose_colorbrewer_palette

seaborn.choose_colorbrewer_palette(data_type, as_cmap=False)

在 ColorBrewer 集中选择一个调色板。

这些调色板内置于 matplotlib 库中，可以通过名字在 seaborn 函数中调用，或者作为对象返回给这个函数。

参数：data_type：{‘sequential’, ‘diverging’, ‘qualitative’}

描述您想要实现可视化的数据类型。查看 serborn 调色板文档来了解更多如何取值。注意，您可以传递子字符串（例如，‘q’ 代表 ‘qualitative‘）

as_cmap：bool

如果为 True 值，则返回 matplotlib colormap 而不是离散颜色的列表。

返回值：pal or cmap：颜色列表或 matplotlib colormap

可以被传递给 plotting 函数的对象。

另外

创建具有暗低值的连续调色板。创建具有亮低值的连续调色板。从选中的颜色中创建发散调色板。使用 cubehelix 创建连续调色板或者 colormap。

seaborn.choose_cubehelix_palette

seaborn.choose_cubehelix_palette(as_cmap=False)

启动交互式小部件以创建顺序 cubehelix 调色板。

这与 cubehelix_palette() 函数相对应。这种调色板在数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时很有用。cubehelix 系统允许调色板在整个范围内具有更多的色调变化，这有助于区分更广泛的值。

需要 2.0 以上版本 IPython，必须在 notebook 中使用。

参数：as_cmap：bool

如果为 True 值，则返回 matplotlib colormap 而不是离散颜色的列表。

返回值：pal or cmap：颜色列表或 matplotlib colormap

可以被传递给 plotting 函数的对象。

另外

使用 cubehelix 创建连续调色板或者 colormap。

seaborn.choose_light_palette

seaborn.choose_light_palette(input='husl', as_cmap=False)

启动交互式小部件以创建亮色顺序调色板。

与 light_palette() 函数相对应。 这种调色板在数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时很有用。

需要 2.0 以上版本 IPython，必须在 notebook 中使用。

参数：input：{‘husl’, ‘hls’, ‘rgb’}

色彩空间用于定义种子值。请注意，此默认值与 light_palette() 的默认输入值不同。

参数：as_cmap：bool

如果为 True 值，则返回 matplotlib colormap 而不是离散颜色的列表。

返回值：pal or cmap：颜色列表或 matplotlib colormap

可以被传递给 plotting 函数的对象。

另外

创建具有暗低值的连续调色板。创建具有亮低值的连续调色板。使用 cubehelix 创建连续调色板或者 colormap。

seaborn.choose_dark_palette

seaborn.choose_dark_palette(input='husl', as_cmap=False)

启动交互式小部件以创建暗色顺序调色板。

与 dark_palette() 函数相对应。这种调色板在数据集的范围从相对低值(不感兴趣)到相对高值(很感兴趣)时很有用。

需要 2.0 以上版本 IPython，必须在 notebook 中使用。

参数：input：{‘husl’, ‘hls’, ‘rgb’}

色彩空间用于定义种子值。请注意，此默认值与 dark_palette() 的默认输入值不同。

参数：as_cmap：bool

如果为 True 值，则返回 matplotlib colormap 而不是离散颜色的列表。

返回值：pal or cmap：颜色列表或 matplotlib colormap

可以被传递给 plotting 函数的对象。

另外

创建具有暗低值的连续调色板。创建具有亮低值的连续调色板。使用 cubehelix 创建连续调色板或者 colormap。

seaborn.choose_diverging_palette

seaborn.choose_diverging_palette(as_cmap=False)

启动交互式小部件以创建一个发散调色板。

这与 diverging_palette() 函数相对应。这种调色板适用于对低值和高值都感兴趣并且中间点也有意义的数据。（例如，相对与某些基准值的分数变化）。

需要 2.0 以上版本 IPython，必须在 notebook 中使用。

参数：as_cmap：bool

如果为 True 值，则返回 matplotlib colormap 而不是离散颜色的列表。

返回值：pal or cmap：颜色列表或 matplotlib colormap

可以被传递给 plotting 函数的对象。

另外

生成一个发散调色板或者 colormap。从 colorbrewer 集中交互式选择调色板，包括发散调色板。

seaborn.load_dataset

seaborn.load_dataset(name, cache=True, data_home=None, **kws)

从在线库中获取数据集（需要联网）。

参数：name：字符串

数据集的名字 (name.csv on https://github.com/mwaskom/seaborn-data)。 您可以通过 get_dataset_names() 获取可用的数据集。

cache：boolean, 可选

如果为True，则在本地缓存数据并在后续调用中使用缓存。

data_home：string, 可选

用于存储缓存数据的目录。 默认情况下使用 ~/seaborn-data/

kws：dict, 可选

传递给 pandas.read_csv

seaborn.despine

seaborn.despine(fig=None, ax=None, top=True, right=True, left=False, bottom=False, offset=None, trim=False)

从图中移除顶部和右侧脊柱。

fig : matplotlib 值, 可选

去除所有轴脊柱，默认使用当前数值。

ax : matplotlib 轴, 可选

去除特定的轴脊柱。

top, right, left, bottom : boolean, 可选

如果为 True，去除脊柱。

offset : int or dict, 可选

绝对距离（以磅为单位）应将脊椎移离轴线（负值向内移动脊柱）。 单个值适用于所有脊柱; 字典可用于设置每侧的偏移值。

trim : bool, 可选

如果为True，则将脊柱限制为每个非去除脊柱的轴上的最小和最大主刻度。

返回值：None || —- | —- |

seaborn.desaturate

seaborn.desaturate(color, prop)

减少颜色的饱和度。

参数：color：matplotlib 颜色

十六进制，rgb 元组或者html颜色名字

prop：float

颜色的饱和度将乘以该值

返回值：new_color：rgb 元组

RGB元组表示去饱和的颜色代码

seaborn.saturate

seaborn.saturate(color)

返回具有相同色调的完全饱和的颜色。

参数：color：matplotlib 颜色

十六进制，rgb 元组或者html颜色名字

返回值：new_color：rgb 元组

RGB元组表示的饱和颜色代码

seaborn.set_hls_values

seaborn.set_hls_values(color, h=None, l=None, s=None)

独立修改一个颜色的 h, l 或 s 值。

参数：color：matplotlib 颜色

十六进制，rgb 元组或者html颜色名字

h, l, s：0 到 1 之间的浮点数，或者为 None

hls 空间中的新值。

返回值：new_color：rgb 元组

RGB元组表示中的新颜色代码

Seaborn实战

• Seaborn 绘制 21 种超实用精美图表