Pandas-2-2-中文文档-二十四-

Pandas 2.2 中文文档（二十四）

原文：pandas.pydata.org/docs/

pandas.DataFrame.plot.area

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.area.html

DataFrame.plot.area(x=None, y=None, stacked=True, **kwargs)

绘制堆叠的区域图。

区域图可视化显示定量数据。此函数包装了 matplotlib 的 area 函数。

参数：

x轴标签或位置，可选

X 轴的坐标。默认情况下使用索引。

y轴标签或位置，可选

要绘制的列。默认情况下使用所有列。

stacked布尔值，默认为 True

默认情况下，区域图是堆叠的。设置为 False 以创建非堆叠图。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或 numpy.ndarray

区域图，或者如果 subplots 为 True，则为区域图数组。

另请参阅

DataFrame.plot

使用 matplotlib / pylab 绘制 DataFrame 的图形。

示例

基于基本业务指标绘制区域图：

>>> df = pd.DataFrame({
...     'sales': [3, 2, 3, 9, 10, 6],
...     'signups': [5, 5, 6, 12, 14, 13],
...     'visits': [20, 42, 28, 62, 81, 50],
... }, index=pd.date_range(start='2018/01/01', end='2018/07/01',
...                        freq='ME'))
>>> ax = df.plot.area() 

默认情况下，区域图是堆叠的。要生成非堆叠图，请传递stacked=False：

>>> ax = df.plot.area(stacked=False) 

绘制单列的区域图：

>>> ax = df.plot.area(y='sales') 

使用不同的 x 绘制：

>>> df = pd.DataFrame({
...     'sales': [3, 2, 3],
...     'visits': [20, 42, 28],
...     'day': [1, 2, 3],
... })
>>> ax = df.plot.area(x='day') 

pandas.DataFrame.plot.bar

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.bar.html

DataFrame.plot.bar(x=None, y=None, **kwargs)

垂直条形图。

条形图是一种用矩形条表示分类数据的图表，其长度与它们代表的值成比例。条形图显示离散类别之间的比较。图表的一个轴显示正在比较的具体类别，另一个轴代表一个测量值。

参数：

x标签或位置，可选

允许绘制一列与另一列的图。如果未指定，则使用 DataFrame 的索引。

y标签或位置，可选

允许绘制一列与另一列的图。如果未指定，则使用所有数值列。

颜色str，类似数组或字典，可选

DataFrame 的每一列的颜色。可能的值有：

• 一个单一的颜色字符串，通过名称、RGB 或 RGBA 代码，

  例如‘红色’或‘#a98d19’。

• 一系列颜色字符串，通过名称、RGB 或 RGBA 引用

  代码，将递归地用于每一列。例如[‘绿色’，‘黄色’]，每一列的条形图将交替填充为绿色或黄色。如果只有一个要绘制的列，则只会使用颜色列表中的第一个颜色。

• 一个形如{列名颜色}的字典，这样每一列都会

  相应着色。例如，如果你的列名为 a 和 b，那么传递{‘a’：‘绿色’，‘b’：‘红色’}将使列 a 的条形图呈绿色，列 b 的条形图呈红色。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或它们的 np.ndarray

当subplots=True时，每列返回一个matplotlib.axes.Axes的 ndarray。

另请参阅

DataFrame.plot.barh

水平条形图。

DataFrame.plot

绘制 DataFrame 的图表。

matplotlib.pyplot.bar

使用 matplotlib 制作条形图。

示例

基本图表。

>>> df = pd.DataFrame({'lab':['A', 'B', 'C'], 'val':[10, 30, 20]})
>>> ax = df.plot.bar(x='lab', y='val', rot=0) 

将整个数据框绘制为条形图。每一列被分配一个不同的颜色，每一行在水平轴上嵌套在一个组中。

>>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]
>>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]
>>> index = ['snail', 'pig', 'elephant',
...          'rabbit', 'giraffe', 'coyote', 'horse']
>>> df = pd.DataFrame({'speed': speed,
...                    'lifespan': lifespan}, index=index)
>>> ax = df.plot.bar(rot=0) 

为 DataFrame 绘制堆叠条形图

>>> ax = df.plot.bar(stacked=True) 

不需要嵌套，可以通过subplots=True按列拆分图表。在这种情况下，会返回一个numpy.ndarray的matplotlib.axes.Axes。

>>> axes = df.plot.bar(rot=0, subplots=True)
>>> axes[1].legend(loc=2) 

如果你不喜欢默认的颜色，你可以指定每一列的颜色。

>>> axes = df.plot.bar(
...     rot=0, subplots=True, color={"speed": "red", "lifespan": "green"}
... )
>>> axes[1].legend(loc=2) 

绘制单列。

>>> ax = df.plot.bar(y='speed', rot=0) 

仅为数据框绘制选定的类别。

>>> ax = df.plot.bar(x='lifespan', rot=0) 

pandas.DataFrame.plot.barh

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.barh.html

DataFrame.plot.barh(x=None, y=None, **kwargs)

制作一个水平条形图。

水平条形图是一种用矩形条表示数量数据的图表，其长度与它们代表的值成比例。条形图显示了离散类别之间的比较。图表的一个轴显示了正在比较的具体类别，另一个轴代表了一个测量值。

参数：

x标签或位置，可选

允许绘制一列与另一列的关系。如果未指定，则使用 DataFrame 的索引。

y标签或位置，可选

允许绘制一列与另一列的关系。如果未指定，则使用所有数值列。

colorstr、array-like 或 dict，可选

DataFrame 的每一列的颜色。可能的值包括：

• 一个单一的颜色字符串，通过名称、RGB 或 RGBA 代码引用，

  例如‘red’或‘#a98d19’。

• 一系列颜色字符串，通过名称、RGB 或 RGBA 引用

  代码，将递归地用于每一列。例如[‘green’,’yellow’]，每一列的条形图将交替填充为绿色或黄色。如果只有一个要绘制的列，则只会使用颜色列表中的第一个颜色。

• 一个形如{列名颜色}的字典，以便每一列都会

  相应着颜色。例如，如果你的列名为 a 和 b，那么传入{‘a’: ‘green’, ‘b’: ‘red’}将会用绿色为列 a 的条形图上色，用红色为列 b 的条形图上色。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或它们的 np.ndarray

当subplots=True时，每列返回一个matplotlib.axes.Axes或它们的 np.ndarray。

另请参阅

DataFrame.plot.bar

垂直条形图。

DataFrame.plot

使用 matplotlib 绘制 DataFrame 的图表。

matplotlib.axes.Axes.bar

使用 matplotlib 绘制垂直条形图。

示例

基本示例

>>> df = pd.DataFrame({'lab': ['A', 'B', 'C'], 'val': [10, 30, 20]})
>>> ax = df.plot.barh(x='lab', y='val') 

将整个 DataFrame 绘制为水平条形图

>>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]
>>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]
>>> index = ['snail', 'pig', 'elephant',
...          'rabbit', 'giraffe', 'coyote', 'horse']
>>> df = pd.DataFrame({'speed': speed,
...                    'lifespan': lifespan}, index=index)
>>> ax = df.plot.barh() 

为 DataFrame 绘制堆叠的水平条形图

>>> ax = df.plot.barh(stacked=True) 

我们可以为每一列指定颜色

>>> ax = df.plot.barh(color={"speed": "red", "lifespan": "green"}) 

绘制数据框的一列到水平条形图

>>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]
>>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]
>>> index = ['snail', 'pig', 'elephant',
...          'rabbit', 'giraffe', 'coyote', 'horse']
>>> df = pd.DataFrame({'speed': speed,
...                    'lifespan': lifespan}, index=index)
>>> ax = df.plot.barh(y='speed') 

绘制数据框与所需列的关系

>>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]
>>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]
>>> index = ['snail', 'pig', 'elephant',
...          'rabbit', 'giraffe', 'coyote', 'horse']
>>> df = pd.DataFrame({'speed': speed,
...                    'lifespan': lifespan}, index=index)
>>> ax = df.plot.barh(x='lifespan') 

pandas.DataFrame.plot.box

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.box.html

DataFrame.plot.box(by=None, **kwargs)

绘制 DataFrame 列的箱线图。

箱线图是一种通过其四分位数图形地描绘数值数据组的方法。 箱子从数据的 Q1 到 Q3 四分位数值延伸，中位数（Q2）处有一条线。 箱须从箱子的边缘延伸以显示数据的范围。 箱须的位置默认设置为离箱子边缘 1.5 倍 IQR（IQR = Q3 - Q1）。 异常点是那些超出箱须末端的点。

有关详细信息，请参阅维基百科的箱线图条目。

使用此图表时需要考虑的一个问题是，箱体和箱须可能会重叠，在绘制少量数据时非常常见。

参数：

bystr 或序列

DataFrame 中用于分组的列。

在版本 1.4.0 中更改：以前，by 会被静默忽略并且不进行分组

**kwargs

其他关键字在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或其数组

另请参见

DataFrame.boxplot

绘制箱线图的另一种方法。

Series.plot.box

从一个 Series 对象绘制箱线图。

matplotlib.pyplot.boxplot

在 matplotlib 中绘制箱线图。

示例

从具有四列随机生成数据的 DataFrame 绘制箱线图。

>>> data = np.random.randn(25, 4)
>>> df = pd.DataFrame(data, columns=list('ABCD'))
>>> ax = df.plot.box() 

如果指定 by 参数（可以是列名，也可以是列名的列表或元组），还可以生成分组：

在版本 1.4.0 中更改。

>>> age_list = [8, 10, 12, 14, 72, 74, 76, 78, 20, 25, 30, 35, 60, 85]
>>> df = pd.DataFrame({"gender": list("MMMMMMMMFFFFFF"), "age": age_list})
>>> ax = df.plot.box(column="age", by="gender", figsize=(10, 8)) 

pandas.DataFrame.plot.density

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.density.html

DataFrame.plot.density(bw_method=None, ind=None, **kwargs)

使用高斯核生成核密度估计图。

在统计学中，核密度估计（KDE）是一种非参数估计随机变量概率密度函数（PDF）的方法。该函数使用高斯核并包括自动带宽确定。

参数：

bw_methodstr，标量或可调用对象，可选

用于计算估计器带宽的方法。可以是‘scott’，‘silverman’，标量常数或可调用对象。如果为 None（默认），则使用‘scott’。有关更多信息，请参阅scipy.stats.gaussian_kde。

indNumPy 数组或整数，可选

用于估计 PDF 的评估点。如果为 None（默认），则使用 1000 个等间距点。如果 ind 是 NumPy 数组，则在传递的点处评估 KDE。如果 ind 是整数，则使用 ind 数量的等间距点。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或其 numpy.ndarray

另请参阅

scipy.stats.gaussian_kde

使用高斯核的核密度估计的表示。这是内部用于估计 PDF 的函数。

示例

给定从未知分布中随机抽样的一系列点，使用具有自动带宽确定的 KDE 估计其 PDF，并在 1000 个等间距点（默认）上评估结果并绘制：

>>> s = pd.Series([1, 2, 2.5, 3, 3.5, 4, 5])
>>> ax = s.plot.kde() 

可以指定标量带宽。使用较小的带宽值可能导致过拟合，而使用较大的带宽值可能导致欠拟合：

>>> ax = s.plot.kde(bw_method=0.3) 

>>> ax = s.plot.kde(bw_method=3) 

最后，ind 参数确定了用于绘制估计 PDF 的评估点：

>>> ax = s.plot.kde(ind=[1, 2, 3, 4, 5]) 

对于 DataFrame，它的工作方式相同：

>>> df = pd.DataFrame({
...     'x': [1, 2, 2.5, 3, 3.5, 4, 5],
...     'y': [4, 4, 4.5, 5, 5.5, 6, 6],
... })
>>> ax = df.plot.kde() 

可以指定标量带宽。使用较小的带宽值可能导致过拟合，而使用较大的带宽值可能导致欠拟合：

>>> ax = df.plot.kde(bw_method=0.3) 

>>> ax = df.plot.kde(bw_method=3) 

最后，ind 参数确定了估计概率密度函数的绘图评估点：

>>> ax = df.plot.kde(ind=[1, 2, 3, 4, 5, 6]) 

pandas.DataFrame.plot.hexbin

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.hexbin.html

DataFrame.plot.hexbin(x, y, C=None, reduce_C_function=None, gridsize=None, **kwargs)

生成一个六边形 binning 图。

生成 x 与 y 的六边形 binning 图。如果 C 为 None（默认值），这是一个关于观察值在 (x[i], y[i]) 处出现次数的直方图。

如果指定了 C，则指定给定坐标 (x[i], y[i]) 处的值。这些值将累积到每个六边形箱中，然后根据 reduce_C_function 进行减少，其默认值为 NumPy 的均值函数（numpy.mean()）。（如果指定了 C，则它必须也是与 x 和 y 长度相同的 1-D 序列，或者是一个列标签。）

参数：

xint or str

x 点的列标签或位置。

yint or str

y 点的列标签或位置。

Cint or str, optional

(x, y) 点值的列标签或位置。

reduce_C_functioncallable, default np.mean

一个参数的函数，将箱中的所有值减少到一个单一数字（例如 np.mean, np.max, np.sum, np.std）。

gridsizeint or tuple of (int, int), default 100

x 方向上的六边形数量。选择 y 方向上相应数量的六边形，以使六边形大致规则。或者，gridsize 可以是一个包含两个元素的元组，指定 x 方向和 y 方向上的六边形数量。

**kwargs

额外的关键字参数在DataFrame.plot()中有记录。

返回：

matplotlib.AxesSubplot

绘制六边形 binning 的 matplotlib Axes。

另请参阅

DataFrame.plot

绘制 DataFrame 的图。

matplotlib.pyplot.hexbin

使用 matplotlib 进行六边形 binning 绘图，这是在幕后使用的 matplotlib 函数。

示例

以下示例是使用正态分布的随机数据生成的。

>>> n = 10000
>>> df = pd.DataFrame({'x': np.random.randn(n),
...                    'y': np.random.randn(n)})
>>> ax = df.plot.hexbin(x='x', y='y', gridsize=20) 

下一个示例使用 C 和 np.sum 作为 reduce_C_function。请注意，'observations' 的值范围从 1 到 5，但结果图显示的值超过 25。这是由于 reduce_C_function。

>>> n = 500
>>> df = pd.DataFrame({
...     'coord_x': np.random.uniform(-3, 3, size=n),
...     'coord_y': np.random.uniform(30, 50, size=n),
...     'observations': np.random.randint(1,5, size=n)
...     })
>>> ax = df.plot.hexbin(x='coord_x',
...                     y='coord_y',
...                     C='observations',
...                     reduce_C_function=np.sum,
...                     gridsize=10,
...                     cmap="viridis") 

pandas.DataFrame.plot.hist

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.hist.html

DataFrame.plot.hist(by=None, bins=10, **kwargs)

绘制 DataFrame 列的一个直方图。

直方图是数据分布的表示。此函数将 DataFrame 中所有给定 Series 的值分组到箱中，并在一个matplotlib.axes.Axes中绘制所有箱。当 DataFrame 的 Series 在相似的比例时，这是很有用的。

参数：

bystr 或序列，可选

要按列分组的 DataFrame 中的列。

从版本 1.4.0 开始更改：以前，by 被忽略并且不进行分组

binsint，默认值为 10

要使用的直方图箱的数量。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

类：matplotlib.AxesSubplot

返回一个直方图图表。

另请参见

DataFrame.hist

绘制每个 DataFrame 的 Series 的直方图。

Series.hist

绘制具有 Series 数据的直方图。

示例

当我们掷骰子 6000 次时，我们期望每个值出现大约 1000 次。但是当我们掷两个骰子并求和结果时，分布将会有所不同。直方图说明了这些分布。

>>> df = pd.DataFrame(np.random.randint(1, 7, 6000), columns=['one'])
>>> df['two'] = df['one'] + np.random.randint(1, 7, 6000)
>>> ax = df.plot.hist(bins=12, alpha=0.5) 

通过提供参数 by（可以是列名或列名列表）可以生成分组的直方图：

>>> age_list = [8, 10, 12, 14, 72, 74, 76, 78, 20, 25, 30, 35, 60, 85]
>>> df = pd.DataFrame({"gender": list("MMMMMMMMFFFFFF"), "age": age_list})
>>> ax = df.plot.hist(column=["age"], by="gender", figsize=(10, 8)) 

pandas.DataFrame.plot.kde

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.kde.html

DataFrame.plot.kde(bw_method=None, ind=None, **kwargs)

使用高斯核生成核密度估计图。

在统计学中，核密度估计（KDE）是一种非参数估计随机变量概率密度函数（PDF）的方法。该函数使用高斯核，并包括自动带宽确定。

参数：

bw_method字符串、标量或可调用对象，可选

用于计算估计器带宽的方法。可以是'scott'、'silverman'、标量常数或可调用对象。如果为 None（默认），则使用'scott'。有关更多信息，请参阅scipy.stats.gaussian_kde。

indNumPy 数组或整数，可选

估计 PDF 的评估点。如果为 None（默认），则使用 1000 个等间距点。如果 ind 是 NumPy 数组，则在传递的点处评估 KDE。如果 ind 是整数，则使用 ind 数量的等间距点。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或其 numpy.ndarray

另请参阅

scipy.stats.gaussian_kde

使用高斯核估计核密度的表示。这是内部用于估计 PDF 的函数。

示例

给定从未知分布中随机抽样的点系列，使用自动带宽确定的 KDE 估计其 PDF，并绘制结果，在 1000 个等间距点（默认）上评估它们：

>>> s = pd.Series([1, 2, 2.5, 3, 3.5, 4, 5])
>>> ax = s.plot.kde() 

可以指定标量带宽。使用较小的带宽值可能导致过度拟合，而使用较大的带宽值可能导致欠拟合：

>>> ax = s.plot.kde(bw_method=0.3) 

>>> ax = s.plot.kde(bw_method=3) 

最后，ind 参数确定了估计 PDF 的绘图评估点：

>>> ax = s.plot.kde(ind=[1, 2, 3, 4, 5]) 

对于 DataFrame，它的工作方式相同：

>>> df = pd.DataFrame({
...     'x': [1, 2, 2.5, 3, 3.5, 4, 5],
...     'y': [4, 4, 4.5, 5, 5.5, 6, 6],
... })
>>> ax = df.plot.kde() 

可以指定标量带宽。使用较小的带宽值可能导致过度拟合，而使用较大的带宽值可能导致欠拟合：

>>> ax = df.plot.kde(bw_method=0.3) 

>>> ax = df.plot.kde(bw_method=3) 

最后，ind 参数确定了估计 PDF 的绘图评估点：

>>> ax = df.plot.kde(ind=[1, 2, 3, 4, 5, 6]) 

pandas.DataFrame.plot.line

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.line.html

DataFrame.plot.line(x=None, y=None, **kwargs)

将系列或数据框绘制为线条。

此函数用于使用数据框的值作为坐标绘制线条。

参数：

x标签或位置，可选

允许绘制一列与另一列的关系。如果未指定，则使用数据框的索引。

y标签或位置，可选

允许绘制一列与另一列的关系。如果未指定，则使用所有数值列。

colorstr，类似数组或字典，可选

数据框的每一列的颜色。可能的值为：

• 一个单一的颜色字符串，通过名称、RGB 或 RGBA 代码，

  例如‘红色’或‘#a98d19’。

• 一系列颜色字符串，通过名称、RGB 或 RGBA 引用

  代码，将递归地用于每一列。例如[‘绿色’，‘黄色’]，每一列的线条将交替填充为绿色或黄色。如果只有一列要绘制，则只使用颜色列表中的第一种颜色。

• 一个形式为{列名颜色}的字典，以便每一列都将

  相应着色。例如，如果您的列名为 a 和 b，则传递{‘a’：‘绿色’，‘b’：‘红色’}将使列 a 的线条呈绿色，列 b 的线条呈红色。

**kwargs

额外的关键字参数在DataFrame.plot()中有文档记录。

返回：

matplotlib.axes.Axes 或其 np.ndarray

当subplots=True时，每列返回一个matplotlib.axes.Axes。

另请参阅

matplotlib.pyplot.plot

将 y 相对于 x 绘制为线条和/或标记。

示例

>>> s = pd.Series([1, 3, 2])
>>> s.plot.line() 

以下示例显示了一些动物随着时间的人口数量。

>>> df = pd.DataFrame({
...    'pig': [20, 18, 489, 675, 1776],
...    'horse': [4, 25, 281, 600, 1900]
...    }, index=[1990, 1997, 2003, 2009, 2014])
>>> lines = df.plot.line() 

一个包含子图的示例，因此返回一个轴数组。

>>> axes = df.plot.line(subplots=True)
>>> type(axes)
<class 'numpy.ndarray'> 

让我们重复相同的示例，但为每一列指定颜色（在这种情况下，为每种动物）。

>>> axes = df.plot.line(
...     subplots=True, color={"pig": "pink", "horse": "#742802"}
... ) 

以下示例显示了两个人口之间的关系。

>>> lines = df.plot.line(x='pig', y='horse') 

pandas.DataFrame.plot.pie

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.pie.html

DataFrame.plot.pie(**kwargs)

生成一个饼图。

饼图是对列中的数值数据的比例表示。此函数为指定的列包装了matplotlib.pyplot.pie()。如果没有传递列引用且subplots=True，则会为每个数值列独立绘制一个饼图。

参数：

yint 或标签，可选

要绘制的列的标签或位置。如果未提供，必须传递subplots=True参数。

**kwargs

要传递给DataFrame.plot()的关键字参数。

返回：

matplotlib.axes.Axes 或它们的 np.ndarray

当 subplots 为 True 时返回一个 NumPy 数组。

另请参见

Series.plot.pie

为一个序列生成饼图。

DataFrame.plot

绘制数据框的图。

示例

在下面的示例中，我们有一个包含有关行星质量和半径信息的数据框。我们将“质量”列传递给饼图函数以获得一个饼图。

>>> df = pd.DataFrame({'mass': [0.330, 4.87 , 5.97],
...                    'radius': [2439.7, 6051.8, 6378.1]},
...                   index=['Mercury', 'Venus', 'Earth'])
>>> plot = df.plot.pie(y='mass', figsize=(5, 5)) 

>>> plot = df.plot.pie(subplots=True, figsize=(11, 6)) 

pandas.DataFrame.plot.scatter

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.scatter.html

DataFrame.plot.scatter(x, y, s=None, c=None, **kwargs)

创建一个散点图，其中标记点的大小和颜色各不相同。

每个点的坐标由两个数据框列定义，并使用填充圆表示每个点。这种图表对于查看两个变量之间的复杂相关性很有用。例如，点可以是自然的 2D 坐标，如地图上的经度和纬度，或者一般来说，可以相互绘制的任何一对度量。

参数：

xint 或 str

要用作每个点的水平坐标的列名或列位置。

yint 或 str

要用作每个点的垂直坐标的列名或列位置。

sstr，标量或类似数组，可选

每个点的大小。可能的值为：

• 用于标记大小的列的名称字符串。

• 单个标量，因此所有点都具有相同的大小。

• 一系列标量，将递归地用于每个点的大小。例如，当传递[2,14]时，所有点的大小将交替为 2 或 14。

cstr，int 或类似数组，可选

每个点的颜色。可能的值为：

• 单个颜色字符串，通过名称、RGB 或 RGBA 代码引用，例如‘red’或‘#a98d19’。

• 一系列颜色字符串，通过名称、RGB 或 RGBA 代码引用，将递归地用于每个点的颜色。例如[‘green’,’yellow’]，所有点将交替填充为绿色或黄色。

• 列名或位置，其值将用于根据颜色图对标记点着色。

**kwargs

要传递给DataFrame.plot()的关键字参数。

返回：

matplotlib.axes.Axes或它们的 numpy.ndarray

另请参见

matplotlib.pyplot.scatter

使用多种输入数据格式的散点图。

示例

让我们看看如何使用数据框列中的值来绘制散点图。

>>> df = pd.DataFrame([[5.1, 3.5, 0], [4.9, 3.0, 0], [7.0, 3.2, 1],
...                    [6.4, 3.2, 1], [5.9, 3.0, 2]],
...                   columns=['length', 'width', 'species'])
>>> ax1 = df.plot.scatter(x='length',
...                       y='width',
...                       c='DarkBlue') 

现在颜色也由一列确定。

>>> ax2 = df.plot.scatter(x='length',
...                       y='width',
...                       c='species',
...                       colormap='viridis') 

pandas.DataFrame.boxplot

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.boxplot.html

DataFrame.boxplot(column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, backend=None, **kwargs)

从 DataFrame 列制作箱线图。

从 DataFrame 列制作箱线图，可选择按其他某些列分组。箱线图是一种通过四分位数图形化表示数值数据组的方法。箱子从数据的 Q1 到 Q3 四分位值延伸，中位数（Q2）处有一条线。触须从箱子的边缘延伸，显示数据的范围。默��情况下，它们不会超过箱子边缘的 1.5 * IQR（IQR = Q3 - Q1），结束于该间隔内最远的数据点。异常值将作为单独的点绘制。

更多细节请参阅维基百科关于箱线图的条目。

参数：

column 字符串或字符串列表，可选

列名或名称列表，或向量。可以是任何有效的输入到 pandas.DataFrame.groupby() 的内容。

by 字符串或类数组，可选

DataFrame 中用于 pandas.DataFrame.groupby() 的列。将根据 by 中列的每个值绘制一个箱线图。

ax 类 matplotlib.axes.Axes 的对象，可选

用于箱线图的 matplotlib 坐标轴。

fontsize 浮点数或字符串

刻度标签字体大小，以点或字符串形式（例如，large）。

rot 浮点数，默认为 0

标签相对于屏幕坐标系的旋转角度（以度为单位）。

grid 布尔值，默认为 True

将此设置为 True 将显示网格。

figsize 一个元组（宽度，高度），单位为英寸

在 matplotlib 中创建的图的大小。

layout 元组（行，列），可选

例如，（3，5）将使用 3 行 5 列显示子图，从左上角开始。

return_type {‘axes’, ‘dict’, ‘both’} 或 None，默认为 ‘axes’

要返回的对象类型。默认为 axes。

• ‘axes’ 返回绘制箱线图的 matplotlib 坐标轴。

• ‘dict’ 返回一个字典，其值为箱线图的 matplotlib 线条。

• ‘both’ 返回一个具有坐标轴和字典的命名元组。

• 使用 by 进行分组时，将返回将列映射到 return_type 的 Series。

  如果 return_type 为 None，则返回一个与 layout 形状相同的 NumPy 数组的坐标轴。

backend 字符串，默认为 None

要使用的后端，而不是在选项 plotting.backend 中指定的后端。例如，‘matplotlib’。或者，要为整个会话指定 plotting.backend，请设置 pd.options.plotting.backend。

**kwargs

要传递给 matplotlib.pyplot.boxplot() 的所有其他绘图关键字参数。

返回：

结果

请参阅注释。

另请参见

pandas.Series.plot.hist

制作直方图。

matplotlib.pyplot.boxplot

Matplotlib 等效图。

注意

返回类型取决于return_type参数：

• ‘axes’：matplotlib.axes.Axes 类的对象

• ‘dict’：包含 matplotlib.lines.Line2D 对象的字典

• ‘both’：一个具有结构（ax，lines）的命名元组

对使用by分组的数据，返回上述内容的 Series 或 NumPy 数组：

• Series

• array（对于return_type = None）

当您想要在绘图后调整线条外观时，请使用return_type='dict'。在这种情况下，返回一个包含组成箱子、帽子、离群值、中位数和须的线条的字典。

示例

可以通过df.boxplot()或指定要使用的列来为数据框中的每一列创建箱线图：

>>> np.random.seed(1234)
>>> df = pd.DataFrame(np.random.randn(10, 4),
...                   columns=['Col1', 'Col2', 'Col3', 'Col4'])
>>> boxplot = df.boxplot(column=['Col1', 'Col2', 'Col3']) 

可以使用选项by创建根据第三个变量的值分组的变量分布的箱线图。例如：

>>> df = pd.DataFrame(np.random.randn(10, 2),
...                   columns=['Col1', 'Col2'])
>>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',
...                      'B', 'B', 'B', 'B', 'B'])
>>> boxplot = df.boxplot(by='X') 

可以向 boxplot 传递一个字符串列表（即['X'，'Y']），以便按 x 轴中变量的组合对数据进行分组：

>>> df = pd.DataFrame(np.random.randn(10, 3),
...                   columns=['Col1', 'Col2', 'Col3'])
>>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',
...                      'B', 'B', 'B', 'B', 'B'])
>>> df['Y'] = pd.Series(['A', 'B', 'A', 'B', 'A',
...                      'B', 'A', 'B', 'A', 'B'])
>>> boxplot = df.boxplot(column=['Col1', 'Col2'], by=['X', 'Y']) 

可以通过向layout提供一个元组来调整箱线图的布局：

>>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
...                      layout=(2, 1)) 

可以对箱线图进行额外的格式设置，如取消网格（grid=False），旋转 x 轴上的标签（即rot=45）或更改字体大小（即fontsize=15）：

>>> boxplot = df.boxplot(grid=False, rot=45, fontsize=15) 

参数return_type可用于选择箱线图返回的元素类型。当选择return_type='axes'时，返回绘制箱线图的 matplotlib 轴：

>>> boxplot = df.boxplot(column=['Col1', 'Col2'], return_type='axes')
>>> type(boxplot)
<class 'matplotlib.axes._axes.Axes'> 

使用by进行分组时，返回将列映射到return_type的 Series：

>>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
...                      return_type='axes')
>>> type(boxplot)
<class 'pandas.core.series.Series'> 

如果return_type为 None，则返回与layout形状相同的轴的 NumPy 数组：

>>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',
...                      return_type=None)
>>> type(boxplot)
<class 'numpy.ndarray'> 

pandas.DataFrame.hist

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.hist.html

DataFrame.hist(column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, backend=None, legend=False, **kwargs)

绘制 DataFrame 的列的直方图。

直方图是数据分布的一种表示。此函数对 DataFrame 中的每个系列调用matplotlib.pyplot.hist()，每列生成一个直方图。

参数：

dataDataFrame

包含数据的 pandas 对象。

column字符串或序列，可选

如果传递，则将用于将数据限制为列的子集。

by对象，可选

如果传递，则用于为不同组形成直方图。

grid布尔值，默认为 True

是否显示轴网格线。

xlabelsize整数，默认为 None

如果指定，则更改 x 轴标签大小。

xrot浮点数，默认为 None

x 轴标签的旋转。例如，值为 90 会将 x 标签顺时针旋转 90 度。

ylabelsize整数，默认为 None

如果指定，则更改 y 轴标签大小。

yrot浮点数，默认为 None

y 轴标签的旋转。例如，值为 90 会将 y 标签顺时针旋转 90 度。

axMatplotlib axes 对象，默认为 None

要绘制直方图的轴。

sharex布尔值，默认为 True（如果 ax 为 None）否则为 False

如果 subplots=True，则共享 x 轴并将一些 x 轴标签设置为不可见；如果 ax 为 None，则默认为 True，否则如果传入了 ax，则为 False。请注意，同时传入 ax 和 sharex=True 将改变图中所有子图的所有 x 轴标签。

sharey布尔值，默认为 False

如果 subplots=True，则共享 y 轴并将一些 y 轴标签设置为不可见。

figsize元组，可选

要创建的图的英寸大小。默认情况下使用 matplotlib.rcParams 中的值。

layout元组，可选

直方图布局的（行，列）元组。

bins整数或序列，默认为 10

要使用的直方图箱数。如果给定整数，则计算并返回 bins + 1 个箱边。如果 bins 是一个序列，则给出箱边，包括第一个箱的左边缘和最后一个箱的右边缘。在这种情况下，bins 将不经修改地返回。

backend字符串，默认为 None

要使用的后端，而不是在选项plotting.backend中指定的后端。例如，‘matplotlib’。或者，要为整个会话指定plotting.backend，请设置pd.options.plotting.backend。

legend布尔值，默认为 False

是否显示图例。

**kwargs

传递给matplotlib.pyplot.hist()的所有其他绘图关键字参数。

返回：

matplotlib.AxesSubplot 或其 numpy.ndarray

另请参见

matplotlib.pyplot.hist

使用 matplotlib 绘制直方图。

示例

此示例基于一些动物的长度和宽度绘制了一个直方图，显示在三个 bin 中

>>> data = {'length': [1.5, 0.5, 1.2, 0.9, 3],
...         'width': [0.7, 0.2, 0.15, 0.2, 1.1]}
>>> index = ['pig', 'rabbit', 'duck', 'chicken', 'horse']
>>> df = pd.DataFrame(data, index=index)
>>> hist = df.hist(bins=3) 

pandas.DataFrame.sparse.density

pandas.pydata.org/docs/reference/api/pandas.DataFrame.sparse.density.html

DataFrame.sparse.density

非稀疏点与总（密集）数据点的比率。

示例

>>> df = pd.DataFrame({"A": pd.arrays.SparseArray([0, 1, 0, 1])})
>>> df.sparse.density
0.5 

pandas.DataFrame.sparse.from_spmatrix

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.sparse.from_spmatrix.html

classmethod DataFrame.sparse.from_spmatrix(data, index=None, columns=None)

从 scipy 稀疏矩阵创建一个新的 DataFrame。

参数：

datascipy.sparse.spmatrix

必须可转换为 csc 格式。

index, columns索引，可选

用于生成结果 DataFrame 的行和列标签。默认为 RangeIndex。

返回：

DataFrame

DataFrame 的每一列都存储为arrays.SparseArray。

示例

>>> import scipy.sparse
>>> mat = scipy.sparse.eye(3, dtype=float)
>>> pd.DataFrame.sparse.from_spmatrix(mat)
 0    1    2
0  1.0    0    0
1    0  1.0    0
2    0    0  1.0 

pandas.DataFrame.sparse.to_coo

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.sparse.to_coo.html

DataFrame.sparse.to_coo()

将帧的内容作为稀疏的 SciPy COO 矩阵返回。

返回：

scipy.sparse.spmatrix

如果调用者是异构的，并包含布尔值或对象，则结果将是 dtype=object。请参阅注意事项。

注意事项

dtype 将是最低公共分母类型（隐式提升）；也就是说，如果 dtypes（即使是数值类型）混合，将选择能够容纳所有类型的那个。

例如，如果 dtypes 为 float16 和 float32，则 dtype 将被提升为 float32。根据 numpy.find_common_type 的约定，混合 int64 和 uint64 将导致 float64 dtype。

示例

>>> df = pd.DataFrame({"A": pd.arrays.SparseArray([0, 1, 0, 1])})
>>> df.sparse.to_coo()
<4x1 sparse matrix of type '<class 'numpy.int64'>'
 with 2 stored elements in COOrdinate format> 

pandas.DataFrame.sparse.to_dense

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.sparse.to_dense.html

DataFrame.sparse.to_dense()

将稀疏值的 DataFrame 转换为密集形式。

返回：

DataFrame

一个将相同值存储为密集数组的 DataFrame。

示例

>>> df = pd.DataFrame({"A": pd.arrays.SparseArray([0, 1, 0])})
>>> df.sparse.to_dense()
 A
0  0
1  1
2  0 

pandas.DataFrame.from_dict

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.from_dict.html

classmethod DataFrame.from_dict(data, orient='columns', dtype=None, columns=None)

从数组样式或字典的字典构造 DataFrame。

通过列或索引从字典创建 DataFrame 对象，允许指定 dtype。

参数：

data字典

以{field : array-like}或{field : dict}的形式。

orient，默认为‘columns’

数据的“方向”。如果传递的字典的键应该是生成的 DataFrame 的列，请传递‘columns’（默认）。否则，如果键应该是行，请传递‘index’。如果‘tight’，假定一个具有键[‘index’、‘columns’、‘data’、‘index_names’、‘column_names’]的字典。

1.4.0 版本中的新功能：‘tight’作为orient参数的允许值

dtypedtype，默认为 None

在 DataFrame 构造之后强制的数据类型，否则推断。

columns列表，默认为 None

在orient='index'时要使用的列标签。如果与orient='columns'或orient='tight'一起使用会引发 ValueError。

返回：

DataFrame

另请参阅

DataFrame.from_records

从结构化的 ndarray、元组序列或字典或 DataFrame 创建 DataFrame。

DataFrame

使用构造函数创建 DataFrame 对象。

DataFrame.to_dict

将 DataFrame 转换为字典。

示例

默认情况下，字典的键成为 DataFrame 的列：

>>> data = {'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
>>> pd.DataFrame.from_dict(data)
 col_1 col_2
0      3     a
1      2     b
2      1     c
3      0     d 

指定orient='index'以使用字典键作为行创建 DataFrame：

>>> data = {'row_1': [3, 2, 1, 0], 'row_2': ['a', 'b', 'c', 'd']}
>>> pd.DataFrame.from_dict(data, orient='index')
 0  1  2  3
row_1  3  2  1  0
row_2  a  b  c  d 

在使用‘index’方向时，可以手动指定列名：

>>> pd.DataFrame.from_dict(data, orient='index',
...                        columns=['A', 'B', 'C', 'D'])
 A  B  C  D
row_1  3  2  1  0
row_2  a  b  c  d 

指定orient='tight'以使用‘tight’格式创建 DataFrame：

>>> data = {'index': [('a', 'b'), ('a', 'c')],
...         'columns': [('x', 1), ('y', 2)],
...         'data': [[1, 3], [2, 4]],
...         'index_names': ['n1', 'n2'],
...         'column_names': ['z1', 'z2']}
>>> pd.DataFrame.from_dict(data, orient='tight')
z1     x  y
z2     1  2
n1 n2
a  b   1  3
 c   2  4 

pandas.DataFrame.from_records

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.from_records.html

classmethod DataFrame.from_records(data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None)

将结构化或记录 ndarray 转换为 DataFrame。

从结构化 ndarray、元组序列或字典或 DataFrame 创建 DataFrame 对象。

参数：

data结构化 ndarray、元组序列或字典，或 DataFrame

结构化输入数据。

自版本 2.1.0 起已弃用：传递 DataFrame 已被弃用。

indexstr、字段列表、类似数组

用作索引的数组字段，或者要使用的特定一组输入标签。

excludesequence，默认为 None

要排除的列或字段。

columnssequence，默认为 None

要使用的列名。如果传递的数据没有与其关联的名称，此参数为列提供名称。否则，此参数指示结果中列的顺序（数据中未找到的任何名称将成为全 NA 列）。

coerce_floatbool，默认为 False

尝试将非字符串、非数字对象（如 decimal.Decimal）的值转换为浮点数，对于 SQL 结果集很有用。

nrowsint，默认为 None

如果数据是迭代器，则要读取的行数。

返回：

DataFrame

另请参阅

DataFrame.from_dict

从字典的类似数组或字典创建 DataFrame。

DataFrame

使用构造函数创建 DataFrame 对象。

示例

数据可以作为结构化 ndarray 提供：

>>> data = np.array([(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')],
...                 dtype=[('col_1', 'i4'), ('col_2', 'U1')])
>>> pd.DataFrame.from_records(data)
 col_1 col_2
0      3     a
1      2     b
2      1     c
3      0     d 

数据可以作为字典列表提供：

>>> data = [{'col_1': 3, 'col_2': 'a'},
...         {'col_1': 2, 'col_2': 'b'},
...         {'col_1': 1, 'col_2': 'c'},
...         {'col_1': 0, 'col_2': 'd'}]
>>> pd.DataFrame.from_records(data)
 col_1 col_2
0      3     a
1      2     b
2      1     c
3      0     d 

数据可以作为具有相应列的元组列表提供：

>>> data = [(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')]
>>> pd.DataFrame.from_records(data, columns=['col_1', 'col_2'])
 col_1 col_2
0      3     a
1      2     b
2      1     c
3      0     d 

pandas.DataFrame.to_orc

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_orc.html

DataFrame.to_orc(path=None, *, engine='pyarrow', index=None, engine_kwargs=None)

将 DataFrame 写入 ORC 格式。

版本 1.5.0 中的新功能。

参数：

pathstr、文件类似对象或 None，默认为 None

如果是字符串，则在写入分区数据集时将其用作根目录路径。 通过文件类似对象，我们指的是具有 write() 方法的对象，例如文件句柄（例如通过内置的 open 函数）。 如果路径为 None，则返回一个字节对象。

engine，默认为 ‘pyarrow’

要使用的 ORC 库。

indexbool，可选

如果为 True，则在文件输出中包括数据帧的索引。 如果为 False，则不会写入文件。 如果为 None，与 infer 类似，数据帧的索引将被保存。 但是，索引将以元数据中的范围形式存储，因此不需要太多的空间，速度更快。 其他索引将包含在文件输出中作为列。

engine_kwargsdict[str, Any] 或 None，默认为 None

传递给 pyarrow.orc.write_table() 的其他关键字参数。

返回：

如果未提供路径参数，则为字节，否则为 None

引发：

未实现错误

一个或多个列的 Dtype 是类别、无符号整数、间隔、周期或稀疏。

值错误

引擎不是 pyarrow。

另请参阅

read_orc

读取 ORC 文件。

DataFrame.to_parquet

写入一个 parquet 文件。

DataFrame.to_csv

写入一个 csv 文件。

DataFrame.to_sql

写入到 SQL 表。

DataFrame.to_hdf

写入到 hdf。

注意事项

• 在使用此功能之前，您应该阅读有关 ORC 的 用户指南 和 安装可选依赖项。

• 此函数需要 pyarrow 库。

• 有关支持的数据类型，请参阅 Arrow 中支持的 ORC 特性。

• 当前，将日期时间列转换为 ORC 文件时，不会保留时区。

示例

>>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [4, 3]})
>>> df.to_orc('df.orc')  
>>> pd.read_orc('df.orc')  
 col1  col2
0     1     4
1     2     3 

如果您想要获得 orc 内容的缓冲区，可以将其写入 io.BytesIO

>>> import io
>>> b = io.BytesIO(df.to_orc())  
>>> b.seek(0)  
0
>>> content = b.read() 

pandas.DataFrame.to_parquet

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_parquet.html

DataFrame.to_parquet(path=None, *, engine='auto', compression='snappy', index=None, partition_cols=None, storage_options=None, **kwargs)

将 DataFrame 写入二进制 parquet 格式。

此函数将数据框写入parquet 文件。您可以选择不同的 parquet 后端，并选择压缩选项。有关更多详细信息，请参阅用户指南。

参数：

pathstr，路径对象，文件对象或 None，默认为 None

字符串、路径对象（实现os.PathLike[str]）或实现二进制write()函数的文件对象。如果为 None，则结果以字节形式返回。如果是字符串或路径，则在写入分区数据集时将用作根目录路径。

engine，默认为‘auto’

要使用的 parquet 库。如果为‘auto’，则使用选项io.parquet.engine。默认io.parquet.engine行为是尝试‘pyarrow’，如果‘pyarrow’不可用，则退回到‘fastparquet’。

compressionstr 或 None，默认为‘snappy’

使用的压缩名称。使用None表示不压缩。支持的选项：‘snappy’、‘gzip’、‘brotli’、‘lz4’、‘zstd’。

indexbool，默认为 None

如果为True，则将数据框的索引包含在文件输出中。如果为False，则不会写入文件。如果为None，类似于True，数据框的索引将被保存。但是，RangeIndex 将作为元数据中的范围存储，因此不需要太多空间并且更快。其他索引将包含在文件输出中作为列。

partition_colslist，可选，默认为 None

用于分区数据集的列名。按给定顺序对列进行分区。如果路径不是字符串，则必须为 None。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并且有关存储选项的更多示例，请参考这里。

**kwargs

传递给 parquet 库的其他参数。有关更多详细信息，请参阅 pandas io。

返回：

如果未提供路径参数，则为字节，否则为 None

另请参阅

read_parquet

读取 parquet 文件。

DataFrame.to_orc

写入 orc 文件。

DataFrame.to_csv

写入 csv 文件。

DataFrame.to_sql

写入到一个 SQL 表。

DataFrame.to_hdf

写入到 HDF。

注意事项

这个函数需要使用fastparquet或pyarrow库。

示例

>>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [3, 4]})
>>> df.to_parquet('df.parquet.gzip',
...               compression='gzip')  
>>> pd.read_parquet('df.parquet.gzip')  
 col1  col2
0     1     3
1     2     4 

如果你想要获取到 parquet 内容的缓冲区，你可以使用一个 io.BytesIO 对象，只要你不使用 partition_cols，这会创建多个文件。

>>> import io
>>> f = io.BytesIO()
>>> df.to_parquet(f)
>>> f.seek(0)
0
>>> content = f.read() 

pandas.DataFrame.to_pickle

pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_pickle.html

DataFrame.to_pickle(path, *, compression='infer', protocol=5, storage_options=None)

将对象序列化（pickle）到文件。

参数：

pathstr、路径对象或类似文件的对象

字符串、路径对象（实现os.PathLike[str]）或实现二进制write()函数的类似文件的对象。pickle 对象将存储的文件路径。

compression字符串或字典，默认为‘infer’

用于即时压缩输出数据。如果‘infer’和‘path’是类似路径的对象，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’或‘.tar.bz2’（否则不压缩）。设置为None表示不压缩。也可以是一个字典，其中键'method'设置为其中之一{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发给zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以传递以下内容以进行更快的压缩并创建可重现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

版本 1.5.0 中的新功能：增加对.tar 文件的支持。

protocol整数

指示 pickler 应使用的协议的整数，默认为 HIGHEST_PROTOCOL（参见[1]第 12.1.2 段）。可能的值为 0、1、2、3、4、5。协议参数的负值等效于将其值设置为 HIGHEST_PROTOCOL。

[1]

docs.python.org/3/library/pickle.html.

storage_options字典，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并参考此处获取有关存储选项的更多示例。

另请参阅

read_pickle

从文件加载 pickle 的 pandas 对象（或任何对象）。

DataFrame.to_hdf

将 DataFrame 写入 HDF5 文件。

DataFrame.to_sql

将 DataFrame 写入 SQL 数据库。

DataFrame.to_parquet

将 DataFrame 写入二进制 parquet 格式。

示例

>>> original_df = pd.DataFrame({"foo": range(5), "bar": range(5, 10)})  
>>> original_df  
 foo  bar
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9
>>> original_df.to_pickle("./dummy.pkl") 

>>> unpickled_df = pd.read_pickle("./dummy.pkl")  
>>> unpickled_df  
 foo  bar
0    0    5
1    1    6
2    2    7
3    3    8
4    4    9 

pandas.DataFrame.to_csv

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html

DataFrame.to_csv(path_or_buf=None, *, sep=',', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, mode='w', encoding=None, compression='infer', quoting=None, quotechar='"', lineterminator=None, chunksize=None, date_format=None, doublequote=True, escapechar=None, decimal='.', errors='strict', storage_options=None)

将对象写入逗号分隔值（csv）文件。

参数：

path_or_buf字符串、路径对象、类文件对象或 None，默认为 None

字符串、路径对象（实现 os.PathLike[str]）、或实现了 write()函数的类似文件对象。如果为 None，则结果将作为字符串返回。如果传递了非二进制文件对象，则应该使用 newline=''打开它，禁用通用换行符。如果传递了二进制文件对象，则可能需要在 mode 中包含'b'。

sep字符串，默认为','

长度为 1 的字符串。输出文件的字段分隔符。

na_rep字符串，默认为''

缺失数据表示。

float_format字符串、可调用对象，默认为 None

浮点数的格式字符串。如果给出了一个可调用对象，则它优先于其他数字格式化参数，如小数。

columns序列，可选的

要写的列。

header布尔值或字符串列表，默认为 True

写出列名。如果给定一个字符串列表，则假定它是列名的别名。

index布尔值，默认为 True

写入行名称（索引）。

index_label字符串或序列，或 False，默认为 None

如果需要，用于索引列的列标签。如果给出了 None，并且 header 和 index 为 True，则使用索引名称。如果对象使用 MultiIndex，则应该给出一个序列。如果为 False，则不打印索引名称字段。在 R 中更容易导入，请使用 index_label=False。

mode，默认为'w'

转发到 open(mode=)或 fsspec.open(mode=)以控制文件打开。典型的值包括：

• 'w'，先截断文件。

• 'x'，独占创建，如果文件已经存在则失败。

• 'a'，如果文件存在，则追加到文件末尾。

encoding字符串，可选的

表示要在输出文件中使用的编码的字符串，默认为'utf-8'。如果 path_or_buf 是非二进制文件对象，则不支持编码。

compression字符串或字典，默认为'infer'

用于即时压缩输出数据。如果'推断'和'path_or_buf'是路径类的，则从以下扩展名中检测压缩：'.gz'、'.bz2'、'.zip'、'.xz'、'.zst'、'.tar'、'.tar.gz'、'.tar.xz'或'.tar.bz2'（否则不压缩）。设置为None表示不压缩。也可以是一个字典，其中键'method'设置为其中一个{'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发给zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile或tarfile.TarFile。例如，可以传递以下内容以获得更快的压缩并创建可重现的 gzip 归档文件：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

新版本新增功能：1.5.0 版：增加对.tar 文件的支持。

可能是一个字典，其中键'method'作为压缩模式，其他条目作为额外的压缩选项，如果压缩模式为'zip'。

将压缩选项作为字典键传递支持压缩模式'gzip'、'bz2'、'zstd'和'zip'。

quotingcsv 模块的可选常量

默认为 csv.QUOTE_MINIMAL。如果设置了 float_format，则浮点数将转换为字符串，因此 csv.QUOTE_NONNUMERIC 将将它们视为非数字。

quotecharstr，默认为'"'

长度为 1 的字符串。用于引用字段。

lineterminatorstr，可选

输出文件中要使用的换行符或换行符序列。默认为 os.linesep，这取决于调用此方法的操作系统（linux 为'\n'，Windows 为'\r\n'）。

自版本 1.5.0 更改：先前为 line_terminator，现已与 read_csv 和标准库'csv'模块保持一致。

chunksizeint 或 None

每次写入的行数。

date_formatstr，默认为 None

用于日期时间对象的格式字符串。

doublequotebool，默认为 True

控制字段内引用的 quotechar 的引用。

escapecharstr，默认为 None

长度为 1 的字符串。适当时用于转义 sep 和 quotechar 的字符。

decimalstr，默认为'.'

作为十进制分隔符识别的字符。例如，对于欧洲数据，请使用','。

errorsstr，默认为'strict'

指定如何处理编码和解码错误。有关完整选项列表，请参阅open()的 errors 参数。

storage_optionsdict，可选

对于特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发到urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发到fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并查看有关存储选项的更多示例，请参考这里。

返回：

None 或 str

如果 path_or_buf 为 None，则返回生成的 csv 格式字符串。否则返回 None。

另请参见

read_csv

将 CSV 文件加载到 DataFrame 中。

to_excel

将 DataFrame 写入 Excel 文件。

示例

创建包含没有索引的'df'的'out.csv'

>>> df = pd.DataFrame({'name': ['Raphael', 'Donatello'],
...                    'mask': ['red', 'purple'],
...                    'weapon': ['sai', 'bo staff']})
>>> df.to_csv('out.csv', index=False) 

创建包含'out.csv'的'out.zip'

>>> df.to_csv(index=False)
'name,mask,weapon\nRaphael,red,sai\nDonatello,purple,bo staff\n'
>>> compression_opts = dict(method='zip',
...                         archive_name='out.csv')  
>>> df.to_csv('out.zip', index=False,
...           compression=compression_opts) 

要将 csv 文件写入新文件夹或嵌套文件夹，您首先需要使用 Pathlib 或 os 创建它：

>>> from pathlib import Path  
>>> filepath = Path('folder/subfolder/out.csv')  
>>> filepath.parent.mkdir(parents=True, exist_ok=True)  
>>> df.to_csv(filepath) 

>>> import os  
>>> os.makedirs('folder/subfolder', exist_ok=True)  
>>> df.to_csv('folder/subfolder/out.csv') 

pandas.DataFrame.to_hdf

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_hdf.html

DataFrame.to_hdf(path_or_buf, *, key, mode='a', complevel=None, complib=None, append=False, format=None, index=True, min_itemsize=None, nan_rep=None, dropna=None, data_columns=None, errors='strict', encoding='UTF-8')

使用 HDFStore 将包含的数据写入 HDF5 文件。

分层数据格式（HDF）是自描述的，允许应用程序解释文件的结构和内容，而无需外部信息。一个 HDF 文件可以保存一组相关对象，可以作为一组或单独对象访问。

要将另一个 DataFrame 或 Series 添加到现有的 HDF 文件中，请使用追加模式和不同的键。

警告

可以将 DataFrame 或 Series 的子类存储到 HDF5 中，但在存储时会丢失子类的类型。

有关更多信息，请参阅用户指南。

参数：

path_or_bufstr 或 pandas.HDFStore

文件路径或 HDFStore 对象。

keystr

存储中的组的标识符。

mode，默认为 ‘a’

打开文件的模式：

• ‘w’：写入，创建一个新文件（同名的现有文件将被删除）。

• ‘a’：追加，打开现有文件进行读取和写入，如果文件不存在，则创建它。

• ‘r+’：类似于 ‘a’，但文件必须已经存在。

complevel，默认为 None

为数据指定一个压缩级别。值为 0 或 None 禁用压缩。

complib，默认为 ‘zlib’

指定要使用的压缩库。支持这些额外的 Blosc 压缩器（如果未指定压缩器，则默认为 ‘blosc:blosclz’）：{‘blosc:blosclz’, ‘blosc:lz4’, ‘blosc:lz4hc’, ‘blosc:snappy’, ‘blosc:zlib’, ‘blosc:zstd’}。指定不可用的压缩库会引发 ValueError。

appendbool，默认为 False

对于表格格式，将输入数据追加到现有数据中。

format，默认为 ‘fixed’

可能的值：

• ‘fixed’：固定格式。快速写入/读取。不可追加，也不可搜索。

• ‘table’：表格格式。写入 PyTables 表结构，可能性能较差，但允许更灵活的操作，如搜索/选择数据子集。

• 如果为 None，则检查 pd.get_option(‘io.hdf.default_format’)，然后回退到“fixed”。

indexbool，默认为 True

将 DataFrame 索引写入作为一列。

min_itemsizedict 或 int，可选

将列名映射到列的最小字符串大小。

nan_rep任意，可选

如何将空值表示为字符串。不允许与 append=True 一起使用。

dropnabool，默认为 False，可选

删除缺失值。

data_columns列的列表或 True，可选

要创建为磁盘查询的索引数据列的列列表，或者为 True 以使用所有列。默认情况下，只有对象的轴被索引。有关更多信息，请参见通过数据列进行查询。

errorsstr，默认为 ‘strict’

指定如何处理编码和解码错误。查看 open() 的 errors 参数以获取完整的选项列表。

encodingstr，默认为“UTF-8”

另请参阅

read_hdf

从 HDF 文件中读取。

DataFrame.to_orc

将 DataFrame 写入二进制 Orc 格式。

DataFrame.to_parquet

将 DataFrame 写入二进制 Parquet 格式。

DataFrame.to_sql

将数据写入 SQL 表格。

DataFrame.to_feather

为 DataFrame 写出羽毛格式。

DataFrame.to_csv

将数据写入 csv 文件。

示例

>>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]},
...                   index=['a', 'b', 'c'])  
>>> df.to_hdf('data.h5', key='df', mode='w') 

我们可以将另一个对象添加到同一个文件中：

>>> s = pd.Series([1, 2, 3, 4])  
>>> s.to_hdf('data.h5', key='s') 

从 HDF 文件中读取：

>>> pd.read_hdf('data.h5', 'df')  
A  B
a  1  4
b  2  5
c  3  6
>>> pd.read_hdf('data.h5', 's')  
0    1
1    2
2    3
3    4
dtype: int64 

pandas.DataFrame.to_sql

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html

DataFrame.to_sql(name, con, *, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None, method=None)

将存储在 DataFrame 中的记录写入 SQL 数据库。

支持 SQLAlchemy[1]支持的数据库。可以新建表，追加或覆盖表。

参数：

namestr

SQL 表的名称。

consqlalchemy.engine.(Engine 或 Connection)或 sqlite3.Connection

使用 SQLAlchemy 可以使用该库支持的任何 DB。为 sqlite3.Connection 对象提供了旧版支持。用户负责对 SQLAlchemy 可连接对象进行引擎处理和连接关闭。请参阅此处。如果传递的是已在事务中的 sqlalchemy.engine.Connection，则不会提交事务。如果传递 sqlite3.Connection，则将无法回滚记录插入。

schemastr，可选

指定模式（如果数据库支持）。如果为 None，则使用默认模式。

if_exists，默认为‘fail’

如果表已经存在，则如何行为。

• 失败：引发 ValueError。

• replace：在插入新值之前删除表。

• append：将新值插入到现有表中。

indexbool，默认为 True

将 DataFrame 索引写入列中。在表中使用 index_label 作为列名。为该列创建表索引。

index_labelstr 或序列，默认为 None

索引列的列标签。如果给出 None（默认值）并且 index 为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则应给出序列。

chunksizeint，可选

指定每次写入的批处理中的行数。默认情况下，所有行将一次性写入。

dtypedict 或标量，可选

指定列的数据类型。如果使用字典，则键应为列名，值应为 SQLAlchemy 类型或 sqlite3 旧模式的字符串。如果提供标量，则将应用于所有列。

method，可选

控制使用的 SQL 插入子句：

• None：使用标准 SQL INSERT子句（每行一个）。

• ‘multi’：在单个INSERT子句中传递多个值。

• 具有签名(pd_table, conn, keys, data_iter)的可调用对象。

详细信息和示例可在插入方法部分找到。

返回：

None 或 int

to_sql 影响的行数。如果传递给method的可调用对象不返回整数行数，则返回 None。

返回的受影响行数是sqlite3.Cursor或 SQLAlchemy 可连接对象的rowcount属性的总和，这可能不反映sqlite3或SQLAlchemy中规定的确切写入行数。

版本 1.4.0 中的新内容。

引发：

ValueError

当表已经存在且 if_exists 为‘fail’（默认）时。

参见

read_sql

从表中读取一个 DataFrame。

注意

如果数据库支持，时区感知的 datetime 列将被写入为Timestamp with timezone类型的 SQLAlchemy。否则，datetimes 将以原始时区为本地的无时区时间戳存储。

并非所有数据存储支持method="multi"。例如，Oracle 不支持多值插入。

参考

[1]

docs.sqlalchemy.org

[2]

www.python.org/dev/peps/pep-0249/

示例

创建一个内存中的 SQLite 数据库。

>>> from sqlalchemy import create_engine
>>> engine = create_engine('sqlite://', echo=False) 

从头开始创建一个包含 3 行的表。

>>> df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})
>>> df
 name
0  User 1
1  User 2
2  User 3 

>>> df.to_sql(name='users', con=engine)
3
>>> from sqlalchemy import text
>>> with engine.connect() as conn:
...    conn.execute(text("SELECT * FROM users")).fetchall()
[(0, 'User 1'), (1, 'User 2'), (2, 'User 3')] 

也可以将 sqlalchemy.engine.Connection 传递给 con：

>>> with engine.begin() as connection:
...     df1 = pd.DataFrame({'name' : ['User 4', 'User 5']})
...     df1.to_sql(name='users', con=connection, if_exists='append')
2 

允许这样做是为了支持需要整个操作使用相同的 DBAPI 连接的操作。

>>> df2 = pd.DataFrame({'name' : ['User 6', 'User 7']})
>>> df2.to_sql(name='users', con=engine, if_exists='append')
2
>>> with engine.connect() as conn:
...    conn.execute(text("SELECT * FROM users")).fetchall()
[(0, 'User 1'), (1, 'User 2'), (2, 'User 3'),
 (0, 'User 4'), (1, 'User 5'), (0, 'User 6'),
 (1, 'User 7')] 

仅使用df2覆盖表。

>>> df2.to_sql(name='users', con=engine, if_exists='replace',
...            index_label='id')
2
>>> with engine.connect() as conn:
...    conn.execute(text("SELECT * FROM users")).fetchall()
[(0, 'User 6'), (1, 'User 7')] 

使用method定义一个可调用的插入方法，在 PostgreSQL 数据库中的表上发生主键冲突时不执行任何操作。

>>> from sqlalchemy.dialects.postgresql import insert
>>> def insert_on_conflict_nothing(table, conn, keys, data_iter):
...     # "a" is the primary key in "conflict_table"
...     data = [dict(zip(keys, row)) for row in data_iter]
...     stmt = insert(table.table).values(data).on_conflict_do_nothing(index_elements=["a"])
...     result = conn.execute(stmt)
...     return result.rowcount
>>> df_conflict.to_sql(name="conflict_table", con=conn, if_exists="append", method=insert_on_conflict_nothing)  
0 

对于 MySQL，如果主键冲突，则更新列b和c的可调用函数。

>>> from sqlalchemy.dialects.mysql import insert
>>> def insert_on_conflict_update(table, conn, keys, data_iter):
...     # update columns "b" and "c" on primary key conflict
...     data = [dict(zip(keys, row)) for row in data_iter]
...     stmt = (
...         insert(table.table)
...         .values(data)
...     )
...     stmt = stmt.on_duplicate_key_update(b=stmt.inserted.b, c=stmt.inserted.c)
...     result = conn.execute(stmt)
...     return result.rowcount
>>> df_conflict.to_sql(name="conflict_table", con=conn, if_exists="append", method=insert_on_conflict_update)  
2 

指定 dtype（对于具有缺失值的整数特别有用）。请注意，虽然 pandas 被强制将数据存储为浮点数，但数据库支持可空整数。在使用 Python 检索数据时，我们会得到整数标量。

>>> df = pd.DataFrame({"A": [1, None, 2]})
>>> df
 A
0  1.0
1  NaN
2  2.0 

>>> from sqlalchemy.types import Integer
>>> df.to_sql(name='integers', con=engine, index=False,
...           dtype={"A": Integer()})
3 

>>> with engine.connect() as conn:
...   conn.execute(text("SELECT * FROM integers")).fetchall()
[(1,), (None,), (2,)] 

pandas.DataFrame.to_dict

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_dict.html

DataFrame.to_dict(orient='dict', *, into=<class 'dict'>, index=True)

将 DataFrame 转换为字典。

键值对的类型可以通过参数进行自定义（参见下文）。

参数：

orientstr {‘dict’，‘list’，‘series’，‘split’，‘tight’，‘records’，‘index’}

确定字典的值的类型。

• ‘dict’（默认值）：类似于 {列 -> {索引 -> 值}} 的字典

• ‘list’：类似于 {列 -> [值]} 的字典

• ‘series’：类似于 {列 -> Series(值)} 的字典

• ‘split’：类似于 {‘index’ -> [索引]，‘columns’ -> [列]，‘data’ -> [值]} 的字典

• ‘tight’：类似于 {‘index’ -> [索引]，‘columns’ -> [列]，‘data’ -> [值]，‘index_names’ -> [索引名称]，‘column_names’ -> [列名称]} 的字典

• ‘records’：类似于 [{列 -> 值}，…，{列 -> 值}] 的列表

• ‘index’：类似于 {索引 -> {列 -> 值}} 的字典

新版本 1.4.0 中新增：‘tight’ 作为 orient 参数的允许值

into类，默认为 dict

返回值中所有映射使用的 collections.abc.MutableMapping 子类。可以是实际类，也可以是您想要的映射类型的空实例。如果您想要一个 collections.defaultdict，您必须传入已初始化的 defaultdict。

indexbool，默认为 True

是否在返回的字典中包含索引项（如果 orient 是 ‘tight’，还包括 index_names 项）。当 orient 是 ‘split’ 或 ‘tight’ 时，只能是 False。

新版本 2.0.0 中新增。

返回值：

dict、list 或 collections.abc.MutableMapping

返回一个表示 DataFrame 的 collections.abc.MutableMapping 对象。结果的转换取决于 orient 参数。

另请参见

DataFrame.from_dict

从字典创建 DataFrame。

DataFrame.to_json

将 DataFrame 转换为 JSON 格式。

示例

>>> df = pd.DataFrame({'col1': [1, 2],
...                    'col2': [0.5, 0.75]},
...                   index=['row1', 'row2'])
>>> df
 col1  col2
row1     1  0.50
row2     2  0.75
>>> df.to_dict()
{'col1': {'row1': 1, 'row2': 2}, 'col2': {'row1': 0.5, 'row2': 0.75}} 

您可以指定返回的方向。

>>> df.to_dict('series')
{'col1': row1    1
 row2    2
Name: col1, dtype: int64,
'col2': row1    0.50
 row2    0.75
Name: col2, dtype: float64} 

>>> df.to_dict('split')
{'index': ['row1', 'row2'], 'columns': ['col1', 'col2'],
 'data': [[1, 0.5], [2, 0.75]]} 

>>> df.to_dict('records')
[{'col1': 1, 'col2': 0.5}, {'col1': 2, 'col2': 0.75}] 

>>> df.to_dict('index')
{'row1': {'col1': 1, 'col2': 0.5}, 'row2': {'col1': 2, 'col2': 0.75}} 

>>> df.to_dict('tight')
{'index': ['row1', 'row2'], 'columns': ['col1', 'col2'],
 'data': [[1, 0.5], [2, 0.75]], 'index_names': [None], 'column_names': [None]} 

您还可以指定映射类型。

>>> from collections import OrderedDict, defaultdict
>>> df.to_dict(into=OrderedDict)
OrderedDict([('col1', OrderedDict([('row1', 1), ('row2', 2)])),
 ('col2', OrderedDict([('row1', 0.5), ('row2', 0.75)]))]) 

如果您想要一个 defaultdict，您需要初始化它：

>>> dd = defaultdict(list)
>>> df.to_dict('records', into=dd)
[defaultdict(<class 'list'>, {'col1': 1, 'col2': 0.5}),
 defaultdict(<class 'list'>, {'col1': 2, 'col2': 0.75})] 

pandas.DataFrame.to_excel

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_excel.html

DataFrame.to_excel(excel_writer, *, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, inf_rep='inf', freeze_panes=None, storage_options=None, engine_kwargs=None)

将对象写入 Excel 表格。

要将单个对象写入 Excel .xlsx 文件，只需指定目标文件名即可。要写入多个工作表，需要创建一个带有目标文件名的 ExcelWriter 对象，并指定要写入的文件中的工作表。

可通过指定唯一的 sheet_name 来写入多个工作表。将所有数据写入文件后，需要保存更改。请注意，使用已存在的文件名创建 ExcelWriter 对象将导致擦除现有文件的内容。

参数：

excel_writer类似路径、类似文件或 ExcelWriter 对象

文件路径或现有的 ExcelWriter。

sheet_namestr，默认为‘Sheet1’

包含 DataFrame 的工作表的名称。

na_repstr，默认为‘’

缺失数据表示。

float_formatstr，可选

浮点数的格式字符串。例如，float_format="%.2f"将 0.1234 格式化为 0.12。

columns序列或字符串列表，可选

要写入的列。

headerbool 或字符串列表，默认为 True

写出列名。如果给定字符串列表，则假定为列名的别名。

indexbool，默认为 True

写入行名称（索引）。

index_labelstr 或序列，可选

如果需要，用于索引列的列标签。如果未指定，并且标题和索引为 True，则使用索引名称。如果数据框使用 MultiIndex，则应给出一个序列。

startrowint，默认为 0

要将数据框转储到的左上角单元格行。

startcolint，默认为 0

要将数据框转储到的左上角单元格列。

enginestr，可选

要使用的写引擎，‘openpyxl’或‘xlsxwriter’。您还可以通过选项io.excel.xlsx.writer或io.excel.xlsm.writer设置此选项。

merge_cellsbool，默认为 True

将 MultiIndex 和分层行写为合并单元格。

inf_repstr，默认为‘inf’

无穷大的表示（Excel 中没有本机表示无穷大）。

freeze_panesint 元组（长度为 2），可选

指定要冻结的基于一的最底部行和最右侧列。

storage_optionsdict，可选

适用于特定存储连接的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并有关存储选项的更多示例，请参考这里。

版本 1.2.0 中的新功能。

engine_kwargsdict，可选

传递给 Excel 引擎的任意关键字参数。

另请参见

to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

ExcelWriter

用于将 DataFrame 对象写入 Excel 表格的类。

read_excel

将 Excel 文件读取为 pandas DataFrame。

read_csv

将逗号分隔值（csv）文件读取为 DataFrame。

io.formats.style.Styler.to_excel

向 Excel 表格添加样式。

注意事项

为了与to_csv()兼容，to_excel 在写入之前将列表和字典序列化为字符串。

一旦工作簿被保存，就无法再写入更多数据，除非重新写入整个工作簿。

示例

创建、写入和保存工作簿：

>>> df1 = pd.DataFrame([['a', 'b'], ['c', 'd']],
...                    index=['row 1', 'row 2'],
...                    columns=['col 1', 'col 2'])
>>> df1.to_excel("output.xlsx") 

指定表格名称：

>>> df1.to_excel("output.xlsx",
...              sheet_name='Sheet_name_1') 

如果要向工作簿中的多个表写入数据，则需要指定一个 ExcelWriter 对象：

>>> df2 = df1.copy()
>>> with pd.ExcelWriter('output.xlsx') as writer:  
...     df1.to_excel(writer, sheet_name='Sheet_name_1')
...     df2.to_excel(writer, sheet_name='Sheet_name_2') 

ExcelWriter 也可以用于向现有的 Excel 文件追加：

>>> with pd.ExcelWriter('output.xlsx',
...                     mode='a') as writer:  
...     df1.to_excel(writer, sheet_name='Sheet_name_3') 

要设置用于编写 Excel 文件的库，可以传递 engine 关键字（默认引擎会根据文件扩展名自动选择）：

>>> df1.to_excel('output1.xlsx', engine='xlsxwriter') 

pandas.DataFrame.to_json

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html

DataFrame.to_json(path_or_buf=None, *, orient=None, date_format=None, double_precision=10, force_ascii=True, date_unit='ms', default_handler=None, lines=False, compression='infer', index=None, indent=None, storage_options=None, mode='w')

将对象转换为 JSON 字符串。

注意 NaN 和 None 将被转换为 null，而日期时间对象将被转换为 UNIX 时间戳。

参数：

path_or_bufstr、路径对象、类文件对象或 None，默认为 None

字符串、路径对象（实现 os.PathLike[str]）、或实现 write() 函数的类文件对象。如果为 None，则结果将作为字符串返回。

orientstr

预期的 JSON 字符串格式的指示。

• Series:

  • 默认为 ‘index’
  • 允许的值有：{‘split’、‘records’、‘index’、‘table’}。

• DataFrame:

  • 默认为 ‘columns’
  • 允许的值有：{‘split’、‘records’、‘index’、‘columns’、‘values’、‘table’}。

• JSON 字符串的格式：

  • ‘split’ : 类似字典
  • ‘records’ : 类似列表 [{column -> value}, … , {column -> value}]
  • ‘index’ : 类似字典 {index -> {column -> value}}
  • ‘columns’ : 类似字典 {column -> {index -> value}}
  • ‘values’ : 只有值数组
  • ‘table’ : 类似字典 {‘schema’: {schema}, ‘data’: {data}}

  描述数据，其中数据组件类似 orient='records'。

date_format

日期转换的类型。‘epoch’ = 纪元毫秒，‘iso’ = ISO8601。默认取决于 orient。对于 orient='table'，默认为 ‘iso’。对于所有其他 orient， 默认为 ‘epoch’。

double_precisionint，默认为 10

在编码浮点值时要使用的小数位数。可能的最大值是 15。传递大于 15 的 double_precision 将引发 ValueError。

force_asciibool，默认为 True

强制编码的字符串为 ASCII。

date_unitstr，默认为 ‘ms’（毫秒）

要编码到的时间单位，控制时间戳和 ISO8601 的精度。‘s’、‘ms’、‘us’、‘ns’ 分别代表秒、毫秒、微秒和纳秒。

default_handlercallable，默认为 None

如果对象无法被转换为 JSON 的合适格式，则调用处理程序。应接收一个参数，该参数是要转换的对象，并返回一个可序列化对象。

linesbool，默认为 False

如果‘orient’为‘records’，则写出分行的 json 格式。如果‘orient’不正确，将抛出 ValueError，因为其他格式不是类似列表的。

compressionstr 或字典，默认为 ‘infer’

用于即时压缩输出数据。如果 ‘infer’ 并且 ‘path_or_buf’ 是类似路径的，则从以下扩展名中检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’ 或 ‘.tar.bz2’（否则不压缩）。设置为 None 表示不压缩。也可以是一个字典，其中键为 'method'，值为其中之一 {'zip', 'gzip', 'bz2', 'zstd', 'xz', 'tar'}，其他键值对将被传递给 zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile 或 tarfile.TarFile。例如，可以传递以下内容以获得更快的压缩和创建可重现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

1.5.0 版本中的新功能：增加了对 .tar 文件的支持。

1.4.0 版本中的更改：增加了对 Zstandard 的支持。

index bool 或 None，默认为 None

仅当 ‘orient’ 为 ‘split’、‘index’、‘column’ 或 ‘table’ 时才使用索引。其中，‘index’ 和 ‘column’ 不支持 index=False。

indent int，可选

用于缩进每个记录的空格长度。

storage_options dict，可选

针对特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项传递给 urllib.request.Request。对于其他 URL（例如以 “s3://” 和 “gcs://” 开头的 URL），键值对将传递给 fsspec.open。请参阅 fsspec 和 urllib 以获取更多详细信息，并参考 这里 了解更多关于存储选项的示例。

mode str，默认为 ‘w’（写入）

在提供 path_or_buf 时指定输出的 IO 模式。接受的参数只有 ‘w’（写入）和 ‘a’（追加）。只有当 lines 为 True 且 orient 为 ‘records’ 时才支持 mode=’a’。

返回：

None 或 str

如果 path_or_buf 为 None，则将生成的 JSON 格式作为字符串返回。否则返回 None。

另请参阅

read_json

将 JSON 字符串转换为 pandas 对象。

注意事项

indent=0 的行为与标准库不同，它不会缩进输出，但会插入换行符。目前，在 pandas 中，indent=0 和默认的 indent=None 是等效的，尽管这可能会在将来的版本中发生变化。

orient='table' 包含了 ‘schema’ 下的 ‘pandas_version’ 字段。这个字段存储了在最新版本的 schema 中使用的 pandas 版本。

示例

>>> from json import loads, dumps
>>> df = pd.DataFrame(
...     [["a", "b"], ["c", "d"]],
...     index=["row 1", "row 2"],
...     columns=["col 1", "col 2"],
... ) 

>>> result = df.to_json(orient="split")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "columns": [
 "col 1",
 "col 2"
 ],
 "index": [
 "row 1",
 "row 2"
 ],
 "data": [
 [
 "a",
 "b"
 ],
 [
 "c",
 "d"
 ]
 ]
} 

使用 'records' 格式化的 JSON 进行编码/解码 Dataframe。请注意，此编码不会保留索引标签。

>>> result = df.to_json(orient="records")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
[
 {
 "col 1": "a",
 "col 2": "b"
 },
 {
 "col 1": "c",
 "col 2": "d"
 }
] 

使用 'index' 格式化的 JSON 进行编码/解码：

>>> result = df.to_json(orient="index")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "row 1": {
 "col 1": "a",
 "col 2": "b"
 },
 "row 2": {
 "col 1": "c",
 "col 2": "d"
 }
} 

使用 'columns' 格式化的 JSON 进行编码/解码：

>>> result = df.to_json(orient="columns")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "col 1": {
 "row 1": "a",
 "row 2": "c"
 },
 "col 2": {
 "row 1": "b",
 "row 2": "d"
 }
} 

使用 'values' 格式化的 JSON 进行编码/解码：

>>> result = df.to_json(orient="values")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
[
 [
 "a",
 "b"
 ],
 [
 "c",
 "d"
 ]
] 

使用 Table Schema 进行编码：

>>> result = df.to_json(orient="table")
>>> parsed = loads(result)
>>> dumps(parsed, indent=4)  
{
 "schema": {
 "fields": [
 {
 "name": "index",
 "type": "string"
 },
 {
 "name": "col 1",
 "type": "string"
 },
 {
 "name": "col 2",
 "type": "string"
 }
 ],
 "primaryKey": [
 "index"
 ],
 "pandas_version": "1.4.0"
 },
 "data": [
 {
 "index": "row 1",
 "col 1": "a",
 "col 2": "b"
 },
 {
 "index": "row 2",
 "col 1": "c",
 "col 2": "d"
 }
 ]
} 

pandas.DataFrame.to_html

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_html.html

DataFrame.to_html(buf=None, *, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, max_rows=None, max_cols=None, show_dimensions=False, decimal='.', bold_rows=True, classes=None, escape=True, notebook=False, border=None, table_id=None, render_links=False, encoding=None)

将 DataFrame 呈现为 HTML 表格。

参数：

bufstr，路径或类似 StringIO 的对象，可选，默认为 None

要写入的缓冲区。如果为 None，则输出将作为字符串返回。

columns类数组，可选，默认为 None

要写入的列的子集。默认写入所有列。

col_spacestr 或 int，int 或 str 的列表或字典，可选

每个列的最小宽度以 CSS 长度单位表示。假定 int 为 px 单位。

headerbool，可选

是否打印列标签，默认为 True。

indexbool，可选，默认为 True

是否打印索引（行）标签。

na_repstr，可选，默认为‘NaN’

要使用的NaN的字符串表示。

formatters列表，元组或一参数函数的字典，可选

按位置或名称应用于列元素的格式化函数。每个函数的结果必须是 unicode 字符串。列表/元组的长度必须等于列数。

float_format一参数函数，可选，默认为 None

要应用于列元素的格式化函数，如果它们是浮点数。此函数必须返回一个 unicode 字符串，并且仅应用于非NaN元素，NaN由na_rep处理。

sparsifybool，可选，默认为 True

对于具有分层索引的 DataFrame，设置为 False 以在每行打印每个多重索引键。

index_namesbool，可选，默认为 True

打印索引的名称。

justifystr，默认为 None

如何对齐列标签。如果为 None，则使用打印配置中的选项（由 set_option 控制），默认为‘right’。有效值为

• 左

• 右

• 居中

• 对齐

• 对齐所有

• 开始

• 结束

• 继承

• 匹配父级

• 初始

• 未设置。

max_rowsint，可选

在控制台中显示的最大行数。

max_colsint，可选

在控制台中显示的最大列数。

show_dimensionsbool，默认为 False

显示 DataFrame 的维度（行数乘以列数）。

decimalstr，默认为‘.’

作为十进制分隔符识别的字符，例如欧洲的‘,’。

bold_rowsbool，默认为 True

使输出中的行标签加粗。

classesstr 或列表或元组，默认为 None

要应用于生成的 HTML 表格的 CSS 类（们）。

escapebool，默认为 True

将字符<，>和&转换为 HTML 安全序列。

notebook，默认为 False

生成的 HTML 是否用于 IPython Notebook。

borderint

在开放的

标签中包含border=border属性。默认为pd.options.display.html.border。

table_idstr，可选

如果指定了 css id，则在开放的

标签中包含。

render_linksbool，默认为 False

将 URL 转换为 HTML 链接。

encodingstr，默认为“utf-8”

设置字符编码。

返回：

字符串或 None

如果 buf 为 None，则将结果作为字符串返回。否则返回 None。

另请参阅

to_string

将 DataFrame 转换为字符串。

示例

>>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [4, 3]})
>>> html_string = '''<table border="1" class="dataframe">
...   <thead>
...     <tr style="text-align: right;">
...       <th></th>
...       <th>col1</th>
...       <th>col2</th>
...     </tr>
...   </thead>
...   <tbody>
...     <tr>
...       <th>0</th>
...       <td>1</td>
...       <td>4</td>
...     </tr>
...     <tr>
...       <th>1</th>
...       <td>2</td>
...       <td>3</td>
...     </tr>
...   </tbody>
... </table>'''
>>> assert html_string == df.to_html() 

pandas.DataFrame.to_feather

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_feather.html

DataFrame.to_feather(path, **kwargs)

将 DataFrame 写入二进制 Feather 格式。

参数：

路径str、路径对象、类文件对象

字符串、路径对象（实现os.PathLike[str]）、或实现二进制write()函数的类文件对象。如果是字符串或路径，它将用作写入分区数据集时的根目录路径。

**kwargs

传递给pyarrow.feather.write_feather()的额外关键字。这包括压缩、压缩级别、块大小和版本关键字。

注意

此函数将数据框写入feather 文件。需要一个默认索引。要使用支持自定义索引的方法保存带有自定义索引的 DataFrame，例如 to_parquet。

示例

>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]])
>>> df.to_feather("file.feather") 

pandas.DataFrame.to_latex

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_latex.html

DataFrame.to_latex(buf=None, *, columns=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=False, column_format=None, longtable=None, escape=None, encoding=None, decimal='.', multicolumn=None, multicolumn_format=None, multirow=None, caption=None, label=None, position=None)

将对象呈现为 LaTeX tabular、longtable 或嵌套表格。

需要 \usepackage{{booktabs}}。输出可以复制/粘贴到主 LaTeX 文档中，或者用 \input{{table.tex}} 从外部文件读取。

从 2.0.0 版本开始更改：重构为使用 jinja2 模板化的 Styler 实现。

参数：

bufstr、路径或类似 StringIO 的对象，可选，默认为 None

要写入的缓冲区。如果为 None，则输出将作为字符串返回。

columns标签列表，可选

要写入的列的子集。默认情况下，写入所有列。

headerbool 或字符串列表，默认为 True

写出列名。如果给定字符串列表，则假定为列名的别名。

indexbool，默认为 True

写入行名称（索引）。

na_repstr，默认为‘NaN’

缺失数据表示。

formatters函数列表或{{str: function}}字典，可选

要应用于按位置或名称的列元素的格式化程序函数。每个函数的结果必须是 unicode 字符串。列表的长度必须等于列数。

float_format一参数函数或 str，可选，默认为 None

浮点数格式化程序。例如 float_format="%.2f" 和 float_format="{{:0.2f}}".format 都将使 0.1234 格式化为 0.12。

sparsifybool，可选

对于具有分层索引的 DataFrame，将其设置为 False，以在每行中打印每个多重索引键。默认情况下，该值将从配置模块中读取。

index_namesbool，默认为 True

打印索引的名称。

bold_rowsbool，默认为 False

使输出中的行标签加粗。

column_formatstr，可选

列的格式如 LaTeX table format 中指定的那样，例如对于 3 列为‘rcl’。默认情况下，对于所有列，除了数字列，默认为‘l’。

longtablebool，可选

使用 longtable 环境而不是 tabular。需要在 LaTeX 导言中添加 usepackage{{longtable}}。默认情况下，该值将从 pandas 配置模块中读取，并且如果选项 styler.latex.environment 为 “longtable”，则将其设置为 True。

从 2.0.0 版本开始更改：影响此参数的 pandas 选项已更改。

escapebool，可选

默认情况下，该值将从 pandas 配置模块中读取，并且如果选项 styler.format.escape 为 “latex”，则将其设置为 True。当设置为 False 时，防止在列名中转义 latex 特殊字符。

从 2.0.0 版本开始更改：影响此参数的 pandas 选项已更改，其默认值也已更改为 False。

encodingstr，可选

表示要在输出文件中使用的编码的字符串，默认为‘utf-8’。

decimalstr，默认为‘.’

作为十进制分隔符的字符，例如欧洲的‘,’。

multicolumnbool，默认为 True

使用 multicolumn 来增强 MultiIndex 列。默认值将从配置模块中读取，并设置为选项styler.sparse.columns。

在版本 2.0.0 中更改：影响此参数的 pandas 选项已更改。

multicolumn_formatstr，默认为‘r’

用于多列的多列的对齐，类似于 column_format。默认值将从配置模块中读取，并设置为选项styler.latex.multicol_align。

在版本 2.0.0 中更改：影响此参数的 pandas 选项已更改，以及默认值为“r”。

multirowbool，默认为 True

使用 multirow 来增强 MultiIndex 行。需要在 LaTeX 导言中添加usepackage{{multirow}}。将在包含的行中打印居中标签（而不是顶部对齐），通过 clines 分隔组。默认值将从 pandas 配置模块中读取，并设置为选项styler.sparse.index。

在版本 2.0.0 中更改：影响此参数的 pandas 选项已更改，以及默认值为 True。

captionstr 或元组，可选

元组（full_caption，short_caption），其结果为\caption[short_caption]{{full_caption}}；如果传递单个字符串，则不会设置短标题。

labelstr，可选

放置在输出中的 LaTeX 标签。这与主.tex文件中的\ref{{}}一起使用。

positionstr，可选

LaTeX 表格的位置参数，需放置在输出中的\begin{{}}之后。

返回：

str 或 None

如果 buf 为 None，则将结果作为字符串返回。否则返回 None。

另请参阅

io.formats.style.Styler.to_latex

将 DataFrame 呈现为带有条件格式的 LaTeX。

DataFrame.to_string

将 DataFrame 呈现为适合控制台的表格输出。

DataFrame.to_html

将 DataFrame 呈现为 HTML 表格。

注意

从 v2.0.0 开始，此方法已更改为使用jinja2模板作为Styler.to_latex()的一部分。这意味着jinja2是一个要求，并且需要安装，以使此方法正常运行。建议用户切换到使用 Styler，因为该实现更经常更新，并且在输出方面具有更大的灵活性。

示例

将通用 DataFrame 转换为带有格式的 LaTeX：

>>> df = pd.DataFrame(dict(name=['Raphael', 'Donatello'],
...                        age=[26, 45],
...                        height=[181.23, 177.65]))
>>> print(df.to_latex(index=False,
...                   formatters={"name": str.upper},
...                   float_format="{:.1f}".format,
... ))  
\begin{tabular}{lrr}
\toprule
name & age & height \\
\midrule
RAPHAEL & 26 & 181.2 \\
DONATELLO & 45 & 177.7 \\
\bottomrule
\end{tabular} 

pandas.DataFrame.to_stata

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_stata.html

DataFrame.to_stata(path, *, convert_dates=None, write_index=True, byteorder=None, time_stamp=None, data_label=None, variable_labels=None, version=114, convert_strl=None, compression='infer', storage_options=None, value_labels=None)

将 DataFrame 对象导出到 Stata dta 格式。

将 DataFrame 写入 Stata 数据集文件。“dta” 文件包含一个 Stata 数据集。

参数：

pathstr、路径对象或缓冲区

字符串、路径对象（实现 os.PathLike[str]）或实现二进制 write() 函数的类文件对象。

convert_datesdict

将包含日期时间类型的列映射到写入日期时要使用的 stata 内部格式的字典。选项是‘tc’、‘td’、‘tm’、‘tw’、‘th’、‘tq’、‘ty’。列可以是整数或名称。如果日期时间列有时区信息，则会引发 NotImplementedError。

write_indexbool

将索引写入 Stata 数据集。

byteorderstr

可以是“>”、“<”、“little”或“big”。默认为 sys.byteorder。

time_stampdatetime

用作文件创建日期的日期时间。默认为当前时间。

data_labelstr，可选

数据集的标签。必须是 80 个字符或更少。

variable_labelsdict

包含列作为键和变量标签作为值的字典。每个标签必须是 80 个字符或更少。

version，默认为 114

要在输出 dta 文件中使用的版本。将其设置为 None，以让 pandas 根据框架中的列数决定 118 或 119 格式。版本 114 可以被 Stata 10 及更高版本读取。版本 117 可以被 Stata 13 或更高版本读取。版本 118 支持 Stata 14 及更高版本。版本 119 支持 Stata 15 及更高版本。版本 114 将字符串变量限制为 244 个字符或更少，而版本 117 及更高版本允许长度最长为 2,000,000 的字符串。版本 118 和 119 支持 Unicode 字符，版本 119 支持超过 32,767 个变量。

通常只有在变量数超过 dta 格式 118 的容量时才应使用版本 119。以格式 119 导出较小的数据集可能会产生意想不到的后果，并且截至 2020 年 11 月，Stata SE 无法读取版本 119 文件。

convert_strllist，可选

要转换为 Stata StrL 格式的字符串列的列名列表。仅在版本为 117 时可用。如果字符串超过 8 个字符并且值重复，将字符串存储在 StrL 格式中可以生成更小的 dta 文件。

compressionstr 或 dict，默认为 'infer'

用于输出数据的即时压缩。如果 ‘infer’ 并且 ‘path’ 是类似路径，则从以下扩展名检测压缩：‘.gz’、‘.bz2’、‘.zip’、‘.xz’、‘.zst’、‘.tar’、‘.tar.gz’、‘.tar.xz’ 或 ‘.tar.bz2’（否则不压缩）。设置为 None 以不进行压缩。也可以是一个字典，其键 'method' 设置为其中一个 {'zip'、'gzip'、'bz2'、'zstd'、'xz'、'tar'}，其他键值对转发到 zipfile.ZipFile、gzip.GzipFile、bz2.BZ2File、zstandard.ZstdCompressor、lzma.LZMAFile 或 tarfile.TarFile。例如，可以传递以下内容以进行更快的压缩并创建可复现的 gzip 存档：compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}。

版本 1.5.0 中新增了对 .tar 文件的支持。

在版本 1.4.0 中更改：Zstandard 支持。

storage_optionsdict，可选

对于特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对会作为标头选项转发给 urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对会转发给 fsspec.open。请参阅 fsspec 和 urllib 以获取更多详细信息，并且有关存储选项的更多示例，请参阅 这里。

value_labels字典的字典

包含列作为键和列值到标签字典的字典。单个变量的标签必须小于或等于 32,000 个字符。

版本 1.4.0 中新增。

引发：

NotImplementedError

• 如果日期时间包含时区信息

• 列的 dtype 不能在 Stata 中表示

ValueError

• 在 convert_dates 中列出的列既不是 datetime64[ns] 类型，也不是 datetime.datetime 类型

• 在 DataFrame 中列出的列不在 convert_dates 中

• 分类标签包含超过 32,000 个字符

另请参阅

read_stata

导入 Stata 数据文件。

io.stata.StataWriter

用于 Stata 数据文件的低级写入器。

io.stata.StataWriter117

用于版本 117 文件的低级写入器。

示例

>>> df = pd.DataFrame({'animal': ['falcon', 'parrot', 'falcon',
...                               'parrot'],
...                    'speed': [350, 18, 361, 15]})
>>> df.to_stata('animals.dta') 

pandas.DataFrame.to_gbq

译文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_gbq.html

DataFrame.to_gbq(destination_table, *, project_id=None, chunksize=None, reauth=False, if_exists='fail', auth_local_webserver=True, table_schema=None, location=None, progress_bar=True, credentials=None)

将 DataFrame 写入 Google BigQuery 表。

自 2.2.0 版本起弃用：请改用pandas_gbq.to_gbq。

此函数需要pandas-gbq 包。

查看如何使用 Google BigQuery 进行身份验证指南以获取身份验证说明。

参数：

destination_table字符串

要写入的表的名称，格式为dataset.tablename。

project_id字符串，可选

Google BigQuery 帐户项目 ID。如果环境中可用，则可选。

chunksize整数，可选

从数据框中每个块中要插入的行数。设置为None以一次性加载整个数据框。

reauth布尔值，默认为 False

强制 Google BigQuery 重新对用户进行身份验证。如果使用多个帐户，这很有用。

if_exists字符串，默认为‘fail’

目标表存在时的行为。值可以是以下之一：

'fail'

如果表存在，则引发 pandas_gbq.gbq.TableCreationError。

'replace'

如果表存在，则删除它，重新创建它，并插入数据。

'append'

如果表存在，则插入数据。如果不存在，则创建。

auth_local_webserver布尔值，默认为 True

在获取用户凭据时，使用本地 Web 服务器流而不是控制台流。

pandas-gbq 的 0.2.0 版本中新增。

1.5.0 版本中更改：默认值更改为True。Google 已弃用auth_local_webserver = False “out of band” (copy-paste)流。

table_schema字典列表，可选

按照 DataFrame 列符合的 BigQuery 表字段列表，例如[{'name': 'col1', 'type': 'STRING'},...]。如果未提供模式，则将根据 DataFrame 列的数据类型生成模式。请参阅 BigQuery API 文档以获取字段的可用名称。

pandas-gbq 的 0.3.1 版本中新增。

location字符串，可选

加载作业应该运行的位置。请参阅BigQuery 位置文档以获取可用位置列表。位置必须与目标数据集的位置匹配。

pandas-gbq 的 0.5.0 版本中新增。

progress_bar布尔值，默认为 True

使用 tqdm 库按块显示上传进度条。

pandas-gbq 的 0.5.0 版本中新增。

credentialsgoogle.auth.credentials.Credentials，可选

访问 Google API 的凭据。使用此参数来覆盖默认凭据，例如直接使用 Compute Engine google.auth.compute_engine.Credentials 或 Service Account google.oauth2.service_account.Credentials。

在 pandas-gbq 的 0.8.0 版本中新增。

另请参阅

pandas_gbq.to_gbq

这个函数在 pandas-gbq 库中。

read_gbq

从 Google BigQuery 读取 DataFrame。

示例

示例取自Google BigQuery 文档

>>> project_id = "my-project"
>>> table_id = 'my_dataset.my_table'
>>> df = pd.DataFrame({
...                   "my_string": ["a", "b", "c"],
...                   "my_int64": [1, 2, 3],
...                   "my_float64": [4.0, 5.0, 6.0],
...                   "my_bool1": [True, False, True],
...                   "my_bool2": [False, True, False],
...                   "my_dates": pd.date_range("now", periods=3),
...                   }
...                   ) 

>>> df.to_gbq(table_id, project_id=project_id) 

pandas.DataFrame.to_records

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_records.html

DataFrame.to_records(index=True, column_dtypes=None, index_dtypes=None)

将 DataFrame 转换为 NumPy 记录数组。

如果需要，索引将作为记录数组的第一个字段包含在内。

参数：

indexbool, default True

在结果记录数组中包含索引，存储在 'index' 字段中或使用索引标签（如果设置）。

column_dtypesstr, type, dict, default None

如果是字符串或类型，则是用于存储所有列的数据类型。如果是字典，则是列名和索引（从零开始）到特定数据类型的映射。

index_dtypesstr, type, dict, default None

如果是字符串或类型，则是用于存储所有索引级别的数据类型。如果是字典，则是索引级别名称和索引（从零开始）到特定数据类型的映射。

仅当 index=True 时才应用此映射。

返回：

numpy.rec.recarray

具有 DataFrame 标签作为字段和 DataFrame 每行作为条目的 NumPy ndarray。

参见

DataFrame.from_records

将结构化或记录的 ndarray 转换为 DataFrame。

numpy.rec.recarray

一个允许使用属性进行字段访问的 ndarray，类似于电子表格中的类型化列。

示例

>>> df = pd.DataFrame({'A': [1, 2], 'B': [0.5, 0.75]},
...                   index=['a', 'b'])
>>> df
 A     B
a  1  0.50
b  2  0.75
>>> df.to_records()
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
 dtype=[('index', 'O'), ('A', '<i8'), ('B', '<f8')]) 

如果 DataFrame 索引没有标签，则 recarray 字段名设置为 'index'。如果索引有标签，则将其用作字段名：

>>> df.index = df.index.rename("I")
>>> df.to_records()
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
 dtype=[('I', 'O'), ('A', '<i8'), ('B', '<f8')]) 

索引可以从记录数组中排除：

>>> df.to_records(index=False)
rec.array([(1, 0.5 ), (2, 0.75)],
 dtype=[('A', '<i8'), ('B', '<f8')]) 

可以为列指定数据类型：

>>> df.to_records(column_dtypes={"A": "int32"})
rec.array([('a', 1, 0.5 ), ('b', 2, 0.75)],
 dtype=[('I', 'O'), ('A', '<i4'), ('B', '<f8')]) 

以及索引：

>>> df.to_records(index_dtypes="<S2")
rec.array([(b'a', 1, 0.5 ), (b'b', 2, 0.75)],
 dtype=[('I', 'S2'), ('A', '<i8'), ('B', '<f8')]) 

>>> index_dtypes = f"<S{df.index.str.len().max()}"
>>> df.to_records(index_dtypes=index_dtypes)
rec.array([(b'a', 1, 0.5 ), (b'b', 2, 0.75)],
 dtype=[('I', 'S1'), ('A', '<i8'), ('B', '<f8')]) 

pandas.DataFrame.to_string

pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_string.html

DataFrame.to_string(buf=None, *, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, max_rows=None, max_cols=None, show_dimensions=False, decimal='.', line_width=None, min_rows=None, max_colwidth=None, encoding=None)

将 DataFrame 呈现为友好的控制台表格输出。

参数：

bufstr、路径或类似 StringIO 的对象，可选，默认为 None

要写入的缓冲区。如果为 None，则将输出作为字符串返回。

columns类数组，可选，默认为 None

要写入的列的子集。默认情况下写出所有列。

col_spaceint，可选的整数，列表或整数的字典

每列的最小宽度。如果给出 int 列表，则每个整数对应一个列。如果给出字典，则键引用列，而值定义要使用的空间。

headerbool 或 str 的列表，可选

写出列名。如果给出列的列表，则假定它是列名的别名。

indexbool，可选，默认为 True

是否打印索引（行）标签。

na_repstr，可选，默认为‘NaN’

用于NaN的字符串表示。

formatters列表，元组或一个参数的函数字典，可选

根据位置或名称应用于列元素的格式化函数。每个函数的结果必须是 Unicode 字符串。列表/元组的长度必须等于列数。

float_format一个参数函数，可选，默认为 None

如果它们是浮点数，则应用于列元素的格式化函数。此函数必须返回 Unicode 字符串，并且仅应用于非NaN元素，其中NaN由na_rep处理。

sparsifybool，可选，默认为 True

对于具有分层索引的 DataFrame，设置为 False 以在每行处打印每个多索引键。

index_namesbool，可选，默认为 True

打印索引的名称。

justifystr，默认为 None

如何对齐列标签。如果为 None，则使用打印配置的选项（由 set_option 控制），默认为‘right’。有效值为

• 左

• 右

• 居中

• 对齐

• justify-all

• 开始

• end

• 继承

• 匹配父级

• 初始

• 取消设置。

max_rowsint，可选

在控制台中显示的最大行数。

max_colsint，可选

在控制台中显示的最大列数。

show_dimensionsbool，默认为 False

显示 DataFrame 维度（行数乘以列数）。

decimalstr，默认为‘.’

作为十进制分隔符识别的字符，例如欧洲的‘,’。

line_widthint，可选

每行字符的换行宽度。

min_rowsint，可选

在控制台中显示的截断 repr 中的行数（当行数超过 max_rows 时）。

max_colwidthint，可选

每列截断的最大宽度（以字符为单位）。默认情况下，没有限制。

encodingstr，默认为“utf-8”

设置字符编码。

返回：

str 或 None

如果 buf 为 None，则将结果作为字符串返回。否则返回 None。

另见

to_html

将 DataFrame 转换为 HTML。

示例

>>> d = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
>>> df = pd.DataFrame(d)
>>> print(df.to_string())
 col1  col2
0     1     4
1     2     5
2     3     6 

pandas.DataFrame.to_clipboard

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_clipboard.html

DataFrame.to_clipboard(*, excel=True, sep=None, **kwargs)

将对象复制到系统剪贴板。

将对象的文本表示写入系统剪贴板。例如，这可以粘贴到 Excel 中。

参数：

excelbool，默认为 True

生成 csv 格式的输出，以便轻松粘贴到 excel 中。

• True，使用提供的分隔符进行 csv 粘贴。

• False，将对象的字符串表示写入剪贴板。

sepstr，默认为'\t'

字段分隔符。

**kwargs

这些参数将传递给 DataFrame.to_csv。

另请参阅

DataFrame.to_csv

将 DataFrame 写入逗号分隔值（csv）文件。

read_clipboard

从剪贴板读取文本并传递给 read_csv。

注意

您平台的要求。

• Linux：xclip，或 xsel（带有 PyQt4 模块）
• Windows：无
• macOS：无

此方法使用了为包 pyperclip 开发的进程。在示例中给出了渲染任何输出字符串格式的解决方案。

示例

将 DataFrame 的内容复制到剪贴板。

>>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C']) 

>>> df.to_clipboard(sep=',')  
... # Wrote the following to the system clipboard:
... # ,A,B,C
... # 0,1,2,3
... # 1,4,5,6 

通过传递关键字索引并将其设置为 false，我们可以省略索引。

>>> df.to_clipboard(sep=',', index=False)  
... # Wrote the following to the system clipboard:
... # A,B,C
... # 1,2,3
... # 4,5,6 

使用原始的 pyperclip 包进行任何字符串输出格式。

import pyperclip
html = df.style.to_html()
pyperclip.copy(html) 

pandas.DataFrame.to_markdown

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_markdown.html

DataFrame.to_markdown(buf=None, *, mode='wt', index=True, storage_options=None, **kwargs)

将 DataFrame 打印成适合 Markdown 的格式。

参数：

bufstr，路径或类似 StringIO 的对象，可选，默认为 None

要写入的缓冲区。如果为 None，则将输出作为字符串返回。

modestr，可选

文件打开的模式，默认为“wt”。

indexbool，可选，默认为 True

添加索引（行）标签。

storage_optionsdict，可选

针对特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对将作为标头选项转发给urllib.request.Request。对于其他 URL（例如以“s3://”和“gcs://”开头的 URL），键值对将转发给fsspec.open。请参阅fsspec和urllib以获取更多详细信息，并参考此处的存储选项示例。

**kwargs

这些参数将传递给tabulate。

返回：

str

以适合 Markdown 的格式输出的 DataFrame。

注意事项

需要tabulate包。

示例

>>> df = pd.DataFrame(
...     data={"animal_1": ["elk", "pig"], "animal_2": ["dog", "quetzal"]}
... )
>>> print(df.to_markdown())
|    | animal_1   | animal_2   |
|---:|:-----------|:-----------|
|  0 | elk        | dog        |
|  1 | pig        | quetzal    | 

使用 tabulate 选项输出 markdown。

>>> print(df.to_markdown(tablefmt="grid"))
+----+------------+------------+
|    | animal_1   | animal_2   |
+====+============+============+
|  0 | elk        | dog        |
+----+------------+------------+
|  1 | pig        | quetzal    |
+----+------------+------------+ 

pandas.DataFrame.style

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.style.html

property DataFrame.style

返回一个 Styler 对象。

包含构建 DataFrame 样式化 HTML 表示的方法。

另请参阅

io.formats.style.Styler

使用 HTML 和 CSS 根据数据样式化 DataFrame 或 Series。

示例

>>> df = pd.DataFrame({'A': [1, 2, 3]})
>>> df.style 

请参阅表格可视化以获取更多示例。

pandas.DataFrame.__dataframe__

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.__dataframe__.html

DataFrame.__dataframe__(nan_as_null=False, allow_copy=True)

返回实现交换协议的数据帧交换对象。

参数：

nan_as_null 布尔型，默认为 False

nan_as_null 已被弃用且无效。请避免使用它；它将在未来的版本中被移除。

allow_copy 布尔型，默认为 True

在导出时是否允许内存复制。如果设置为 False，会导致非零拷贝的导出失败。

返回：

数据帧交换对象

消费库可以使用的对象来接收数据帧。

注意

交换协议的详细信息：data-apis.org/dataframe-protocol/latest/index.html

示例

>>> df_not_necessarily_pandas = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> interchange_object = df_not_necessarily_pandas.__dataframe__()
>>> interchange_object.column_names()
Index(['A', 'B'], dtype='object')
>>> df_pandas = (pd.api.interchange.from_dataframe
...              (interchange_object.select_columns_by_name(['A'])))
>>> df_pandas
 A
0    1
1    2 

这些方法（column_names、select_columns_by_name）应该适用于任何实现交换协议的数据帧库。

pandas 数组、标量和数据类型

原文：pandas.pydata.org/docs/reference/arrays.html

对象

对于大多数数据类型，pandas 使用 NumPy 数组作为包含在 Index、Series 或 DataFrame 中的具体对象。

对于一些数据类型，pandas 扩展了 NumPy 的类型系统。这些类型的字符串别名可以在 dtypes 中找到。

数据类型	pandas 数据类型	标量	数组
时区感知日期时间	DatetimeTZDtype	Timestamp	日期时间
时间增量	(无)	Timedelta	时间增量
时期（时间跨度）	PeriodDtype	Period	时期
区间	IntervalDtype	Interval	区间
可空整数	Int64Dtype, …	(无)	可空整数
可空浮点数	Float64Dtype, …	(无)	可空浮点数
分类	CategoricalDtype	(无)	分类
稀疏	SparseDtype	(无)	稀疏
字符串	StringDtype	str	字符串
可空布尔值	BooleanDtype	bool	可空布尔值
PyArrow	ArrowDtype	Python 标量或NA	PyArrow

pandas 和第三方库可以扩展 NumPy 的类型系统（参见扩展类型）。顶层的 array() 方法可用于创建一个新数组，该数组可以存储在 Series、Index 中，或作为 DataFrame 中的一列。

array(data[, dtype, copy])	创建一个数组。

PyArrow

警告

此功能是实验性的，API 可能在未来的发布中更改而不提供警告。

arrays.ArrowExtensionArray 是由 pyarrow.ChunkedArray 支持的，具有 pyarrow.DataType 而不是 NumPy 数组和数据类型。arrays.ArrowExtensionArray 的 .dtype 是一个 ArrowDtype。

Pyarrow 提供了与 NumPy 类似的数组和数据类型支持，包括所有数据类型的一流可空支持，不可变性等。

下表显示了 pandas 可识别的等效的 pyarrow-backed (pa)、pandas 扩展和 numpy (np) 类型。下面的 pyarrow-backed 类型需要传递给 ArrowDtype 才能被 pandas 识别，例如 pd.ArrowDtype(pa.bool_())

PyArrow 类型	pandas 扩展类型	NumPy 类型
pyarrow.bool_()	BooleanDtype	np.bool_
pyarrow.int8()	Int8Dtype	np.int8
pyarrow.int16()	Int16Dtype	np.int16
pyarrow.int32()	Int32Dtype	np.int32
pyarrow.int64()	Int64Dtype	np.int64
pyarrow.uint8()	UInt8Dtype	np.uint8
pyarrow.uint16()	UInt16Dtype	np.uint16
pyarrow.uint32()	UInt32Dtype	np.uint32
pyarrow.uint64()	UInt64Dtype	np.uint64
pyarrow.float32()	Float32Dtype	np.float32
pyarrow.float64()	Float64Dtype	np.float64
pyarrow.time32()	(无)	(无)
pyarrow.time64()	(无)	(无)
pyarrow.timestamp()	DatetimeTZDtype	np.datetime64
pyarrow.date32()	(无)	(无)
pyarrow.date64()	(无)	(无)
pyarrow.duration()	(无)	np.timedelta64
pyarrow.binary()	(无)	(无)
pyarrow.string()	StringDtype	np.str_
pyarrow.decimal128()	(无)	(无)
pyarrow.list_()	(无)	(无)
pyarrow.map_()	(无)	(无)
pyarrow.dictionary()	CategoricalDtype	(无)

注意

Pyarrow 支持的字符串支持由 pd.StringDtype("pyarrow") 和 pd.ArrowDtype(pa.string()) 提供。如果指定了字符串别名 "string[pyarrow]"，则会返回 pd.StringDtype("pyarrow")，如下所述在 string 部分 中描述。 pd.ArrowDtype(pa.string()) 通常与不同类型的 ArrowDtype 具有更好的互操作性。

在 arrays.ArrowExtensionArray 中，单个值存储为 PyArrow 对象，而标量则以对应的 Python 标量返回，例如，PyArrow int64 将返回为 Python int，或者对于缺失值，返回 NA。

arrays.ArrowExtensionArray(values)	由 PyArrow ChunkedArray 支持的 Pandas ExtensionArray。
ArrowDtype(pyarrow_dtype)	适用于 PyArrow 数据类型的 ExtensionDtype。

欲了解更多信息，请参阅 PyArrow 用户指南 ### Datetimes

NumPy 无法本地表示带时区的日期时间。pandas 支持使用 arrays.DatetimeArray 扩展数组来实现这一点，该数组可以保存时区非感知或时区感知的值。

Timestamp是 pandas 的标量类型，用于时区非感知或时区感知的日期时间数据。NaT是缺失的日期时间数据值。

Timestamp([ts_input, year, month, day, ...])	Pandas 替代了 Python datetime.datetime 对象。

属性

Timestamp.asm8	返回纳秒单位的 numpy datetime64 格式。
Timestamp.day
Timestamp.dayofweek	返回星期几。
Timestamp.day_of_week	返回星期几。
Timestamp.dayofyear	返回一年中的第几天。
Timestamp.day_of_year	返回一年中的第几天。
Timestamp.days_in_month	返回月份的天数。
Timestamp.daysinmonth	返回月份的天数。
Timestamp.fold
Timestamp.hour
Timestamp.is_leap_year	如果年份是闰年则返回 True。
Timestamp.is_month_end	检查日期是否是月份的最后一天。
Timestamp.is_month_start	检查日期是否是月份的第一天。
Timestamp.is_quarter_end	检查日期是否是季度的最后一天。
Timestamp.is_quarter_start	检查日期是否是季度的第一天。
Timestamp.is_year_end	如果日期是一年的最后一天，则返回 True。
Timestamp.is_year_start	如果日期是一年的第一天，则返回 True。
Timestamp.max
Timestamp.microsecond
Timestamp.min
Timestamp.minute
Timestamp.month
Timestamp.nanosecond
Timestamp.quarter	返回一年中的季度。
Timestamp.resolution
Timestamp.second
Timestamp.tz	tzinfo 的别名。
Timestamp.tzinfo
Timestamp.unit	与 self._creso 相关联的缩写。
Timestamp.value
Timestamp.week	返回一年中的周数。
Timestamp.weekofyear	返回一年中的周数。
Timestamp.year

方法

Timestamp.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定的单位。
Timestamp.astimezone(tz)	将时区感知的 Timestamp 转换为另一个时区。
Timestamp.ceil(freq[, ambiguous, nonexistent])	返回一个新的 Timestamp，其分辨率为此。
Timestamp.combine(date, time)	将日期、时间组合为具有相同日期和时间字段的日期时间。
Timestamp.ctime()	返回 ctime() 格式的字符串。
Timestamp.date()	返回具有相同年、月和日的日期对象。
Timestamp.day_name([locale])	返回具有指定语言环境的时间戳的星期几名称。
Timestamp.dst()	返回夏令时（DST）调整。
Timestamp.floor(freq[, ambiguous, nonexistent])	返回一个新的时间戳，以此分辨率向下取整。
Timestamp.fromordinal(ordinal[, tz])	从普通的格里高利历序数构造时间戳。
Timestamp.fromtimestamp(ts)	将时间戳（带时区）从 POSIX 时间戳转换为 tz 的本地时间。
Timestamp.isocalendar()	返回包含 ISO 年、周数和工作日的命名元组。
Timestamp.isoformat([sep, timespec])	根据 ISO 8601 格式返回时间。
Timestamp.isoweekday()	返回日期表示的星期几。
Timestamp.month_name([locale])	返回具有指定语言环境的时间戳的月份名称。
Timestamp.normalize()	将时间戳标准化为午夜，保留时区信息。
Timestamp.now([tz])	返回表示当前时间的新时间戳对象，本地化到 tz。
Timestamp.replace([year, month, day, hour, ...])	实现 datetime.replace，处理纳秒。
Timestamp.round(freq[, ambiguous, nonexistent])	将时间戳四舍五入到指定的分辨率。
Timestamp.strftime(format)	返回 Timestamp 的格式化字符串。
Timestamp.strptime(string, format)	函数未实现。
Timestamp.time()	返回具有相同时间但 tzinfo=None 的时间对象。
Timestamp.timestamp()	返回 POSIX 时间戳作为浮点数。
Timestamp.timetuple()	返回与 time.localtime() 兼容的时间元组。
Timestamp.timetz()	返回具有相同时间和 tzinfo 的时间对象。
Timestamp.to_datetime64()	返回具有相同精度的 numpy.datetime64 对象。
Timestamp.to_numpy([dtype, copy])	将 Timestamp 转换为 NumPy datetime64。
Timestamp.to_julian_date()	将 TimeStamp 转换为儒略日。
Timestamp.to_period([freq])	返回一个周期，该时间戳是其观测值。
Timestamp.to_pydatetime([warn])	将 Timestamp 对象转换为本机 Python datetime 对象。
Timestamp.today([tz])	返回当前时区的当前时间。
Timestamp.toordinal()	返回普罗列普提克·格里高利的序数。
Timestamp.tz_convert(tz)	将带有时区信息的 Timestamp 转换为另一个时区。
Timestamp.tz_localize(tz[, ambiguous, ...])	将时间戳本地化为时区。
Timestamp.tzname()	返回时区名称。
Timestamp.utcfromtimestamp(ts)	从 POSIX 时间戳构造带有时区信息的 UTC 日期时间。
Timestamp.utcnow()	返回表示 UTC 日期和时间的新 Timestamp。
Timestamp.utcoffset()	返回 UTC 偏移量。
Timestamp.utctimetuple()	返回 UTC 时间元组，与 time.localtime() 兼容。
Timestamp.weekday()	返回由日期表示的星期几。

时间戳的集合可以存储在 arrays.DatetimeArray 中。对于带时区的数据，arrays.DatetimeArray 的 .dtype 是 DatetimeTZDtype。对于时区非感知的数据，使用 np.dtype("datetime64[ns]")。

如果数据具有时区感知，则数组中的每个值必须具有相同的时区。

arrays.DatetimeArray(values[, dtype, freq, copy])	用于时区非感知或时区感知的日期时间数据的 Pandas ExtensionArray。

| DatetimeTZDtype([unit, tz]) | 用于带时区的日期时间数据的 ExtensionDtype。 | ### 时间间隔

NumPy 可以本地表示时间间隔。pandas 提供了用于与 Timestamp 对称的 Timedelta。NaT 是时间间隔数据的缺失值。

Timedelta([value, unit])	表示持续时间，即两个日期或时间之间的差异。

属性

Timedelta.asm8	返回 numpy timedelta64 数组标量视图。
Timedelta.components	返回类似于命名元组的组件。
Timedelta.days	返回时间间隔的天数。
Timedelta.max
Timedelta.microseconds
Timedelta.min
Timedelta.nanoseconds	返回纳秒数（n），其中 0 <= n < 1 微秒。
Timedelta.resolution
Timedelta.seconds	返回时间增量的总小时、分钟和秒数（以秒为单位）。
Timedelta.unit
Timedelta.value
Timedelta.view(dtype)	数组视图兼容性。

方法

Timedelta.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定单位。
Timedelta.ceil(freq)	返回一个新的 Timedelta，它以这种分辨率进行了上舍入。
Timedelta.floor(freq)	返回一个新的 Timedelta，它以这种分辨率进行了下舍入。
Timedelta.isoformat()	将 Timedelta 格式化为 ISO 8601 时长。
Timedelta.round(freq)	将时间增量舍入到指定的分辨率。
Timedelta.to_pytimedelta()	将 pandas Timedelta 对象转换为 python datetime.timedelta 对象。
Timedelta.to_timedelta64()	返回一个具有'ns'精度的 numpy.timedelta64 对象。
Timedelta.to_numpy([dtype, copy])	将 Timedelta 转换为 NumPy timedelta64。
Timedelta.total_seconds()	时长的总秒数。

一个 Timedelta 集合可以存储在 TimedeltaArray 中。

| arrays.TimedeltaArray(values[, dtype, freq, ...]) | 用于 timedelta 数据的 Pandas ExtensionArray。 | ### 时期

pandas 以 Period 对象表示时间跨度。

时期

Period([value, freq, ordinal, year, month, ...])	表示一段时间。

属性

Period.day	获取 Period 所在月份的日期。
Period.dayofweek	Period 所在的星期几，星期一为 0，星期日为 6。
Period.day_of_week	Period 所在的星期几，星期一为 0，星期日为 6。
Period.dayofyear	返回一年中的第几天。
Period.day_of_year	返回一年中的第几天。
Period.days_in_month	获取该期间所在月份的总天数。
Period.daysinmonth	获取该期间所在月份的总天数。
Period.end_time	获取周期结束的时间戳。
Period.freq
Period.freqstr	返回频率的字符串表示形式。
Period.hour	获取 Period 的天部分的小时。
Period.is_leap_year	如果 Period 所在的年份是闰年，则返回 True。
Period.minute	获取 Period 的小时部分的分钟。
Period.month	返回 Period 所在的月份。
Period.ordinal
Period.quarter	返回 Period 所在的季度。
Period.qyear	根据其开始季度确定的 Period 所在财年。
Period.second	获取 Period 的秒钟部分。
Period.start_time	获取周期开始的时间戳。
Period.week	获取给定周期的年份周数。
Period.weekday	周期所在的星期几，星期一=0，星期日=6。
Period.weekofyear	获取给定周期的年份周数。
Period.year	返回此周期所在的年份。

方法

Period.asfreq(freq[, how])	将周期转换为所需频率，在间隔的开始或结束。
Period.now(freq)	返回当前日期的周期。
Period.strftime(fmt)	返回Period的格式化字符串表示。
Period.to_timestamp	返回周期的时间戳表示。

一组Period可以存储在arrays.PeriodArray中。arrays.PeriodArray中的每个周期必须具有相同的freq。

arrays.PeriodArray(values[, dtype, freq, copy])	用于存储周期数据的 Pandas ExtensionArray。
PeriodDtype(freq)	用于周期数据的 ExtensionDtype。

间隔

任意间隔可以表示为Interval对象。

Interval	实现间隔的不可变对象，类似于有界的切片间隔。

属性

Interval.closed	描述间隔的包含侧的字符串。
Interval.closed_left	检查间隔是否在左侧关闭。
Interval.closed_right	检查区间是否在右侧关闭。
Interval.is_empty	指示区间是否为空，即不包含任何点。
Interval.left	区间的左边界。
Interval.length	返回区间的长度。
Interval.mid	返回区间的中点。
Interval.open_left	检查区间是否在左侧开放。
Interval.open_right	检查区间是否在右侧开放。
Interval.overlaps(other)	检查两个区间对象是否重叠。
Interval.right	区间的右边界。

区间集合可以存储在 arrays.IntervalArray 中。

arrays.IntervalArray(data[, closed, dtype, ...])	区间数据的 Pandas 数组，这些数据在同一侧关闭。

| IntervalDtype([subtype, closed]) | 用于区间数据的扩展数据类型。 | ### 可空整数

numpy.ndarray 无法原生表示具有缺失值的整数数据。pandas 通过 arrays.IntegerArray 提供了此功能。

arrays.IntegerArray(values, mask[, copy])	整数（可选缺失）值的数组。
Int8Dtype()	用于 int8 整数数据的扩展数据类型。
Int16Dtype()	用于 int16 整数数据的扩展数据类型。
Int32Dtype()	用于 int32 整数数据的扩展数据类型。
Int64Dtype()	用于 int64 整数数据的 ExtensionDtype。
UInt8Dtype()	用于 uint8 整数数据的 ExtensionDtype。
UInt16Dtype()	用于 uint16 整数数据的 ExtensionDtype。
UInt32Dtype()	用于 uint32 整数数据的 ExtensionDtype。

| UInt64Dtype() | 用于 uint64 整数数据的 ExtensionDtype。 | ### 可空浮点数

arrays.FloatingArray(values, mask[, copy])	浮点（可选缺失）值的数组。
Float32Dtype()	用于 float32 数据的 ExtensionDtype。

| Float64Dtype() | 用于 float64 数据的 ExtensionDtype。 | ### 分类

pandas 定义了一种自定义数据类型，用于表示只能取有限固定值集的数据。Categorical的 dtype 可以由CategoricalDtype描述。

CategoricalDtype([categories, ordered])	具有类别和有序性的分类数据类型。
CategoricalDtype.categories	包含允许的唯一类别的Index。
CategoricalDtype.ordered	类别是否具有有序关系。

分类数据可以存储在pandas.Categorical中

Categorical(values[, categories, ordered, ...])	以经典 R / S-plus 风格表示分类变量。

当您���经有类别和整数代码时，可以使用替代的Categorical.from_codes()构造函数：

Categorical.from_codes(codes[, categories, ...])	从代码和类别或 dtype 创建一个分类类型。

dtype 信息可在Categorical上找到

Categorical.dtype	此实例的 CategoricalDtype。
Categorical.categories	这个分类的类别。
Categorical.ordered	类别是否具有有序关系。
Categorical.codes	这个分类索引的类别代码。

np.asarray(categorical) 通过实现数组接口来运作。请注意，这会将 Categorical 转换回 NumPy 数组，因此类别和顺序信息不会被保留！

Categorical.__array__([dtype, copy])	numpy 数组接口。

Categorical 可以存储在 Series 或 DataFrame 中。要创建 dtype 为 category 的 Series，请使用 cat = s.astype(dtype) 或 Series(..., dtype=dtype)，其中 dtype 是

• 字符串 'category'

• CategoricalDtype 的一个实例。

如果 Series 的 dtype 是 CategoricalDtype，则可以使用 Series.cat 来更改分类数据。更多信息请参见 分类访问器。 ### 稀疏

数据中重复多次的单个值（例如 0 或 NaN）可以高效地存储为 arrays.SparseArray。

arrays.SparseArray(data[, sparse_index, ...])	用于存储稀疏数据的 ExtensionArray。
SparseDtype([dtype, fill_value])	存储在 SparseArray 中的数据的 Dtype。

当 Series 包含稀疏值时，可以使用 Series.sparse 访问器来访问稀疏特定的属性和方法。更多信息请参见 稀疏访问器 和 用户指南。 ### 字符串

在处理文本数据时，每个有效元素为字符串或缺失时，建议使用StringDtype（别名为"string"）。

arrays.StringArray(values[, copy])	用于字符串数据的扩展数组。
arrays.ArrowStringArray(values)	用于pyarrow.ChunkedArray中的字符串数据的扩展数组。
StringDtype([storage])	用于字符串数据的扩展 dtype。

对于由arrays.StringArray支持的Series，可使用Series.str访问器。有关更多信息，请参见字符串处理。 ### 可空布尔

布尔 dtype（别名为"boolean"）支持存储带有缺失值的布尔数据（True，False），这是使用布尔numpy.ndarray不可能的。

arrays.BooleanArray(values, mask[, copy])	具有缺失值的布尔（True/False）数据数组。
BooleanDtype()	用于布尔数据的扩展 dtype。

实用工具

构造函数

api.types.union_categoricals(to_union[, ...])	合并类别列表，联合类别。
api.types.infer_dtype(value[, skipna])	返回标量或类似值的类型的字符串标签。
api.types.pandas_dtype(dtype)	将输入转换为仅限于 pandas 的 dtype 对象或 numpy 的 dtype 对象。

数据类型内省

api.types.is_any_real_numeric_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为实数 dtype。
api.types.is_bool_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为布尔 dtype。
api.types.is_categorical_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为分类数据类型。
api.types.is_complex_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为复数数据类型。
api.types.is_datetime64_any_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_dtype(arr_or_dtype)	检查数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_ns_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64[ns]数据类型。
api.types.is_datetime64tz_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为 DatetimeTZDtype 数据类型。
api.types.is_extension_array_dtype(arr_or_dtype)	检查对象是否为 pandas 扩展数组类型。
api.types.is_float_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为浮点数数据类型。
api.types.is_int64_dtype(arr_or_dtype)	(已弃用) 检查提供的数组或数据类型是否为 int64 数据类型。
api.types.is_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为整数数据类型。
api.types.is_interval_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为 Interval 数据类型。
api.types.is_numeric_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为数值数据类型。
api.types.is_object_dtype(arr_or_dtype)	检查数组样式或数据类型是否为对象数据类型。
api.types.is_period_dtype(arr_or_dtype)	(已弃用) 检查数组样式或数据类型是否为 Period 数据类型。
api.types.is_signed_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为有符号整数数据类型。
api.types.is_string_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为字符串数据类型。
api.types.is_timedelta64_dtype(arr_or_dtype)	检查数组样式或数据类型是否为 timedelta64 数据类型。
api.types.is_timedelta64_ns_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 timedelta64[ns]数据类型。
api.types.is_unsigned_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为无符号整数数据类型。
api.types.is_sparse(arr)	(已弃用) 检查数组样式是否为 1-D pandas 稀疏数组。

可迭代对象内省

api.types.is_dict_like(obj)	检查对象是否类似于字典。
api.types.is_file_like(obj)	检查对象是否为类似文件的对象。
api.types.is_list_like(obj[, allow_sets])	检查对象是否类似于列表。
api.types.is_named_tuple(obj)	检查对象是否为命名元组。
api.types.is_iterator(obj)	检查对象是否为迭代器。

标量内省

api.types.is_bool(obj)	如果给定对象是布尔值，则返回 True。
api.types.is_complex(obj)	如果给定对象是复数，则返回 True。
api.types.is_float(obj)	如果给定对象是浮点数，则返回 True。
api.types.is_hashable(obj)	如果 hash(obj) 成功，则返回 True，否则返回 False。
api.types.is_integer(obj)	如果给定对象是整数，则返回 True。
api.types.is_interval(obj)
api.types.is_number(obj)	检查对象是否为数字。
api.types.is_re(obj)	检查对象是否为正则表达式模式实例。
api.types.is_re_compilable(obj)	检查对象是否可以编译为正则表达式模式实例。
api.types.is_scalar(val)	如果给定对象是标量，则返回 True。

对象

对于大多数数据类型，pandas 使用 NumPy 数组作为包含在 Index、Series 或 DataFrame 中的具体对象。

对于某些数据类型，pandas 扩展了 NumPy 的类型系统。这些类型的字符串别名可以在 dtypes 中找到。

数据类型	pandas 数据类型	标量	数组
时区感知日期时间	DatetimeTZDtype	Timestamp	日期时间
时间增量	(无)	Timedelta	时间增量
时期（时间跨度）	PeriodDtype	Period	时期
区间	IntervalDtype	Interval	区间
可空整数	Int64Dtype, …	(无)	可空整数
可空浮点数	Float64Dtype, …	(无)	可空浮点数
分类	CategoricalDtype	(无)	分类
稀疏	SparseDtype	(无)	稀疏
字符串	StringDtype	str	字符串
可空布尔值	BooleanDtype	bool	可空布尔值
PyArrow	ArrowDtype	Python 标量或 NA	PyArrow

pandas 和第三方库可以扩展 NumPy 的类型系统（参见 扩展类型）。顶层的 array() 方法可用于创建一个新数组，该数组可以存储在 Series、Index 中，或作为 DataFrame 中的一列。

array(数据[, dtype, copy])	创建一个数组。

PyArrow

警告

此功能是实验性的，API 可能在未经警告的情况下在未来版本中更改。

arrays.ArrowExtensionArray 是由 pyarrow.ChunkedArray 支持的，而不是 NumPy 数组和数据类型。arrays.ArrowExtensionArray 的 .dtype 是一个 ArrowDtype。

Pyarrow 提供与 NumPy 类似的数组和数据类型支持，包括所有数据类型的一流可空性支持、不可变性等。

下表显示了 pandas 可识别的等效 pyarrow 支持的 (pa)、pandas 扩展和 numpy (np) 类型。下面的 pyarrow 支持的类型需要传入 ArrowDtype 才能被 pandas 识别，例如 pd.ArrowDtype(pa.bool_())

PyArrow 类型	pandas 扩展类型	NumPy 类型
pyarrow.bool_()	BooleanDtype	np.bool_
pyarrow.int8()	Int8Dtype	np.int8
pyarrow.int16()	Int16Dtype	np.int16
pyarrow.int32()	Int32Dtype	np.int32
pyarrow.int64()	Int64Dtype	np.int64
pyarrow.uint8()	UInt8Dtype	np.uint8
pyarrow.uint16()	UInt16Dtype	np.uint16
pyarrow.uint32()	UInt32Dtype	np.uint32
pyarrow.uint64()	UInt64Dtype	np.uint64
pyarrow.float32()	Float32Dtype	np.float32
pyarrow.float64()	Float64Dtype	np.float64
pyarrow.time32()	(无)	(无)
pyarrow.time64()	(无)	(无)
pyarrow.timestamp()	DatetimeTZDtype	np.datetime64
pyarrow.date32()	(无)	(无)
pyarrow.date64()	(无)	(无)
pyarrow.duration()	(无)	np.timedelta64
pyarrow.binary()	(无)	(无)
pyarrow.string()	StringDtype	np.str_
pyarrow.decimal128()	(无)	(无)
pyarrow.list_()	(无)	(无)
pyarrow.map_()	(无)	(无)
pyarrow.dictionary()	CategoricalDtype	(无)

注：

Pyarrow 支持的字符串由 pd.StringDtype("pyarrow") 和 pd.ArrowDtype(pa.string()) 提供。如果指定字符串别名 "string[pyarrow]"，则将返回 pd.StringDtype("pyarrow")，如下所述在 string section 中。 pd.ArrowDtype(pa.string()) 通常与不同类型的 ArrowDtype 具有更好的互操作性。

虽然 arrays.ArrowExtensionArray 中的单个值存储为 PyArrow 对象，但标量会以对应数据类型的 Python 标量返回，例如 PyArrow int64 会以 Python int 返回，或者对于缺失值会返回 NA。

arrays.ArrowExtensionArray(values)	由 PyArrow ChunkedArray 支持的 Pandas ExtensionArray。
ArrowDtype(pyarrow_dtype)	用于 PyArrow 数据类型的 ExtensionDtype。

更多信息，请参阅 PyArrow 用户指南 ### 日期时间

NumPy 无法原生表示时区感知日期时间。pandas 支持使用 arrays.DatetimeArray 扩展数组来实现，该数组可以保存时区无关或时区感知的值。

Timestamp，是 datetime.datetime 的子类，是 pandas 用于时区无关或时区感知日期时间数据的标量类型。 NaT 是日期时间数据的缺失值。

Timestamp([ts_input, year, month, day, ...])	用于替代 python datetime.datetime 对象的 Pandas 类型。

属性

Timestamp.asm8	以纳秒为单位返回 numpy datetime64 格式。
Timestamp.day
Timestamp.dayofweek	返回星期几。
Timestamp.day_of_week	返回星期几。
Timestamp.dayofyear	返回一年中的第几天。
Timestamp.day_of_year	返回一年中的第几天。
Timestamp.days_in_month	返回该月的天数。
Timestamp.daysinmonth	返回该月的天数。
Timestamp.fold
Timestamp.hour
Timestamp.is_leap_year	如果年份是闰年则返回 True。
Timestamp.is_month_end	检查日期是否为月份的最后一天。
Timestamp.is_month_start	检查日期是否为月份的第一天。
Timestamp.is_quarter_end	检查日期是否为季度的最后一天。
Timestamp.is_quarter_start	检查日期是否为季度的第一天。
Timestamp.is_year_end	如果日期是一年的最后一天则返回 True。
Timestamp.is_year_start	如果日期是一年的第一天则返回 True。
Timestamp.max
Timestamp.microsecond
Timestamp.min
Timestamp.minute
Timestamp.month
Timestamp.nanosecond
Timestamp.quarter	返回年份的季度。
Timestamp.resolution
Timestamp.second
Timestamp.tz	tzinfo 的别名。
Timestamp.tzinfo
Timestamp.unit	与 self._creso 相关的缩写。
Timestamp.value
Timestamp.week	返回一年中的周数。
Timestamp.weekofyear	返回一年中的周数。
Timestamp.year

方法

Timestamp.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定单位。
Timestamp.astimezone(tz)	将带有时区信息的 Timestamp 转换为另一个时区的时间。
Timestamp.ceil(freq[, ambiguous, nonexistent])	返回按此分辨率取天花板的新 Timestamp。
Timestamp.combine(date, time)	将日期、时间合并为具有相同日期和时间字段的日期时间。
Timestamp.ctime()	返回 ctime() 格式的字符串。
Timestamp.date()	返回具有相同年、月和日的日期对象。
Timestamp.day_name([locale])	返回指定区域设置的 Timestamp 的星期几。
Timestamp.dst()	返回夏令时（DST）调整。
Timestamp.floor(freq[, ambiguous, nonexistent])	返回按此分辨率取整的新 Timestamp。
Timestamp.fromordinal(ordinal[, tz])	从普通公历序数构造时间戳。
Timestamp.fromtimestamp(ts)	从 POSIX 时间戳转换时间戳[, 时区] 到时区的本地时间。
Timestamp.isocalendar()	返回包含 ISO 年份、周数和工作日的命名元组。
Timestamp.isoformat([sep, timespec])	返回根据 ISO 8601 格式化的时间。
Timestamp.isoweekday()	返回日期代表的星期几。
Timestamp.month_name([locale])	返回具有指定语言环境的时间戳的月份名称。
Timestamp.normalize()	将 Timestamp 规范化为午夜时间，并保留 tz 信息。
Timestamp.now([tz])	返回表示当前本地时间的新 Timestamp 对象。
Timestamp.replace([year, month, day, hour, ...])	实现 datetime.replace，处理纳秒。
Timestamp.round(freq[, ambiguous, nonexistent])	将 Timestamp 四舍五入到指定的分辨率。
Timestamp.strftime(format)	返回 Timestamp 的格式化字符串。
Timestamp.strptime(string, format)	此函数未实现。
Timestamp.time()	返回具有相同时间但 tzinfo=None 的时间对象。
Timestamp.timestamp()	返回浮点型的 POSIX 时间戳。
Timestamp.timetuple()	返回时间元组，与 time.localtime() 兼容。
Timestamp.timetz()	返回具有相同时间和 tzinfo 的时间对象。
Timestamp.to_datetime64()	返回具有相同精度的 numpy.datetime64 对象。
Timestamp.to_numpy([dtype, copy])	将 Timestamp 转换为 NumPy datetime64。
Timestamp.to_julian_date()	将 TimeStamp 转换为儒略日期。
Timestamp.to_period([freq])	返回一个时间段，其中此时间戳是一个观测值。
Timestamp.to_pydatetime([warn])	将 Timestamp 对象转换为本机 Python datetime 对象。
Timestamp.today([tz])	返回当前时区的当前时间。
Timestamp.toordinal()	返回普通格里高利历的序数。
Timestamp.tz_convert(tz)	将时区感知的时间戳转换为另一个时区。
Timestamp.tz_localize(tz[, ambiguous, ...])	将时间戳本地化到一个时区。
Timestamp.tzname()	返回时区名称。
Timestamp.utcfromtimestamp(ts)	从 POSIX 时间戳构造一个时区感知的 UTC 日期时间。
Timestamp.utcnow()	返回表示 UTC 日期和时间的新 Timestamp。
Timestamp.utcoffset()	返回 UTC 偏移。
Timestamp.utctimetuple()	返回与 time.localtime() 兼容的 UTC 时间元组。
Timestamp.weekday()	返回日期所代表的星期几。

时间戳的集合可以存储在 arrays.DatetimeArray 中。对于时区感知的数据，arrays.DatetimeArray 的 .dtype 是一个 DatetimeTZDtype。对于时区无关的数据，使用 np.dtype("datetime64[ns]")。

如果数据是时区感知的，则数组中的每个值必须具有相同的时区。

arrays.DatetimeArray(values[, dtype, freq, copy])	用于时区无关或时区感知的日期时间数据的 Pandas ExtensionArray。

| DatetimeTZDtype([unit, tz]) | 用于时区感知的日期时间数据的扩展数据类型。 | ### 时间增量

NumPy 可以原生表示时间增量。pandas 提供了Timedelta以与Timestamp对称。NaT是时间增量数据的缺失值。

Timedelta([value, unit])	表示持续时间，即两个日期或时间之间的差异。

属性

Timedelta.asm8	返回一个 numpy timedelta64 数组标量视图。
Timedelta.components	返回类似于命名元组的组件。
Timedelta.days	返回时间增量的天数。
Timedelta.max
Timedelta.microseconds
Timedelta.min
Timedelta.nanoseconds	返回纳秒数（n），其中 0 <= n < 1 微秒。
Timedelta.resolution
Timedelta.seconds	返回时间增量的总小时数、分钟数和秒数（以秒为单位）。
Timedelta.unit
Timedelta.value
Timedelta.view(dtype)	数组视图兼容性。

方法

Timedelta.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定的单位。
Timedelta.ceil(freq)	返回一个新的时间增量，使其上限为此分辨率。
Timedelta.floor(freq)	返回一个新的时间增量，使其下限为此分辨率。
Timedelta.isoformat()	将时间增量格式化为 ISO 8601 持续时间。
Timedelta.round(freq)	将 Timedelta 四舍五入到指定的分辨率。
Timedelta.to_pytimedelta()	将 pandas Timedelta 对象转换为 python datetime.timedelta 对象。
Timedelta.to_timedelta64()	返回一个具有 'ns' 精度的 numpy.timedelta64 对象。
Timedelta.to_numpy([dtype, copy])	将 Timedelta 转换为 NumPy timedelta64。
Timedelta.total_seconds()	持续时间中的总秒数。

一组Timedelta可以存储在TimedeltaArray中。

| arrays.TimedeltaArray(values[, dtype, freq, ...]) | 用于时间差数据的 Pandas 扩展数组。 | ### 周期

pandas 将时间段表示为Period对象。

周期

Period([value, freq, ordinal, year, month, ...])	表示一段时间。

属性

Period.day	获取周期落在的月份的日期。
Period.dayofweek	周期所处的星期几，星期一为 0，星期日为 6。
Period.day_of_week	周期所处的星期几，星期一为 0，星期日为 6。
Period.dayofyear	返回一年中的第几天。
Period.day_of_year	返回一年中的第几天。
Period.days_in_month	获取此周期所在月份的总天数。
Period.daysinmonth	获取此周期所在月份的总天数。
Period.end_time	获取周期结束时间的时间戳。
Period.freq
Period.freqstr	返回频率的字符串表示。
Period.hour	获取周期的小时组件。
Period.is_leap_year	如果周期的年份是闰年，则返回 True。
Period.minute	获取周期的小时分钟组件。
Period.month	返回此周期所在的月份。
Period.ordinal
Period.quarter	返回此周期所在的季度。
Period.qyear	根据其起始季度确定周期所在的财政年度。
Period.second	获取周期的秒组件。
Period.start_time	获取周期开始时间的时间戳。
Period.week	获取给定周期的一年中的周数。
Period.weekday	周期所在的星期几，星期一=0，星期日=6。
Period.weekofyear	获取给定周期的一年中的周数。
Period.year	返回此周期所在的年份。

方法

Period.asfreq(freq[, how])	将周期转换为所需频率，位于间隔的开始或结束。
Period.now(freq)	返回当前日期的周期。
Period.strftime(fmt)	返回Period的格式化字符串表示。
Period.to_timestamp([freq, how])	返回周期的时间戳表示。

一组Period可以存储在arrays.PeriodArray中。arrays.PeriodArray中的每个周期必须具有相同的freq。

arrays.PeriodArray(values[, dtype, freq, copy])	用于存储周期数据的 Pandas ExtensionArray。
PeriodDtype(freq)	用于周期数据的扩展数据类型。

区间

任意区间可以表示为Interval对象。

Interval	实现区间（Interval）的不可变对象，类似于有界的切片区间。

属性

Interval.closed	描述区间的包含侧的字符串。
Interval.closed_left	检查区间左侧是否闭合。
Interval.closed_right	检查区间右侧是否闭合。
Interval.is_empty	指示区间是否为空，即是否不包含任何点。
Interval.left	区间的左边界。
Interval.length	返回区间的长度。
Interval.mid	返回区间的中点。
Interval.open_left	检查区间左侧是否开放。
Interval.open_right	检查区间右侧是否开放。
Interval.overlaps(other)	检查两个区间对象是否重叠。
Interval.right	区间的右边界。

一组区间可以存储在arrays.IntervalArray中。

arrays.IntervalArray(data[, closed, dtype, ...])	用于在同一侧关闭的区间数据的 Pandas 数组。

| IntervalDtype([subtype, closed]) | 区间数据的扩展 dtype。 | ### 可空整数

numpy.ndarray 无法原生地表示带有缺失值的整数数据。pandas 通过 arrays.IntegerArray 提供了这种功能。

arrays.IntegerArray(values, mask[, copy])	整数（可选缺失）值数组。
Int8Dtype()	用于 int8 整数数据的扩展 dtype。
Int16Dtype()	用于 int16 整数数据的扩展 dtype。
Int32Dtype()	用于 int32 整数数据的扩展 dtype。
Int64Dtype()	用于 int64 整数数据的扩展 dtype。
UInt8Dtype()	用于 uint8 整数数据的扩展 dtype。
UInt16Dtype()	用于 uint16 整数数据的扩展 dtype。
UInt32Dtype()	用于 uint32 整数数据的扩展 dtype。

| UInt64Dtype() | 用于 uint64 整数数据的扩展 dtype。 | ### 可空浮点数

arrays.FloatingArray(values, mask[, copy])	浮点数（可选缺失）值数组。
Float32Dtype()	用于 float32 数据的扩展 dtype。

| Float64Dtype() | 用于 float64 数据的扩展 dtype。 | ### 分类

pandas 定义了一种自定义数据类型，用于表示只能采用有限的、固定集合的数据。 Categorical 的 dtype 可以由 CategoricalDtype 描述。

CategoricalDtype([categories, ordered])	具有类别和顺序的分类数据类型。
CategoricalDtype.categories	包含允许的唯一类别的Index。
CategoricalDtype.ordered	类别是否具有有序关系。

分类数据可以存储在pandas.Categorical中

分类(values[, categories, ordered, ...])	以经典的 R / S-plus 风格表示分类变量。

当您已经有类别和整数编码时，可以使用替代的Categorical.from_codes()构造函数：

Categorical.from_codes(codes[, categories, ...])	从代码和类别或 dtype 创建一个分类类型。

dtype 信息可在分类上找到

分类.dtype	此实例的CategoricalDtype。
分类.categories	此分类的类别。
分类.ordered	类别是否具有有序关系。
分类.codes	此分类索引的类别代码。

np.asarray(categorical)通过实现数组接口来工作。请注意，这会将分类转换回 NumPy 数组，因此类别和顺序信息不会被保留！

分类.__array__([dtype, copy])	numpy 数组接口。

一个分类可以存储在Series或DataFrame中。要创建一个category类型的 Series，使用cat = s.astype(dtype)或Series(..., dtype=dtype)，其中dtype可以是

• 字符串'category'

• 一个CategoricalDtype的实例。

如果 Series 的数据类型是 CategoricalDtype，则可以使用 Series.cat 来更改分类数据。查看 分类访问器 了解更多。 ### 稀疏

单个值重复多次的数据（例如 0 或 NaN）可以高效地存储为 arrays.SparseArray。

arrays.SparseArray(data[, sparse_index, ...])	用于存储稀疏数据的 ExtensionArray。
SparseDtype([dtype, fill_value])	存储在 SparseArray 中的数据类型。

Series.sparse 访问器可用于访问稀疏值特定的属性和方法，如果 Series 包含稀疏值。查看 稀疏访问器 和 用户指南 了解更多。 ### 字符串

在处理文本数据时，每个有效元素是字符串或缺失值时，建议使用 StringDtype（别名为 "string"）。

arrays.StringArray(values[, copy])	字符串数据的扩展数组。
arrays.ArrowStringArray(values)	在 pyarrow.ChunkedArray 中存储字符串数据的扩展数组。
StringDtype([storage])	字符串数据的扩展数据类型。

Series.str 访问器适用于由 arrays.StringArray 支持的 Series。查看 字符串处理 了解更多。 ### 可空布尔

布尔数据类型（别名为 "boolean"）支持存储布尔数据（True、False）和缺失值，这是使用 bool numpy.ndarray 不可能实现的。

arrays.BooleanArray(values, mask[, copy])	包含缺失值的布尔（True/False）数据数组。

| BooleanDtype() | 布尔数据的扩展数据类型。 | ### PyArrow

警告

此功能是实验性的，API 可能在未来的发布中更改而没有警告。

arrays.ArrowExtensionArray 由 pyarrow.ChunkedArray 支持，使用 pyarrow.DataType 而不是 NumPy 数组和数据类型。 arrays.ArrowExtensionArray 的 .dtype 是 ArrowDtype。

Pyarrow 提供类似 NumPy 的数组和数据类型支持，包括对所有数据类型的一流可空支持，不可变性等。

下表显示了 pandas 认可的等效 pyarrow 支持（pa）、pandas 扩展和 numpy (np) 类型。下表中的 Pyarrow 支持类型需要传递给 ArrowDtype 才能被 pandas 识别，例如 pd.ArrowDtype(pa.bool_())。

PyArrow 类型	pandas 扩展类型	NumPy 类型
pyarrow.bool_()	BooleanDtype	np.bool_
pyarrow.int8()	Int8Dtype	np.int8
pyarrow.int16()	Int16Dtype	np.int16
pyarrow.int32()	Int32Dtype	np.int32
pyarrow.int64()	Int64Dtype	np.int64
pyarrow.uint8()	UInt8Dtype	np.uint8
pyarrow.uint16()	UInt16Dtype	np.uint16
pyarrow.uint32()	UInt32Dtype	np.uint32
pyarrow.uint64()	UInt64Dtype	np.uint64
pyarrow.float32()	Float32Dtype	np.float32
pyarrow.float64()	Float64Dtype	np.float64
pyarrow.time32()	(无)	(无)
pyarrow.time64()	(无)	(无)
pyarrow.timestamp()	DatetimeTZDtype	np.datetime64
pyarrow.date32()	(无)	(无)
pyarrow.date64()	(无)	(无)
pyarrow.duration()	(无)	np.timedelta64
pyarrow.binary()	(无)	(无)
pyarrow.string()	StringDtype	np.str_
pyarrow.decimal128()	(无)	(无)
pyarrow.list_()	(无)	(无)
pyarrow.map_()	(无)	(无)
pyarrow.dictionary()	CategoricalDtype	(无)

注意

PyArrow 支持的字符串支持由pd.StringDtype("pyarrow")和pd.ArrowDtype(pa.string())提供。pd.StringDtype("pyarrow")在 字符串部分 中描述，并且如果指定了字符串别名 "string[pyarrow]"，将返回该别名。pd.ArrowDtype(pa.string())通常与不同类型的 ArrowDtype 更好地实现互操作性。

虽然arrays.ArrowExtensionArray中的单个值存储为 PyArrow 对象，但标量会返回对应于数据类型的 Python 标量，例如，PyArrow int64 将返回为 Python int，或者对于缺失值将返回 NA。

arrays.ArrowExtensionArray(values)	由 PyArrow ChunkedArray 支持的 Pandas ExtensionArray。
ArrowDtype(pyarrow_dtype)	用于 PyArrow 数据类型的 ExtensionDtype。

有关更多信息，请参阅 PyArrow 用户指南

日期时间

NumPy 无法原生表示时区感知的日期时间。pandas 支持使用arrays.DatetimeArray扩展数组来实现此功能，该数组可以容纳时区感知或时区无关的值。

Timestamp是 datetime.datetime的子类，是 pandas 用于时区无关或时区感知日期时间数据的标量类型。NaT 是日期时间数据的缺失值。

Timestamp([ts_input, year, month, day, ...])	用于 pandas 的 python datetime.datetime 对象的替代品。

属性

Timestamp.asm8	以纳秒为单位返回 numpy datetime64 格式。
Timestamp.day
Timestamp.dayofweek	返回星期几。
Timestamp.day_of_week	返回星期几。
Timestamp.dayofyear	返回一年中的第几天。
Timestamp.day_of_year	返回一年中的第几天。
Timestamp.days_in_month	返回月份的天数。
Timestamp.daysinmonth	返回月份的天数。
Timestamp.fold
Timestamp.hour
Timestamp.is_leap_year	如果年份为闰年，则返回 True。
Timestamp.is_month_end	检查日期是否为月份的最后一天。
Timestamp.is_month_start	检查日期是否为月份的第一天。
Timestamp.is_quarter_end	检查日期是否为季度的最后一天。
Timestamp.is_quarter_start	检查日期是否为季度的第一天。
Timestamp.is_year_end	如果日期为一年的最后一天，则返回 True。
Timestamp.is_year_start	如果日期为一年的第一天，则返回 True。
Timestamp.max
Timestamp.microsecond
Timestamp.min
Timestamp.minute
Timestamp.month
Timestamp.nanosecond
Timestamp.quarter	返回一年中的季度。
Timestamp.resolution
Timestamp.second
Timestamp.tz	tzinfo 的别名。
Timestamp.tzinfo
Timestamp.unit	与 self._creso 关联的缩写。
Timestamp.value
Timestamp.week	返回一年中的周数。
Timestamp.weekofyear	返回一年中的周数。
Timestamp.year

方法

Timestamp.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定的单位。
Timestamp.astimezone(tz)	将带有时区信息的时间戳转换为另一个时区。
Timestamp.ceil(freq[, ambiguous, nonexistent])	返回一个按此分辨率向上取整的新时间戳。
Timestamp.combine(date, time)	将日期、时间组合成具有相同日期和时间字段的日期时间。
Timestamp.ctime()	返回 ctime() 样式的字符串。
Timestamp.date()	返回具有相同年、月和日的日期对象。
Timestamp.day_name([locale])	返回具有指定区域设置的时间戳的星期几名称。
Timestamp.dst()	返回夏令时（DST）调整。
Timestamp.floor(freq[, ambiguous, nonexistent])	返回一个按此分辨率向下取整的新时间戳。
Timestamp.fromordinal(ordinal[, tz])	从普罗利普提克格里高利序数构造时间戳。
Timestamp.fromtimestamp(ts)	将时间戳[, tz]从 POSIX 时间戳转换为 tz 的本地时间。
Timestamp.isocalendar()	返回包含 ISO 年份、周数和工作日的命名元组。
Timestamp.isoformat([sep, timespec])	根据 ISO 8601 格式返回时间。
Timestamp.isoweekday()	返回日期表示的星期几。
Timestamp.month_name([locale])	返回具有指定区域设置的时间戳的月份名称。
Timestamp.normalize()	将时间戳规范化为午夜，保留 tz 信息。
Timestamp.now([tz])	返回表示当前本地时间的新时间戳对象。
Timestamp.replace([year, month, day, hour, ...])	实现 datetime.replace，处理纳秒。
Timestamp.round(freq[, ambiguous, nonexistent])	将时间戳舍入到指定的分辨率。
Timestamp.strftime(format)	返回时间戳的格式化字符串。
Timestamp.strptime(string, format)	该函数未实现。
Timestamp.time()	返回具有相同时间但 tzinfo=None 的时间对象。
Timestamp.timestamp()	返回 POSIX 时间戳作为浮点数。
Timestamp.timetuple()	返回与 time.localtime()兼容的时间元组。
Timestamp.timetz()	返回具有相同时间和 tzinfo 的时间对象。
Timestamp.to_datetime64()	返回具有相同精度的 numpy.datetime64 对象。
Timestamp.to_numpy([dtype, copy])	将时间戳转换为 NumPy datetime64。
Timestamp.to_julian_date()	将 TimeStamp 转换为儒略日。
Timestamp.to_period([freq])	返回一个周期，该周期是此时间戳的观察结果。
Timestamp.to_pydatetime([warn])	将时间戳对象转换为本机 Python datetime 对象。
Timestamp.today([tz])	返回本地时区的当前时间。
Timestamp.toordinal()	返回普通的格里高利序数。
Timestamp.tz_convert(tz)	将带有时区的时间戳转换为另一个时区。
Timestamp.tz_localize(tz[, ambiguous, ...])	将时间戳本地化到一个时区。
Timestamp.tzname()	返回时区名称。
Timestamp.utcfromtimestamp(ts)	从 POSIX 时间戳构造一个带时区的 UTC 日期时间。
Timestamp.utcnow()	返回表示 UTC 日期和时间的新时间戳。
Timestamp.utcoffset()	返回 UTC 偏移量。
Timestamp.utctimetuple()	返回 UTC 时间元组，与 time.localtime() 兼容。
Timestamp.weekday()	返回日期代表的星期几。

时间戳的集合可以存储在arrays.DatetimeArray中。对于时区感知数据，arrays.DatetimeArray的.dtype是DatetimeTZDtype。对于非时区感知数据，使用np.dtype("datetime64[ns]")。

如果数据是时区感知的，则数组中的每个值必须具有相同的时区。

arrays.DatetimeArray(values[, dtype, freq, copy])	用于时区感知或非时区感知日期时间数据的 Pandas ExtensionArray。
DatetimeTZDtype([unit, tz])	用于时区感知日期时间数据的 ExtensionDtype。

属性

Timestamp.asm8	返回纳秒的 numpy datetime64 格式。
Timestamp.day
Timestamp.dayofweek	返回一周中的天数。
Timestamp.day_of_week	返回一周中的天数。
Timestamp.dayofyear	返回一年中的天数。
Timestamp.day_of_year	返回一年中的天数。
Timestamp.days_in_month	返回该月的天数。
Timestamp.daysinmonth	返回该月的天数。
Timestamp.fold
Timestamp.hour
Timestamp.is_leap_year	如果年份是闰年，则返回 True。
Timestamp.is_month_end	检查日期是否是该月的最后一天。
Timestamp.is_month_start	检查日期是否是该月的第一天。
Timestamp.is_quarter_end	检查日期是否为季度的最后一天。
Timestamp.is_quarter_start	检查日期是否为季度的第一天。
Timestamp.is_year_end	如果日期是年份的最后一天，则返回 True。
Timestamp.is_year_start	如果日期是年份的第一天，则返回 True。
Timestamp.max
Timestamp.microsecond
Timestamp.min
Timestamp.minute
Timestamp.month
Timestamp.nanosecond
Timestamp.quarter	返回年份的季度。
Timestamp.resolution
Timestamp.second
Timestamp.tz	tzinfo 的别名。
Timestamp.tzinfo
Timestamp.unit	与 self._creso 关联的缩写。
Timestamp.value
Timestamp.week	返回年份的周数。
Timestamp.weekofyear	返回年份的周数。
Timestamp.year

方法

Timestamp.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定的单位。
Timestamp.astimezone(tz)	将时区感知的时间戳转换为另一个时区的时间。
Timestamp.ceil(freq[, ambiguous, nonexistent])	返回一个新的时间戳，其精度高于此分辨率。
Timestamp.combine(date, time)	将日期和时间合并为具有相同日期和时间字段的日期时间。
Timestamp.ctime()	返回 ctime() 格式的字符串。
Timestamp.date()	返回具有相同年份、月份和日期的日期对象。
Timestamp.day_name([locale])	返回具有指定区域设置的时间戳的星期几名称。
Timestamp.dst()	返回夏令时（DST）调整。
Timestamp.floor(freq[, ambiguous, nonexistent])	返回一个新的时间戳，其精度低于此分辨率。
Timestamp.fromordinal(ordinal[, tz])	从修正后的公历序数构造时间戳。
Timestamp.fromtimestamp(ts)	将 POSIX 时间戳转换为 tz 的本地时间。
Timestamp.isocalendar()	返回一个命名元组，其中包含 ISO 年、周编号和工作日。
Timestamp.isoformat([sep, timespec])	返回按照 ISO 8601 格式化的时间。
Timestamp.isoweekday()	返回日期所代表的星期几。
Timestamp.month_name([locale])	返回具有指定区域设置的时间戳的月份名称。
Timestamp.normalize()	将时间戳归一化为午夜，保留时区信息。
Timestamp.now([tz])	返回表示当前本地时间的新 Timestamp 对象。
Timestamp.replace([year, month, day, hour, ...])	实现 datetime.replace，处理纳秒。
Timestamp.round(freq[, ambiguous, nonexistent])	将时间戳舍入到指定的分辨率。
Timestamp.strftime(format)	返回时间戳的格式化字符串。
Timestamp.strptime(string, format)	该函数尚未实现。
Timestamp.time()	返回具有相同时间但 tzinfo=None 的时间对象。
Timestamp.timestamp()	返回 POSIX 时间戳作为浮点数。
Timestamp.timetuple()	返回与 time.localtime() 兼容的时间元组。
Timestamp.timetz()	返回具有相同时间和 tzinfo 的时间对象。
Timestamp.to_datetime64()	返回具有相同精度的 numpy.datetime64 对象。
Timestamp.to_numpy	将时间戳转换为 NumPy datetime64。
Timestamp.to_julian_date()	将 TimeStamp 转换为儒略日。
Timestamp.to_period([freq])	返回一个周期，其中该时间戳是一个观测点。
Timestamp.to_pydatetime([warn])	将时间戳对象转换为本机 Python datetime 对象。
Timestamp.today([tz])	返回本地时区的当前时间。
Timestamp.toordinal()	返回普通格里高利历的序数。
Timestamp.tz_convert(tz)	将带时区信息的时间戳转换为另一个时区。
Timestamp.tz_localize(tz[, ambiguous, ...])	将时间戳本地化到一个时区。
Timestamp.tzname()	返回时区名称。
Timestamp.utcfromtimestamp(ts)	从 POSIX 时间戳构造一个带时区的 UTC 日期时间。
Timestamp.utcnow()	返回表示 UTC 日期和时间的新时间戳。
Timestamp.utcoffset()	返回 UTC 偏移量。
Timestamp.utctimetuple()	返回与 time.localtime() 兼容的 UTC 时间元组。
Timestamp.weekday()	返回日期所代表的星期几。

时间戳的集合可以存储在 arrays.DatetimeArray 中。对于带时区的数据，arrays.DatetimeArray 的 .dtype 是 DatetimeTZDtype。对于不带时区的数据，使用 np.dtype("datetime64[ns]")。

如果数据带有时区信息，则数组中的每个值必须具有相同的时区。

arrays.DatetimeArray(values[, dtype, freq, copy])	用于不带时区或带时区的日期时间数据的 Pandas ExtensionArray。
DatetimeTZDtype([unit, tz])	用于带时区的日期时间数据的 ExtensionDtype。

时间差

NumPy 可以原生表示时间差。pandas 提供了 Timedelta 以与 Timestamp 对称。NaT 是时间差数据的缺失值。

Timedelta([value, unit])	表示两个日期或时间之间的持续时间。

属性

Timedelta.asm8	返回一个 numpy timedelta64 数组标量视图。
Timedelta.components	返回一个类似命名元组的组件。
Timedelta.days	返回 timedelta 的天数。
Timedelta.max
Timedelta.microseconds
Timedelta.min
Timedelta.nanoseconds	返回纳秒数 (n)，其中 0 <= n < 1 微秒。
Timedelta.resolution
Timedelta.seconds	返回 timedelta 的总小时数、分钟数和秒数（以秒为单位）。
Timedelta.unit
Timedelta.value
Timedelta.view(dtype)	数组视图兼容性。

Methods

Timedelta.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定的单位。
Timedelta.ceil(freq)	返回一个新的 Timedelta，使其上限为此分辨率。
Timedelta.floor(freq)	返回一个新的 Timedelta，使其分辨率下限为此。
Timedelta.isoformat()	将 Timedelta 格式化为 ISO 8601 Duration。
Timedelta.round(freq)	将 Timedelta 四舍五入到指定的分辨率。
Timedelta.to_pytimedelta()	将 pandas Timedelta 对象转换为 python datetime.timedelta 对象。
Timedelta.to_timedelta64()	返回一个带有'ns'精度的 numpy.timedelta64 对象。
Timedelta.to_numpy([dtype, copy])	将 Timedelta 转换为 NumPy timedelta64。
Timedelta.total_seconds()	持续时间的总秒数。

一组 Timedelta 可以存储在 TimedeltaArray 中。

arrays.TimedeltaArray(values[, dtype, freq, ...])	用于时间数据的 Pandas ExtensionArray。

属性

Timedelta.asm8	返回一个 numpy timedelta64 数组标量视图。
Timedelta.components	返回类似于 components 的命名元组。
Timedelta.days	返回 timedelta 的天数。
Timedelta.max
Timedelta.microseconds
Timedelta.min
Timedelta.nanoseconds	返回纳秒数（n），其中 0 <= n < 1 微秒。
Timedelta.resolution
Timedelta.seconds	返回 timedelta 的总小时数、分钟数和秒数（以秒为单位）。
Timedelta.unit
Timedelta.value
Timedelta.view(dtype)	数组视图兼容性。

方法

Timedelta.as_unit(unit[, round_ok])	将底层 int64 表示转换为给定单位。
Timedelta.ceil(freq)	返回一个新的 Timedelta，其分辨率为此分辨率。
Timedelta.floor(freq)	返回一个新的 Timedelta，其分辨率为此分辨率。
Timedelta.isoformat()	将 Timedelta 格式化为 ISO 8601 时长。
Timedelta.round(freq)	将 Timedelta 舍入到指定的分辨率。
Timedelta.to_pytimedelta()	将 pandas Timedelta 对象转换为 python datetime.timedelta对象。
Timedelta.to_timedelta64()	返回具有'ns'精度的 numpy.timedelta64 对象。
Timedelta.to_numpy([dtype, copy])	将 Timedelta 转换为 NumPy timedelta64。
Timedelta.total_seconds()	持续时间的总秒数。

一组Timedelta可以存储在TimedeltaArray中。

arrays.TimedeltaArray(values[, dtype, freq, ...])	用于 timedelta 数据的 Pandas ExtensionArray。

时期

pandas 将时间段表示为Period对象。

Period

Period([value, freq, ordinal, year, month, ...])	表示一段时间。

Properties

Period.day	获取周期落在的月份的日期。
Period.dayofweek	该周期所在的星期几，星期一为 0，星期日为 6。
Period.day_of_week	该周期所在的星期几，星期一为 0，星期日为 6。
Period.dayofyear	返回一年中的第几天。
Period.day_of_year	返回一年中的第几天。
Period.days_in_month	获取该周期所在月份的总天数。
Period.daysinmonth	获取该周期所在月份的总天数。
Period.end_time	获取周期结束的时间戳。
Period.freq
Period.freqstr	返回频率的字符串表示。
Period.hour	获取周期的一天中的小时组件。
Period.is_leap_year	如果周期的年份是闰年，则返回 True。
Period.minute	获取周期的小时中的分钟组件。
Period.month	返回此周期所在的月份。
Period.ordinal
Period.quarter	返回此周期所在的季度。
Period.qyear	根据其起始季度确定周期所在的财政年度。
Period.second	获取周期的秒组件。
Period.start_time	获取周期开始的时间戳。
Period.week	获取给定周期所在的一年中的周数。
Period.weekday	周期所在的星期几，星期一为 0，星期日为 6。
Period.weekofyear	获取给定周期所在的一年中的周数。
Period.year	返回此周期所在的年份。

方法

Period.asfreq(freq[, how])	将周期转换为所需频率，位于间隔的开始或结束。
Period.now(freq)	返回当前日期的周期。
Period.strftime(fmt)	返回Period的格式化字符串表示。
Period.to_timestamp([freq, how])	返回周期的时间戳表示。

一组 Period 可能存储在 arrays.PeriodArray 中。arrays.PeriodArray 中的每个 Period 必须具有相同的 freq。

arrays.PeriodArray(values[, dtype, freq, copy])	用于存储 Period 数据的 Pandas ExtensionArray。
PeriodDtype(freq)	用于 Period 数据的 ExtensionDtype。

属性

Period.day	获取 Period 所在月份的日期。
Period.dayofweek	Period 所在的星期几，星期一为 0，星期日为 6。
Period.day_of_week	Period 所在的星期几，星期一为 0，星期日为 6。
Period.dayofyear	返回一年中的第几天。
Period.day_of_year	返回一年中的第几天。
Period.days_in_month	获取该期间所在月份的总天数。
Period.daysinmonth	获取该期间所在月份的总天数。
Period.end_time	获取期间结束时间的时间戳。
Period.freq
Period.freqstr	返回频率的字符串表示。
Period.hour	获取 Period 的一天中的小时数。
Period.is_leap_year	如果该期间所在年份是闰年，则返回 True。
Period.minute	获取 Period 的小时数。
Period.month	返回 Period 所在的月份。
Period.ordinal
Period.quarter	返回此周期所属的季度。
Period.qyear	根据其起始季度确定周期所在的财政年度。
Period.second	获取周期的第二个组成部分。
Period.start_time	获取周期开始的时间戳。
Period.week	获取给定周期的年份周数。
Period.weekday	周期所在的星期几，星期一为 0，星期日为 6。
Period.weekofyear	获取给定周期的年份周数。
Period.year	返回此周期所在的年份。

方法

Period.asfreq(freq[, how])	将周期转换为所需频率，以间隔的开始或结束为准。
Period.now(freq)	返回当前日期的周期。
Period.strftime(fmt)	返回Period的格式化字符串表示形式。
Period.to_timestamp([freq, how])	返回周期的时间戳表示。

一组Period可以存储在arrays.PeriodArray中。arrays.PeriodArray中的每个周期必须具有相同的freq。

arrays.PeriodArray(values[, dtype, freq, copy])	用于存储周期数据的 Pandas 扩展数组。
PeriodDtype(freq)	用于周期数据的 ExtensionDtype。

区间

任意间隔都可以表示为Interval对象。

Interval	实现区间的不可变对象，类似于有界切片。

属性

Interval.closed	描述区间包含侧的字符串。
Interval.closed_left	检查区间左侧是否闭合。
Interval.closed_right	检查区间右侧是否闭合。
Interval.is_empty	指示区间是否为空，即不包含任何点。
Interval.left	区间的左边界。
Interval.length	返回区间的长度。
Interval.mid	返回区间的中点。
Interval.open_left	检查区间左侧是否开放。
Interval.open_right	检查区间右侧是否开放。
Interval.overlaps(other)	检查两个区间对象是否重叠。
Interval.right	区间的右边界。

一组区间可以存储在arrays.IntervalArray中。

arrays.IntervalArray(data[, closed, dtype, ...])	用于在同一侧闭合的区间数据的 Pandas 数组。
IntervalDtype([subtype, closed])	用于区间数据的扩展数据类型。

属性

Interval.closed	描述区间包含侧的字符串。
Interval.closed_left	检查区间左侧是否闭合。
Interval.closed_right	检查区间右侧是否闭合。
Interval.is_empty	指示区间是否为空，即不包含任何点。
Interval.left	区间的左边界。
Interval.length	返回区间的长度。
Interval.mid	返回区间的中点。
Interval.open_left	检查区间左侧是否开放。
Interval.open_right	检查区间右侧是否开放。
Interval.overlaps(other)	检查两个区间对象是否重叠。
Interval.right	区间的右边界。

区间的集合可以存储在 arrays.IntervalArray 中。

arrays.IntervalArray(data[, closed, dtype, ...])	存储在同一侧封闭的区间数据的 Pandas 数组。
IntervalDtype([subtype, closed])	用于区间数据的 ExtensionDtype。

可空整数

numpy.ndarray 无法原生表示具有缺失值的整数数据。pandas 通过 arrays.IntegerArray 实现了这一点。 |

arrays.IntegerArray(values, mask[, copy])	整数（可选缺失）值的数组。
Int8Dtype()	用于 int8 整数数据的 ExtensionDtype。
Int16Dtype()	用于 int16 整数数据的 ExtensionDtype。
Int32Dtype()	用于 int32 整数数据的 ExtensionDtype。
Int64Dtype()	用于 int64 整数数据的 ExtensionDtype。
UInt8Dtype()	用于 uint8 整数数据的 ExtensionDtype。
UInt16Dtype()	用于 uint16 整数数据的 ExtensionDtype。
UInt32Dtype()	用于 uint32 整数数据的扩展数据类型。
UInt64Dtype()	用于 uint64 整数数据的扩展数据类型。

可空浮点数

arrays.FloatingArray(values, mask[, copy])	浮点数（可选缺失）值数组。
Float32Dtype()	用于 float32 数据的扩展数据类型。
Float64Dtype()	用于 float64 数据的扩展数据类型。

分类数据

pandas 定义了一种自定义数据类型来表示只能取有限固定值集的数据。Categorical 的数据类型可以由 CategoricalDtype 描述。

CategoricalDtype([categories, ordered])	分类数据的类型，包括类别和顺序。
CategoricalDtype.categories	包含允许的唯一类别的索引。
CategoricalDtype.ordered	类别是否具有顺序关系。

分类数据可以存储在 pandas.Categorical 中。

Categorical(values[, categories, ordered, ...])	以经典的 R / S-plus 方式表示分类变量。

当你已经有了类别和整数编码时，可以使用另一种 Categorical.from_codes() 构造函数：

Categorical.from_codes(codes[, categories, ...])	从代码和类别或数据类型创建分类类型。

数据类型信息可在 Categorical 上找到。

Categorical.dtype	此实例的 CategoricalDtype。
Categorical.categories	此分类的类别。
Categorical.ordered	类别是否具有有序关系。
Categorical.codes	此分类索引的类别代码。

np.asarray(categorical)通过实现数���接口来工作。请注意，这会将Categorical转换回 NumPy 数组，因此类别和顺序信息不会被保留！

Categorical.__array__([dtype, copy])	numpy 数组接口。

一个Categorical可以存储在Series或DataFrame中。要创建 dtype 为category的 Series，使用cat = s.astype(dtype)或Series(..., dtype=dtype)，其中dtype可以是

• 字符串'category'

• 一个CategoricalDtype的实例。

如果Series的 dtype 为CategoricalDtype，则可以使用Series.cat来更改分类数据。更多信息请参见分类访问器。

稀疏

数据中一个值重复多次（例如0或NaN）可以高效地存储为arrays.SparseArray。

arrays.SparseArray(data[, sparse_index, ...])	用于存储稀疏数据的 ExtensionArray。
SparseDtype([dtype, fill_value])	存储在SparseArray中的数据类型。

如果Series包含稀疏值，则可以使用Series.sparse访问器来访问稀疏特定属性和方法。更多信息请参见稀疏访问器和用户指南。

字符串

在处理文本数据时，其中每个有效元素都是字符串或缺失值，我们建议使用StringDtype（别名为"string"）。

arrays.StringArray(values[, copy])	用于字符串数据的扩展数组。
arrays.ArrowStringArray(values)	在 pyarrow.ChunkedArray 中存储字符串数据的扩展数组。
StringDtype([storage])	用于字符串数据的扩展数据类型。

由 arrays.StringArray 支持的 Series 的 str 访问器可用。更多信息请参见字符串处理。

可空布尔

布尔数据类型（别名为"boolean"）支持存储具有缺失值的布尔数据（True，False），这在布尔 numpy.ndarray 中是不可能的。

arrays.BooleanArray(values, mask[, copy])	存储具有缺失值的布尔（True/False）数据的数组。
BooleanDtype()	用于布尔数据的扩展数据类型。

实用工具

构造函数

api.types.union_categoricals(to_union[, ...])	结合类别列表，联合类别。
api.types.infer_dtype(value[, skipna])	返回标量或类似值的类型的字符串标签。
api.types.pandas_dtype(dtype)	将输入转换为仅限于 pandas 的数据类型对象或 numpy 的数据类型对象。

数据类型内省

api.types.is_any_real_numeric_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为实数数据类型。
api.types.is_bool_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为布尔数据类型。
api.types.is_categorical_dtype(arr_or_dtype)	（已弃用）检查数组样式或数据类型是否为分类数据类型。
api.types.is_complex_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为复数数据类型。
api.types.is_datetime64_any_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_dtype(arr_or_dtype)	检查数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_ns_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64[ns]数据类型。
api.types.is_datetime64tz_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为 DatetimeTZDtype 数据类型。
api.types.is_extension_array_dtype(arr_or_dtype)	检查对象是否为 pandas 扩展数组类型。
api.types.is_float_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为浮点数数据类型。
api.types.is_int64_dtype(arr_or_dtype)	(已弃用) 检查提供的数组或数据类型是否为 int64 数据类型。
api.types.is_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为整数数据类型。
api.types.is_interval_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为区间数据类型。
api.types.is_numeric_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为数值数据类型。
api.types.is_object_dtype(arr_or_dtype)	检查数组或数据类型是否为对象数据类型。
api.types.is_period_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为周期数据类型。
api.types.is_signed_integer_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为带符号整数 dtype。
api.types.is_string_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为字符串 dtype。
api.types.is_timedelta64_dtype(arr_or_dtype)	检查数组或 dtype 是否为 timedelta64 dtype。
api.types.is_timedelta64_ns_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为 timedelta64[ns] dtype。
api.types.is_unsigned_integer_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为无符号整数 dtype。
api.types.is_sparse(arr)	(已弃用) 检查数组样式是否为 1-D pandas 稀疏数组。

Iterable introspection

api.types.is_dict_like(obj)	检查对象是否类似字典。
api.types.is_file_like(obj)	检查对象是否为类似文件的对象。
api.types.is_list_like(obj[, allow_sets])	检查对象是否为类似列表。
api.types.is_named_tuple(obj)	检查对象是否为命名元组。
api.types.is_iterator(obj)	检查对象是否为迭代器。

Scalar introspection

api.types.is_bool(obj)	如果给定对象是布尔值，则返回 True。
api.types.is_complex(obj)	如果给定对象是复数，则返回 True。
api.types.is_float(obj)	如果给定对象是浮点数，则返回 True。
api.types.is_hashable(obj)	如果 hash(obj) 成功，则返回 True，否则返回 False。
api.types.is_integer(obj)	如果给定对象为整数，则返回 True。
api.types.is_interval(obj)
api.types.is_number(obj)	检查对象是否为数字。
api.types.is_re(obj)	检查对象是否为正则表达式模式实例。
api.types.is_re_compilable(obj)	检查对象是否可编译为正则表达式模式实例。
api.types.is_scalar(val)	如果给定对象为标量，则返回 True。

构造函数

api.types.union_categoricals(to_union[, ...])	组合类别类似的 Categorical 对象列表，合并类别。
api.types.infer_dtype(value[, skipna])	返回标量或类似值列表的类型的字符串标签。
api.types.pandas_dtype(dtype)	将输入转换为仅限于 pandas 的 dtype 对象或 numpy 的 dtype 对象。

数据类型内省

api.types.is_any_real_numeric_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为实数 dtype。
api.types.is_bool_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为布尔 dtype。
api.types.is_categorical_dtype(arr_or_dtype)	(已弃用) 检查数组类似对象或 dtype 是否为分类 dtype。
api.types.is_complex_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为复数 dtype。
api.types.is_datetime64_any_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_dtype(arr_or_dtype)	检查数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_ns_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64[ns] 数据类型。
api.types.is_datetime64tz_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为 DatetimeTZDtype 数据类型。
api.types.is_extension_array_dtype(arr_or_dtype)	检查对象是否为 pandas 扩展数组类型。
api.types.is_float_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为浮点数数据类型。
api.types.is_int64_dtype(arr_or_dtype)	(已弃用) 检查提供的数组或数据类型是否为 int64 数据类型。
api.types.is_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为整数数据类型。
api.types.is_interval_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为 Interval 数据类型。
api.types.is_numeric_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为数值数据类型。
api.types.is_object_dtype(arr_or_dtype)	检查数组或数据类型是否为 object 数据类型。
api.types.is_period_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为 Period 数据类型。
api.types.is_signed_integer_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为有符号整数 dtype。
api.types.is_string_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为字符串 dtype。
api.types.is_timedelta64_dtype(arr_or_dtype)	检查数组样式或 dtype 是否为 timedelta64 dtype。
api.types.is_timedelta64_ns_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为 timedelta64[ns] dtype。
api.types.is_unsigned_integer_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为无符号整数 dtype。
api.types.is_sparse(arr)	（已弃用）检查数组样式是否为 1-D pandas 稀疏数组。

可迭代对象内省

api.types.is_dict_like(obj)	检查对象是否类似字典。
api.types.is_file_like(obj)	检查对象是否为类文件对象。
api.types.is_list_like(obj[, allow_sets])	检查对象是否类似列表。
api.types.is_named_tuple(obj)	检查对象是否为命名元组。
api.types.is_iterator(obj)	检查对象是否为迭代器。

标量内省

api.types.is_bool(obj)	如果给定对象为布尔值，则返回 True。
api.types.is_complex(obj)	如果给定对象为复数，则返回 True。
api.types.is_float(obj)	如果给定对象为浮点数，则返回 True。
api.types.is_hashable(obj)	如果 hash(obj)成功，则返回 True，否则返回 False。
api.types.is_integer(obj)	如果给定对象是整数，则返回 True。
api.types.is_interval(obj)
api.types.is_number(obj)	检查对象是否为数字。
api.types.is_re(obj)	检查对象是否为正则表达式模式实例。
api.types.is_re_compilable(obj)	检查对象是否可以编译为正则表达式模式实例。
api.types.is_scalar(val)	如果给定对象是标量，则返回 True。

数据类型内省

api.types.is_any_real_numeric_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为实数数据类型。
api.types.is_bool_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为布尔数据类型。
api.types.is_categorical_dtype(arr_or_dtype)	(已弃用) 检查数组或数据类型是否为分类数据类型。
api.types.is_complex_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为复数数据类型。
api.types.is_datetime64_any_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_dtype(arr_or_dtype)	检查数组或数据类型是否为 datetime64 数据类型。
api.types.is_datetime64_ns_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为 datetime64[ns]数据类型。
api.types.is_datetime64tz_dtype(arr_or_dtype)	（已弃用）检查数组或数据类型是否为 DatetimeTZDtype 数据类型。
api.types.is_extension_array_dtype(arr_or_dtype)	检查对象是否为 pandas 扩展数组类型。
api.types.is_float_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为浮点数数据类型。
api.types.is_int64_dtype(arr_or_dtype)	（已弃用）检查提供的数组或数据类型是否为 int64 数据类型。
api.types.is_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为整数数据类型。
api.types.is_interval_dtype(arr_or_dtype)	（已弃用）检查数组或数据类型是否为 Interval 数据类型。
api.types.is_numeric_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为数值数据类型。
api.types.is_object_dtype(arr_or_dtype)	检查数组或数据类型是否为对象数据类型。
api.types.is_period_dtype(arr_or_dtype)	（已弃用）检查数组或数据类型是否为 Period 数据类型。
api.types.is_signed_integer_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为有��号整数数据类型。
api.types.is_string_dtype(arr_or_dtype)	检查提供的数组或数据类型是否为字符串数据类型。
api.types.is_timedelta64_dtype(arr_or_dtype)	检查数组或数据类型是否为 timedelta64 数据类型。
api.types.is_timedelta64_ns_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为 timedelta64[ns] dtype。
api.types.is_unsigned_integer_dtype(arr_or_dtype)	检查提供的数组或 dtype 是否为无符号整数 dtype。
api.types.is_sparse(arr)	(已弃用) 检查数组样式是否为 1-D pandas 稀疏数组。

可迭代内省

api.types.is_dict_like(obj)	检查对象是否类似字典。
api.types.is_file_like(obj)	检查对象是否为文件样对象。
api.types.is_list_like(obj[, allow_sets])	检查对象是否类似列表。
api.types.is_named_tuple(obj)	检查对象是否为命名元组。
api.types.is_iterator(obj)	检查对象是否为迭代器。

标量内省

api.types.is_bool(obj)	如果给定对象是布尔值，则返回 True。
api.types.is_complex(obj)	如果给定对象是复数，则返回 True。
api.types.is_float(obj)	如果给定对象是浮点数，则返回 True。
api.types.is_hashable(obj)	如果 hash(obj) 成功，则返回 True；否则返回 False。
api.types.is_integer(obj)	如果给定对象是整数，则返回 True。
api.types.is_interval(obj)
api.types.is_number(obj)	检查对象是否为数字。
api.types.is_re(obj)	检查对象是否为正则表达式模式实例。
api.types.is_re_compilable(obj)	检查对象是否可以编译为正则表达式模式实例。
api.types.is_scalar(val)	如果给定对象是标量，则返回 True。