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

Pandas 2.2 中文文档（二十三）

原文：pandas.pydata.org/docs/

pandas.DataFrame.isna

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

DataFrame.isna()

检测缺失值。

返回一个布尔值对象，指示值是否为 NA。 NA 值，如 None 或 numpy.NaN，被映射为 True 值。 其他所有值被映射为 False 值。 诸如空字符串 '' 或 numpy.inf 的字符不被视为 NA 值（除非您设置 pandas.options.mode.use_inf_as_na = True）。

返回：

DataFrame

DataFrame 中每个元素的布尔值掩码，指示元素是否为 NA 值。

另请参阅

DataFrame.isnull

isna 的别名。

DataFrame.notna

isna 的布尔值取反。

DataFrame.dropna

忽略具有缺失值的轴标签。

isna

顶层 isna。

示例

显示 DataFrame 中的哪些条目是 NA。

>>> df = pd.DataFrame(dict(age=[5, 6, np.nan],
...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),
...                              pd.Timestamp('1940-04-25')],
...                        name=['Alfred', 'Batman', ''],
...                        toy=[None, 'Batmobile', 'Joker']))
>>> df
 age       born    name        toy
0  5.0        NaT  Alfred       None
1  6.0 1939-05-27  Batman  Batmobile
2  NaN 1940-04-25              Joker 

>>> df.isna()
 age   born   name    toy
0  False   True  False   True
1  False  False  False  False
2   True  False  False  False 

显示 Series 中的哪些条目是 NA。

>>> ser = pd.Series([5, 6, np.nan])
>>> ser
0    5.0
1    6.0
2    NaN
dtype: float64 

>>> ser.isna()
0    False
1    False
2     True
dtype: bool 

pandas.DataFrame.isnull

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

DataFrame.isnull()

DataFrame.isnull 是 DataFrame.isna 的别名。

检测缺失值。

返回一个布尔值相同大小的对象，指示值是否为 NA。NA 值，如 None 或 numpy.NaN，被映射为 True 值。其他一切被映射为 False 值。诸如空字符串 '' 或 numpy.inf 等字符不被视为 NA 值（除非你设置了 pandas.options.mode.use_inf_as_na = True）。

返回：

DataFrame

一个布尔值掩码，用于 DataFrame 中的每个元素，指示元素是否为 NA 值。

另请参阅

DataFrame.isnull

isna 的别名。

DataFrame.notna

isna 的布尔值的反义。

DataFrame.dropna

忽略带有缺失值的轴标签。

isna

顶级 isna。

示例

显示 DataFrame 中的哪些条目为 NA。

>>> df = pd.DataFrame(dict(age=[5, 6, np.nan],
...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),
...                              pd.Timestamp('1940-04-25')],
...                        name=['Alfred', 'Batman', ''],
...                        toy=[None, 'Batmobile', 'Joker']))
>>> df
 age       born    name        toy
0  5.0        NaT  Alfred       None
1  6.0 1939-05-27  Batman  Batmobile
2  NaN 1940-04-25              Joker 

>>> df.isna()
 age   born   name    toy
0  False   True  False   True
1  False  False  False  False
2   True  False  False  False 

显示 Series 中的哪些条目为 NA。

>>> ser = pd.Series([5, 6, np.nan])
>>> ser
0    5.0
1    6.0
2    NaN
dtype: float64 

>>> ser.isna()
0    False
1    False
2     True
dtype: bool 

pandas.DataFrame.notna

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

DataFrame.notna()

检测存在的（非缺失）值。

返回一个布尔型对象，指示数值是否不为 NA。非缺失值映射为 True。例如空字符串 '' 或 numpy.inf 不被视为 NA 值（除非设置 pandas.options.mode.use_inf_as_na = True）。NA 值，如 None 或 numpy.NaN，映射为 False 值。

返回：

DataFrame

DataFrame 中每个元素的布尔值掩码，指示元素是否不是 NA 值。

另请参阅

DataFrame.notnull

notna 的别名。

DataFrame.isna

notna 的布尔反转。

DataFrame.dropna

省略具有缺失值的轴标签。

notna

顶层的 notna。

示例

显示 DataFrame 中不为 NA 的条目。

>>> df = pd.DataFrame(dict(age=[5, 6, np.nan],
...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),
...                              pd.Timestamp('1940-04-25')],
...                        name=['Alfred', 'Batman', ''],
...                        toy=[None, 'Batmobile', 'Joker']))
>>> df
 age       born    name        toy
0  5.0        NaT  Alfred       None
1  6.0 1939-05-27  Batman  Batmobile
2  NaN 1940-04-25              Joker 

>>> df.notna()
 age   born  name    toy
0   True  False  True  False
1   True   True  True   True
2  False   True  True   True 

显示 Series 中不为 NA 的条目。

>>> ser = pd.Series([5, 6, np.nan])
>>> ser
0    5.0
1    6.0
2    NaN
dtype: float64 

>>> ser.notna()
0     True
1     True
2    False
dtype: bool 

pandas.DataFrame.notnull

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

DataFrame.notnull()

DataFrame.notnull 是 DataFrame.notna 的别名。

检测现有（非缺失）值。

返回一个布尔值相同大小的对象，指示值是否不是 NA。非缺失值映射为 True。诸如空字符串 '' 或 numpy.inf 这样的字符不被视为 NA 值（除非设置 pandas.options.mode.use_inf_as_na = True）。诸如 None 或 numpy.NaN 这样的 NA 值会映射为 False 值。

返回：

DataFrame

DataFrame 中每个元素的布尔值掩码，指示该元素是否不是 NA 值。

另见

DataFrame.notnull

notna 的别名。

DataFrame.isna

notna 的布尔反转。

DataFrame.dropna

忽略具有缺失值的轴标签。

notna

顶级的 notna。

示例

显示 DataFrame 中哪些条目不是 NA 值。

>>> df = pd.DataFrame(dict(age=[5, 6, np.nan],
...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),
...                              pd.Timestamp('1940-04-25')],
...                        name=['Alfred', 'Batman', ''],
...                        toy=[None, 'Batmobile', 'Joker']))
>>> df
 age       born    name        toy
0  5.0        NaT  Alfred       None
1  6.0 1939-05-27  Batman  Batmobile
2  NaN 1940-04-25              Joker 

>>> df.notna()
 age   born  name    toy
0   True  False  True  False
1   True   True  True   True
2  False   True  True   True 

显示 Series 中哪些条目不是 NA 值。

>>> ser = pd.Series([5, 6, np.nan])
>>> ser
0    5.0
1    6.0
2    NaN
dtype: float64 

>>> ser.notna()
0     True
1     True
2    False
dtype: bool 

pandas.DataFrame.pad

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

DataFrame.pad(*, axis=None, inplace=False, limit=None, downcast=_NoDefault.no_default)

通过将最后一个有效观察值传播到下一个有效值来填充 NA/NaN 值。

从版本 2.0 开始弃用：Series/DataFrame.pad 已被弃用。请使用 Series/DataFrame.ffill 代替。

返回：

Series/DataFrame 或 None

带有缺失值填充的对象，如果inplace=True则为 None。

示例

请参见DataFrame.ffill()，或者Series.ffill()的示例。

pandas.DataFrame.replace

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

DataFrame.replace(to_replace=None, value=_NoDefault.no_default, *, inplace=False, limit=None, regex=False, method=_NoDefault.no_default)

用给定的值替换 to_replace 中的值。

Series/DataFrame 的值会动态替换为其他值。这与使用 .loc 或 .iloc 进行更新不同，后者需要您指定要用某个值更新的位置。

参数：

to_replacestr、regex、列表、字典、Series、int、float 或 None

如何找到将被替换的值。

• 数字、str 或 regex：

  • 数字：等于 to_replace 的数值将被替换为 value
  • str：与 to_replace 完全匹配的字符串将被替换为 value
  • regex：匹配 to_replace 的正则表达式将被替换为 value

• 字符串、正则表达式或数字的列表：

  • 首先，如果 to_replace 和 value 都是列表，则它们 必须 是相同的长度。
  • 其次，如果 regex=True，那么两个列表中的所有字符串都将被解释为正则表达式，否则它们将直接匹配。对于 value 来说，这并不重要，因为您可以使用的替换正则表达式很少。
  • str、regex 和数字规则同上。

• 字典：

  • 字典可用于指定不同的替换值以替换不同的现有值。例如，{'a': 'b', 'y': 'z'} 将值 ‘a’ 替换为 ‘b’，‘y’ 替换为 ‘z’。要以这种方式使用字典，应不提供可选的 value 参数。
  • 对于 DataFrame，字典可以指定应在不同列中替换不同的值。例如，{'a': 1, 'b': 'z'} 在列 ‘a’ 中查找值 1，在列 ‘b’ 中查找值 ‘z’，并将这些值替换为 value 中指定的内容。在这种情况下，value 参数不应为 None。您可以将此视为传递两个列表的特殊情况，只是您正在指定要搜索的列。
  • 对于 DataFrame 嵌套字典，例如 {'a': {'b': np.nan}}，读取方式如下：在列 ‘a’ 中查找值 ‘b’，并将其���换为 NaN。在这种情况下，不应指定可选的 value 参数以使用嵌套字典。您也可以嵌套正则表达式。请注意，列名（嵌套字典中顶层字典键）不能是正则表达式。

• None：

  • 这意味着 regex 参数必须是字符串、编译的正则表达式、列表、字典、ndarray 或 Series 中的元素。如果 value 也是 None，那么这个 必须 是一个嵌套的字典或 Series。

请参考示例部分，查看每个示例。

value标量、字典、列表、字符串、正则表达式，默认为 None

要用来替换与 to_replace 匹配的任何值的值。对于 DataFrame，可以使用值字典来指定每列使用哪个值（字典中没有的列将不会填充）。还允许正则表达式、字符串、列表或这些对象的字典。

inplacebool，默认为 False

如果为 True，则在原地执行操作并返回 None。

limitint，默认为 None

向前或向后填充的最大大小间隙。

自版本 2.1.0 起已弃用。

regexbool 或与 to_replace 相同类型，默认为 False

是否将 to_replace 和/或 value 解释为正则表达式。或者，这可以是一个正则表达式，或者是一个正则表达式的列表、字典或数组，其中 to_replace 必须为 None。

method

当 to_replace 是标量、列表或元组，而 value 是 None 时使用的方法。

自版本 2.1.0 起已弃用。

返回：

Series/DataFrame

替换后的对象。

引发：

AssertionError

• 如果 regex 不是 bool，且 to_replace 不是 None。

TypeError

• 如果 to_replace 不是标量、类似数组、dict 或 None

• 如果 to_replace 是一个 dict，而 value 不是一个 list、dict、ndarray 或 Series

• 如果 to_replace 是 None，且 regex 无法编译成正则表达式，或者是一个列表、字典、ndarray 或 Series。

• 当替换多个 bool 或 datetime64 对象时，to_replace 的参数与要替换的值的类型不匹配

ValueError

• 如果传递给 to_replace 和 value 的是一个 list 或一个 ndarray，但它们的长度不相同。

另请参阅

Series.fillna

填充 NA 值。

DataFrame.fillna

填充 NA 值。

Series.where

根据布尔条件替换值。

DataFrame.where

根据布尔条件替换值。

DataFrame.map

对 Dataframe 逐元素应用函数。

Series.map

根据输入映射或函数映射 Series 的值。

Series.str.replace

简单的字符串替换。

注意事项

• 在底层使用 re.sub 执行正则表达式替换。re.sub 的替换规则相同。

• 正则表达式只会在字符串上进行替换，这意味着您不能提供例如匹配浮点数的正则表达式，并期望您的框架中具有数值 dtype 的列被匹配。但是，如果这些浮点数是字符串，那么您可以这样做。

• 该方法有 很多 选项。鼓励您尝试并使用该方法来获得��于其工作方式的直觉。

• 当字典用作 to_replace 值时，字典中的键是要替换的部分，字典中的值是值参数。

示例

标量 to_replace 和 value

>>> s = pd.Series([1, 2, 3, 4, 5])
>>> s.replace(1, 5)
0    5
1    2
2    3
3    4
4    5
dtype: int64 

>>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],
...                    'B': [5, 6, 7, 8, 9],
...                    'C': ['a', 'b', 'c', 'd', 'e']})
>>> df.replace(0, 5)
 A  B  C
0  5  5  a
1  1  6  b
2  2  7  c
3  3  8  d
4  4  9  e 

类似列表的 to_replace

>>> df.replace([0, 1, 2, 3], 4)
 A  B  C
0  4  5  a
1  4  6  b
2  4  7  c
3  4  8  d
4  4  9  e 

>>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])
 A  B  C
0  4  5  a
1  3  6  b
2  2  7  c
3  1  8  d
4  4  9  e 

>>> s.replace([1, 2], method='bfill')
0    3
1    3
2    3
3    4
4    5
dtype: int64 

类似字典的 to_replace

>>> df.replace({0: 10, 1: 100})
 A  B  C
0   10  5  a
1  100  6  b
2    2  7  c
3    3  8  d
4    4  9  e 

>>> df.replace({'A': 0, 'B': 5}, 100)
 A    B  C
0  100  100  a
1    1    6  b
2    2    7  c
3    3    8  d
4    4    9  e 

>>> df.replace({'A': {0: 100, 4: 400}})
 A  B  C
0  100  5  a
1    1  6  b
2    2  7  c
3    3  8  d
4  400  9  e 

正则表达式 to_replace

>>> df = pd.DataFrame({'A': ['bat', 'foo', 'bait'],
...                    'B': ['abc', 'bar', 'xyz']})
>>> df.replace(to_replace=r'^ba.$', value='new', regex=True)
 A    B
0   new  abc
1   foo  new
2  bait  xyz 

>>> df.replace({'A': r'^ba.$'}, {'A': 'new'}, regex=True)
 A    B
0   new  abc
1   foo  bar
2  bait  xyz 

>>> df.replace(regex=r'^ba.$', value='new')
 A    B
0   new  abc
1   foo  new
2  bait  xyz 

>>> df.replace(regex={r'^ba.$': 'new', 'foo': 'xyz'})
 A    B
0   new  abc
1   xyz  new
2  bait  xyz 

>>> df.replace(regex=[r'^ba.$', 'foo'], value='new')
 A    B
0   new  abc
1   new  new
2  bait  xyz 

比较s.replace({'a': None})和s.replace('a', None)的行为，以了解to_replace参数的特殊之处：

>>> s = pd.Series([10, 'a', 'a', 'b', 'a']) 

当将字典用作to_replace值时，就好像字典中的值等于value参数。s.replace({'a': None})等同于s.replace(to_replace={'a': None}, value=None, method=None)：

>>> s.replace({'a': None})
0      10
1    None
2    None
3       b
4    None
dtype: object 

当未明确传递value且to_replace是标量、列表或元组时，replace使用method参数（默认为‘pad’）进行替换。这就是为什么在这种情况下，行 1 和 2 中的‘a’值被替换为 10，行 4 中的‘b’。

>>> s.replace('a')
0    10
1    10
2    10
3     b
4     b
dtype: object 

自版本 2.1.0 起弃用：‘method’参数和填充行为已弃用。

另一方面，如果对于value明确传递了None，它将被尊重：

>>> s.replace('a', None)
0      10
1    None
2    None
3       b
4    None
dtype: object 

自版本 1.4.0 起更改：以前明确的None会被静默忽略。

当regex=True，value不是None且to_replace是一个字符串时，替换将应用于 DataFrame 的所有列。

>>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],
...                    'B': ['a', 'b', 'c', 'd', 'e'],
...                    'C': ['f', 'g', 'h', 'i', 'j']}) 

>>> df.replace(to_replace='^[a-g]', value='e', regex=True)
 A  B  C
0  0  e  e
1  1  e  e
2  2  e  h
3  3  e  i
4  4  e  j 

如果value不是None且to_replace是一个字典，则字典键将是将应用替换的 DataFrame 列。

>>> df.replace(to_replace={'B': '^[a-c]', 'C': '^[h-j]'}, value='e', regex=True)
 A  B  C
0  0  e  f
1  1  e  g
2  2  e  e
3  3  d  e
4  4  e  e 

pandas.DataFrame.droplevel

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

DataFrame.droplevel(level, axis=0)

返回 Series/DataFrame，其中已删除请求的索引/列水平轴。

参数：

level整数、字符串或类似列表

如果给出字符串，则必须是水平轴的名称；如果类似列表，元素必须是水平轴的名称或位置索引。

axis，默认为 0

要删除的水平轴：

• 0 或 'index'：删除列中的水平轴。

• 1 或 'columns'：删除行中的水平轴。

对于 Series，此参数未使用，默认为 0。

返回值：

Series/DataFrame

Series/DataFrame，其中已删除请求的索引/列水平轴。

示例

>>> df = pd.DataFrame([
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12]
... ]).set_index([0, 1]).rename_axis(['a', 'b']) 

>>> df.columns = pd.MultiIndex.from_tuples([
...     ('c', 'e'), ('d', 'f')
... ], names=['level_1', 'level_2']) 

>>> df
level_1   c   d
level_2   e   f
a b
1 2      3   4
5 6      7   8
9 10    11  12 

>>> df.droplevel('a')
level_1   c   d
level_2   e   f
b
2        3   4
6        7   8
10      11  12 

>>> df.droplevel('level_2', axis=1)
level_1   c   d
a b
1 2      3   4
5 6      7   8
9 10    11  12 

pandas.DataFrame.pivot

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

DataFrame.pivot(*, columns, index=_NoDefault.no_default, values=_NoDefault.no_default)

按给定索引/列值组织的重塑 DataFrame。

根据列值重塑数据（生成“数据透视表”）。使用指定索引/列的唯一值来形成结果 DataFrame 的轴。此函数不支持数据聚合，多个值将导致列中的 MultiIndex。有关更多关于重塑的信息，请参阅用户指南。

参数：

columnsstr 或对象或字符串列表

用于创建新框架列的列。

indexstr 或对象或字符串列表，可选

用于创建新框架索引的列。如果未给出，则使用现有索引。

valuesstr、对象或先前的字符串列表，可选

用于填充新框架值的列（s）。如果未指定，将使用所有剩余列，并且结果将具有层次化索引的列。

返回：

DataFrame

返回重塑的 DataFrame。

引发：

ValueError：

当存在具有多个值的任何索引、列组合时，使用 DataFrame.pivot_table 进行聚合。

另请参见

DataFrame.pivot_table

pivot 的泛化，可以处理一个索引/列对的重复值。

DataFrame.unstack

基于索引值而不是列的枢轴。

wide_to_long

将宽面板转换为长格式。比 melt 更少灵活但更用户友好。

注意事项

如需更精细的控制，请参阅分层索引文档以及相关的堆栈/取消堆栈方法。

有关更多示例，请参阅用户指南。

示例

>>> df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two',
...                            'two'],
...                    'bar': ['A', 'B', 'C', 'A', 'B', 'C'],
...                    'baz': [1, 2, 3, 4, 5, 6],
...                    'zoo': ['x', 'y', 'z', 'q', 'w', 't']})
>>> df
 foo   bar  baz  zoo
0   one   A    1    x
1   one   B    2    y
2   one   C    3    z
3   two   A    4    q
4   two   B    5    w
5   two   C    6    t 

>>> df.pivot(index='foo', columns='bar', values='baz')
bar  A   B   C
foo
one  1   2   3
two  4   5   6 

>>> df.pivot(index='foo', columns='bar')['baz']
bar  A   B   C
foo
one  1   2   3
two  4   5   6 

>>> df.pivot(index='foo', columns='bar', values=['baz', 'zoo'])
 baz       zoo
bar   A  B  C   A  B  C
foo
one   1  2  3   x  y  z
two   4  5  6   q  w  t 

您还可以分配列名称列表或索引名称列表。

>>> df = pd.DataFrame({
...        "lev1": [1, 1, 1, 2, 2, 2],
...        "lev2": [1, 1, 2, 1, 1, 2],
...        "lev3": [1, 2, 1, 2, 1, 2],
...        "lev4": [1, 2, 3, 4, 5, 6],
...        "values": [0, 1, 2, 3, 4, 5]})
>>> df
 lev1 lev2 lev3 lev4 values
0   1    1    1    1    0
1   1    1    2    2    1
2   1    2    1    3    2
3   2    1    2    4    3
4   2    1    1    5    4
5   2    2    2    6    5 

>>> df.pivot(index="lev1", columns=["lev2", "lev3"], values="values")
lev2    1         2
lev3    1    2    1    2
lev1
1     0.0  1.0  2.0  NaN
2     4.0  3.0  NaN  5.0 

>>> df.pivot(index=["lev1", "lev2"], columns=["lev3"], values="values")
 lev3    1    2
lev1  lev2
 1     1  0.0  1.0
 2  2.0  NaN
 2     1  4.0  3.0
 2  NaN  5.0 

如果存在任何重复项，则引发 ValueError。

>>> df = pd.DataFrame({"foo": ['one', 'one', 'two', 'two'],
...                    "bar": ['A', 'A', 'B', 'C'],
...                    "baz": [1, 2, 3, 4]})
>>> df
 foo bar  baz
0  one   A    1
1  one   A    2
2  two   B    3
3  two   C    4 

请注意，我们的索引和列参数的前两行相同。

>>> df.pivot(index='foo', columns='bar', values='baz')
Traceback (most recent call last):
  ...
ValueError: Index contains duplicate entries, cannot reshape 

pandas.DataFrame.pivot_table

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

DataFrame.pivot_table(values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All', observed=_NoDefault.no_default, sort=True)

创建一个类似电子表格的透视表作为 DataFrame。

透视表中的级别将存储在结果 DataFrame 的索引和列上的 MultiIndex 对象（分层索引）中。

参数：

values 列表样式或标量，可选

聚合的列或列。

index 列，Grouper，数组或先前的列表

在数据透视表索引上分组的键。如果传递了列表，则可以包含任何其他类型（除了列表）。如果传递了数组，则必须与数据的长度相同，并将与列值以相同的方式使用。

columns 列，Grouper，数组或先前的列表

在数据透视表列上分组的键。如果传递了列表，则可以包含任何其他类型（除了列表）。如果传递了数组，则必须与数据的长度相同，并将与列值以相同的方式使用。

aggfunc 函数，函数列表，字典，默认为 “mean”

如果传递了函数列表，则生成的透视表将具有层次化列，其顶级是函数名称（从函数对象本身推断）。如果传递了字典，则键是要聚合的列，值是函数或函数列表。如果 margin=True，将使用 aggfunc 计算部分聚合。

fill_value 标量，默认为 None

用于替换缺失值的值（在聚合后的透视表中）。

margins 布尔值，默认为 False

如果 margins=True，将在行和列上添加特殊的 All 列和行，其中包含跨行和列的部分组聚合。

dropna 布尔值，默认为 True

不包括条目全部为 NaN 的列。如果为 True，则在计算边距之前，将省略任何列中存在 NaN 值的行。

margins_name 字符串，默认为 'All'

当 margins 为 True 时，包含总计的行/列的名称。

observed 布尔值，默认为 False

这仅适用于任何分组器为分类的情况。如果为 True：仅显示分类分组器的观察值。如果为 False：显示分类分组器的所有值。

Deprecated since version 2.2.0: 默认值为 False 的参数已被弃用，并将在 pandas 的未来版本中更改为 True。

sort 布尔值，默认为 True

指定结果是否应该排序。

新功能在版本 1.3.0 中添加。

返回：

DataFrame

Excel 样式的透视表。

另请参见

DataFrame.pivot

无需聚合的数据透视。

DataFrame.melt

将 DataFrame 从宽格式转换为长格式，可选择保留标识符。

wide_to_long

将宽面板转换为长格式。比melt方法不太灵活，但更用户友好。

注意事项

参考用户指南获取更多示例。

示例

>>> df = pd.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
...                          "bar", "bar", "bar", "bar"],
...                    "B": ["one", "one", "one", "two", "two",
...                          "one", "one", "two", "two"],
...                    "C": ["small", "large", "large", "small",
...                          "small", "large", "small", "small",
...                          "large"],
...                    "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
...                    "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]})
>>> df
 A    B      C  D  E
0  foo  one  small  1  2
1  foo  one  large  2  4
2  foo  one  large  2  5
3  foo  two  small  3  5
4  foo  two  small  3  6
5  bar  one  large  4  6
6  bar  one  small  5  8
7  bar  two  small  6  9
8  bar  two  large  7  9 

这个第一个示例通过求和来聚合数值。

>>> table = pd.pivot_table(df, values='D', index=['A', 'B'],
...                        columns=['C'], aggfunc="sum")
>>> table
C        large  small
A   B
bar one    4.0    5.0
 two    7.0    6.0
foo one    4.0    1.0
 two    NaN    6.0 

我们还可以使用fill_value参数填充缺失值。

>>> table = pd.pivot_table(df, values='D', index=['A', 'B'],
...                        columns=['C'], aggfunc="sum", fill_value=0)
>>> table
C        large  small
A   B
bar one      4      5
 two      7      6
foo one      4      1
 two      0      6 

下一个示例通过计算多列的均值来聚合数据。

>>> table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
...                        aggfunc={'D': "mean", 'E': "mean"})
>>> table
 D         E
A   C
bar large  5.500000  7.500000
 small  5.500000  8.500000
foo large  2.000000  4.500000
 small  2.333333  4.333333 

我们还可以针对任何给定的数值列计算多种类型的聚合。

>>> table = pd.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
...                        aggfunc={'D': "mean",
...                                 'E': ["min", "max", "mean"]})
>>> table
 D   E
 mean max      mean  min
A   C
bar large  5.500000   9  7.500000    6
 small  5.500000   9  8.500000    8
foo large  2.000000   5  4.500000    4
 small  2.333333   6  4.333333    2 

pandas.DataFrame.reorder_levels

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

DataFrame.reorder_levels(order, axis=0)

使用输入顺序重新排列索引级别。可能不会删除或重复级别。

参数：

order整数列表或字符串列表

表示新层次顺序的列表。通过数字（位置）或键（标签）引用级别。

axis，默认为 0

重新排序级别的位置。

返回：

DataFrame

示例

>>> data = {
...     "class": ["Mammals", "Mammals", "Reptiles"],
...     "diet": ["Omnivore", "Carnivore", "Carnivore"],
...     "species": ["Humans", "Dogs", "Snakes"],
... }
>>> df = pd.DataFrame(data, columns=["class", "diet", "species"])
>>> df = df.set_index(["class", "diet"])
>>> df
 species
class      diet
Mammals    Omnivore                Humans
 Carnivore                 Dogs
Reptiles   Carnivore               Snakes 

让我们重新排序索引的级别：

>>> df.reorder_levels(["diet", "class"])
 species
diet      class
Omnivore  Mammals                  Humans
Carnivore Mammals                    Dogs
 Reptiles                 Snakes 

pandas.DataFrame.sort_values

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

DataFrame.sort_values(by, *, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)

沿着任一轴按值排序。

参数：

by字符串或字符串列表

要按其名称或名称列表排序。

• 如果 axis 为 0 或 ‘index’，则 by 可能包含索引级别和/或列标签。

• 如果 axis 为 1 或 ‘columns’，则 by 可能包含列级别和/或索引标签。

axis“{0 或 ‘index’，1 或 ‘columns’}”，默认为 0

要排序的轴。

ascending布尔值或布尔值列表，默认为 True

指定升序还是降序。为多个排序顺序指定列表。如果这是一个布尔值列表，则必须与 by 的长度匹配。

inplace布尔值，默认为 False

如果为 True，则原地执行操作。

kind，默认为 ‘quicksort’

选择排序算法。另请参见 numpy.sort() 以获取更多信息。mergesort 和 stable 是唯一的稳定算法。对于 DataFrames，仅在对单列或标签进行排序时才应用此选项。

na_position，默认为 ‘last’

如果首先将 NaN 放在最前面；如果最后，则将 NaN 放在最后。

ignore_index布尔值，默认为 False

如果为 True，则生成的轴将被标记为 0, 1, …, n - 1。

key可调用，可选

在排序之前对值应用关键函数。这类似于内置 sorted() 函数中的 key 参数，但有一个显著的区别，即这个 key 函数应该是矢量化的。它应该期望一个 Series 并返回一个与输入形状相同的 Series。它将独立地应用于 by 中的每一列。

返回：

DataFrame 或 None

按排序值排序的 DataFrame，如果 inplace=True 则为 None。

另请参见

DataFrame.sort_index

按索引对 DataFrame 进行排序。

Series.sort_values

Series 的类似方法。

示例

>>> df = pd.DataFrame({
...     'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
...     'col2': [2, 1, 9, 8, 7, 4],
...     'col3': [0, 1, 9, 4, 2, 3],
...     'col4': ['a', 'B', 'c', 'D', 'e', 'F']
... })
>>> df
 col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
3  NaN     8     4    D
4    D     7     2    e
5    C     4     3    F 

按 col1 排序

>>> df.sort_values(by=['col1'])
 col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
5    C     4     3    F
4    D     7     2    e
3  NaN     8     4    D 

按多列排序

>>> df.sort_values(by=['col1', 'col2'])
 col1  col2  col3 col4
1    A     1     1    B
0    A     2     0    a
2    B     9     9    c
5    C     4     3    F
4    D     7     2    e
3  NaN     8     4    D 

降序排序

>>> df.sort_values(by='col1', ascending=False)
 col1  col2  col3 col4
4    D     7     2    e
5    C     4     3    F
2    B     9     9    c
0    A     2     0    a
1    A     1     1    B
3  NaN     8     4    D 

将 NAs 放在最前面

>>> df.sort_values(by='col1', ascending=False, na_position='first')
 col1  col2  col3 col4
3  NaN     8     4    D
4    D     7     2    e
5    C     4     3    F
2    B     9     9    c
0    A     2     0    a
1    A     1     1    B 

使用关键函数进行排序

>>> df.sort_values(by='col4', key=lambda col: col.str.lower())
 col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
3  NaN     8     4    D
4    D     7     2    e
5    C     4     3    F 

使用 key 参数进行自然排序，使用 natsort https://github.com/SethMMorton/natsort 包。

>>> df = pd.DataFrame({
...    "time": ['0hr', '128hr', '72hr', '48hr', '96hr'],
...    "value": [10, 20, 30, 40, 50]
... })
>>> df
 time  value
0    0hr     10
1  128hr     20
2   72hr     30
3   48hr     40
4   96hr     50
>>> from natsort import index_natsorted
>>> df.sort_values(
...     by="time",
...     key=lambda x: np.argsort(index_natsorted(df["time"]))
... )
 time  value
0    0hr     10
3   48hr     40
2   72hr     30
4   96hr     50
1  128hr     20 

pandas.DataFrame.sort_index

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

DataFrame.sort_index(*, axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None)

按标签（沿轴线）对对象进行排序。

如果 inplace 参数为False，则返回按标签排序的新 DataFrame，否则更新原始 DataFrame 并返回 None。

参数：

axis，默认为 0

要排序的轴。值 0 标识行，值 1 标识列。

levelint 或级别名称或整数列表或级别名称列表

如果不为 None，则在指定的索引级别上进行值排序。

ascendingbool 或类似布尔值的列表， 默认为 True

升序还是降序排序。当索引为 MultiIndex 时，可以分别控制每个级别的排序方向。

inplacebool， 默认为 False

是否修改 DataFrame 而不是创建新的。

kind，默认为‘quicksort’

选择排序算法。更多信息请参见numpy.sort()。mergesort 和 stable 是唯一的稳定算法。对于 DataFrames，在仅对单列或标签进行排序时才应用此选项。

na_position，默认为‘last’

如果首位，则将 NaN 放在开头；如果末位，则将 NaN 放在末尾。不适用于 MultiIndex。

sort_remainingbool，默认为 True

如果为 True，并且按级别排序且索引为多级，则在按指定级别排序后，按顺序对其他级别进行排序。

ignore_indexbool，默认为 False

如果为 True，则生成的轴将被标记为 0、1、…、n - 1。

keycallable，可选

如果不为 None，则在排序前将键函数应用于索引值。这类似于内置sorted()函数中的 key 参数，但有一个显著的区别，即此键函数应该是矢量化的。它应该期望一个Index并返回相同形状的Index。对于 MultiIndex 输入，键会逐级应用。

返回：

DataFrame 或 None

原始 DataFrame 按标签排序或如果inplace=True则为 None。

另请参见

Series.sort_index

按索引对系列进行排序。

DataFrame.sort_values

按值对 DataFrame 进行排序。

Series.sort_values

按值对系列进行排序。

示例

>>> df = pd.DataFrame([1, 2, 3, 4, 5], index=[100, 29, 234, 1, 150],
...                   columns=['A'])
>>> df.sort_index()
 A
1    4
29   2
100  1
150  5
234  3 

默认情况下，按升序排序，要按降序排序，请使用ascending=False

>>> df.sort_index(ascending=False)
 A
234  3
150  5
100  1
29   2
1    4 

可以指定一个键函数，该函数应用于排序前的索引。对于MultiIndex，这将分别应用于每个级别。

>>> df = pd.DataFrame({"a": [1, 2, 3, 4]}, index=['A', 'b', 'C', 'd'])
>>> df.sort_index(key=lambda x: x.str.lower())
 a
A  1
b  2
C  3
d  4 

pandas.DataFrame.nlargest

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

DataFrame.nlargest(n, columns, keep='first')

返回按列按降序排列的前 n 行。

返回列中最大值的前 n 行，按降序排列。未指定的列也会返回，但不用于排序。

此方法等同于df.sort_values(columns, ascending=False).head(n)，但性能更好。

参数：

n整数

要返回的行数。

columns标签或标签列表

要按其排序的列标签。

keep，默认为‘first’

当存在重复值时：

• first：优先考虑第一次出现的情况

• last：优先考虑最后一次出现的情况

• all：保留所有最小项的关联，即使这意味着选择超过n个项目。

返回：

DataFrame

按给定列按降序排列的前 n 行。

另请参阅

DataFrame.nsmallest

返回按升序排列的列中的前 n 行。

DataFrame.sort_values

按值对 DataFrame 进行排序。

DataFrame.head

返回前 n 行而不重新排序。

注意

此函数不能与所有列类型一起使用。例如，当指定包含对象或类别 dtype 的列时，会引发TypeError。

示例

>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
...                                   434000, 434000, 337000, 11300,
...                                   11300, 11300],
...                    'GDP': [1937894, 2583560 , 12011, 4520, 12128,
...                            17036, 182, 38, 311],
...                    'alpha-2': ["IT", "FR", "MT", "MV", "BN",
...                                "IS", "NR", "TV", "AI"]},
...                   index=["Italy", "France", "Malta",
...                          "Maldives", "Brunei", "Iceland",
...                          "Nauru", "Tuvalu", "Anguilla"])
>>> df
 population      GDP alpha-2
Italy       59000000  1937894      IT
France      65000000  2583560      FR
Malta         434000    12011      MT
Maldives      434000     4520      MV
Brunei        434000    12128      BN
Iceland       337000    17036      IS
Nauru          11300      182      NR
Tuvalu         11300       38      TV
Anguilla       11300      311      AI 

在下面的示例中，我们将使用nlargest选择具有“population”列中最大值的三行。

>>> df.nlargest(3, 'population')
 population      GDP alpha-2
France    65000000  2583560      FR
Italy     59000000  1937894      IT
Malta       434000    12011      MT 

当使用keep='last'时，关联项按相反顺序解决：

>>> df.nlargest(3, 'population', keep='last')
 population      GDP alpha-2
France    65000000  2583560      FR
Italy     59000000  1937894      IT
Brunei      434000    12128      BN 

当使用keep='all'时，如果最小元素存在重复值，则保留的元素数量可能超过n，所有关联项都会被保留：

>>> df.nlargest(3, 'population', keep='all')
 population      GDP alpha-2
France      65000000  2583560      FR
Italy       59000000  1937894      IT
Malta         434000    12011      MT
Maldives      434000     4520      MV
Brunei        434000    12128      BN 

但是，nlargest不会保留n个不同的最大元素：

>>> df.nlargest(5, 'population', keep='all')
 population      GDP alpha-2
France      65000000  2583560      FR
Italy       59000000  1937894      IT
Malta         434000    12011      MT
Maldives      434000     4520      MV
Brunei        434000    12128      BN 

要按“population”列中的最大值，然后按“GDP”列中的最大值排序，我们可以像下一个示例中那样指定多个列。

>>> df.nlargest(3, ['population', 'GDP'])
 population      GDP alpha-2
France    65000000  2583560      FR
Italy     59000000  1937894      IT
Brunei      434000    12128      BN 

pandas.DataFrame.nsmallest

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

DataFrame.nsmallest(n, columns, keep='first')

按列升序排列，返回前 n 行。

按升序排列，返回列中最小值的前 n 行。返回未指定的列，但不用于排序。

该方法等效于df.sort_values(columns, ascending=True).head(n)，但性能更高。

参数：

n：整数

要检索的项数。

columns：列表或字符串

要按其顺序排序的列名或列名。

keep：{‘first’，‘last’，‘all’}，默认为‘first’

当存在重复值时：

• first：获取第一次出现的值。

• last：获取最后一次出现的值。

• all：即使这意味着选择超过n个项目，也保留最大项目的所有连接。

返回：

数据帧

另请参见

DataFrame.nlargest

按列降序排列，返回前 n 行。

DataFrame.sort_values

按值对数据帧进行排序。

DataFrame.head

返回前 n 行而不重新排序。

示例

>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
...                                   434000, 434000, 337000, 337000,
...                                   11300, 11300],
...                    'GDP': [1937894, 2583560 , 12011, 4520, 12128,
...                            17036, 182, 38, 311],
...                    'alpha-2': ["IT", "FR", "MT", "MV", "BN",
...                                "IS", "NR", "TV", "AI"]},
...                   index=["Italy", "France", "Malta",
...                          "Maldives", "Brunei", "Iceland",
...                          "Nauru", "Tuvalu", "Anguilla"])
>>> df
 population      GDP alpha-2
Italy       59000000  1937894      IT
France      65000000  2583560      FR
Malta         434000    12011      MT
Maldives      434000     4520      MV
Brunei        434000    12128      BN
Iceland       337000    17036      IS
Nauru         337000      182      NR
Tuvalu         11300       38      TV
Anguilla       11300      311      AI 

在下面的示例中，我们将使用nsmallest来选择“population”列中具有最小值的三行。

>>> df.nsmallest(3, 'population')
 population    GDP alpha-2
Tuvalu         11300     38      TV
Anguilla       11300    311      AI
Iceland       337000  17036      IS 

使用keep='last'时，连接以相反顺序解决：

>>> df.nsmallest(3, 'population', keep='last')
 population  GDP alpha-2
Anguilla       11300  311      AI
Tuvalu         11300   38      TV
Nauru         337000  182      NR 

使用keep='all'时，如果最大元素有重复值，则保留的元素数量可以超过n，所有的连接都会保留。

>>> df.nsmallest(3, 'population', keep='all')
 population    GDP alpha-2
Tuvalu         11300     38      TV
Anguilla       11300    311      AI
Iceland       337000  17036      IS
Nauru         337000    182      NR 

但是，nsmallest不会保留n个不同的最小元素：

>>> df.nsmallest(4, 'population', keep='all')
 population    GDP alpha-2
Tuvalu         11300     38      TV
Anguilla       11300    311      AI
Iceland       337000  17036      IS
Nauru         337000    182      NR 

要按“population”列中的最小值，然后按“GDP”列排序，我们可以像下一个示例中那样指定多个列。

>>> df.nsmallest(3, ['population', 'GDP'])
 population  GDP alpha-2
Tuvalu         11300   38      TV
Anguilla       11300  311      AI
Nauru         337000  182      NR 

pandas.DataFrame.swaplevel

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

DataFrame.swaplevel(i=-2, j=-1, axis=0)

在 MultiIndex 中交换级别 i 和 j。

默认是交换索引的最内层两个级别。

参数：

i, jint 或 str

要交换的索引的级别。可以将级别名称作为字符串传递。

轴，默认为 0

要交换级别的轴。0 或 'index' 表示按行交换，1 或 'columns' 表示按列交换。

返回：

DataFrame

在 MultiIndex 中交换级别的 DataFrame。

例子

>>> df = pd.DataFrame(
...     {"Grade": ["A", "B", "A", "C"]},
...     index=[
...         ["Final exam", "Final exam", "Coursework", "Coursework"],
...         ["History", "Geography", "History", "Geography"],
...         ["January", "February", "March", "April"],
...     ],
... )
>>> df
 Grade
Final exam  History     January      A
 Geography   February     B
Coursework  History     March        A
 Geography   April        C 

在下面的示例中，我们将交换索引的级别。在这里，我们将按列交换级别，但是级别可以以类似的方式按行交换。请注意，默认行为是按列交换。通过不提供 i 和 j 的任何参数，我们交换最后一个和倒数第二个索引。

>>> df.swaplevel()
 Grade
Final exam  January     History         A
 February    Geography       B
Coursework  March       History         A
 April       Geography       C 

通过提供一个参数，我们可以选择将最后一个索引与哪个索引交换。例如，我们可以将第一个索引与最后一个索引交换如下。

>>> df.swaplevel(0)
 Grade
January     History     Final exam      A
February    Geography   Final exam      B
March       History     Coursework      A
April       Geography   Coursework      C 

我们还可以通过为 i 和 j 提供值来明确定义我们要交换的索引。在这里，例如，我们交换第一个和第二个索引。

>>> df.swaplevel(0, 1)
 Grade
History     Final exam  January         A
Geography   Final exam  February        B
History     Coursework  March           A
Geography   Coursework  April           C 

pandas.DataFrame.stack

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

DataFrame.stack(level=-1, dropna=_NoDefault.no_default, sort=_NoDefault.no_default, future_stack=False)

将列中的指定级别堆叠到索引中。

返回一个重新塑造的 DataFrame 或 Series，具有比当前 DataFrame 更多的一个或多个新的最内层级别的多级索引。新的最内层级别是通过对当前 DataFrame 的列进行透视而创建的：

• 如果列只有一个级别，则输出为 Series；
• 如果列具有多个级别，则新的索引级别将来自于指定的级别，并且输出为 DataFrame。

参数：

levelint, str, list, default -1

从列轴堆叠到索引轴的级别（或级别），定义为一个索引或标签，或索引或标签列表。

dropnabool, default True

是否删除结果 Frame/Series 中存在缺失值的行。将列级别堆叠到索引轴可能会创建索引和列值的组合，这些组合在原始 DataFrame 中缺失。请参阅示例部分。

sortbool, default True

是否对结果 MultiIndex 的级别进行排序。

future_stackbool, default False

是否使用新的实现，该实现将在 pandas 3.0 中替换当前的实现。当为 True 时，dropna 和 sort 对结果没有影响，必须保持未指定。有关更多详细信息，请参阅 pandas 2.1.0 发布说明 。

返回值：

DataFrame 或 Series

堆叠后的 DataFrame 或 Series。

另请参阅

DataFrame.unstack

从索引轴上的预设级别取消堆叠到列轴。

DataFrame.pivot

将 DataFrame 从长格式重塑为宽格式。

DataFrame.pivot_table

创建一个类似电子表格的透视表作为 DataFrame。

注意事项

该函数的命名类比于一组书从水平位置（DataFrame 的列）重新组织为垂直堆叠在一起（DataFrame 的索引）。

更多示例请参阅 用户指南 。

示例

单级列

>>> df_single_level_cols = pd.DataFrame([[0, 1], [2, 3]],
...                                     index=['cat', 'dog'],
...                                     columns=['weight', 'height']) 

带有单级列轴的 DataFrame 进行堆叠返回一个 Series：

>>> df_single_level_cols
 weight height
cat       0      1
dog       2      3
>>> df_single_level_cols.stack(future_stack=True)
cat  weight    0
 height    1
dog  weight    2
 height    3
dtype: int64 

多级列：简单情况

>>> multicol1 = pd.MultiIndex.from_tuples([('weight', 'kg'),
...                                        ('weight', 'pounds')])
>>> df_multi_level_cols1 = pd.DataFrame([[1, 2], [2, 4]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol1) 

带有多级列轴的 DataFrame 进行堆叠：

>>> df_multi_level_cols1
 weight
 kg    pounds
cat       1        2
dog       2        4
>>> df_multi_level_cols1.stack(future_stack=True)
 weight
cat kg           1
 pounds       2
dog kg           2
 pounds       4 

缺失值

>>> multicol2 = pd.MultiIndex.from_tuples([('weight', 'kg'),
...                                        ('height', 'm')])
>>> df_multi_level_cols2 = pd.DataFrame([[1.0, 2.0], [3.0, 4.0]],
...                                     index=['cat', 'dog'],
...                                     columns=multicol2) 

当将具有多级列的 DataFrame 进行堆叠时，通常会出现缺失值，因为堆叠后的 DataFrame 通常比原始 DataFrame 多出更多的值。缺失值将被填充为 NaN：

>>> df_multi_level_cols2
 weight height
 kg      m
cat    1.0    2.0
dog    3.0    4.0
>>> df_multi_level_cols2.stack(future_stack=True)
 weight  height
cat kg     1.0     NaN
 m      NaN     2.0
dog kg     3.0     NaN
 m      NaN     4.0 

指定要堆叠的级别

第一个参数控制堆叠的级别：

>>> df_multi_level_cols2.stack(0, future_stack=True)
 kg    m
cat weight  1.0  NaN
 height  NaN  2.0
dog weight  3.0  NaN
 height  NaN  4.0
>>> df_multi_level_cols2.stack([0, 1], future_stack=True)
cat  weight  kg    1.0
 height  m     2.0
dog  weight  kg    3.0
 height  m     4.0
dtype: float64 

pandas.DataFrame.unstack

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

DataFrame.unstack(level=-1, fill_value=None, sort=True)

将（必然是分层的）索引标签的一个级别进行旋转。

返回一个 DataFrame，其列标签的新级别由旋转后的索引标签的最内层级别组成。

如果索引不是 MultiIndex，则输出将是一个 Series（当列不是 MultiIndex 时的 stack 的类比）。

参数：

levelint、str 或这些的列表，默认为-1（最后一个级别）

要 unstack 的索引级别，可以传递级别名称。

fill_valueint、str 或字典

如果 unstack 产生缺失值，则用此值替换 NaN。

sortbool，默认为 True

对结果 MultiIndex 列中的级别进行排序。

返回：

Series 或 DataFrame

另请参阅

DataFrame.pivot

根据列值对表进行旋转。

DataFrame.stack

旋转列标签的一个级别（与 unstack 的相反操作）。

注意事项

更多示例请参考用户指南。

示例

>>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),
...                                    ('two', 'a'), ('two', 'b')])
>>> s = pd.Series(np.arange(1.0, 5.0), index=index)
>>> s
one  a   1.0
 b   2.0
two  a   3.0
 b   4.0
dtype: float64 

>>> s.unstack(level=-1)
 a   b
one  1.0  2.0
two  3.0  4.0 

>>> s.unstack(level=0)
 one  two
a  1.0   3.0
b  2.0   4.0 

>>> df = s.unstack(level=0)
>>> df.unstack()
one  a  1.0
 b  2.0
two  a  3.0
 b  4.0
dtype: float64 

pandas.DataFrame.swapaxes

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

DataFrame.swapaxes(axis1, axis2, copy=None)

交换轴并适当交换值轴。

自版本 2.1.0 起已弃用：swapaxes已弃用并将被移除。请改用transpose。

返回：

与输入相同

示例

请查看DataFrame.transpose()的示例。

pandas.DataFrame.melt

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

DataFrame.melt(id_vars=None, value_vars=None, var_name=None, value_name='value', col_level=None, ignore_index=True)

将 DataFrame 从宽格式转换为长格式，可选择保留标识符。

此函数可将 DataFrame 整理成一种格式，其中一个或多个列是标识符变量（id_vars），而所有其他列，被视为测量变量（value_vars），被“解开”到行轴上，只留下两个非标识符列，‘variable’和‘value’。

参数：

id_vars标量，元组，列表或 ndarray，可选

用作标识符变量的列。

value_vars标量，元组，列表或 ndarray，可选

要解开的列。如果未指定，则使用所有未设置为 id_vars 的列。

var_name标量，默认为 None

用于‘variable’列的名称。如果为 None，则使用frame.columns.name或‘variable’。

value_name标量，默认为‘value’

用于“value”列的名称，不能是现有的列标签。

col_level标量，可选

如果列是多级索引，则使用此级别进行解开。

ignore_index布尔值，默认为 True

如果为 True，则忽略原始索引。如果为 False，则保留原始索引。必要时将重复索引标签。

返回：

DataFrame

解开的 DataFrame。

另请参见

melt

相同的方法。

pivot_table

创建一个类似电子表格的透视表作为 DataFrame。

DataFrame.pivot

返回由给定索引/列值组织的重塑 DataFrame。

DataFrame.explode

将 DataFrame 从类似列表的列展开到长格式。

注意

参考用户指南获取更多示例。

示例

>>> df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'},
...                    'B': {0: 1, 1: 3, 2: 5},
...                    'C': {0: 2, 1: 4, 2: 6}})
>>> df
 A  B  C
0  a  1  2
1  b  3  4
2  c  5  6 

>>> df.melt(id_vars=['A'], value_vars=['B'])
 A variable  value
0  a        B      1
1  b        B      3
2  c        B      5 

>>> df.melt(id_vars=['A'], value_vars=['B', 'C'])
 A variable  value
0  a        B      1
1  b        B      3
2  c        B      5
3  a        C      2
4  b        C      4
5  c        C      6 

可自定义‘variable’和‘value’列的名称：

>>> df.melt(id_vars=['A'], value_vars=['B'],
...         var_name='myVarname', value_name='myValname')
 A myVarname  myValname
0  a         B          1
1  b         B          3
2  c         B          5 

可保留原始索引值：

>>> df.melt(id_vars=['A'], value_vars=['B', 'C'], ignore_index=False)
 A variable  value
0  a        B      1
1  b        B      3
2  c        B      5
0  a        C      2
1  b        C      4
2  c        C      6 

如果您有多级索引列：

>>> df.columns = [list('ABC'), list('DEF')]
>>> df
 A  B  C
 D  E  F
0  a  1  2
1  b  3  4
2  c  5  6 

>>> df.melt(col_level=0, id_vars=['A'], value_vars=['B'])
 A variable  value
0  a        B      1
1  b        B      3
2  c        B      5 

>>> df.melt(id_vars=[('A', 'D')], value_vars=[('B', 'E')])
 (A, D) variable_0 variable_1  value
0      a          B          E      1
1      b          B          E      3
2      c          B          E      5 

pandas.DataFrame.explode

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

DataFrame.explode(column, ignore_index=False)

将列表式的每个元素转换为一行，复制索引值。

参数：

columnIndexLabel

展开的列。对于多列，请指定一个非空列表，其中每个元素都是 str 或 tuple，并且指定的列在 frame 的同一行上的列表数据必须具有匹配的长度。

1.3.0 版本新增：多列展开

ignore_indexbool，默认为 False

如果为 True，则生成的索引将标记为 0, 1, …, n - 1。

返回值：

DataFrame

将子集列的展开列表展开为行；这些行的索引将重复。

引发：

ValueError

• 如果 frame 的列不是唯一的。

• 如果指定的要展开的列为空列表。

• 如果指定的要展开的列在 frame 中的行上没有匹配的元素计数。

另请参见

DataFrame.unstack

透视（必须是分层的）索引标签的一个级别。

DataFrame.melt

将 DataFrame 从宽格式转换为长格式。

Series.explode

将 DataFrame 从类似列表的列展开为长格式。

注意事项

此例程将爆炸列表式（包括列表、元组、集合、Series 和 np.ndarray）。子集行的结果 dtype 将为 object。标量将保持不变，空列表样式将导致该行的 np.nan。此外，当爆炸集合时，输出中的行的顺序是不确定的。

更多示例请参考用户指南。

示例

>>> df = pd.DataFrame({'A': [[0, 1, 2], 'foo', [], [3, 4]],
...                    'B': 1,
...                    'C': [['a', 'b', 'c'], np.nan, [], ['d', 'e']]})
>>> df
 A  B          C
0  [0, 1, 2]  1  [a, b, c]
1        foo  1        NaN
2         []  1         []
3     [3, 4]  1     [d, e] 

单列展开。

>>> df.explode('A')
 A  B          C
0    0  1  [a, b, c]
0    1  1  [a, b, c]
0    2  1  [a, b, c]
1  foo  1        NaN
2  NaN  1         []
3    3  1     [d, e]
3    4  1     [d, e] 

多列展开。

>>> df.explode(list('AC'))
 A  B    C
0    0  1    a
0    1  1    b
0    2  1    c
1  foo  1  NaN
2  NaN  1  NaN
3    3  1    d
3    4  1    e 

pandas.DataFrame.squeeze

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

DataFrame.squeeze(axis=None)

将 1 维轴对象挤压为标量。

具有单个元素的 Series 或 DataFrames 被挤压为标量。具有单列或单行的 DataFrames 被挤压为 Series。否则，对象保持不变。

当您不知道对象是 Series 还是 DataFrame，但您知道它只有单列时，此方法最有用。在这种情况下，您可以安全地调用 squeeze 来确保您有一个 Series。

参数：

轴，默认为 None

要挤压的特定轴。默认情况下，所有长度为 1 的轴都会被挤压。对于 Series，此参数未使用，默认为 None。

返回：

DataFrame、Series 或标量

挤压轴或所有轴后的投影。

另请参阅

Series.iloc

基于整数位置的索引以选择标量。

DataFrame.iloc

用于选择 Series 的基于整数位置的索引。

Series.to_frame

DataFrame 的单列的 DataFrame.squeeze 的反向操作。

示例

>>> primes = pd.Series([2, 3, 5, 7]) 

切片可能会产生具有单个值的 Series：

>>> even_primes = primes[primes % 2 == 0]
>>> even_primes
0    2
dtype: int64 

>>> even_primes.squeeze()
2 

对每个轴具有多个值的对象进行挤压不会产生任何效果：

>>> odd_primes = primes[primes % 2 == 1]
>>> odd_primes
1    3
2    5
3    7
dtype: int64 

>>> odd_primes.squeeze()
1    3
2    5
3    7
dtype: int64 

当与 DataFrames 一起使用时，挤压效果更佳。

>>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])
>>> df
 a  b
0  1  2
1  3  4 

对单列进行切片将产生具有仅一个值的列的 DataFrame：

>>> df_a = df[['a']]
>>> df_a
 a
0  1
1  3 

因此，列可以被挤压，结果是一个 Series：

>>> df_a.squeeze('columns')
0    1
1    3
Name: a, dtype: int64 

从单列中切片出单行将产生单个标量 DataFrame：

>>> df_0a = df.loc[df.index < 1, ['a']]
>>> df_0a
 a
0  1 

挤压行会产生单个标量 Series：

>>> df_0a.squeeze('rows')
a    1
Name: 0, dtype: int64 

挤压所有轴将直接投影为标量：

>>> df_0a.squeeze()
1 

pandas.DataFrame.to_xarray

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

DataFrame.to_xarray()

从 pandas 对象返回一个 xarray 对象。

返回：

xarray.DataArray 或 xarray.Dataset

如果对象是 DataFrame，则将 pandas 结构中的数据转换为 Dataset，如果对象是 Series，则转换为 DataArray。

另请参阅

DataFrame.to_hdf

将 DataFrame 写入 HDF5 文件。

DataFrame.to_parquet

将 DataFrame 写入二进制 parquet 格式。

注意

查看xarray 文档

示例

>>> df = pd.DataFrame([('falcon', 'bird', 389.0, 2),
...                    ('parrot', 'bird', 24.0, 2),
...                    ('lion', 'mammal', 80.5, 4),
...                    ('monkey', 'mammal', np.nan, 4)],
...                   columns=['name', 'class', 'max_speed',
...                            'num_legs'])
>>> df
 name   class  max_speed  num_legs
0  falcon    bird      389.0         2
1  parrot    bird       24.0         2
2    lion  mammal       80.5         4
3  monkey  mammal        NaN         4 

>>> df.to_xarray()  
<xarray.Dataset>
Dimensions:    (index: 4)
Coordinates:
 * index      (index) int64 32B 0 1 2 3
Data variables:
 name       (index) object 32B 'falcon' 'parrot' 'lion' 'monkey'
 class      (index) object 32B 'bird' 'bird' 'mammal' 'mammal'
 max_speed  (index) float64 32B 389.0 24.0 80.5 nan
 num_legs   (index) int64 32B 2 2 4 4 

>>> df['max_speed'].to_xarray()  
<xarray.DataArray 'max_speed' (index: 4)>
array([389\. ,  24\. ,  80.5,   nan])
Coordinates:
 * index    (index) int64 0 1 2 3 

>>> dates = pd.to_datetime(['2018-01-01', '2018-01-01',
...                         '2018-01-02', '2018-01-02'])
>>> df_multiindex = pd.DataFrame({'date': dates,
...                               'animal': ['falcon', 'parrot',
...                                          'falcon', 'parrot'],
...                               'speed': [350, 18, 361, 15]})
>>> df_multiindex = df_multiindex.set_index(['date', 'animal']) 

>>> df_multiindex
 speed
date       animal
2018-01-01 falcon    350
 parrot     18
2018-01-02 falcon    361
 parrot     15 

>>> df_multiindex.to_xarray()  
<xarray.Dataset>
Dimensions:  (date: 2, animal: 2)
Coordinates:
 * date     (date) datetime64[ns] 2018-01-01 2018-01-02
 * animal   (animal) object 'falcon' 'parrot'
Data variables:
 speed    (date, animal) int64 350 18 361 15 

pandas.DataFrame.T

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

property DataFrame.T

DataFrame 的转置。

返回：

DataFrame

DataFrame 的转置。

请参阅

DataFrame.transpose

转置索引和列。

示例

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

>>> df.T
 0  1
col1  1  2
col2  3  4 

pandas.DataFrame.transpose

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

DataFrame.transpose(*args, copy=False)

转置索引和列。

通过将行写为列并反之来反映 DataFrame 在其主对角线上的转置。属性 T 是方法 transpose() 的访问器。

参数：

*args 元组，可选

为了与 NumPy 兼容而被接受。

copy 布尔值，默认为 False

在转置后是否复制数据，即使是对于具有单一数据类型的 DataFrame。

注意，对于混合数据类型的 DataFrame 或具有任何扩展类型的 DataFrame，总是需要复制。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制 将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在 pandas 的将来版本中被移除。

你可以通过启用写时复制 pd.options.mode.copy_on_write = True 来获得未来的行为和改进。

返回：

DataFrame

转置后的 DataFrame。

另请参见

numpy.transpose

重新排列给定数组的维度。

注

将具有混合数据类型的 DataFrame 转置将导致一个具有对象数据类型的同质 DataFrame。在这种情况下，数据的副本总是被创建。

示例

具有同质数据类型的方形 DataFrame

>>> d1 = {'col1': [1, 2], 'col2': [3, 4]}
>>> df1 = pd.DataFrame(data=d1)
>>> df1
 col1  col2
0     1     3
1     2     4 

>>> df1_transposed = df1.T  # or df1.transpose()
>>> df1_transposed
 0  1
col1  1  2
col2  3  4 

当原始 DataFrame 中的数据类型是同质的时，我们得到具有相同数据类型的转置 DataFrame：

>>> df1.dtypes
col1    int64
col2    int64
dtype: object
>>> df1_transposed.dtypes
0    int64
1    int64
dtype: object 

具有混合数据类型的非方形 DataFrame

>>> d2 = {'name': ['Alice', 'Bob'],
...       'score': [9.5, 8],
...       'employed': [False, True],
...       'kids': [0, 0]}
>>> df2 = pd.DataFrame(data=d2)
>>> df2
 name  score  employed  kids
0  Alice    9.5     False     0
1    Bob    8.0      True     0 

>>> df2_transposed = df2.T  # or df2.transpose()
>>> df2_transposed
 0     1
name      Alice   Bob
score       9.5   8.0
employed  False  True
kids          0     0 

当 DataFrame 具有混合数据类型时，我们得到一个对象数据类型的转置 DataFrame：

>>> df2.dtypes
name         object
score       float64
employed       bool
kids          int64
dtype: object
>>> df2_transposed.dtypes
0    object
1    object
dtype: object 

pandas.DataFrame.assign

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

DataFrame.assign(**kwargs)

为 DataFrame 分配新列。

返回一个新对象，其中包含所有原始列以及新列。重新分配的现有列将被覆盖。

参数：

****kwargs**dict of {str: callable or Series}

列名是关键字。如果值是可调用对象，则在 DataFrame 上计算并分配给新列。可调用对象不能更改输入的 DataFrame（尽管 pandas 不会检查）。如果值不是可调用对象（例如 Series、标量或数组），则简单地赋值。

返回：

DataFrame

返回一个新的 DataFrame，其中包含新列以及所有现有列。

Notes

在同一个 assign 中分配多个列是可能的。在 kwargs 中的后续项可能会引用 'df' 中新创建或修改的列；项目按顺序计算并分配到 'df' 中。

示例

>>> df = pd.DataFrame({'temp_c': [17.0, 25.0]},
...                   index=['Portland', 'Berkeley'])
>>> df
 temp_c
Portland    17.0
Berkeley    25.0 

当值为可调用对象时，在 df 上进行评估：

>>> df.assign(temp_f=lambda x: x.temp_c * 9 / 5 + 32)
 temp_c  temp_f
Portland    17.0    62.6
Berkeley    25.0    77.0 

或者，可以通过直接引用现有 Series 或序列来实现相同的行为：

>>> df.assign(temp_f=df['temp_c'] * 9 / 5 + 32)
 temp_c  temp_f
Portland    17.0    62.6
Berkeley    25.0    77.0 

在同一个 assign 中，可以创建多个列，其中一个列依赖于同一个 assign 中定义的另一个列：

>>> df.assign(temp_f=lambda x: x['temp_c'] * 9 / 5 + 32,
...           temp_k=lambda x: (x['temp_f'] + 459.67) * 5 / 9)
 temp_c  temp_f  temp_k
Portland    17.0    62.6  290.15
Berkeley    25.0    77.0  298.15 

pandas.DataFrame.compare

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

DataFrame.compare(other, align_axis=1, keep_shape=False, keep_equal=False, result_names=('self', 'other'))

与另一个 DataFrame 进行比较并显示差异。

参数：

otherDataFrame

用于比较的对象。

align_axis，默认为 1

确定比较应该对齐在哪个轴上。

• 0，或者‘index’，导致的差异垂直堆叠

  从 self 和 other 交替绘制的行。

• 1，或者‘columns’，导致的差异水平对齐

  从 self 和 other 交替绘制的列。

keep_shapebool，默认为 False

如果为 true，则保留所有行和列。否则，只保留具有不同值的行和列。

keep_equalbool，默认为 False

如果为 true，则结果保留相等的值。否则，相等的值显示为 NaN。

result_names元组，默认为（‘self’，‘other’）

在比较中设置数据帧的名称。

新版本 1.5.0 中新增。

返回：

DataFrame

将显示的差异堆叠在一起的 DataFrame。

结果索引将是 MultiIndex，‘self’和‘other’交替堆叠在内部级别。

引发：

ValueError

当两个 DataFrame 的标签或形状不完全相同时。

另请参阅

Series.compare

与另一个 Series 进行比较并显示差异。

DataFrame.equals

测试两个对象是否包含相同的元素。

注释

匹配的 NaN 将不会显示为差异。

只能比较标签相同（即形状相同，行和列标签相同）的 DataFrame

示例

>>> df = pd.DataFrame(
...     {
...         "col1": ["a", "a", "b", "b", "a"],
...         "col2": [1.0, 2.0, 3.0, np.nan, 5.0],
...         "col3": [1.0, 2.0, 3.0, 4.0, 5.0]
...     },
...     columns=["col1", "col2", "col3"],
... )
>>> df
 col1  col2  col3
0    a   1.0   1.0
1    a   2.0   2.0
2    b   3.0   3.0
3    b   NaN   4.0
4    a   5.0   5.0 

>>> df2 = df.copy()
>>> df2.loc[0, 'col1'] = 'c'
>>> df2.loc[2, 'col3'] = 4.0
>>> df2
 col1  col2  col3
0    c   1.0   1.0
1    a   2.0   2.0
2    b   3.0   4.0
3    b   NaN   4.0
4    a   5.0   5.0 

在列上对齐差异

>>> df.compare(df2)
 col1       col3
 self other self other
0    a     c  NaN   NaN
2  NaN   NaN  3.0   4.0 

分配结果名称

>>> df.compare(df2, result_names=("left", "right"))
 col1       col3
 left right left right
0    a     c  NaN   NaN
2  NaN   NaN  3.0   4.0 

将差异堆叠在行上

>>> df.compare(df2, align_axis=0)
 col1  col3
0 self     a   NaN
 other    c   NaN
2 self   NaN   3.0
 other  NaN   4.0 

保留相等的值

>>> df.compare(df2, keep_equal=True)
 col1       col3
 self other self other
0    a     c  1.0   1.0
2    b     b  3.0   4.0 

保留所有原始行和列

>>> df.compare(df2, keep_shape=True)
 col1       col2       col3
 self other self other self other
0    a     c  NaN   NaN  NaN   NaN
1  NaN   NaN  NaN   NaN  NaN   NaN
2  NaN   NaN  NaN   NaN  3.0   4.0
3  NaN   NaN  NaN   NaN  NaN   NaN
4  NaN   NaN  NaN   NaN  NaN   NaN 

保留所有原始行和列，以及所有原始值

>>> df.compare(df2, keep_shape=True, keep_equal=True)
 col1       col2       col3
 self other self other self other
0    a     c  1.0   1.0  1.0   1.0
1    a     a  2.0   2.0  2.0   2.0
2    b     b  3.0   3.0  3.0   4.0
3    b     b  NaN   NaN  4.0   4.0
4    a     a  5.0   5.0  5.0   5.0 

pandas.DataFrame.join

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

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False, validate=None)

加入另一个 DataFrame 的列。

通过索引或关键列将其他 DataFrame 的列与另一个 DataFrame 连接。通过一次传递列表来高效地按索引同时连接多个 DataFrame 对象。

参数：

otherDataFrame，Series 或包含它们任意组合的列表

索引应与此列中的列之一类似。如果传递了 Series，则其 name 属性必须设置，并且将在结果连接的 DataFrame 中用作列名。

onstr，str 列表或类数组，可选

调用者中要在其索引上连接的列或索引级别名称，在其他中连接索引，否则在索引上连接索引。如果给定多个值，则其他 DataFrame 必须具有 MultiIndex。如果关键字不在调用 DataFrame 中，则可以传递数组作为连接键。类似于 Excel 的 VLOOKUP 操作。

how，默认为‘left’

如何处理两个对象的操作。

• left：使用调用框架的索引（或者如果指定了 on，则使用列）

• right：使用其他的索引。

• outer：将调用框架的索引（或者如果指定了 on，则使用列）与其他的索引形成联合，并按字典顺序对其进行排序。

• inner：形成调用框架的索引（或者如果指定了 on，则使用列）与其他的索引的交集，保留调用的顺序。

• cross：从两个框架创建笛卡尔积，保留左键的顺序。

lsuffixstr，默认为‘’

从左侧框的重叠列中使用的后缀。

rsuffixstr，默认为‘’

从右侧框的重叠列中使用的后缀。

sortbool，默认为 False

按连接键的字典顺序对结果 DataFrame 进行排序。如果为 False，则连接键的顺序取决于连接类型（how 关键字）。

validatestr，可选

如果指定了，检查连接是否为指定类型。

• “one_to_one”或“1:1”：检查左侧和右侧数据集中的连接键是否唯一。

• “one_to_many”或“1:m”：检查左侧数据集中的连接键是否唯一。

• “many_to_one”或“m:1”：检查右侧数据集中的连接键是否唯一。

• “many_to_many”或“m:m”：允许，但不会进行检查。

1.5.0 版中的新功能。

返回：

DataFrame

包含来自调用者和其他 DataFrame 的列的 DataFrame。

另请参见

DataFrame.merge

对于列对列操作。

注意

当传递 DataFrame 对象列表时，不支持参数 on，lsuffix 和 rsuffix。

示例

>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'],
...                    'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']}) 

>>> df
 key   A
0  K0  A0
1  K1  A1
2  K2  A2
3  K3  A3
4  K4  A4
5  K5  A5 

>>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'],
...                       'B': ['B0', 'B1', 'B2']}) 

>>> other
 key   B
0  K0  B0
1  K1  B1
2  K2  B2 

使用它们的索引连接 DataFrame。

>>> df.join(other, lsuffix='_caller', rsuffix='_other')
 key_caller   A key_other    B
0         K0  A0        K0   B0
1         K1  A1        K1   B1
2         K2  A2        K2   B2
3         K3  A3       NaN  NaN
4         K4  A4       NaN  NaN
5         K5  A5       NaN  NaN 

如果我们想要使用关键列进行连接，我们需要将关键设置为 df 和 other 中的索引。连接后的 DataFrame 将以关键作为其索引。

>>> df.set_index('key').join(other.set_index('key'))
 A    B
key
K0   A0   B0
K1   A1   B1
K2   A2   B2
K3   A3  NaN
K4   A4  NaN
K5   A5  NaN 

使用关键列加入的另一种选项是使用 on 参数。DataFrame.join 始终使用其他的索引，但我们可以使用 df 中的任何列。此方法在结果中保留了原始 DataFrame 的索引。

>>> df.join(other.set_index('key'), on='key')
 key   A    B
0  K0  A0   B0
1  K1  A1   B1
2  K2  A2   B2
3  K3  A3  NaN
4  K4  A4  NaN
5  K5  A5  NaN 

使用非唯一键值显示它们的匹配方式。

>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K1', 'K3', 'K0', 'K1'],
...                    'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']}) 

>>> df
 key   A
0  K0  A0
1  K1  A1
2  K1  A2
3  K3  A3
4  K0  A4
5  K1  A5 

>>> df.join(other.set_index('key'), on='key', validate='m:1')
 key   A    B
0  K0  A0   B0
1  K1  A1   B1
2  K1  A2   B1
3  K3  A3  NaN
4  K0  A4   B0
5  K1  A5   B1 

pandas.DataFrame.merge

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

DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=None, indicator=False, validate=None)

用数据库风格的连接合并数据框或命名系列对象。

命名系列对象被视为具有单个命名列的数据框。

连接是在列或索引上完成的。如果在列上连接列，则数据框索引将被忽略。否则，如果在索引上连接索引或在列或列上连接索引，则索引将被传递。执行交叉合并时，不允许对要合并的列进行规范。

警告

如果两个键列都包含键为 null 值的行，则这些行将与彼此匹配。这与通常的 SQL 连接行为不同，可能导致意外结果。

参数：

right数据框或命名系列

要合并的对象。

how，默认为‘inner’

要执行的合并类型。

• left：仅使用左侧数据框的键，类似于 SQL 的左外连接；保留键顺序。

• right：仅使用右侧数据框的键，类似于 SQL 的右外连接；保留键顺序。

• outer：使用两个数据框的键的并集，类似于 SQL 的完全外连接；按字典顺序排序键。

• inner：使用两个数据框的键的交集，类似于 SQL 的内连接；保留左侧键的顺序。

• cross：从两个数据框创建笛卡尔积，保留左侧键的顺序。

on标签或列表

要连接的列或索引级别名称。这些必须在两个数据框中找到。如果 on 为 None 并且不是在索引上合并，则默认为两个数据框中列的交集。

left_on标签或列表，或类似数组

要在左侧数据框中连接的列或索引级别名称。也可以是左侧数据框长度的数组或数组列表。这些数组将被视为列。

right_on标签或列表，或类似数组

要在右侧数据框中连接的列或索引级别名称。也可以是右侧数据框长度的数组或数组列表。这些数组将被视为列。

left_index布尔值，默认为 False

使用左侧数据框的索引作为连接键。如果是多重索引，则另一个数据框中的键的数量（可以是索引或多列）必须与级别的数量匹配。

right_index布尔值，默认为 False

使用右侧数据框的索引作为连接键。与 left_index 一样的注意事项。

sort布尔值，默认为 False

在结果数据框中按字典顺序对连接键进行排序。如果为 False，则连接键的顺序取决于连接类型（how 关键字）。

suffixes类似列表，默认为（“_x”，“_y”）

一个长度为 2 的序列，每个元素都可以是指示左侧和右侧重叠列名称后缀的字符串。将 None 值传递而不是字符串以指示应保留左侧或右侧的列名，不附加后缀。至少一个值必须不是 None。

copy bool，默认为 True

如果为 False，则尽可能避免复制。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制 将成为默认启用的，这意味着所有带有 copy 关键字的方法将使用惰性复制机制来延迟复制并忽略 copy 关键字。copy 关键字将在 pandas 的将来版本中删除。

您可以通过启用写时复制来获得未来的行为和改进 pd.options.mode.copy_on_write = True

indicator bool 或 str，默认为 False

如果为 True，则在输出 DataFrame 中添加一个名为 “_merge” 的列，其中包含每行来源的信息。可以通过提供字符串参数给列命名不同的名称。该列将具有分类类型，对于仅在左侧 DataFrame 中出现合并键的观测，“left_only” 的值；对于仅在右侧 DataFrame 中出现合并键的观测，“right_only” 的值；对于观测的合并键同时在两个 DataFrame 中出现的情况，“both” 的值。

validate str，可选

如果指定，则检查合并是否为指定类型。

• “one_to_one” 或 “1:1”：检查左右数据集中的合并键是否唯一。

• “one_to_many” 或 “1:m”：检查左侧数据集中的合并键是否唯一。

• “many_to_one” 或 “m:1”：检查右侧数据集中的合并键是否唯一。

• “many_to_many” 或 “m:m”：允许，但不进行检查。

返回：

DataFrame

两个合并对象的 DataFrame。

另请参见

merge_ordered

合并并进行可选填充/插值。

merge_asof

在最近的键上合并。

DataFrame.join

使用索引的类似方法。

示例

>>> df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
...                     'value': [1, 2, 3, 5]})
>>> df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
...                     'value': [5, 6, 7, 8]})
>>> df1
 lkey value
0   foo      1
1   bar      2
2   baz      3
3   foo      5
>>> df2
 rkey value
0   foo      5
1   bar      6
2   baz      7
3   foo      8 

在 lkey 和 rkey 列上合并 df1 和 df2。值列具有默认后缀 _x 和 _y。

>>> df1.merge(df2, left_on='lkey', right_on='rkey')
 lkey  value_x rkey  value_y
0  foo        1  foo        5
1  foo        1  foo        8
2  bar        2  bar        6
3  baz        3  baz        7
4  foo        5  foo        5
5  foo        5  foo        8 

将指定的左侧和右侧后缀附加到任何重叠列上合并 DataFrame df1 和 df2。

>>> df1.merge(df2, left_on='lkey', right_on='rkey',
...           suffixes=('_left', '_right'))
 lkey  value_left rkey  value_right
0  foo           1  foo            5
1  foo           1  foo            8
2  bar           2  bar            6
3  baz           3  baz            7
4  foo           5  foo            5
5  foo           5  foo            8 

合并 DataFrame df1 和 df2，但如果 DataFrame 有任何重叠列，则引发异常。

>>> df1.merge(df2, left_on='lkey', right_on='rkey', suffixes=(False, False))
Traceback (most recent call last):
...
ValueError: columns overlap but no suffix specified:
 Index(['value'], dtype='object') 

>>> df1 = pd.DataFrame({'a': ['foo', 'bar'], 'b': [1, 2]})
>>> df2 = pd.DataFrame({'a': ['foo', 'baz'], 'c': [3, 4]})
>>> df1
 a  b
0   foo  1
1   bar  2
>>> df2
 a  c
0   foo  3
1   baz  4 

>>> df1.merge(df2, how='inner', on='a')
 a  b  c
0   foo  1  3 

>>> df1.merge(df2, how='left', on='a')
 a  b  c
0   foo  1  3.0
1   bar  2  NaN 

>>> df1 = pd.DataFrame({'left': ['foo', 'bar']})
>>> df2 = pd.DataFrame({'right': [7, 8]})
>>> df1
 left
0   foo
1   bar
>>> df2
 right
0   7
1   8 

>>> df1.merge(df2, how='cross')
 left  right
0   foo      7
1   foo      8
2   bar      7
3   bar      8 

pandas.DataFrame.update

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

DataFrame.update(other, join='left', overwrite=True, filter_func=None, errors='ignore')

使用另一个 DataFrame 的非 NA 值就地修改。

在索引上对齐。没有返回值。

参数：

otherDataFrame，或可转换为 DataFrame 的对象

应至少具有一个与原始 DataFrame 匹配的索引/列标签。如果传递了一个 Series，则其 name 属性必须设置，那将用作与原始 DataFrame 对齐的列名。

join，默认为 ‘left’

仅实现了左连接，保留了原始对象的索引和列。

overwritebool，默认为 True

如何处理重叠键的非 NA 值：

• True：用 other 的值覆盖原始 DataFrame 的值。

• False：仅更新原始 DataFrame 中的 NA 值。

filter_funccallable(1d-array) -> bool 1d-array，可选

可选择替换非 NA 的值。对应应该更新的值返回 True。

errors，默认为 ‘ignore’

如果 'raise'，并且 DataFrame 和 other 在相同位置都包含非 NA 数据，则会引发 ValueError。

返回：

None

此方法直接更改调用对象。

引发：

ValueError

• 当 errors='raise' 且存在重叠的非 NA 数据时。

• 当 errors 不是 ‘ignore’ 或 ‘raise’ 时

NotImplementedError

• 如果 join != ‘left’

另请参阅

dict.update

字典的类似方法。

DataFrame.merge

对于列与列的操作。

示例

>>> df = pd.DataFrame({'A': [1, 2, 3],
...                    'B': [400, 500, 600]})
>>> new_df = pd.DataFrame({'B': [4, 5, 6],
...                        'C': [7, 8, 9]})
>>> df.update(new_df)
>>> df
 A  B
0  1  4
1  2  5
2  3  6 

数据帧的长度不会因更新而增加，只有在匹配的索引/列标签处才会更新值。

>>> df = pd.DataFrame({'A': ['a', 'b', 'c'],
...                    'B': ['x', 'y', 'z']})
>>> new_df = pd.DataFrame({'B': ['d', 'e', 'f', 'g', 'h', 'i']})
>>> df.update(new_df)
>>> df
 A  B
0  a  d
1  b  e
2  c  f 

>>> df = pd.DataFrame({'A': ['a', 'b', 'c'],
...                    'B': ['x', 'y', 'z']})
>>> new_df = pd.DataFrame({'B': ['d', 'f']}, index=[0, 2])
>>> df.update(new_df)
>>> df
 A  B
0  a  d
1  b  y
2  c  f 

对于 Series，其 name 属性必须设置。

>>> df = pd.DataFrame({'A': ['a', 'b', 'c'],
...                    'B': ['x', 'y', 'z']})
>>> new_column = pd.Series(['d', 'e', 'f'], name='B')
>>> df.update(new_column)
>>> df
 A  B
0  a  d
1  b  e
2  c  f 

如果 other 包含 NaN 值，则相应的数值不会在原始数据帧中更新。

>>> df = pd.DataFrame({'A': [1, 2, 3],
...                    'B': [400., 500., 600.]})
>>> new_df = pd.DataFrame({'B': [4, np.nan, 6]})
>>> df.update(new_df)
>>> df
 A      B
0  1    4.0
1  2  500.0
2  3    6.0 

pandas.DataFrame.asfreq

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

DataFrame.asfreq(freq, method=None, how=None, normalize=False, fill_value=None)

将时间序列转换为指定的频率。

返回原始数据调整为具有指定频率的新索引。

如果此 Series/DataFrame 的索引是PeriodIndex，则新索引是通过使用PeriodIndex.asfreq转换原始索引的结果（因此原始索引将一对一地映射到新索引）。

否则，新索引将等同于pd.date_range(start, end, freq=freq)，其中start和end分别是原始索引中的第一个和最后一个条目（请参阅pandas.date_range()）。新索引中任何时间步长对应的值，如果在原始索引中不存在，将为 null（NaN），除非提供了填充此类未知值的方法（请参见下面的method参数）。

如果需要对每组时间步长（例如聚合）执行操作以表示新频率下的数据，则resample()方法更合适。

参数：

freqDateOffset 或字符串

频率 DateOffset 或字符串。

method，默认为 None

用于填充重新索引 Series 中的空洞的方法（请注意，这不会填充已经存在的 NaN）：

• ‘pad’ / ‘ffill’：将最后一个有效观察结果向前传播到下一个有效结果

• ‘backfill’ / ‘bfill’：使用下一个有效观察结果进行填充。

how，默认为 end

仅适用于 PeriodIndex（请参阅 PeriodIndex.asfreq）。

normalize布尔值，默认为 False

是否将输出索引重置为午夜。

fill_value标量，可选

用于缺失值的值，在上采样期间应用（请注意，这不会填充已经存在的 NaN）。

返回：

Series/DataFrame

重新索引为指定频率的 Series/DataFrame 对象。

另请参见

reindex

使用可选的填充逻辑将 DataFrame 调整为新索引。

注意事项

要了解更多关于频率字符串的信息，请参见此链接。

示例

从创建一个具有 4 个一分钟时间戳的系列开始。

>>> index = pd.date_range('1/1/2000', periods=4, freq='min')
>>> series = pd.Series([0.0, None, 2.0, 3.0], index=index)
>>> df = pd.DataFrame({'s': series})
>>> df
 s
2000-01-01 00:00:00    0.0
2000-01-01 00:01:00    NaN
2000-01-01 00:02:00    2.0
2000-01-01 00:03:00    3.0 

将系列上采样为 30 秒间隔。

>>> df.asfreq(freq='30s')
 s
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    NaN
2000-01-01 00:01:00    NaN
2000-01-01 00:01:30    NaN
2000-01-01 00:02:00    2.0
2000-01-01 00:02:30    NaN
2000-01-01 00:03:00    3.0 

再次上采样，提供一个填充值。

>>> df.asfreq(freq='30s', fill_value=9.0)
 s
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    9.0
2000-01-01 00:01:00    NaN
2000-01-01 00:01:30    9.0
2000-01-01 00:02:00    2.0
2000-01-01 00:02:30    9.0
2000-01-01 00:03:00    3.0 

再次上采样，提供一个方法。

>>> df.asfreq(freq='30s', method='bfill')
 s
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    NaN
2000-01-01 00:01:00    NaN
2000-01-01 00:01:30    2.0
2000-01-01 00:02:00    2.0
2000-01-01 00:02:30    3.0
2000-01-01 00:03:00    3.0 

pandas.DataFrame.asof

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

DataFrame.asof(where, subset=None)

返回在 where 之前没有任何 NaN 的最后一行（行）。

对于每个 where 中的元素（如果是列表），取出没有任何 NaN 的最后一行。对于DataFrame，只考虑列的子集中没有 NaN 的最后一行（如果不是 None）

如果没有好的值，对于 Series 返回 NaN，对于 DataFrame 返回一系列 NaN 值

参数：

where：日期或者日期的 array-like

返回最后一行（行）之前的日期。

subset：str 或者 str 的 array-like，默认为 None

对于 DataFrame，如果不是 None，只使用这些列来检查 NaN 值。

返回：

标量、Series 或者 DataFrame

返回可以是：

• scalar：当 self 是一个 Series 且 where 是一个标量时

• Series：当 self 是一个 Series 且 where 是一个 array-like，或者当 self 是 DataFrame 且 where 是一个标量时

• DataFrame：当 self 是 DataFrame 且 where 是一个 array-like 时

另请参阅

merge_asof

执行 asof 合并。类似于左连接。

注意事项

假设日期是排序的。如果不是这样，会引发异常。

示例

一个 Series 和一个标量 where。

>>> s = pd.Series([1, 2, np.nan, 4], index=[10, 20, 30, 40])
>>> s
10    1.0
20    2.0
30    NaN
40    4.0
dtype: float64 

>>> s.asof(20)
2.0 

对于一个序列 where，返回一个 Series。第一个值是 NaN，因为 where 的第一个元素在第一个索引值之前。

>>> s.asof([5, 20])
5     NaN
20    2.0
dtype: float64 

不考虑缺失值。下面的是2.0，而不是 NaN，尽管 NaN 在30的索引位置。

>>> s.asof(30)
2.0 

考虑所有列

>>> df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],
...                    'b': [None, None, None, None, 500]},
...                   index=pd.DatetimeIndex(['2018-02-27 09:01:00',
...                                           '2018-02-27 09:02:00',
...                                           '2018-02-27 09:03:00',
...                                           '2018-02-27 09:04:00',
...                                           '2018-02-27 09:05:00']))
>>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',
...                           '2018-02-27 09:04:30']))
 a   b
2018-02-27 09:03:30 NaN NaN
2018-02-27 09:04:30 NaN NaN 

考虑单个列

>>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',
...                           '2018-02-27 09:04:30']),
...         subset=['a'])
 a   b
2018-02-27 09:03:30  30.0 NaN
2018-02-27 09:04:30  40.0 NaN 

pandas.DataFrame.shift

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

DataFrame.shift(periods=1, freq=None, axis=0, fill_value=_NoDefault.no_default, suffix=None)

通过所需的周期数转移索引，并可选的时间频率。

当未传递 freq 时，转移索引而不重新对齐数据。如果传递了 freq（在这种情况下，索引必须是日期或日期时间，否则会引发 NotImplementedError），则将使用 periods 和 freq 增加索引。如果指定为“infer”，则可以推断 freq，只要索引中设置了 freq 或 inferred_freq 属性。

参数：

periods整数或序列

要转移的周期数。可以是正数或负数。如果是整数的可迭代对象，则数据将按每个整数一次转移一次。这相当于一次转移一个值并连接所有结果帧。生成的列将在其列名后缀中具有转移后缀。对于多个周期，axis 不能为 1。

freqDateOffset、tseries.offsets、timedelta 或字符串，可选

从 tseries 模块或时间规则（例如‘EOM’）中使用的偏移量。如果指定了 freq，则索引值会发生偏移，但数据不会重新对齐。也就是说，如果希望在转移时扩展索引并保留原始数据，请使用 freq。如果将 freq 指定为“infer”，则将从索引的 freq 或 inferred_freq 属性中推断。如果这两个属性都不存在，则会引发 ValueError。

axis，默认为 None

转变方向。对于 Series，此参数未使用，默认为 0。

fill_value对象，可选

用于新引入的缺失值的标量值。默认取决于 self 的 dtype。对于数值数据，使用np.nan。对于日期时间、时间间隔或周期数据等，使用NaT。对于扩展的 dtype，使用self.dtype.na_value。

suffix字符串，可选

如果 str 和 periods 是可迭代的，则将其添加到每个转移列名的列名之后和转移值之前。

返回：

DataFrame

输入对象的副本，已转移。

另请参阅

Index.shift

转移 Index 的值。

DatetimeIndex.shift

转移 DatetimeIndex 的值。

PeriodIndex.shift

转移 PeriodIndex 的值。

示例

>>> df = pd.DataFrame({"Col1": [10, 20, 15, 30, 45],
...                    "Col2": [13, 23, 18, 33, 48],
...                    "Col3": [17, 27, 22, 37, 52]},
...                   index=pd.date_range("2020-01-01", "2020-01-05"))
>>> df
 Col1  Col2  Col3
2020-01-01    10    13    17
2020-01-02    20    23    27
2020-01-03    15    18    22
2020-01-04    30    33    37
2020-01-05    45    48    52 

>>> df.shift(periods=3)
 Col1  Col2  Col3
2020-01-01   NaN   NaN   NaN
2020-01-02   NaN   NaN   NaN
2020-01-03   NaN   NaN   NaN
2020-01-04  10.0  13.0  17.0
2020-01-05  20.0  23.0  27.0 

>>> df.shift(periods=1, axis="columns")
 Col1  Col2  Col3
2020-01-01   NaN    10    13
2020-01-02   NaN    20    23
2020-01-03   NaN    15    18
2020-01-04   NaN    30    33
2020-01-05   NaN    45    48 

>>> df.shift(periods=3, fill_value=0)
 Col1  Col2  Col3
2020-01-01     0     0     0
2020-01-02     0     0     0
2020-01-03     0     0     0
2020-01-04    10    13    17
2020-01-05    20    23    27 

>>> df.shift(periods=3, freq="D")
 Col1  Col2  Col3
2020-01-04    10    13    17
2020-01-05    20    23    27
2020-01-06    15    18    22
2020-01-07    30    33    37
2020-01-08    45    48    52 

>>> df.shift(periods=3, freq="infer")
 Col1  Col2  Col3
2020-01-04    10    13    17
2020-01-05    20    23    27
2020-01-06    15    18    22
2020-01-07    30    33    37
2020-01-08    45    48    52 

>>> df['Col1'].shift(periods=[0, 1, 2])
 Col1_0  Col1_1  Col1_2
2020-01-01      10     NaN     NaN
2020-01-02      20    10.0     NaN
2020-01-03      15    20.0    10.0
2020-01-04      30    15.0    20.0
2020-01-05      45    30.0    15.0 

pandas.DataFrame.first_valid_index

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

DataFrame.first_valid_index()

返回第一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。

返回：

索引类型

示例

对于 Series：

>>> s = pd.Series([None, 3, 4])
>>> s.first_valid_index()
1
>>> s.last_valid_index()
2 

>>> s = pd.Series([None, None])
>>> print(s.first_valid_index())
None
>>> print(s.last_valid_index())
None 

如果 Series 中所有元素都是 NA/null，则返回 None。

>>> s = pd.Series()
>>> print(s.first_valid_index())
None
>>> print(s.last_valid_index())
None 

如果 Series 为空，则返回 None。

对于 DataFrame：

>>> df = pd.DataFrame({'A': [None, None, 2], 'B': [None, 3, 4]})
>>> df
 A      B
0  NaN    NaN
1  NaN    3.0
2  2.0    4.0
>>> df.first_valid_index()
1
>>> df.last_valid_index()
2 

>>> df = pd.DataFrame({'A': [None, None, None], 'B': [None, None, None]})
>>> df
 A      B
0  None   None
1  None   None
2  None   None
>>> print(df.first_valid_index())
None
>>> print(df.last_valid_index())
None 

如果 DataFrame 中所有元素都是 NA/null，则返回 None。

>>> df = pd.DataFrame()
>>> df
Empty DataFrame
Columns: []
Index: []
>>> print(df.first_valid_index())
None
>>> print(df.last_valid_index())
None 

如果 DataFrame 为空，则返回 None。

pandas.DataFrame.last_valid_index

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

DataFrame.last_valid_index()

返回最后一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。

返回：

索引的类型

示例

对于 Series：

>>> s = pd.Series([None, 3, 4])
>>> s.first_valid_index()
1
>>> s.last_valid_index()
2 

>>> s = pd.Series([None, None])
>>> print(s.first_valid_index())
None
>>> print(s.last_valid_index())
None 

如果 Series 中的所有元素都是 NA/null，则返回 None。

>>> s = pd.Series()
>>> print(s.first_valid_index())
None
>>> print(s.last_valid_index())
None 

如果 Series 为空，则返回 None。

对于 DataFrame：

>>> df = pd.DataFrame({'A': [None, None, 2], 'B': [None, 3, 4]})
>>> df
 A      B
0  NaN    NaN
1  NaN    3.0
2  2.0    4.0
>>> df.first_valid_index()
1
>>> df.last_valid_index()
2 

>>> df = pd.DataFrame({'A': [None, None, None], 'B': [None, None, None]})
>>> df
 A      B
0  None   None
1  None   None
2  None   None
>>> print(df.first_valid_index())
None
>>> print(df.last_valid_index())
None 

如果 DataFrame 中的所有元素都是 NA/null，则返回 None。

>>> df = pd.DataFrame()
>>> df
Empty DataFrame
Columns: []
Index: []
>>> print(df.first_valid_index())
None
>>> print(df.last_valid_index())
None 

如果 DataFrame 为空，则返回 None。

pandas.DataFrame.resample

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

DataFrame.resample(rule, axis=_NoDefault.no_default, closed=None, label=None, convention=_NoDefault.no_default, kind=_NoDefault.no_default, on=None, level=None, origin='start_day', offset=None, group_keys=False)

重新取样时间序列数据。

频率转换和时间序列重新取样的便捷方法。对象必须具有类似日期时间的索引（DatetimeIndex、PeriodIndex 或 TimedeltaIndex），或者调用者必须将类似日期时间的系列/索引的标签传递给on/level关键字参数。

参数：

ruleDateOffset、Timedelta 或 str

表示目标转换的偏移字符串或对象。

axis，默认为 0

用于上采样或下采样的轴。对于 Series，此参数未使用且默认为 0。必须是 DatetimeIndex、TimedeltaIndex 或 PeriodIndex。

从版本 2.0.0 开始弃用：改用 frame.T.resample(…)。

closed，默认为 None

哪一侧的箱子间隔是闭合的。默认为‘left’，除了‘ME’、‘YE’、‘QE’、‘BME’、‘BA’、‘BQE’和‘W’，它们的默认值都是‘right’。

label，默认为 None

用于标记桶的哪个箱边标签。默认为‘left’，除了‘ME’、‘YE’、‘QE’、‘BME’、‘BA’、‘BQE’和‘W’，它们的默认值都是‘right’。

convention，默认为‘start’

仅对 PeriodIndex 有效，控制使用规则的开始或结束。

从版本 2.2.0 开始弃用：在重新取样之前将 PeriodIndex 转换为 DatetimeIndex。

kind，可选，默认为 None

将生成的索引转换为 DateTimeIndex 的‘timestamp’或转换为 PeriodIndex 的‘period’。默认情况下保留输入表示。

从版本 2.2.0 开始弃用：显式将索引转换为所需类型。

onstr，可选

对于 DataFrame，用于重新取样的列而不是索引。列必须类似于日期时间。

levelstr 或 int，可选

对于 MultiIndex，用于重新取样的级别（名称或编号）。级别必须类似于日期时间。

originTimestamp 或 str，默认为‘start_day’

调整分组的时间戳。原点的时区必须与索引的时区匹配。如果是字符串，必须是以下之一：

• ‘epoch’：原点是 1970-01-01

• ‘start’：原点是时间序列的第一个值

• ‘start_day’：原点是时间序列午夜的第一天

• ‘end’：原点是时间序列的最后一个值

• ‘end_day’：原点是最后一天的午夜

1.3.0 版本中的新功能。

注意

仅对 Tick 频率（即固定频率，如天、小时和分钟，而不是月份或季度）有效。

offsetTimedelta 或 str，默认为 None

添加到原点的偏移时间间隔。

group_keysbool，默认为 False

在对重新取样对象使用.apply()时，是否在结果索引中包含组键。

1.5.0 版本中的新功能：不指定group_keys将保留与 pandas 1.4 及更早版本相同的值相关行为（请参阅 pandas 1.5.0 发布说明以获取示例）。

在 2.0.0 版本中更改：group_keys现在默认为False。

返回：

pandas.api.typing.Resampler

Resampler对象。

另请参阅

Series.resample

对 Series 进行重新采样。

DataFrame.resample

对 DataFrame 进行重新采样。

groupby

通过映射、函数、标签或标签列表对 Series/DataFrame 进行分组。

asfreq

使用给定的频率重新索引 Series/DataFrame 而不进行分组。

注意

查看用户指南以获取更多信息。

要了解更多关于偏移字符串的信息，请参阅此链接。

示例

从创建具有 9 个一分钟时间戳的系列开始。

>>> index = pd.date_range('1/1/2000', periods=9, freq='min')
>>> series = pd.Series(range(9), index=index)
>>> series
2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    2
2000-01-01 00:03:00    3
2000-01-01 00:04:00    4
2000-01-01 00:05:00    5
2000-01-01 00:06:00    6
2000-01-01 00:07:00    7
2000-01-01 00:08:00    8
Freq: min, dtype: int64 

将系列下采样为 3 分钟的区间，并对落入区间的时间戳的值进行求和。

>>> series.resample('3min').sum()
2000-01-01 00:00:00     3
2000-01-01 00:03:00    12
2000-01-01 00:06:00    21
Freq: 3min, dtype: int64 

将系列下采样为 3 分钟的区间，但使用右边缘标记每个区间而不是左边缘。请注意，用作标签的桶中的值不包括在标记的桶中。例如，在原始系列中，桶2000-01-01 00:03:00包含值 3，但在具有标签2000-01-01 00:03:00的重新采样桶中，总和值不包括 3（如果包括，总和值将是 6，而不是 3）。

>>> series.resample('3min', label='right').sum()
2000-01-01 00:03:00     3
2000-01-01 00:06:00    12
2000-01-01 00:09:00    21
Freq: 3min, dtype: int64 

要包含此值，请关闭区间的右侧，如下所示。

>>> series.resample('3min', label='right', closed='right').sum()
2000-01-01 00:00:00     0
2000-01-01 00:03:00     6
2000-01-01 00:06:00    15
2000-01-01 00:09:00    15
Freq: 3min, dtype: int64 

将系列上采样为 30 秒的区间。

>>> series.resample('30s').asfreq()[0:5]   # Select first 5 rows
2000-01-01 00:00:00   0.0
2000-01-01 00:00:30   NaN
2000-01-01 00:01:00   1.0
2000-01-01 00:01:30   NaN
2000-01-01 00:02:00   2.0
Freq: 30s, dtype: float64 

将系列上采样为 30 秒的区间，并使用ffill方法填充NaN值。

>>> series.resample('30s').ffill()[0:5]
2000-01-01 00:00:00    0
2000-01-01 00:00:30    0
2000-01-01 00:01:00    1
2000-01-01 00:01:30    1
2000-01-01 00:02:00    2
Freq: 30s, dtype: int64 

将系列上采样为 30 秒的区间，并使用bfill方法填充NaN值。

>>> series.resample('30s').bfill()[0:5]
2000-01-01 00:00:00    0
2000-01-01 00:00:30    1
2000-01-01 00:01:00    1
2000-01-01 00:01:30    2
2000-01-01 00:02:00    2
Freq: 30s, dtype: int64 

通过apply传递自定义函数

>>> def custom_resampler(arraylike):
...     return np.sum(arraylike) + 5
...
>>> series.resample('3min').apply(custom_resampler)
2000-01-01 00:00:00     8
2000-01-01 00:03:00    17
2000-01-01 00:06:00    26
Freq: 3min, dtype: int64 

对于 DataFrame 对象，关键字on可用于指定重新采样时的列而不是索引。

>>> d = {'price': [10, 11, 9, 13, 14, 18, 17, 19],
...      'volume': [50, 60, 40, 100, 50, 100, 40, 50]}
>>> df = pd.DataFrame(d)
>>> df['week_starting'] = pd.date_range('01/01/2018',
...                                     periods=8,
...                                     freq='W')
>>> df
 price  volume week_starting
0     10      50    2018-01-07
1     11      60    2018-01-14
2      9      40    2018-01-21
3     13     100    2018-01-28
4     14      50    2018-02-04
5     18     100    2018-02-11
6     17      40    2018-02-18
7     19      50    2018-02-25
>>> df.resample('ME', on='week_starting').mean()
 price  volume
week_starting
2018-01-31     10.75    62.5
2018-02-28     17.00    60.0 

对于具有 MultiIndex 的 DataFrame，关键字level可用于指定重新采样需要进行的级别。

>>> days = pd.date_range('1/1/2000', periods=4, freq='D')
>>> d2 = {'price': [10, 11, 9, 13, 14, 18, 17, 19],
...       'volume': [50, 60, 40, 100, 50, 100, 40, 50]}
>>> df2 = pd.DataFrame(
...     d2,
...     index=pd.MultiIndex.from_product(
...         [days, ['morning', 'afternoon']]
...     )
... )
>>> df2
 price  volume
2000-01-01 morning       10      50
 afternoon     11      60
2000-01-02 morning        9      40
 afternoon     13     100
2000-01-03 morning       14      50
 afternoon     18     100
2000-01-04 morning       17      40
 afternoon     19      50
>>> df2.resample('D', level=0).sum()
 price  volume
2000-01-01     21     110
2000-01-02     22     140
2000-01-03     32     150
2000-01-04     36      90 

如果您想根据固定时间戳调整区间的开始：

>>> start, end = '2000-10-01 23:30:00', '2000-10-02 00:30:00'
>>> rng = pd.date_range(start, end, freq='7min')
>>> ts = pd.Series(np.arange(len(rng)) * 3, index=rng)
>>> ts
2000-10-01 23:30:00     0
2000-10-01 23:37:00     3
2000-10-01 23:44:00     6
2000-10-01 23:51:00     9
2000-10-01 23:58:00    12
2000-10-02 00:05:00    15
2000-10-02 00:12:00    18
2000-10-02 00:19:00    21
2000-10-02 00:26:00    24
Freq: 7min, dtype: int64 

>>> ts.resample('17min').sum()
2000-10-01 23:14:00     0
2000-10-01 23:31:00     9
2000-10-01 23:48:00    21
2000-10-02 00:05:00    54
2000-10-02 00:22:00    24
Freq: 17min, dtype: int64 

>>> ts.resample('17min', origin='epoch').sum()
2000-10-01 23:18:00     0
2000-10-01 23:35:00    18
2000-10-01 23:52:00    27
2000-10-02 00:09:00    39
2000-10-02 00:26:00    24
Freq: 17min, dtype: int64 

>>> ts.resample('17min', origin='2000-01-01').sum()
2000-10-01 23:24:00     3
2000-10-01 23:41:00    15
2000-10-01 23:58:00    45
2000-10-02 00:15:00    45
Freq: 17min, dtype: int64 

如果您想使用偏移时间差调整区间的开始，以下两行是等效的：

>>> ts.resample('17min', origin='start').sum()
2000-10-01 23:30:00     9
2000-10-01 23:47:00    21
2000-10-02 00:04:00    54
2000-10-02 00:21:00    24
Freq: 17min, dtype: int64 

>>> ts.resample('17min', offset='23h30min').sum()
2000-10-01 23:30:00     9
2000-10-01 23:47:00    21
2000-10-02 00:04:00    54
2000-10-02 00:21:00    24
Freq: 17min, dtype: int64 

如果您希望将最大的时间戳作为区间的结束：

>>> ts.resample('17min', origin='end').sum()
2000-10-01 23:35:00     0
2000-10-01 23:52:00    18
2000-10-02 00:09:00    27
2000-10-02 00:26:00    63
Freq: 17min, dtype: int64 

与start_day相反，您可以使用end_day将最大时间戳的午夜作为区间的结束，并且删除不包含数据的区间：

>>> ts.resample('17min', origin='end_day').sum()
2000-10-01 23:38:00     3
2000-10-01 23:55:00    15
2000-10-02 00:12:00    45
2000-10-02 00:29:00    45
Freq: 17min, dtype: int64 

pandas.DataFrame.to_period

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

DataFrame.to_period(freq=None, axis=0, copy=None)

将 DataFrame 从 DatetimeIndex 转换为 PeriodIndex。

将 DataFrame 从 DatetimeIndex 转换为 PeriodIndex，并使用所需的频率（如果未传递则从索引中推断）。

参数：

freq 字符串，默认值

PeriodIndex 的频率。

axis {0 或 'index'，1 或 'columns'}，默认为 0

要转换的轴（默认为索引）。

copy 布尔值，默认为 True

如果为 False，则底层输入数据不会被复制。

注意：

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制 将默认启用，这意味着所有带有 copy 关键字的方法都将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在 pandas 的未来版本中被移除。

通过启用写时复制 pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

返回值：

DataFrame

DataFrame 具有 PeriodIndex。

示例：

>>> idx = pd.to_datetime(
...     [
...         "2001-03-31 00:00:00",
...         "2002-05-31 00:00:00",
...         "2003-08-31 00:00:00",
...     ]
... ) 

>>> idx
DatetimeIndex(['2001-03-31', '2002-05-31', '2003-08-31'],
dtype='datetime64[ns]', freq=None) 

>>> idx.to_period("M")
PeriodIndex(['2001-03', '2002-05', '2003-08'], dtype='period[M]') 

对于年度频率

>>> idx.to_period("Y")
PeriodIndex(['2001', '2002', '2003'], dtype='period[Y-DEC]') 

pandas.DataFrame.to_timestamp

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

DataFrame.to_timestamp(freq=None, how='start', axis=0, copy=None)

将时间戳转换为周期的开始。

参数

freqstr，默认为 PeriodIndex 的频率

期望的频率。

how

将周期转换为时间戳的约定；周期的开始与结束。

axis，默认为 0

要转换的轴（默认为索引）。

copybool，默认为 True

如果为 False，则不复制底层输入数据。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制 将默认启用，这意味着所有带有 copy 关键字的方法都将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在 pandas 的将来版本中删除。

您可以通过启用写时复制 pd.options.mode.copy_on_write = True 来获得未来的行为和改进。

返回值：

DataFrame

DataFrame 具有 DatetimeIndex。

示例

>>> idx = pd.PeriodIndex(['2023', '2024'], freq='Y')
>>> d = {'col1': [1, 2], 'col2': [3, 4]}
>>> df1 = pd.DataFrame(data=d, index=idx)
>>> df1
 col1   col2
2023     1      3
2024     2      4 

在这种情况下，生成的时间戳将位于年初。

>>> df1 = df1.to_timestamp()
>>> df1
 col1   col2
2023-01-01     1      3
2024-01-01     2      4
>>> df1.index
DatetimeIndex(['2023-01-01', '2024-01-01'], dtype='datetime64[ns]', freq=None) 

使用频率，即时间戳将具有的偏移量。

>>> df2 = pd.DataFrame(data=d, index=idx)
>>> df2 = df2.to_timestamp(freq='M')
>>> df2
 col1   col2
2023-01-31     1      3
2024-01-31     2      4
>>> df2.index
DatetimeIndex(['2023-01-31', '2024-01-31'], dtype='datetime64[ns]', freq=None) 

pandas.DataFrame.tz_convert

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

DataFrame.tz_convert(tz, axis=0, level=None, copy=None)

将 tz-aware 轴转换为目标时区。

参数：

tzstr 或 tzinfo 对象 或 None

目标时区。传递 None 将转换为 UTC 并移除时区信息。

axis，默认 0

要转换的轴

levelint，str，默认 None

如果 axis 是一个 MultiIndex，转换特定级别。否则必须为 None。

copybool，默认 True

同时复制基础数据。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制 将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在未来的 pandas 版本中被移除。

通过启用写时复制 pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

返回：

Series/DataFrame

具有时区转换的轴的对象。

引发：

类型错误

如果轴是 tz-naive。

示例

转换为另一个时区：

>>> s = pd.Series(
...     [1],
...     index=pd.DatetimeIndex(['2018-09-15 01:30:00+02:00']),
... )
>>> s.tz_convert('Asia/Shanghai')
2018-09-15 07:30:00+08:00    1
dtype: int64 

传递 None 转换为 UTC 并获得一个 tz-naive 索引：

>>> s = pd.Series([1],
...               index=pd.DatetimeIndex(['2018-09-15 01:30:00+02:00']))
>>> s.tz_convert(None)
2018-09-14 23:30:00    1
dtype: int64 

pandas.DataFrame.tz_localize

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

DataFrame.tz_localize(tz, axis=0, level=None, copy=None, ambiguous='raise', nonexistent='raise')

将 Series 或 DataFrame 的 tz-非感知索引本地化到目标时区。

此操作将本地化索引。要将时区非感知的 Series 中的值本地化，请使用 Series.dt.tz_localize()。

参数：

tzstr 或 tzinfo 或 None

要本地化的时区。传递 None 将删除时区信息并保留本地时间。

axis，默认为 0

要本地化的轴

levelint、str，默认为 None

如果轴是 MultiIndex，则本地化特定级别。否则必须为 None。

copybool，默认为 True

还会复制基础数据。

注意

copy 关键字将在 pandas 3.0 中更改行为。Copy-on-Write 将默认启用，这意味着所有带有 copy 关键字的方法将使用惰性复制机制来延迟复制并忽略 copy 关键字。将来版本的 pandas 将删除 copy 关键字。

您可以通过启用 copy on write pd.options.mode.copy_on_write = True 来获得未来行为和改进。

ambiguous‘infer’、bool-ndarray、‘NaT’，默认为 ‘raise’

当钟表由于夏令时而后退时，可能会出现模糊的时间。例如，在中欧时间（UTC+01）中，从 03:00 夏令时到 02:00 非夏令时时，02:30:00 本地时间同时出现在 00:30:00 UTC 和 01:30:00 UTC。在这种情况下，ambiguous 参数指示应如何处理模糊时间。

• ‘infer’ 将尝试根据顺序推断秋季 dst 过渡小时

• bool-ndarray，其中 True 表示 DST 时间，False 表示非 DST 时间（请注意，此标志仅适用于模糊时间）

• 在存在模糊时间时，‘NaT’ 将返回 NaT

• ‘raise’ 将在存在模糊时间时引发 AmbiguousTimeError。

nonexistentstr，默认为 ‘raise’

不存在的时间不存在于特定时区，其中由于夏令时而向前移动的钟表。有效值为：

• ‘shift_forward’ 将不存在的时间向前偏移到最接近的现有时间

• ‘shift_backward’ 将不存在的时间向后偏移到最接近的现有时间

• 在不存在时间时，‘NaT’ 将返回 NaT

• timedelta 对象将使不存在的时间偏移 timedelta

• ‘raise’ 将在存在不存在的时间时引发 NonExistentTimeError。

返回：

Series/DataFrame

与输入相同类型。

引发：

TypeError

如果 TimeSeries 是 tz-感知的且 tz 不为 None。

示例

本地化本地时间：

>>> s = pd.Series(
...     [1],
...     index=pd.DatetimeIndex(['2018-09-15 01:30:00']),
... )
>>> s.tz_localize('CET')
2018-09-15 01:30:00+02:00    1
dtype: int64 

传递 None 以将索引转换为 tz-非感知索引并保留本地时间：

>>> s = pd.Series([1],
...               index=pd.DatetimeIndex(['2018-09-15 01:30:00+02:00']))
>>> s.tz_localize(None)
2018-09-15 01:30:00    1
dtype: int64 

小心处理夏令时变化。当存在连续数据时，pandas 可以推断出夏令时时间：

>>> s = pd.Series(range(7),
...               index=pd.DatetimeIndex(['2018-10-28 01:30:00',
...                                       '2018-10-28 02:00:00',
...                                       '2018-10-28 02:30:00',
...                                       '2018-10-28 02:00:00',
...                                       '2018-10-28 02:30:00',
...                                       '2018-10-28 03:00:00',
...                                       '2018-10-28 03:30:00']))
>>> s.tz_localize('CET', ambiguous='infer')
2018-10-28 01:30:00+02:00    0
2018-10-28 02:00:00+02:00    1
2018-10-28 02:30:00+02:00    2
2018-10-28 02:00:00+01:00    3
2018-10-28 02:30:00+01:00    4
2018-10-28 03:00:00+01:00    5
2018-10-28 03:30:00+01:00    6
dtype: int64 

在某些情况下，推断 DST 是不可能的。在这种情况下，您可以将一个 ndarray 传递给模糊参数，以明确设置 DST。

>>> s = pd.Series(range(3),
...               index=pd.DatetimeIndex(['2018-10-28 01:20:00',
...                                       '2018-10-28 02:36:00',
...                                       '2018-10-28 03:46:00']))
>>> s.tz_localize('CET', ambiguous=np.array([True, True, False]))
2018-10-28 01:20:00+02:00    0
2018-10-28 02:36:00+02:00    1
2018-10-28 03:46:00+01:00    2
dtype: int64 

如果 DST 转换导致不存在的时间，您可以使用 timedelta 对象或 'shift_forward' 或 'shift_backward' 将这些日期向前或向后移动。

>>> s = pd.Series(range(2),
...               index=pd.DatetimeIndex(['2015-03-29 02:30:00',
...                                       '2015-03-29 03:30:00']))
>>> s.tz_localize('Europe/Warsaw', nonexistent='shift_forward')
2015-03-29 03:00:00+02:00    0
2015-03-29 03:30:00+02:00    1
dtype: int64
>>> s.tz_localize('Europe/Warsaw', nonexistent='shift_backward')
2015-03-29 01:59:59.999999999+01:00    0
2015-03-29 03:30:00+02:00              1
dtype: int64
>>> s.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1h'))
2015-03-29 03:30:00+02:00    0
2015-03-29 03:30:00+02:00    1
dtype: int64 

pandas.Flags

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

class pandas.Flags(obj, *, allows_duplicate_labels)

适用于 pandas 对象的标志。

参数：

objSeries 或 DataFrame

与这些标志关联的对象。

allows_duplicate_labelsbool，默认为 True

是否允许此对象中存在重复标签。默认情况下，允许重复标签。将其设置为False将在索引（或 DataFrame 的列）不唯一时引发errors.DuplicateLabelError，或者在任何后续操作中引入重复标签时引发该错误。有关更多信息，请参阅禁止重复标签。

警告

这是一个实验性功能。目前，许多方法都未能传播allows_duplicate_labels值。在将来的版本中，预计每个接受或返回一个或多个 DataFrame 或 Series 对象的方法都将传播allows_duplicate_labels。

示例

属性可以通过两种方式设置：

>>> df = pd.DataFrame()
>>> df.flags
<Flags(allows_duplicate_labels=True)>
>>> df.flags.allows_duplicate_labels = False
>>> df.flags
<Flags(allows_duplicate_labels=False)> 

>>> df.flags['allows_duplicate_labels'] = True
>>> df.flags
<Flags(allows_duplicate_labels=True)> 

属性

allows_duplicate_labels	此对象是否允许重复标签。

方法

pandas.DataFrame.attrs

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

property DataFrame.attrs

此数据集的全局属性字典。

警告

attrs 是实验性的，可能会在没有警告的情况下更改。

另请参阅

DataFrame.flags

适用于此对象的全局标志。

注意

许多创建新数据集的操作都会复制 attrs。复制始终是深层的，因此更改 attrs 只会影响当前数据集。pandas.concat 仅在所有输入数据集具有相同 attrs 时才会复制 attrs。

示例

对于 Series：

>>> ser = pd.Series([1, 2, 3])
>>> ser.attrs = {"A": [10, 20, 30]}
>>> ser.attrs
{'A': [10, 20, 30]} 

对于 DataFrame：

>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> df.attrs = {"A": [10, 20, 30]}
>>> df.attrs
{'A': [10, 20, 30]} 

pandas.DataFrame.plot

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

DataFrame.plot(*args, **kwargs)

绘制 Series 或 DataFrame 的图。

使用由选项plotting.backend指定的后端。默认情况下使用 matplotlib。

参数：

数据Series 或 DataFrame

调用该方法的对象。

x标签或位置，默认为 None

仅在数据为 DataFrame 时使用。

y标签，位置或标签列表，默认为 None

允许绘制一列与另一列。仅在数据为 DataFrame 时使用。

类型str

要生成的图的类型：

• ‘line’：线图（默认）

• ‘bar’：垂直条形图

• ‘barh’：水平条形图

• ‘hist’：直方图

• ‘box’：箱线图

• ‘kde’：核密度估计图

• ‘density’：与‘kde’相同

• ‘area’：面积图

• ‘pie’：饼图

• ‘scatter’：散点图（仅 DataFrame）

• ‘hexbin’：六边形图（仅 DataFrame）

axmatplotlib 轴对象，默认为 None

当前图形的轴。

subplotsbool 或可迭代序列，默认为 False

是否将列分组为子图：

• False：不使用子图

• True：为每列创建单独的子图。

• 列标签的可迭代序列：为每组列创建一个子图。例如[(‘a’, ‘c’), (‘b’, ‘d’)]将创建 2 个子图：一个包含列‘a’和‘c’，另一个包含列‘b’和‘d’。未指定的剩余列将在额外的子图中绘制（每列一个）。

  版本 1.5.0 中的新功能。

sharexbool，默认为 True（如果 ax 为 None）否则为 False

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

shareybool，默认为 False

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

布局元组，可选

（行，列）用于子图布局。

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

图形对象的大小。

use_indexbool，默认为 True

使用索引作为 x 轴的刻度。

标题str 或列表

用于图的标题。如果传递了字符串，则在图的顶部打印字符串。如果传递了列表并且 subplots 为 True，则在相应子图的上方打印列表中的每个项目。

网格bool，默认为 None（matlab 风格默认）

轴网格线。

图例bool 或{‘reverse’}

将图例放置在轴子图上。

样式列表或字典

每列的 matplotlib 线样式。

logxbool 或‘sym’，默认为 False

在 x 轴上使用对数缩放或对数缩放。

logybool 或‘sym’默认为 False

在 y 轴上使用对数缩放或对数缩放。

loglogbool 或‘sym’，默认为 False

在 x 和 y 轴上同时使用对数缩放或对数缩放。

xticks序列

用于 xticks 的值。

yticks序列

用于 yticks 的值。

xlim2-元组/列表

设置当前轴的 x 限制。

ylim2-元组/列表

设置当前轴的 y 限制。

xlabel标签，可选

用于 x 轴上的 xlabel 的名称。默认使用索引名称作为 xlabel，或者对于平面图，使用 x 列名称。

在 2.0.0 版本中更改：现在适用于直方图。

ylabel标签，可选

用于 y 轴标签的名称。默认情况下不显示 y 轴标签，或者对于平面图，显示 y 列名称。

在 2.0.0 版本中更改：现在适用于直方图。

rot浮点数，默认为 None

刻度的旋转（垂直图的 xticks，水平图的 yticks）。

fontsize浮点数，默认为 None

xticks 和 yticks 的字体大小。

colormapstr 或 matplotlib 颜色图对象，默认为 None

从中选择颜色的颜色图。如果是字符串，则从 matplotlib 加载具有该名称的颜色图。

colorbarbool, optional

如果为 True，则绘制颜色条（仅适用于‘scatter’和‘hexbin’图）。

position浮点数

指定条形图布局的相对对齐。从 0（左/底部）到 1（右/顶部）。默认为 0.5（中心）。

tablebool，Series 或 DataFrame，默认为 False

如果为 True，则使用 DataFrame 中的数据绘制表，并且数据将被转置以满足 matplotlib 的默认布局。如果传递了 Series 或 DataFrame，则使用传递的数据绘制表。

yerrDataFrame，Series，类数组，字典和字符串

有关详细信息，请参阅带有误差条的绘图。

xerrDataFrame，Series，类数组，字典和字符串

等效于 yerr。

stackedbool，默认为线图和条形图中的 False，面积图中的 True

如果为 True，则创建堆叠图。

secondary_ybool 或序列，默认为 False

如果是列表/元组，则是否在辅助 y 轴上绘制，要在辅助 y 轴上绘制哪些列。

mark_rightbool，默认为 True

使用辅助 y 轴时，在图例中自动标记列标签为“(right)”。

include_boolbool，默认为 False

如果为 True，则可以绘制布尔值。

backendstr，默认为 None

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

**kwargs

传递给 matplotlib 绘图方法的选项。

返回：

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

如果后端不是默认的 matplotlib，则返回值将是后端返回的对象。

注意

• 有关此主题的更多信息，请在线查看 matplotlib 文档

• 如果 kind = ‘bar’或‘barh’，则可以通过 position 关键字指定条形图布局的相对对齐。从 0（左/底部）到 1（右/顶部）。默认为 0.5（中心）

示例

对于 Series：

>>> ser = pd.Series([1, 2, 3, 3])
>>> plot = ser.plot(kind='hist', title="My plot") 

对于 DataFrame：

>>> df = pd.DataFrame({'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'])
>>> plot = df.plot(title="DataFrame Plot") 

对于 SeriesGroupBy：

>>> lst = [-1, -2, -3, 1, 2, 3]
>>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)
>>> plot = ser.groupby(lambda x: x > 0).plot(title="SeriesGroupBy Plot") 

对于 DataFrameGroupBy：

>>> df = pd.DataFrame({"col1" : [1, 2, 3, 4],
...                   "col2" : ["A", "B", "A", "B"]})
>>> plot = df.groupby("col2").plot(kind="bar", title="DataFrameGroupBy Plot")