python——drop函数

函数定义：

​
def drop(
        self,
        labels=None,
        axis: Axis = 0,
        index=None,
        columns=None,
        level: Level | None = None,
        inplace: bool = False,
        errors: str = "raise",
    ):

注解：

 """
        Drop specified labels from rows or columns.

        Remove rows or columns by specifying label names and corresponding
        axis, or by specifying directly index or column names. When using a
        multi-index, labels on different levels can be removed by specifying
        the level. See the `user guide <advanced.shown_levels>`
        for more information about the now unused levels.

        Parameters
        ----------
        labels : single label or list-like
            Index or column labels to drop. A tuple will be used as a single
            label and not treated as a list-like.
        axis : {0 or 'index', 1 or 'columns'}, default 0
            Whether to drop labels from the index (0 or 'index') or
            columns (1 or 'columns').
        index : single label or list-like
            Alternative to specifying axis (``labels, axis=0``
            is equivalent to ``index=labels``).
        columns : single label or list-like
            Alternative to specifying axis (``labels, axis=1``
            is equivalent to ``columns=labels``).
        level : int or level name, optional
            For MultiIndex, level from which the labels will be removed.
        inplace : bool, default False
            If False, return a copy. Otherwise, do operation
            inplace and return None.
        errors : {'ignore', 'raise'}, default 'raise'
            If 'ignore', suppress error and only existing labels are
            dropped.

        Returns
        -------
        DataFrame or None
            DataFrame without the removed index or column labels or
            None if ``inplace=True``.

        Raises
        ------
        KeyError
            If any of the labels is not found in the selected axis.

        See Also
        --------
        DataFrame.loc : Label-location based indexer for selection by label.
        DataFrame.dropna : Return DataFrame with labels on given axis omitted
            where (all or any) data are missing.
        DataFrame.drop_duplicates : Return DataFrame with duplicate rows
            removed, optionally only considering certain columns.
        Series.drop : Return Series with specified index labels removed.

"""

从行或列中删除指定的标签。



通过指定标签名称和相应的

或者直接指定索引或列名。当使用

多索引、不同级别的标签可以通过指定

水平。请参阅“用户指南<高级”。显示的\u级别>`

有关现在未使用的级别的更多信息。



参数

----------

标签：单个标签或类似列表

要删除的索引或列标签。元组将用作单个

标签，而不是像列表一样处理。

轴：{0或'index'，1或'columns'，默认为0

是从索引（0或“索引”）中删除标签，还是

列（1或“列”）。

索引：单个标签或类似列表

指定轴的替代方法（`labels，axis=0）``

相当于``index=labels`）。

列：单个标签或类似列表

指定轴的替代方法（`labels，axis=1）``

相当于``columns=labels`）。

级别：int或级别名称，可选

对于多索引，将从中删除标签的级别。

原地：bool，默认为False

如果为False，请返回一份副本。否则，请执行操作

原地踏步，一无所获。

错误：{'ignore'，'raise'}，默认值为'raise'

如果为“忽略”，则抑制错误，并且仅显示现有标签

下降。



返回

-------

数据帧或无

没有移除索引或列标签的DataFrame或

如果“`inplace=True`”，则为无。



提高

------

键错误

如果在选定轴中找不到任何标签。



另见

--------

数据帧。loc：基于标签位置的索引器，用于按标签进行选择。

数据帧。dropna：返回给定轴上省略标签的数据帧

（全部或任何）数据缺失的地方。

数据帧。drop_duplicates：返回具有重复行的数据帧

删除，也可以仅考虑某些列。

系列删除：删除指定索引标签的返回序列。

 例子：

--------
        >>> df = pd.DataFrame(np.arange(12).reshape(3, 4),
        ...                   columns=['A', 'B', 'C', 'D'])
        >>> df
           A  B   C   D
        0  0  1   2   3
        1  4  5   6   7
        2  8  9  10  11

      Drop columns

        >>> df.drop(['B', 'C'], axis=1)
           A   D
        0  0   3
        1  4   7
        2  8  11

        >>> df.drop(columns=['B', 'C'])
           A   D
        0  0   3
        1  4   7
        2  8  11

      

  Drop a row by index

        >>> df.drop([0, 1])
           A  B   C   D
        2  8  9  10  11

        Drop columns and/or rows of MultiIndex DataFrame

        >>> midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'],
        ...                              ['speed', 'weight', 'length']],
        ...                      codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],
        ...                             [0, 1, 2, 0, 1, 2, 0, 1, 2]])
        >>> df = pd.DataFrame(index=midx, columns=['big', 'small'],
        ...                   data=[[45, 30], [200, 100], [1.5, 1], [30, 20],
        ...                         [250, 150], [1.5, 0.8], [320, 250],
        ...                         [1, 0.8], [0.3, 0.2]])
        >>> df
                        big     small
        lama    speed   45.0    30.0
                weight  200.0   100.0
                length  1.5     1.0
        cow     speed   30.0    20.0
                weight  250.0   150.0
                length  1.5     0.8
        falcon  speed   320.0   250.0
                weight  1.0     0.8
                length  0.3     0.2

        Drop a specific index combination from the MultiIndex
        DataFrame, i.e., drop the combination ``'falcon'`` and
        ``'weight'``, which deletes only the corresponding row

        >>> df.drop(index=('falcon', 'weight'))
                        big     small
        lama    speed   45.0    30.0
                weight  200.0   100.0
                length  1.5     1.0
        cow     speed   30.0    20.0
                weight  250.0   150.0
                length  1.5     0.8
        falcon  speed   320.0   250.0
                length  0.3     0.2

        >>> df.drop(index='cow', columns='small')
                        big
        lama    speed   45.0
                weight  200.0
                length  1.5
        falcon  speed   320.0
                weight  1.0
                length  0.3

        >>> df.drop(index='length', level=1)
                        big     small
        lama    speed   45.0    30.0
                weight  200.0   100.0
        cow     speed   30.0    20.0
                weight  250.0   150.0
        falcon  speed   320.0   250.0
                weight  1.0     0.8