pandas.CategoricalIndex.add_categories   CategoricalIndex.add_categories(*args, **kwargs)[source]

Add new categories. new_categories will be included at the last/highest place in the categories and will be unused directly after this call.  Parameters

new_categories:category or list-like of category

The new categories to be included.
inplace:bool, default False

Whether or not to add the categories inplace or return a copy of this categorical with added categories.  Deprecated since version 1.3.0.     Returns

cat:Categorical or None

Categorical with new categories added or None if inplace=True.    Raises
 ValueError

If the new categories include old categories or do not validate as categories      See also  rename_categories

Rename categories.  reorder_categories

Reorder categories.  remove_categories

Remove the specified categories.  remove_unused_categories

Remove categories which are not used.  set_categories

Set the categories to the specified ones.    Examples
>>> c = pd.Categorical(['c', 'b', 'c'])
>>> c
['c', 'b', 'c']
Categories (2, object): ['b', 'c']

>>> c.add_categories(['d', 'a'])
['c', 'b', 'c']
Categories (4, object): ['b', 'c', 'd', 'a']


pandas.CategoricalIndex.as_ordered   CategoricalIndex.as_ordered(*args, **kwargs)[source]

Set the Categorical to be ordered.  Parameters

inplace:bool, default False

Whether or not to set the ordered attribute in-place or return a copy of this categorical with ordered set to True.    Returns
 Categorical or None

Ordered Categorical or None if inplace=True.


pandas.CategoricalIndex.as_unordered   CategoricalIndex.as_unordered(*args, **kwargs)[source]

Set the Categorical to be unordered.  Parameters

inplace:bool, default False

Whether or not to set the ordered attribute in-place or return a copy of this categorical with ordered set to False.    Returns
 Categorical or None

Unordered Categorical or None if inplace=True.


pandas.CategoricalIndex.categories   propertyCategoricalIndex.categories

The categories of this categorical. Setting assigns new values to each category (effectively a rename of each individual category). The assigned value has to be a list-like object. All items must be unique and the number of items in the new categories must be the same as the number of items in the old categories. Assigning to categories is a inplace operation!  Raises
 ValueError

If the new categories do not validate as categories or if the number of new categories is unequal the number of old categories      See also  rename_categories

Rename categories.  reorder_categories

Reorder categories.  add_categories

Add new categories.  remove_categories

Remove the specified categories.  remove_unused_categories

Remove categories which are not used.  set_categories

Set the categories to the specified ones.


pandas.CategoricalIndex.codes   propertyCategoricalIndex.codes

The category codes of this categorical. Codes are an array of integers which are the positions of the actual values in the categories array. There is no setter, use the other categorical methods and the normal item setter to change values in the categorical.  Returns
 ndarray[int]

A non-writable view of the codes array.


pandas.CategoricalIndex.equals   CategoricalIndex.equals(other)[source]

Determine if two CategoricalIndex objects contain the same elements.  Returns
 bool

If two CategoricalIndex objects have equal elements True, otherwise False.


pandas.CategoricalIndex.map   CategoricalIndex.map(mapper)[source]

Map values using input an input mapping or function. Maps the values (their categories, not the codes) of the index to new categories. If the mapping correspondence is one-to-one the result is a CategoricalIndex which has the same order property as the original, otherwise an Index is returned. If a dict or Series is used any unmapped category is mapped to NaN. Note that if this happens an Index will be returned.  Parameters

mapper:function, dict, or Series

Mapping correspondence.    Returns
 pandas.CategoricalIndex or pandas.Index

Mapped index.      See also  Index.map

Apply a mapping correspondence on an Index.  Series.map

Apply a mapping correspondence on a Series.  Series.apply

Apply more complex functions on a Series.    Examples
>>> idx = pd.CategoricalIndex(['a', 'b', 'c'])
>>> idx
CategoricalIndex(['a', 'b', 'c'], categories=['a', 'b', 'c'],
                  ordered=False, dtype='category')
>>> idx.map(lambda x: x.upper())
CategoricalIndex(['A', 'B', 'C'], categories=['A', 'B', 'C'],
                 ordered=False, dtype='category')
>>> idx.map({'a': 'first', 'b': 'second', 'c': 'third'})
CategoricalIndex(['first', 'second', 'third'], categories=['first',
                 'second', 'third'], ordered=False, dtype='category')
  If the mapping is one-to-one the ordering of the categories is preserved:
>>> idx = pd.CategoricalIndex(['a', 'b', 'c'], ordered=True)
>>> idx
CategoricalIndex(['a', 'b', 'c'], categories=['a', 'b', 'c'],
                 ordered=True, dtype='category')
>>> idx.map({'a': 3, 'b': 2, 'c': 1})
CategoricalIndex([3, 2, 1], categories=[3, 2, 1], ordered=True,
                 dtype='category')
  If the mapping is not one-to-one an Index is returned:
>>> idx.map({'a': 'first', 'b': 'second', 'c': 'first'})
Index(['first', 'second', 'first'], dtype='object')
  If a dict is used, all unmapped categories are mapped to NaN and the result is an Index:
>>> idx.map({'a': 'first', 'b': 'second'})
Index(['first', 'second', nan], dtype='object')


pandas.CategoricalIndex.ordered   propertyCategoricalIndex.ordered

Whether the categories have an ordered relationship.


pandas.CategoricalIndex.remove_categories   CategoricalIndex.remove_categories(*args, **kwargs)[source]

Remove the specified categories. removals must be included in the old categories. Values which were in the removed categories will be set to NaN  Parameters

removals:category or list of categories

The categories which should be removed.
inplace:bool, default False

Whether or not to remove the categories inplace or return a copy of this categorical with removed categories.  Deprecated since version 1.3.0.     Returns

cat:Categorical or None

Categorical with removed categories or None if inplace=True.    Raises
 ValueError

If the removals are not contained in the categories      See also  rename_categories

Rename categories.  reorder_categories

Reorder categories.  add_categories

Add new categories.  remove_unused_categories

Remove categories which are not used.  set_categories

Set the categories to the specified ones.    Examples
>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
>>> c
['a', 'c', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']

>>> c.remove_categories(['d', 'a'])
[NaN, 'c', 'b', 'c', NaN]
Categories (2, object): ['b', 'c']


pandas.CategoricalIndex.remove_unused_categories   CategoricalIndex.remove_unused_categories(*args, **kwargs)[source]

Remove categories which are not used.  Parameters

inplace:bool, default False

Whether or not to drop unused categories inplace or return a copy of this categorical with unused categories dropped.  Deprecated since version 1.2.0.     Returns

cat:Categorical or None

Categorical with unused categories dropped or None if inplace=True.      See also  rename_categories

Rename categories.  reorder_categories

Reorder categories.  add_categories

Add new categories.  remove_categories

Remove the specified categories.  set_categories

Set the categories to the specified ones.    Examples
>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
>>> c
['a', 'c', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']

>>> c[2] = 'a'
>>> c[4] = 'c'
>>> c
['a', 'c', 'a', 'c', 'c']
Categories (4, object): ['a', 'b', 'c', 'd']

>>> c.remove_unused_categories()
['a', 'c', 'a', 'c', 'c']
Categories (2, object): ['a', 'c']


pandas.CategoricalIndex.rename_categories   CategoricalIndex.rename_categories(*args, **kwargs)[source]

Rename categories.  Parameters

new_categories:list-like, dict-like or callable

New categories which will replace old categories.  list-like: all items must be unique and the number of items in the new categories must match the existing number of categories. dict-like: specifies a mapping from old categories to new. Categories not contained in the mapping are passed through and extra categories in the mapping are ignored. callable : a callable that is called on all items in the old categories and whose return values comprise the new categories.
inplace:bool, default False

Whether or not to rename the categories inplace or return a copy of this categorical with renamed categories.  Deprecated since version 1.3.0.     Returns

cat:Categorical or None

Categorical with removed categories or None if inplace=True.    Raises
 ValueError

If new categories are list-like and do not have the same number of items than the current categories or do not validate as categories      See also  reorder_categories

Reorder categories.  add_categories

Add new categories.  remove_categories

Remove the specified categories.  remove_unused_categories

Remove categories which are not used.  set_categories

Set the categories to the specified ones.    Examples
>>> c = pd.Categorical(['a', 'a', 'b'])
>>> c.rename_categories([0, 1])
[0, 0, 1]
Categories (2, int64): [0, 1]
  For dict-like new_categories, extra keys are ignored and categories not in the dictionary are passed through
>>> c.rename_categories({'a': 'A', 'c': 'C'})
['A', 'A', 'b']
Categories (2, object): ['A', 'b']
  You may also provide a callable to create the new categories
>>> c.rename_categories(lambda x: x.upper())
['A', 'A', 'B']
Categories (2, object): ['A', 'B']


pandas.CategoricalIndex.reorder_categories   CategoricalIndex.reorder_categories(*args, **kwargs)[source]

Reorder categories as specified in new_categories. new_categories need to include all old categories and no new category items.  Parameters

new_categories:Index-like

The categories in new order.
ordered:bool, optional

Whether or not the categorical is treated as a ordered categorical. If not given, do not change the ordered information.
inplace:bool, default False

Whether or not to reorder the categories inplace or return a copy of this categorical with reordered categories.  Deprecated since version 1.3.0.     Returns

cat:Categorical or None

Categorical with removed categories or None if inplace=True.    Raises
 ValueError

If the new categories do not contain all old category items or any new ones      See also  rename_categories

Rename categories.  add_categories

Add new categories.  remove_categories

Remove the specified categories.  remove_unused_categories

Remove categories which are not used.  set_categories

Set the categories to the specified ones.


pandas.CategoricalIndex.set_categories   CategoricalIndex.set_categories(*args, **kwargs)[source]

Set the categories to the specified new_categories. new_categories can include new categories (which will result in unused categories) or remove old categories (which results in values set to NaN). If rename==True, the categories will simple be renamed (less or more items than in old categories will result in values set to NaN or in unused categories respectively). This method can be used to perform more than one action of adding, removing, and reordering simultaneously and is therefore faster than performing the individual steps via the more specialised methods. On the other hand this methods does not do checks (e.g., whether the old categories are included in the new categories on a reorder), which can result in surprising changes, for example when using special string dtypes, which does not considers a S1 string equal to a single char python string.  Parameters

new_categories:Index-like

The categories in new order.
ordered:bool, default False

Whether or not the categorical is treated as a ordered categorical. If not given, do not change the ordered information.
rename:bool, default False

Whether or not the new_categories should be considered as a rename of the old categories or as reordered categories.
inplace:bool, default False

Whether or not to reorder the categories in-place or return a copy of this categorical with reordered categories.  Deprecated since version 1.3.0.     Returns
 Categorical with reordered categories or None if inplace.
  Raises
 ValueError

If new_categories does not validate as categories      See also  rename_categories

Rename categories.  reorder_categories

Reorder categories.  add_categories

Add new categories.  remove_categories

Remove the specified categories.  remove_unused_categories

Remove categories which are not used.


pandas.concat   pandas.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)[source]

Concatenate pandas objects along a particular axis with optional set logic along the other axes. Can also add a layer of hierarchical indexing on the concatenation axis, which may be useful if the labels are the same (or overlapping) on the passed axis number.  Parameters

objs:a sequence or mapping of Series or DataFrame objects

If a mapping is passed, the sorted keys will be used as the keys argument, unless it is passed, in which case the values will be selected (see below). Any None objects will be dropped silently unless they are all None in which case a ValueError will be raised.
axis:{0/’index’, 1/’columns’}, default 0

The axis to concatenate along.
join:{‘inner’, ‘outer’}, default ‘outer’

How to handle indexes on other axis (or axes).
ignore_index:bool, default False

If True, do not use the index values along the concatenation axis. The resulting axis will be labeled 0, …, n - 1. This is useful if you are concatenating objects where the concatenation axis does not have meaningful indexing information. Note the index values on the other axes are still respected in the join.
keys:sequence, default None

If multiple levels passed, should contain tuples. Construct hierarchical index using the passed keys as the outermost level.
levels:list of sequences, default None

Specific levels (unique values) to use for constructing a MultiIndex. Otherwise they will be inferred from the keys.
names:list, default None

Names for the levels in the resulting hierarchical index.
verify_integrity:bool, default False

Check whether the new concatenated axis contains duplicates. This can be very expensive relative to the actual data concatenation.
sort:bool, default False

Sort non-concatenation axis if it is not already aligned when join is ‘outer’. This has no effect when join='inner', which already preserves the order of the non-concatenation axis.  Changed in version 1.0.0: Changed to not sort by default.
copy:bool, default True

If False, do not copy data unnecessarily.    Returns
 object, type of objs

When concatenating all Series along the index (axis=0), a Series is returned. When objs contains at least one DataFrame, a DataFrame is returned. When concatenating along the columns (axis=1), a DataFrame is returned.      See also  Series.append

Concatenate Series.  DataFrame.append

Concatenate DataFrames.  DataFrame.join

Join DataFrames using indexes.  DataFrame.merge

Merge DataFrames by indexes or columns.    Notes The keys, levels, and names arguments are all optional. A walkthrough of how this method fits in with other tools for combining pandas objects can be found here. Examples Combine two Series.
>>> s1 = pd.Series(['a', 'b'])
>>> s2 = pd.Series(['c', 'd'])
>>> pd.concat([s1, s2])
0    a
1    b
0    c
1    d
dtype: object
  Clear the existing index and reset it in the result by setting the ignore_index option to True.
>>> pd.concat([s1, s2], ignore_index=True)
0    a
1    b
2    c
3    d
dtype: object
  Add a hierarchical index at the outermost level of the data with the keys option.
>>> pd.concat([s1, s2], keys=['s1', 's2'])
s1  0    a
    1    b
s2  0    c
    1    d
dtype: object
  Label the index keys you create with the names option.
>>> pd.concat([s1, s2], keys=['s1', 's2'],
...           names=['Series name', 'Row ID'])
Series name  Row ID
s1           0         a
             1         b
s2           0         c
             1         d
dtype: object
  Combine two DataFrame objects with identical columns.
>>> df1 = pd.DataFrame([['a', 1], ['b', 2]],
...                    columns=['letter', 'number'])
>>> df1
  letter  number
0      a       1
1      b       2
>>> df2 = pd.DataFrame([['c', 3], ['d', 4]],
...                    columns=['letter', 'number'])
>>> df2
  letter  number
0      c       3
1      d       4
>>> pd.concat([df1, df2])
  letter  number
0      a       1
1      b       2
0      c       3
1      d       4
  Combine DataFrame objects with overlapping columns and return everything. Columns outside the intersection will be filled with NaN values.
>>> df3 = pd.DataFrame([['c', 3, 'cat'], ['d', 4, 'dog']],
...                    columns=['letter', 'number', 'animal'])
>>> df3
  letter  number animal
0      c       3    cat
1      d       4    dog
>>> pd.concat([df1, df3], sort=False)
  letter  number animal
0      a       1    NaN
1      b       2    NaN
0      c       3    cat
1      d       4    dog
  Combine DataFrame objects with overlapping columns and return only those that are shared by passing inner to the join keyword argument.
>>> pd.concat([df1, df3], join="inner")
  letter  number
0      a       1
1      b       2
0      c       3
1      d       4
  Combine DataFrame objects horizontally along the x axis by passing in axis=1.
>>> df4 = pd.DataFrame([['bird', 'polly'], ['monkey', 'george']],
...                    columns=['animal', 'name'])
>>> pd.concat([df1, df4], axis=1)
  letter  number  animal    name
0      a       1    bird   polly
1      b       2  monkey  george
  Prevent the result from including duplicate index values with the verify_integrity option.
>>> df5 = pd.DataFrame([1], index=['a'])
>>> df5
   0
a  1
>>> df6 = pd.DataFrame([2], index=['a'])
>>> df6
   0
a  2
>>> pd.concat([df5, df6], verify_integrity=True)
Traceback (most recent call last):
    ...
ValueError: Indexes have overlapping values: ['a']


pandas.core.groupby.DataFrameGroupBy.aggregate   DataFrameGroupBy.aggregate(func=None, *args, engine=None, engine_kwargs=None, **kwargs)[source]

Aggregate using one or more operations over the specified axis.  Parameters

func:function, str, list or dict

Function to use for aggregating the data. If a function, must either work when passed a DataFrame or when passed to DataFrame.apply. Accepted combinations are:  function string function name list of functions and/or function names, e.g. [np.sum, 'mean'] dict of axis labels -> functions, function names or list of such.  Can also accept a Numba JIT function with engine='numba' specified. Only passing a single function is supported with this engine. If the 'numba' engine is chosen, the function must be a user defined function with values and index as the first and second arguments respectively in the function signature. Each group’s index will be passed to the user defined function and optionally available for use.  Changed in version 1.1.0.   *args

Positional arguments to pass to func.
engine:str, default None

 'cython' : Runs the function through C-extensions from cython. 'numba' : Runs the function through JIT compiled code from numba. None : Defaults to 'cython' or globally setting compute.use_numba   New in version 1.1.0.
engine_kwargs:dict, default None

 For 'cython' engine, there are no accepted engine_kwargs For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False} and will be applied to the function   New in version 1.1.0.   **kwargs

Keyword arguments to be passed into func.    Returns
 DataFrame
    See also  DataFrame.groupby.apply

Apply function func group-wise and combine the results together.  DataFrame.groupby.transform

Aggregate using one or more operations over the specified axis.  DataFrame.aggregate

Transforms the Series on each group based on the given function.    Notes When using engine='numba', there will be no “fall back” behavior internally. The group data and group index will be passed as numpy arrays to the JITed user defined function, and no alternative execution attempts will be tried. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See Mutating with User Defined Function (UDF) methods for more details.  Changed in version 1.3.0: The resulting dtype will reflect the return value of the passed func, see the examples below.  Examples
>>> df = pd.DataFrame(
...     {
...         "A": [1, 1, 2, 2],
...         "B": [1, 2, 3, 4],
...         "C": [0.362838, 0.227877, 1.267767, -0.562860],
...     }
... )

>>> df
   A  B         C
0  1  1  0.362838
1  1  2  0.227877
2  2  3  1.267767
3  2  4 -0.562860
  The aggregation is for each column.
>>> df.groupby('A').agg('min')
   B         C
A
1  1  0.227877
2  3 -0.562860
  Multiple aggregations
>>> df.groupby('A').agg(['min', 'max'])
    B             C
  min max       min       max
A
1   1   2  0.227877  0.362838
2   3   4 -0.562860  1.267767
  Select a column for aggregation
>>> df.groupby('A').B.agg(['min', 'max'])
   min  max
A
1    1    2
2    3    4
  Different aggregations per column
>>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'})
    B             C
  min max       sum
A
1   1   2  0.590715
2   3   4  0.704907
  To control the output names with different aggregations per column, pandas supports “named aggregation”
>>> df.groupby("A").agg(
...     b_min=pd.NamedAgg(column="B", aggfunc="min"),
...     c_sum=pd.NamedAgg(column="C", aggfunc="sum"))
   b_min     c_sum
A
1      1  0.590715
2      3  0.704907
   The keywords are the output column names The values are tuples whose first element is the column to select and the second element is the aggregation to apply to that column. Pandas provides the pandas.NamedAgg namedtuple with the fields ['column', 'aggfunc'] to make it clearer what the arguments are. As usual, the aggregation can be a callable or a string alias.  See Named aggregation for more.  Changed in version 1.3.0: The resulting dtype will reflect the return value of the aggregating function.
>>> df.groupby("A")[["B"]].agg(lambda x: x.astype(float).min())
      B
A
1   1.0
2   3.0


pandas.core.groupby.DataFrameGroupBy.all   DataFrameGroupBy.all(skipna=True)[source]

Return True if all values in the group are truthful, else False.  Parameters

skipna:bool, default True

Flag to ignore nan values during truth testing.    Returns
 Series or DataFrame

DataFrame or Series of boolean values, where a value is True if all elements are True within its respective group, False otherwise.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.any   DataFrameGroupBy.any(skipna=True)[source]

Return True if any value in the group is truthful, else False.  Parameters

skipna:bool, default True

Flag to ignore nan values during truth testing.    Returns
 Series or DataFrame

DataFrame or Series of boolean values, where a value is True if any element is True within its respective group, False otherwise.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.backfill   DataFrameGroupBy.backfill(limit=None)[source]

Backward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.bfill

Backward fill the missing values in the dataset.  DataFrame.bfill

Backward fill the missing values in the dataset.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.bfill   DataFrameGroupBy.bfill(limit=None)[source]

Backward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.bfill

Backward fill the missing values in the dataset.  DataFrame.bfill

Backward fill the missing values in the dataset.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.boxplot   DataFrameGroupBy.boxplot(subplots=True, column=None, fontsize=None, rot=0, grid=True, ax=None, figsize=None, layout=None, sharex=False, sharey=True, backend=None, **kwargs)[source]

Make box plots from DataFrameGroupBy data.  Parameters

grouped:Grouped DataFrame

subplots:bool

 False - no subplots will be used True - create a subplot for each group.
column:column name or list of names, or vector

Can be any valid input to groupby.
fontsize:int or str

rot:label rotation angle

grid:Setting this to True will show the grid

ax:Matplotlib axis object, default None

figsize:A tuple (width, height) in inches

layout:tuple (optional)

The layout of the plot: (rows, columns).
sharex:bool, default False

Whether x-axes will be shared among subplots.
sharey:bool, default True

Whether y-axes will be shared among subplots.
backend:str, default None

Backend to use instead of the backend specified in the option plotting.backend. For instance, ‘matplotlib’. Alternatively, to specify the plotting.backend for the whole session, set pd.options.plotting.backend.  New in version 1.0.0.   **kwargs

All other plotting keyword arguments to be passed to matplotlib’s boxplot function.    Returns
 dict of key/value = group key/DataFrame.boxplot return value
or DataFrame.boxplot return value in case subplots=figures=False
   Examples You can create boxplots for grouped data and show them as separate subplots:
>>> import itertools
>>> tuples = [t for t in itertools.product(range(1000), range(4))]
>>> index = pd.MultiIndex.from_tuples(tuples, names=['lvl0', 'lvl1'])
>>> data = np.random.randn(len(index),4)
>>> df = pd.DataFrame(data, columns=list('ABCD'), index=index)
>>> grouped = df.groupby(level='lvl1')
>>> grouped.boxplot(rot=45, fontsize=12, figsize=(8,10))
     The subplots=False option shows the boxplots in a single figure.
>>> grouped.boxplot(subplots=False, rot=45, fontsize=12)


pandas.core.groupby.DataFrameGroupBy.corr   propertyDataFrameGroupBy.corr

Compute pairwise correlation of columns, excluding NA/null values.  Parameters

method:{‘pearson’, ‘kendall’, ‘spearman’} or callable

Method of correlation:  pearson : standard correlation coefficient kendall : Kendall Tau correlation coefficient spearman : Spearman rank correlation
 callable: callable with input two 1d ndarrays

and returning a float. Note that the returned matrix from corr will have 1 along the diagonals and will be symmetric regardless of the callable’s behavior.
min_periods:int, optional

Minimum number of observations required per pair of columns to have a valid result. Currently only available for Pearson and Spearman correlation.    Returns
 DataFrame

Correlation matrix.      See also  DataFrame.corrwith

Compute pairwise correlation with another DataFrame or Series.  Series.corr

Compute the correlation between two Series.    Examples
>>> def histogram_intersection(a, b):
...     v = np.minimum(a, b).sum().round(decimals=1)
...     return v
>>> df = pd.DataFrame([(.2, .3), (.0, .6), (.6, .0), (.2, .1)],
...                   columns=['dogs', 'cats'])
>>> df.corr(method=histogram_intersection)
      dogs  cats
dogs   1.0   0.3
cats   0.3   1.0


pandas.core.groupby.DataFrameGroupBy.corrwith   propertyDataFrameGroupBy.corrwith

Compute pairwise correlation. Pairwise correlation is computed between rows or columns of DataFrame with rows or columns of Series or DataFrame. DataFrames are first aligned along both axes before computing the correlations.  Parameters

other:DataFrame, Series

Object with which to compute correlations.
axis:{0 or ‘index’, 1 or ‘columns’}, default 0

The axis to use. 0 or ‘index’ to compute column-wise, 1 or ‘columns’ for row-wise.
drop:bool, default False

Drop missing indices from result.
method:{‘pearson’, ‘kendall’, ‘spearman’} or callable

Method of correlation:  pearson : standard correlation coefficient kendall : Kendall Tau correlation coefficient spearman : Spearman rank correlation
 callable: callable with input two 1d ndarrays

and returning a float.        Returns
 Series

Pairwise correlations.      See also  DataFrame.corr

Compute pairwise correlation of columns.


pandas.core.groupby.DataFrameGroupBy.count   DataFrameGroupBy.count()[source]

Compute count of group, excluding missing values.  Returns
 Series or DataFrame

Count of values within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.cov   propertyDataFrameGroupBy.cov

Compute pairwise covariance of columns, excluding NA/null values. Compute the pairwise covariance among the series of a DataFrame. The returned data frame is the covariance matrix of the columns of the DataFrame. Both NA and null values are automatically excluded from the calculation. (See the note below about bias from missing values.) A threshold can be set for the minimum number of observations for each value created. Comparisons with observations below this threshold will be returned as NaN. This method is generally used for the analysis of time series data to understand the relationship between different measures across time.  Parameters

min_periods:int, optional

Minimum number of observations required per pair of columns to have a valid result.
ddof:int, default 1

Delta degrees of freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  New in version 1.1.0.     Returns
 DataFrame

The covariance matrix of the series of the DataFrame.      See also  Series.cov

Compute covariance with another Series.  core.window.ExponentialMovingWindow.cov

Exponential weighted sample covariance.  core.window.Expanding.cov

Expanding sample covariance.  core.window.Rolling.cov

Rolling sample covariance.    Notes Returns the covariance matrix of the DataFrame’s time series. The covariance is normalized by N-ddof. For DataFrames that have Series that are missing data (assuming that data is missing at random) the returned covariance matrix will be an unbiased estimate of the variance and covariance between the member Series. However, for many applications this estimate may not be acceptable because the estimate covariance matrix is not guaranteed to be positive semi-definite. This could lead to estimate correlations having absolute values which are greater than one, and/or a non-invertible covariance matrix. See Estimation of covariance matrices for more details. Examples
>>> df = pd.DataFrame([(1, 2), (0, 3), (2, 0), (1, 1)],
...                   columns=['dogs', 'cats'])
>>> df.cov()
          dogs      cats
dogs  0.666667 -1.000000
cats -1.000000  1.666667

>>> np.random.seed(42)
>>> df = pd.DataFrame(np.random.randn(1000, 5),
...                   columns=['a', 'b', 'c', 'd', 'e'])
>>> df.cov()
          a         b         c         d         e
a  0.998438 -0.020161  0.059277 -0.008943  0.014144
b -0.020161  1.059352 -0.008543 -0.024738  0.009826
c  0.059277 -0.008543  1.010670 -0.001486 -0.000271
d -0.008943 -0.024738 -0.001486  0.921297 -0.013692
e  0.014144  0.009826 -0.000271 -0.013692  0.977795
  Minimum number of periods This method also supports an optional min_periods keyword that specifies the required minimum number of non-NA observations for each column pair in order to have a valid result:
>>> np.random.seed(42)
>>> df = pd.DataFrame(np.random.randn(20, 3),
...                   columns=['a', 'b', 'c'])
>>> df.loc[df.index[:5], 'a'] = np.nan
>>> df.loc[df.index[5:10], 'b'] = np.nan
>>> df.cov(min_periods=12)
          a         b         c
a  0.316741       NaN -0.150812
b       NaN  1.248003  0.191417
c -0.150812  0.191417  0.895202


pandas.core.groupby.DataFrameGroupBy.cumcount   DataFrameGroupBy.cumcount(ascending=True)[source]

Number each item in each group from 0 to the length of that group - 1. Essentially this is equivalent to
self.apply(lambda x: pd.Series(np.arange(len(x)), x.index))
   Parameters

ascending:bool, default True

If False, number in reverse, from length of group - 1 to 0.    Returns
 Series

Sequence number of each element within each group.      See also  ngroup

Number the groups themselves.    Examples
>>> df = pd.DataFrame([['a'], ['a'], ['a'], ['b'], ['b'], ['a']],
...                   columns=['A'])
>>> df
   A
0  a
1  a
2  a
3  b
4  b
5  a
>>> df.groupby('A').cumcount()
0    0
1    1
2    2
3    0
4    1
5    3
dtype: int64
>>> df.groupby('A').cumcount(ascending=False)
0    3
1    2
2    1
3    1
4    0
5    0
dtype: int64


pandas.core.groupby.DataFrameGroupBy.cummax   DataFrameGroupBy.cummax(axis=0, **kwargs)[source]

Cumulative max for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.cummin   DataFrameGroupBy.cummin(axis=0, **kwargs)[source]

Cumulative min for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.cumprod   DataFrameGroupBy.cumprod(axis=0, *args, **kwargs)[source]

Cumulative product for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.cumsum   DataFrameGroupBy.cumsum(axis=0, *args, **kwargs)[source]

Cumulative sum for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.describe   DataFrameGroupBy.describe(**kwargs)[source]

Generate descriptive statistics. Descriptive statistics include those that summarize the central tendency, dispersion and shape of a dataset’s distribution, excluding NaN values. Analyzes both numeric and object series, as well as DataFrame column sets of mixed data types. The output will vary depending on what is provided. Refer to the notes below for more detail.  Parameters

percentiles:list-like of numbers, optional

The percentiles to include in the output. All should fall between 0 and 1. The default is [.25, .5, .75], which returns the 25th, 50th, and 75th percentiles.
include:‘all’, list-like of dtypes or None (default), optional

A white list of data types to include in the result. Ignored for Series. Here are the options:  ‘all’ : All columns of the input will be included in the output. A list-like of dtypes : Limits the results to the provided data types. To limit the result to numeric types submit numpy.number. To limit it instead to object columns submit the numpy.object data type. Strings can also be used in the style of select_dtypes (e.g. df.describe(include=['O'])). To select pandas categorical columns, use 'category' None (default) : The result will include all numeric columns.
exclude:list-like of dtypes or None (default), optional,

A black list of data types to omit from the result. Ignored for Series. Here are the options:  A list-like of dtypes : Excludes the provided data types from the result. To exclude numeric types submit numpy.number. To exclude object columns submit the data type numpy.object. Strings can also be used in the style of select_dtypes (e.g. df.describe(exclude=['O'])). To exclude pandas categorical columns, use 'category' None (default) : The result will exclude nothing.
datetime_is_numeric:bool, default False

Whether to treat datetime dtypes as numeric. This affects statistics calculated for the column. For DataFrame input, this also controls whether datetime columns are included by default.  New in version 1.1.0.     Returns
 Series or DataFrame

Summary statistics of the Series or Dataframe provided.      See also  DataFrame.count

Count number of non-NA/null observations.  DataFrame.max

Maximum of the values in the object.  DataFrame.min

Minimum of the values in the object.  DataFrame.mean

Mean of the values.  DataFrame.std

Standard deviation of the observations.  DataFrame.select_dtypes

Subset of a DataFrame including/excluding columns based on their dtype.    Notes For numeric data, the result’s index will include count, mean, std, min, max as well as lower, 50 and upper percentiles. By default the lower percentile is 25 and the upper percentile is 75. The 50 percentile is the same as the median. For object data (e.g. strings or timestamps), the result’s index will include count, unique, top, and freq. The top is the most common value. The freq is the most common value’s frequency. Timestamps also include the first and last items. If multiple object values have the highest count, then the count and top results will be arbitrarily chosen from among those with the highest count. For mixed data types provided via a DataFrame, the default is to return only an analysis of numeric columns. If the dataframe consists only of object and categorical data without any numeric columns, the default is to return an analysis of both the object and categorical columns. If include='all' is provided as an option, the result will include a union of attributes of each type. The include and exclude parameters can be used to limit which columns in a DataFrame are analyzed for the output. The parameters are ignored when analyzing a Series. Examples Describing a numeric Series.
>>> s = pd.Series([1, 2, 3])
>>> s.describe()
count    3.0
mean     2.0
std      1.0
min      1.0
25%      1.5
50%      2.0
75%      2.5
max      3.0
dtype: float64
  Describing a categorical Series.
>>> s = pd.Series(['a', 'a', 'b', 'c'])
>>> s.describe()
count     4
unique    3
top       a
freq      2
dtype: object
  Describing a timestamp Series.
>>> s = pd.Series([
...   np.datetime64("2000-01-01"),
...   np.datetime64("2010-01-01"),
...   np.datetime64("2010-01-01")
... ])
>>> s.describe(datetime_is_numeric=True)
count                      3
mean     2006-09-01 08:00:00
min      2000-01-01 00:00:00
25%      2004-12-31 12:00:00
50%      2010-01-01 00:00:00
75%      2010-01-01 00:00:00
max      2010-01-01 00:00:00
dtype: object
  Describing a DataFrame. By default only numeric fields are returned.
>>> df = pd.DataFrame({'categorical': pd.Categorical(['d','e','f']),
...                    'numeric': [1, 2, 3],
...                    'object': ['a', 'b', 'c']
...                   })
>>> df.describe()
       numeric
count      3.0
mean       2.0
std        1.0
min        1.0
25%        1.5
50%        2.0
75%        2.5
max        3.0
  Describing all columns of a DataFrame regardless of data type.
>>> df.describe(include='all')
       categorical  numeric object
count            3      3.0      3
unique           3      NaN      3
top              f      NaN      a
freq             1      NaN      1
mean           NaN      2.0    NaN
std            NaN      1.0    NaN
min            NaN      1.0    NaN
25%            NaN      1.5    NaN
50%            NaN      2.0    NaN
75%            NaN      2.5    NaN
max            NaN      3.0    NaN
  Describing a column from a DataFrame by accessing it as an attribute.
>>> df.numeric.describe()
count    3.0
mean     2.0
std      1.0
min      1.0
25%      1.5
50%      2.0
75%      2.5
max      3.0
Name: numeric, dtype: float64
  Including only numeric columns in a DataFrame description.
>>> df.describe(include=[np.number])
       numeric
count      3.0
mean       2.0
std        1.0
min        1.0
25%        1.5
50%        2.0
75%        2.5
max        3.0
  Including only string columns in a DataFrame description.
>>> df.describe(include=[object])
       object
count       3
unique      3
top         a
freq        1
  Including only categorical columns from a DataFrame description.
>>> df.describe(include=['category'])
       categorical
count            3
unique           3
top              d
freq             1
  Excluding numeric columns from a DataFrame description.
>>> df.describe(exclude=[np.number])
       categorical object
count            3      3
unique           3      3
top              f      a
freq             1      1
  Excluding object columns from a DataFrame description.
>>> df.describe(exclude=[object])
       categorical  numeric
count            3      3.0
unique           3      NaN
top              f      NaN
freq             1      NaN
mean           NaN      2.0
std            NaN      1.0
min            NaN      1.0
25%            NaN      1.5
50%            NaN      2.0
75%            NaN      2.5
max            NaN      3.0


pandas.core.groupby.DataFrameGroupBy.diff   propertyDataFrameGroupBy.diff

First discrete difference of element. Calculates the difference of a Dataframe element compared with another element in the Dataframe (default is element in previous row).  Parameters

periods:int, default 1

Periods to shift for calculating difference, accepts negative values.
axis:{0 or ‘index’, 1 or ‘columns’}, default 0

Take difference over rows (0) or columns (1).    Returns
 Dataframe

First differences of the Series.      See also  Dataframe.pct_change

Percent change over given number of periods.  Dataframe.shift

Shift index by desired number of periods with an optional time freq.  Series.diff

First discrete difference of object.    Notes For boolean dtypes, this uses operator.xor() rather than operator.sub(). The result is calculated according to current dtype in Dataframe, however dtype of the result is always float64. Examples Difference with previous row
>>> df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6],
...                    'b': [1, 1, 2, 3, 5, 8],
...                    'c': [1, 4, 9, 16, 25, 36]})
>>> df
   a  b   c
0  1  1   1
1  2  1   4
2  3  2   9
3  4  3  16
4  5  5  25
5  6  8  36

>>> df.diff()
     a    b     c
0  NaN  NaN   NaN
1  1.0  0.0   3.0
2  1.0  1.0   5.0
3  1.0  1.0   7.0
4  1.0  2.0   9.0
5  1.0  3.0  11.0
  Difference with previous column
>>> df.diff(axis=1)
    a  b   c
0 NaN  0   0
1 NaN -1   3
2 NaN -1   7
3 NaN -1  13
4 NaN  0  20
5 NaN  2  28
  Difference with 3rd previous row
>>> df.diff(periods=3)
     a    b     c
0  NaN  NaN   NaN
1  NaN  NaN   NaN
2  NaN  NaN   NaN
3  3.0  2.0  15.0
4  3.0  4.0  21.0
5  3.0  6.0  27.0
  Difference with following row
>>> df.diff(periods=-1)
     a    b     c
0 -1.0  0.0  -3.0
1 -1.0 -1.0  -5.0
2 -1.0 -1.0  -7.0
3 -1.0 -2.0  -9.0
4 -1.0 -3.0 -11.0
5  NaN  NaN   NaN
  Overflow in input dtype
>>> df = pd.DataFrame({'a': [1, 0]}, dtype=np.uint8)
>>> df.diff()
       a
0    NaN
1  255.0


pandas.core.groupby.DataFrameGroupBy.ffill   DataFrameGroupBy.ffill(limit=None)[source]

Forward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.ffill

Returns Series with minimum number of char in object.  DataFrame.ffill

Object with missing values filled or None if inplace=True.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.fillna   propertyDataFrameGroupBy.fillna

Fill NA/NaN values using the specified method.  Parameters

value:scalar, dict, Series, or DataFrame

Value to use to fill holes (e.g. 0), alternately a dict/Series/DataFrame of values specifying which value to use for each index (for a Series) or column (for a DataFrame). Values not in the dict/Series/DataFrame will not be filled. This value cannot be a list.
method:{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, default None

Method to use for filling holes in reindexed Series pad / ffill: propagate last valid observation forward to next valid backfill / bfill: use next valid observation to fill gap.
axis:{0 or ‘index’, 1 or ‘columns’}

Axis along which to fill missing values.
inplace:bool, default False

If True, fill in-place. Note: this will modify any other views on this object (e.g., a no-copy slice for a column in a DataFrame).
limit:int, default None

If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None.
downcast:dict, default is None

A dict of item->dtype of what to downcast if possible, or the string ‘infer’ which will try to downcast to an appropriate equal type (e.g. float64 to int64 if possible).    Returns
 DataFrame or None

Object with missing values filled or None if inplace=True.      See also  interpolate

Fill NaN values using interpolation.  reindex

Conform object to new index.  asfreq

Convert TimeSeries to specified frequency.    Examples
>>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],
...                    [3, 4, np.nan, 1],
...                    [np.nan, np.nan, np.nan, np.nan],
...                    [np.nan, 3, np.nan, 4]],
...                   columns=list("ABCD"))
>>> df
     A    B   C    D
0  NaN  2.0 NaN  0.0
1  3.0  4.0 NaN  1.0
2  NaN  NaN NaN  NaN
3  NaN  3.0 NaN  4.0
  Replace all NaN elements with 0s.
>>> df.fillna(0)
     A    B    C    D
0  0.0  2.0  0.0  0.0
1  3.0  4.0  0.0  1.0
2  0.0  0.0  0.0  0.0
3  0.0  3.0  0.0  4.0
  We can also propagate non-null values forward or backward.
>>> df.fillna(method="ffill")
     A    B   C    D
0  NaN  2.0 NaN  0.0
1  3.0  4.0 NaN  1.0
2  3.0  4.0 NaN  1.0
3  3.0  3.0 NaN  4.0
  Replace all NaN elements in column ‘A’, ‘B’, ‘C’, and ‘D’, with 0, 1, 2, and 3 respectively.
>>> values = {"A": 0, "B": 1, "C": 2, "D": 3}
>>> df.fillna(value=values)
     A    B    C    D
0  0.0  2.0  2.0  0.0
1  3.0  4.0  2.0  1.0
2  0.0  1.0  2.0  3.0
3  0.0  3.0  2.0  4.0
  Only replace the first NaN element.
>>> df.fillna(value=values, limit=1)
     A    B    C    D
0  0.0  2.0  2.0  0.0
1  3.0  4.0  NaN  1.0
2  NaN  1.0  NaN  3.0
3  NaN  3.0  NaN  4.0
  When filling using a DataFrame, replacement happens along the same column names and same indices
>>> df2 = pd.DataFrame(np.zeros((4, 4)), columns=list("ABCE"))
>>> df.fillna(df2)
     A    B    C    D
0  0.0  2.0  0.0  0.0
1  3.0  4.0  0.0  1.0
2  0.0  0.0  0.0  NaN
3  0.0  3.0  0.0  4.0
  Note that column D is not affected since it is not present in df2.


pandas.core.groupby.DataFrameGroupBy.filter   DataFrameGroupBy.filter(func, dropna=True, *args, **kwargs)[source]

Return a copy of a DataFrame excluding filtered elements. Elements from groups are filtered if they do not satisfy the boolean criterion specified by func.  Parameters

func:function

Function to apply to each subframe. Should return True or False.
dropna:Drop groups that do not pass the filter. True by default;

If False, groups that evaluate False are filled with NaNs.    Returns

filtered:DataFrame

   Notes Each subframe is endowed the attribute ‘name’ in case you need to know which group you are working on. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See Mutating with User Defined Function (UDF) methods for more details. Examples
>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
...                           'foo', 'bar'],
...                    'B' : [1, 2, 3, 4, 5, 6],
...                    'C' : [2.0, 5., 8., 1., 2., 9.]})
>>> grouped = df.groupby('A')
>>> grouped.filter(lambda x: x['B'].mean() > 3.)
     A  B    C
1  bar  2  5.0
3  bar  4  1.0
5  bar  6  9.0


pandas.core.groupby.DataFrameGroupBy.hist   propertyDataFrameGroupBy.hist

Make a histogram of the DataFrame’s columns. A histogram is a representation of the distribution of data. This function calls matplotlib.pyplot.hist(), on each series in the DataFrame, resulting in one histogram per column.  Parameters

data:DataFrame

The pandas object holding the data.
column:str or sequence, optional

If passed, will be used to limit data to a subset of columns.
by:object, optional

If passed, then used to form histograms for separate groups.
grid:bool, default True

Whether to show axis grid lines.
xlabelsize:int, default None

If specified changes the x-axis label size.
xrot:float, default None

Rotation of x axis labels. For example, a value of 90 displays the x labels rotated 90 degrees clockwise.
ylabelsize:int, default None

If specified changes the y-axis label size.
yrot:float, default None

Rotation of y axis labels. For example, a value of 90 displays the y labels rotated 90 degrees clockwise.
ax:Matplotlib axes object, default None

The axes to plot the histogram on.
sharex:bool, default True if ax is None else False

In case subplots=True, share x axis and set some x axis labels to invisible; defaults to True if ax is None otherwise False if an ax is passed in. Note that passing in both an ax and sharex=True will alter all x axis labels for all subplots in a figure.
sharey:bool, default False

In case subplots=True, share y axis and set some y axis labels to invisible.
figsize:tuple, optional

The size in inches of the figure to create. Uses the value in matplotlib.rcParams by default.
layout:tuple, optional

Tuple of (rows, columns) for the layout of the histograms.
bins:int or sequence, default 10

Number of histogram bins to be used. If an integer is given, bins + 1 bin edges are calculated and returned. If bins is a sequence, gives bin edges, including left edge of first bin and right edge of last bin. In this case, bins is returned unmodified.
backend:str, default None

Backend to use instead of the backend specified in the option plotting.backend. For instance, ‘matplotlib’. Alternatively, to specify the plotting.backend for the whole session, set pd.options.plotting.backend.  New in version 1.0.0.
legend:bool, default False

Whether to show the legend.  New in version 1.1.0.   **kwargs

All other plotting keyword arguments to be passed to matplotlib.pyplot.hist().    Returns
 matplotlib.AxesSubplot or numpy.ndarray of them
    See also  matplotlib.pyplot.hist

Plot a histogram using matplotlib.    Examples This example draws a histogram based on the length and width of some animals, displayed in three bins
>>> 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'])
>>> hist = df.hist(bins=3)


pandas.core.groupby.DataFrameGroupBy.idxmax   DataFrameGroupBy.idxmax(axis=0, skipna=True)[source]

Return index of first occurrence of maximum over requested axis. NA/null values are excluded.  Parameters

axis:{0 or ‘index’, 1 or ‘columns’}, default 0

The axis to use. 0 or ‘index’ for row-wise, 1 or ‘columns’ for column-wise.
skipna:bool, default True

Exclude NA/null values. If an entire row/column is NA, the result will be NA.    Returns
 Series

Indexes of maxima along the specified axis.    Raises
 ValueError

 If the row/column is empty       See also  Series.idxmax

Return index of the maximum element.    Notes This method is the DataFrame version of ndarray.argmax. Examples Consider a dataset containing food consumption in Argentina.
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
...                    'co2_emissions': [37.2, 19.66, 1712]},
...                    index=['Pork', 'Wheat Products', 'Beef'])

>>> df
                consumption  co2_emissions
Pork                  10.51         37.20
Wheat Products       103.11         19.66
Beef                  55.48       1712.00
  By default, it returns the index for the maximum value in each column.
>>> df.idxmax()
consumption     Wheat Products
co2_emissions             Beef
dtype: object
  To return the index for the maximum value in each row, use axis="columns".
>>> df.idxmax(axis="columns")
Pork              co2_emissions
Wheat Products     consumption
Beef              co2_emissions
dtype: object


pandas.core.groupby.DataFrameGroupBy.idxmin   DataFrameGroupBy.idxmin(axis=0, skipna=True)[source]

Return index of first occurrence of minimum over requested axis. NA/null values are excluded.  Parameters

axis:{0 or ‘index’, 1 or ‘columns’}, default 0

The axis to use. 0 or ‘index’ for row-wise, 1 or ‘columns’ for column-wise.
skipna:bool, default True

Exclude NA/null values. If an entire row/column is NA, the result will be NA.    Returns
 Series

Indexes of minima along the specified axis.    Raises
 ValueError

 If the row/column is empty       See also  Series.idxmin

Return index of the minimum element.    Notes This method is the DataFrame version of ndarray.argmin. Examples Consider a dataset containing food consumption in Argentina.
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
...                    'co2_emissions': [37.2, 19.66, 1712]},
...                    index=['Pork', 'Wheat Products', 'Beef'])

>>> df
                consumption  co2_emissions
Pork                  10.51         37.20
Wheat Products       103.11         19.66
Beef                  55.48       1712.00
  By default, it returns the index for the minimum value in each column.
>>> df.idxmin()
consumption                Pork
co2_emissions    Wheat Products
dtype: object
  To return the index for the minimum value in each row, use axis="columns".
>>> df.idxmin(axis="columns")
Pork                consumption
Wheat Products    co2_emissions
Beef                consumption
dtype: object


pandas.core.groupby.DataFrameGroupBy.mad   propertyDataFrameGroupBy.mad

Return the mean absolute deviation of the values over the requested axis.  Parameters

axis:{index (0), columns (1)}

Axis for the function to be applied on.
skipna:bool, default True

Exclude NA/null values when computing the result.
level:int or level name, default None

If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.    Returns
 Series or DataFrame (if level specified)


pandas.core.groupby.DataFrameGroupBy.nunique   DataFrameGroupBy.nunique(dropna=True)[source]

Return DataFrame with counts of unique elements in each position.  Parameters

dropna:bool, default True

Don’t include NaN in the counts.    Returns
 nunique: DataFrame
   Examples
>>> df = pd.DataFrame({'id': ['spam', 'egg', 'egg', 'spam',
...                           'ham', 'ham'],
...                    'value1': [1, 5, 5, 2, 5, 5],
...                    'value2': list('abbaxy')})
>>> df
     id  value1 value2
0  spam       1      a
1   egg       5      b
2   egg       5      b
3  spam       2      a
4   ham       5      x
5   ham       5      y

>>> df.groupby('id').nunique()
      value1  value2
id
egg        1       1
ham        1       2
spam       2       1
  Check for rows with the same id but conflicting values:
>>> df.groupby('id').filter(lambda g: (g.nunique() > 1).any())
     id  value1 value2
0  spam       1      a
3  spam       2      a
4   ham       5      x
5   ham       5      y


pandas.core.groupby.DataFrameGroupBy.pad   DataFrameGroupBy.pad(limit=None)[source]

Forward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.ffill

Returns Series with minimum number of char in object.  DataFrame.ffill

Object with missing values filled or None if inplace=True.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.pct_change   DataFrameGroupBy.pct_change(periods=1, fill_method='ffill', limit=None, freq=None, axis=0)[source]

Calculate pct_change of each value to previous entry in group.  Returns
 Series or DataFrame

Percentage changes within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.plot   propertyDataFrameGroupBy.plot

Class implementing the .plot attribute for groupby objects.


pandas.core.groupby.DataFrameGroupBy.quantile   DataFrameGroupBy.quantile(q=0.5, interpolation='linear')[source]

Return group values at the given quantile, a la numpy.percentile.  Parameters

q:float or array-like, default 0.5 (50% quantile)

Value(s) between 0 and 1 providing the quantile(s) to compute.
interpolation:{‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}

Method to use when the desired quantile falls between two points.    Returns
 Series or DataFrame

Return type determined by caller of GroupBy object.      See also  Series.quantile

Similar method for Series.  DataFrame.quantile

Similar method for DataFrame.  numpy.percentile

NumPy method to compute qth percentile.    Examples
>>> df = pd.DataFrame([
...     ['a', 1], ['a', 2], ['a', 3],
...     ['b', 1], ['b', 3], ['b', 5]
... ], columns=['key', 'val'])
>>> df.groupby('key').quantile()
    val
key
a    2.0
b    3.0


pandas.core.groupby.DataFrameGroupBy.rank   DataFrameGroupBy.rank(method='average', ascending=True, na_option='keep', pct=False, axis=0)[source]

Provide the rank of values within each group.  Parameters

method:{‘average’, ‘min’, ‘max’, ‘first’, ‘dense’}, default ‘average’

 average: average rank of group. min: lowest rank in group. max: highest rank in group. first: ranks assigned in order they appear in the array. dense: like ‘min’, but rank always increases by 1 between groups.
ascending:bool, default True

False for ranks by high (1) to low (N).
na_option:{‘keep’, ‘top’, ‘bottom’}, default ‘keep’

 keep: leave NA values where they are. top: smallest rank if ascending. bottom: smallest rank if descending.
pct:bool, default False

Compute percentage rank of data within each group.
axis:int, default 0

The axis of the object over which to compute the rank.    Returns
 DataFrame with ranking of values within each group
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.    Examples
>>> df = pd.DataFrame(
...     {
...         "group": ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"],
...         "value": [2, 4, 2, 3, 5, 1, 2, 4, 1, 5],
...     }
... )
>>> df
  group  value
0     a      2
1     a      4
2     a      2
3     a      3
4     a      5
5     b      1
6     b      2
7     b      4
8     b      1
9     b      5
>>> for method in ['average', 'min', 'max', 'dense', 'first']:
...     df[f'{method}_rank'] = df.groupby('group')['value'].rank(method)
>>> df
  group  value  average_rank  min_rank  max_rank  dense_rank  first_rank
0     a      2           1.5       1.0       2.0         1.0         1.0
1     a      4           4.0       4.0       4.0         3.0         4.0
2     a      2           1.5       1.0       2.0         1.0         2.0
3     a      3           3.0       3.0       3.0         2.0         3.0
4     a      5           5.0       5.0       5.0         4.0         5.0
5     b      1           1.5       1.0       2.0         1.0         1.0
6     b      2           3.0       3.0       3.0         2.0         3.0
7     b      4           4.0       4.0       4.0         3.0         4.0
8     b      1           1.5       1.0       2.0         1.0         2.0
9     b      5           5.0       5.0       5.0         4.0         5.0


pandas.core.groupby.DataFrameGroupBy.resample   DataFrameGroupBy.resample(rule, *args, **kwargs)[source]

Provide resampling when using a TimeGrouper. Given a grouper, the function resamples it according to a string “string” -> “frequency”. See the frequency aliases documentation for more details.  Parameters

rule:str or DateOffset

The offset string or object representing target grouper conversion.  *args, **kwargs

Possible arguments are how, fill_method, limit, kind and on, and other arguments of TimeGrouper.    Returns
 Grouper

Return a new grouper with our resampler appended.      See also  Grouper

Specify a frequency to resample with when grouping by a key.  DatetimeIndex.resample

Frequency conversion and resampling of time series.    Examples
>>> idx = pd.date_range('1/1/2000', periods=4, freq='T')
>>> df = pd.DataFrame(data=4 * [range(2)],
...                   index=idx,
...                   columns=['a', 'b'])
>>> df.iloc[2, 0] = 5
>>> df
                    a  b
2000-01-01 00:00:00  0  1
2000-01-01 00:01:00  0  1
2000-01-01 00:02:00  5  1
2000-01-01 00:03:00  0  1
  Downsample the DataFrame into 3 minute bins and sum the values of the timestamps falling into a bin.
>>> df.groupby('a').resample('3T').sum()
                         a  b
a
0   2000-01-01 00:00:00  0  2
    2000-01-01 00:03:00  0  1
5   2000-01-01 00:00:00  5  1
  Upsample the series into 30 second bins.
>>> df.groupby('a').resample('30S').sum()
                    a  b
a
0   2000-01-01 00:00:00  0  1
    2000-01-01 00:00:30  0  0
    2000-01-01 00:01:00  0  1
    2000-01-01 00:01:30  0  0
    2000-01-01 00:02:00  0  0
    2000-01-01 00:02:30  0  0
    2000-01-01 00:03:00  0  1
5   2000-01-01 00:02:00  5  1
  Resample by month. Values are assigned to the month of the period.
>>> df.groupby('a').resample('M').sum()
            a  b
a
0   2000-01-31  0  3
5   2000-01-31  5  1
  Downsample the series into 3 minute bins as above, but close the right side of the bin interval.
>>> df.groupby('a').resample('3T', closed='right').sum()
                         a  b
a
0   1999-12-31 23:57:00  0  1
    2000-01-01 00:00:00  0  2
5   2000-01-01 00:00:00  5  1
  Downsample the series into 3 minute bins and close the right side of the bin interval, but label each bin using the right edge instead of the left.
>>> df.groupby('a').resample('3T', closed='right', label='right').sum()
                         a  b
a
0   2000-01-01 00:00:00  0  1
    2000-01-01 00:03:00  0  2
5   2000-01-01 00:03:00  5  1


pandas.core.groupby.DataFrameGroupBy.sample   DataFrameGroupBy.sample(n=None, frac=None, replace=False, weights=None, random_state=None)[source]

Return a random sample of items from each group. You can use random_state for reproducibility.  New in version 1.1.0.   Parameters

n:int, optional

Number of items to return for each group. Cannot be used with frac and must be no larger than the smallest group unless replace is True. Default is one if frac is None.
frac:float, optional

Fraction of items to return. Cannot be used with n.
replace:bool, default False

Allow or disallow sampling of the same row more than once.
weights:list-like, optional

Default None results in equal probability weighting. If passed a list-like then values must have the same length as the underlying DataFrame or Series object and will be used as sampling probabilities after normalization within each group. Values must be non-negative with at least one positive element within each group.
random_state:int, array-like, BitGenerator, np.random.RandomState, np.random.Generator, optional

If int, array-like, or BitGenerator, seed for random number generator. If np.random.RandomState or np.random.Generator, use as given.  Changed in version 1.4.0: np.random.Generator objects now accepted     Returns
 Series or DataFrame

A new object of same type as caller containing items randomly sampled within each group from the caller object.      See also  DataFrame.sample

Generate random samples from a DataFrame object.  numpy.random.choice

Generate a random sample from a given 1-D numpy array.    Examples
>>> df = pd.DataFrame(
...     {"a": ["red"] * 2 + ["blue"] * 2 + ["black"] * 2, "b": range(6)}
... )
>>> df
       a  b
0    red  0
1    red  1
2   blue  2
3   blue  3
4  black  4
5  black  5
  Select one row at random for each distinct value in column a. The random_state argument can be used to guarantee reproducibility:
>>> df.groupby("a").sample(n=1, random_state=1)
       a  b
4  black  4
2   blue  2
1    red  1
  Set frac to sample fixed proportions rather than counts:
>>> df.groupby("a")["b"].sample(frac=0.5, random_state=2)
5    5
2    2
0    0
Name: b, dtype: int64
  Control sample probabilities within groups by setting weights:
>>> df.groupby("a").sample(
...     n=1,
...     weights=[1, 1, 1, 0, 0, 1],
...     random_state=1,
... )
       a  b
5  black  5
2   blue  2
0    red  0


pandas.core.groupby.DataFrameGroupBy.shift   DataFrameGroupBy.shift(periods=1, freq=None, axis=0, fill_value=None)[source]

Shift each group by periods observations. If freq is passed, the index will be increased using the periods and the freq.  Parameters

periods:int, default 1

Number of periods to shift.
freq:str, optional

Frequency string.
axis:axis to shift, default 0

Shift direction.
fill_value:optional

The scalar value to use for newly introduced missing values.    Returns
 Series or DataFrame

Object shifted within each group.      See also  Index.shift

Shift values of Index.  tshift

Shift the time index, using the index’s frequency if available.


pandas.core.groupby.DataFrameGroupBy.size   DataFrameGroupBy.size()[source]

Compute group sizes.  Returns
 DataFrame or Series

Number of rows in each group as a Series if as_index is True or a DataFrame if as_index is False.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.DataFrameGroupBy.skew   propertyDataFrameGroupBy.skew

Return unbiased skew over requested axis. Normalized by N-1.  Parameters

axis:{index (0), columns (1)}

Axis for the function to be applied on.
skipna:bool, default True

Exclude NA/null values when computing the result.
level:int or level name, default None

If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
numeric_only:bool, default None

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.  **kwargs

Additional keyword arguments to be passed to the function.    Returns
 Series or DataFrame (if level specified)


pandas.core.groupby.DataFrameGroupBy.take   propertyDataFrameGroupBy.take

Return the elements in the given positional indices along an axis. This means that we are not indexing according to actual values in the index attribute of the object. We are indexing according to the actual position of the element in the object.  Parameters

indices:array-like

An array of ints indicating which positions to take.
axis:{0 or ‘index’, 1 or ‘columns’, None}, default 0

The axis on which to select elements. 0 means that we are selecting rows, 1 means that we are selecting columns.
is_copy:bool

Before pandas 1.0, is_copy=False can be specified to ensure that the return value is an actual copy. Starting with pandas 1.0, take always returns a copy, and the keyword is therefore deprecated.  Deprecated since version 1.0.0.   **kwargs

For compatibility with numpy.take(). Has no effect on the output.    Returns

taken:same type as caller

An array-like containing the elements taken from the object.      See also  DataFrame.loc

Select a subset of a DataFrame by labels.  DataFrame.iloc

Select a subset of a DataFrame by positions.  numpy.take

Take elements from an array along an axis.    Examples
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
...                    ('parrot', 'bird', 24.0),
...                    ('lion', 'mammal', 80.5),
...                    ('monkey', 'mammal', np.nan)],
...                   columns=['name', 'class', 'max_speed'],
...                   index=[0, 2, 3, 1])
>>> df
     name   class  max_speed
0  falcon    bird      389.0
2  parrot    bird       24.0
3    lion  mammal       80.5
1  monkey  mammal        NaN
  Take elements at positions 0 and 3 along the axis 0 (default). Note how the actual indices selected (0 and 1) do not correspond to our selected indices 0 and 3. That’s because we are selecting the 0th and 3rd rows, not rows whose indices equal 0 and 3.
>>> df.take([0, 3])
     name   class  max_speed
0  falcon    bird      389.0
1  monkey  mammal        NaN
  Take elements at indices 1 and 2 along the axis 1 (column selection).
>>> df.take([1, 2], axis=1)
    class  max_speed
0    bird      389.0
2    bird       24.0
3  mammal       80.5
1  mammal        NaN
  We may take elements using negative integers for positive indices, starting from the end of the object, just like with Python lists.
>>> df.take([-1, -2])
     name   class  max_speed
1  monkey  mammal        NaN
3    lion  mammal       80.5


pandas.core.groupby.DataFrameGroupBy.transform   DataFrameGroupBy.transform(func, *args, engine=None, engine_kwargs=None, **kwargs)[source]

Call function producing a like-indexed DataFrame on each group and return a DataFrame having the same indexes as the original object filled with the transformed values.  Parameters

f:function

Function to apply to each group. Can also accept a Numba JIT function with engine='numba' specified. If the 'numba' engine is chosen, the function must be a user defined function with values and index as the first and second arguments respectively in the function signature. Each group’s index will be passed to the user defined function and optionally available for use.  Changed in version 1.1.0.   *args

Positional arguments to pass to func.
engine:str, default None

 'cython' : Runs the function through C-extensions from cython. 'numba' : Runs the function through JIT compiled code from numba. None : Defaults to 'cython' or the global setting compute.use_numba   New in version 1.1.0.
engine_kwargs:dict, default None

 For 'cython' engine, there are no accepted engine_kwargs For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False} and will be applied to the function   New in version 1.1.0.   **kwargs

Keyword arguments to be passed into func.    Returns
 DataFrame
    See also  DataFrame.groupby.apply

Apply function func group-wise and combine the results together.  DataFrame.groupby.aggregate

Aggregate using one or more operations over the specified axis.  DataFrame.transform

Call func on self producing a DataFrame with the same axis shape as self.    Notes Each group is endowed the attribute ‘name’ in case you need to know which group you are working on. The current implementation imposes three requirements on f:  f must return a value that either has the same shape as the input subframe or can be broadcast to the shape of the input subframe. For example, if f returns a scalar it will be broadcast to have the same shape as the input subframe. if this is a DataFrame, f must support application column-by-column in the subframe. If f also supports application to the entire subframe, then a fast path is used starting from the second chunk. f must not mutate groups. Mutation is not supported and may produce unexpected results. See Mutating with User Defined Function (UDF) methods for more details.  When using engine='numba', there will be no “fall back” behavior internally. The group data and group index will be passed as numpy arrays to the JITed user defined function, and no alternative execution attempts will be tried.  Changed in version 1.3.0: The resulting dtype will reflect the return value of the passed func, see the examples below.  Examples
>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
...                           'foo', 'bar'],
...                    'B' : ['one', 'one', 'two', 'three',
...                           'two', 'two'],
...                    'C' : [1, 5, 5, 2, 5, 5],
...                    'D' : [2.0, 5., 8., 1., 2., 9.]})
>>> grouped = df.groupby('A')
>>> grouped.transform(lambda x: (x - x.mean()) / x.std())
          C         D
0 -1.154701 -0.577350
1  0.577350  0.000000
2  0.577350  1.154701
3 -1.154701 -1.000000
4  0.577350 -0.577350
5  0.577350  1.000000
  Broadcast result of the transformation
>>> grouped.transform(lambda x: x.max() - x.min())
   C    D
0  4  6.0
1  3  8.0
2  4  6.0
3  3  8.0
4  4  6.0
5  3  8.0
   Changed in version 1.3.0: The resulting dtype will reflect the return value of the passed func, for example:
>>> grouped[['C', 'D']].transform(lambda x: x.astype(int).max())
   C  D
0  5  8
1  5  9
2  5  8
3  5  9
4  5  8
5  5  9


pandas.core.groupby.DataFrameGroupBy.tshift   propertyDataFrameGroupBy.tshift

Shift the time index, using the index’s frequency if available.  Deprecated since version 1.1.0: Use shift instead.   Parameters

periods:int

Number of periods to move, can be positive or negative.
freq:DateOffset, timedelta, or str, default None

Increment to use from the tseries module or time rule expressed as a string (e.g. ‘EOM’).
axis:{0 or ‘index’, 1 or ‘columns’, None}, default 0

Corresponds to the axis that contains the Index.    Returns

shifted:Series/DataFrame

   Notes If freq is not specified then tries to use the freq or inferred_freq attributes of the index. If neither of those attributes exist, a ValueError is thrown


pandas.core.groupby.DataFrameGroupBy.value_counts   DataFrameGroupBy.value_counts(subset=None, normalize=False, sort=True, ascending=False, dropna=True)[source]

Return a Series or DataFrame containing counts of unique rows.  New in version 1.4.0.   Parameters

subset:list-like, optional

Columns to use when counting unique combinations.
normalize:bool, default False

Return proportions rather than frequencies.
sort:bool, default True

Sort by frequencies.
ascending:bool, default False

Sort in ascending order.
dropna:bool, default True

Don’t include counts of rows that contain NA values.    Returns
 Series or DataFrame

Series if the groupby as_index is True, otherwise DataFrame.      See also  Series.value_counts

Equivalent method on Series.  DataFrame.value_counts

Equivalent method on DataFrame.  SeriesGroupBy.value_counts

Equivalent method on SeriesGroupBy.    Notes  If the groupby as_index is True then the returned Series will have a MultiIndex with one level per input column. If the groupby as_index is False then the returned DataFrame will have an additional column with the value_counts. The column is labelled ‘count’ or ‘proportion’, depending on the normalize parameter.  By default, rows that contain any NA values are omitted from the result. By default, the result will be in descending order so that the first element of each group is the most frequently-occurring row. Examples
>>> df = pd.DataFrame({
...    'gender': ['male', 'male', 'female', 'male', 'female', 'male'],
...    'education': ['low', 'medium', 'high', 'low', 'high', 'low'],
...    'country': ['US', 'FR', 'US', 'FR', 'FR', 'FR']
... })

>>> df
    gender      education       country
0       male    low         US
1       male    medium      FR
2       female  high        US
3       male    low         FR
4       female  high        FR
5       male    low         FR

>>> df.groupby('gender').value_counts()
gender  education  country
female  high       FR         1
                   US         1
male    low        FR         2
                   US         1
        medium     FR         1
dtype: int64

>>> df.groupby('gender').value_counts(ascending=True)
gender  education  country
female  high       FR         1
                   US         1
male    low        US         1
        medium     FR         1
        low        FR         2
dtype: int64

>>> df.groupby('gender').value_counts(normalize=True)
gender  education  country
female  high       FR         0.50
                   US         0.50
male    low        FR         0.50
                   US         0.25
        medium     FR         0.25
dtype: float64

>>> df.groupby('gender', as_index=False).value_counts()
   gender education country  count
0  female      high      FR      1
1  female      high      US      1
2    male       low      FR      2
3    male       low      US      1
4    male    medium      FR      1

>>> df.groupby('gender', as_index=False).value_counts(normalize=True)
   gender education country  proportion
0  female      high      FR        0.50
1  female      high      US        0.50
2    male       low      FR        0.50
3    male       low      US        0.25
4    male    medium      FR        0.25


pandas.core.groupby.GroupBy.__iter__   GroupBy.__iter__()[source]

Groupby iterator.  Returns
 Generator yielding sequence of (name, subsetted object)
for each group


pandas.core.groupby.GroupBy.agg   GroupBy.agg(func, *args, **kwargs)[source]


pandas.core.groupby.GroupBy.all   finalGroupBy.all(skipna=True)[source]

Return True if all values in the group are truthful, else False.  Parameters

skipna:bool, default True

Flag to ignore nan values during truth testing.    Returns
 Series or DataFrame

DataFrame or Series of boolean values, where a value is True if all elements are True within its respective group, False otherwise.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.any   finalGroupBy.any(skipna=True)[source]

Return True if any value in the group is truthful, else False.  Parameters

skipna:bool, default True

Flag to ignore nan values during truth testing.    Returns
 Series or DataFrame

DataFrame or Series of boolean values, where a value is True if any element is True within its respective group, False otherwise.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.apply   GroupBy.apply(func, *args, **kwargs)[source]

Apply function func group-wise and combine the results together. The function passed to apply must take a dataframe as its first argument and return a DataFrame, Series or scalar. apply will then take care of combining the results back together into a single dataframe or series. apply is therefore a highly flexible grouping method. While apply is a very flexible method, its downside is that using it can be quite a bit slower than using more specific methods like agg or transform. Pandas offers a wide range of method that will be much faster than using apply for their specific purposes, so try to use them before reaching for apply.  Parameters

func:callable

A callable that takes a dataframe as its first argument, and returns a dataframe, a series or a scalar. In addition the callable may take positional and keyword arguments.
args, kwargs:tuple and dict

Optional positional and keyword arguments to pass to func.    Returns

applied:Series or DataFrame

    See also  pipe

Apply function to the full GroupBy object instead of to each group.  aggregate

Apply aggregate function to the GroupBy object.  transform

Apply function column-by-column to the GroupBy object.  Series.apply

Apply a function to a Series.  DataFrame.apply

Apply a function to each row or column of a DataFrame.    Notes  Changed in version 1.3.0: The resulting dtype will reflect the return value of the passed func, see the examples below.  Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See Mutating with User Defined Function (UDF) methods for more details. Examples
>>> df = pd.DataFrame({'A': 'a a b'.split(),
...                    'B': [1,2,3],
...                    'C': [4,6,5]})
>>> g = df.groupby('A')
  Notice that g has two groups, a and b. Calling apply in various ways, we can get different grouping results: Example 1: below the function passed to apply takes a DataFrame as its argument and returns a DataFrame. apply combines the result for each group together into a new DataFrame:
>>> g[['B', 'C']].apply(lambda x: x / x.sum())
          B    C
0  0.333333  0.4
1  0.666667  0.6
2  1.000000  1.0
  Example 2: The function passed to apply takes a DataFrame as its argument and returns a Series. apply combines the result for each group together into a new DataFrame.  Changed in version 1.3.0: The resulting dtype will reflect the return value of the passed func.
>>> g[['B', 'C']].apply(lambda x: x.astype(float).max() - x.min())
     B    C
A
a  1.0  2.0
b  0.0  0.0
  Example 3: The function passed to apply takes a DataFrame as its argument and returns a scalar. apply combines the result for each group together into a Series, including setting the index as appropriate:
>>> g.apply(lambda x: x.C.max() - x.B.min())
A
a    5
b    2
dtype: int64


pandas.core.groupby.GroupBy.backfill   GroupBy.backfill(limit=None)[source]

Backward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.bfill

Backward fill the missing values in the dataset.  DataFrame.bfill

Backward fill the missing values in the dataset.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.GroupBy.bfill   finalGroupBy.bfill(limit=None)[source]

Backward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.bfill

Backward fill the missing values in the dataset.  DataFrame.bfill

Backward fill the missing values in the dataset.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.GroupBy.count   finalGroupBy.count()[source]

Compute count of group, excluding missing values.  Returns
 Series or DataFrame

Count of values within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.cumcount   finalGroupBy.cumcount(ascending=True)[source]

Number each item in each group from 0 to the length of that group - 1. Essentially this is equivalent to
self.apply(lambda x: pd.Series(np.arange(len(x)), x.index))
   Parameters

ascending:bool, default True

If False, number in reverse, from length of group - 1 to 0.    Returns
 Series

Sequence number of each element within each group.      See also  ngroup

Number the groups themselves.    Examples
>>> df = pd.DataFrame([['a'], ['a'], ['a'], ['b'], ['b'], ['a']],
...                   columns=['A'])
>>> df
   A
0  a
1  a
2  a
3  b
4  b
5  a
>>> df.groupby('A').cumcount()
0    0
1    1
2    2
3    0
4    1
5    3
dtype: int64
>>> df.groupby('A').cumcount(ascending=False)
0    3
1    2
2    1
3    1
4    0
5    0
dtype: int64


pandas.core.groupby.GroupBy.cummax   finalGroupBy.cummax(axis=0, **kwargs)[source]

Cumulative max for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.cummin   finalGroupBy.cummin(axis=0, **kwargs)[source]

Cumulative min for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.cumprod   finalGroupBy.cumprod(axis=0, *args, **kwargs)[source]

Cumulative product for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.cumsum   finalGroupBy.cumsum(axis=0, *args, **kwargs)[source]

Cumulative sum for each group.  Returns
 Series or DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.ffill   finalGroupBy.ffill(limit=None)[source]

Forward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.ffill

Returns Series with minimum number of char in object.  DataFrame.ffill

Object with missing values filled or None if inplace=True.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.GroupBy.first   finalGroupBy.first(numeric_only=False, min_count=- 1)[source]

Compute first of group values.  Parameters

numeric_only:bool, default False

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.
min_count:int, default -1

The required number of valid values to perform the operation. If fewer than min_count non-NA values are present the result will be NA.    Returns
 Series or DataFrame

Computed first of values within each group.


pandas.core.groupby.GroupBy.get_group   GroupBy.get_group(name, obj=None)[source]

Construct DataFrame from group with provided name.  Parameters

name:object

The name of the group to get as a DataFrame.
obj:DataFrame, default None

The DataFrame to take the DataFrame out of. If it is None, the object groupby was called on will be used.    Returns

group:same type as obj


pandas.core.groupby.GroupBy.groups   propertyGroupBy.groups

Dict {group name -> group labels}.


pandas.core.groupby.GroupBy.head   finalGroupBy.head(n=5)[source]

Return first n rows of each group. Similar to .apply(lambda x: x.head(n)), but it returns a subset of rows from the original DataFrame with original index and order preserved (as_index flag is ignored).  Parameters

n:int

If positive: number of entries to include from start of each group. If negative: number of entries to exclude from end of each group.    Returns
 Series or DataFrame

Subset of original Series or DataFrame as determined by n.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.    Examples
>>> df = pd.DataFrame([[1, 2], [1, 4], [5, 6]],
...                   columns=['A', 'B'])
>>> df.groupby('A').head(1)
   A  B
0  1  2
2  5  6
>>> df.groupby('A').head(-1)
   A  B
0  1  2


pandas.core.groupby.GroupBy.indices   propertyGroupBy.indices

Dict {group name -> group indices}.


pandas.core.groupby.GroupBy.last   finalGroupBy.last(numeric_only=False, min_count=- 1)[source]

Compute last of group values.  Parameters

numeric_only:bool, default False

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.
min_count:int, default -1

The required number of valid values to perform the operation. If fewer than min_count non-NA values are present the result will be NA.    Returns
 Series or DataFrame

Computed last of values within each group.


pandas.core.groupby.GroupBy.max   finalGroupBy.max(numeric_only=False, min_count=- 1)[source]

Compute max of group values.  Parameters

numeric_only:bool, default False

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.
min_count:int, default -1

The required number of valid values to perform the operation. If fewer than min_count non-NA values are present the result will be NA.    Returns
 Series or DataFrame

Computed max of values within each group.


pandas.core.groupby.GroupBy.mean   finalGroupBy.mean(numeric_only=NoDefault.no_default, engine='cython', engine_kwargs=None)[source]

Compute mean of groups, excluding missing values.  Parameters

numeric_only:bool, default True

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.
engine:str, default None

 'cython' : Runs the operation through C-extensions from cython. 'numba' : Runs the operation through JIT compiled code from numba. None : Defaults to 'cython' or globally setting compute.use_numba   New in version 1.4.0.
engine_kwargs:dict, default None

 For 'cython' engine, there are no accepted engine_kwargs For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {{'nopython': True, 'nogil': False, 'parallel': False}}   New in version 1.4.0.     Returns
 pandas.Series or pandas.DataFrame
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.    Examples
>>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
...                    'B': [np.nan, 2, 3, 4, 5],
...                    'C': [1, 2, 1, 1, 2]}, columns=['A', 'B', 'C'])
  Groupby one column and return the mean of the remaining columns in each group.
>>> df.groupby('A').mean()
     B         C
A
1  3.0  1.333333
2  4.0  1.500000
  Groupby two columns and return the mean of the remaining column.
>>> df.groupby(['A', 'B']).mean()
         C
A B
1 2.0  2.0
  4.0  1.0
2 3.0  1.0
  5.0  2.0
  Groupby one column and return the mean of only particular column in the group.
>>> df.groupby('A')['B'].mean()
A
1    3.0
2    4.0
Name: B, dtype: float64


pandas.core.groupby.GroupBy.median   finalGroupBy.median(numeric_only=NoDefault.no_default)[source]

Compute median of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex  Parameters

numeric_only:bool, default True

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.    Returns
 Series or DataFrame

Median of values within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.min   finalGroupBy.min(numeric_only=False, min_count=- 1)[source]

Compute min of group values.  Parameters

numeric_only:bool, default False

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.
min_count:int, default -1

The required number of valid values to perform the operation. If fewer than min_count non-NA values are present the result will be NA.    Returns
 Series or DataFrame

Computed min of values within each group.


pandas.core.groupby.GroupBy.ngroup   finalGroupBy.ngroup(ascending=True)[source]

Number each group from 0 to the number of groups - 1. This is the enumerative complement of cumcount. Note that the numbers given to the groups match the order in which the groups would be seen when iterating over the groupby object, not the order they are first observed.  Parameters

ascending:bool, default True

If False, number in reverse, from number of group - 1 to 0.    Returns
 Series

Unique numbers for each group.      See also  cumcount

Number the rows in each group.    Examples
>>> df = pd.DataFrame({"A": list("aaabba")})
>>> df
   A
0  a
1  a
2  a
3  b
4  b
5  a
>>> df.groupby('A').ngroup()
0    0
1    0
2    0
3    1
4    1
5    0
dtype: int64
>>> df.groupby('A').ngroup(ascending=False)
0    1
1    1
2    1
3    0
4    0
5    1
dtype: int64
>>> df.groupby(["A", [1,1,2,3,2,1]]).ngroup()
0    0
1    0
2    1
3    3
4    2
5    0
dtype: int64


pandas.core.groupby.GroupBy.nth   finalGroupBy.nth(n, dropna=None)[source]

Take the nth row from each group if n is an int, otherwise a subset of rows. Can be either a call or an index. dropna is not available with index notation. Index notation accepts a comma separated list of integers and slices. If dropna, will take the nth non-null row, dropna is either ‘all’ or ‘any’; this is equivalent to calling dropna(how=dropna) before the groupby.  Parameters

n:int, slice or list of ints and slices

A single nth value for the row or a list of nth values or slices.  Changed in version 1.4.0: Added slice and lists containiing slices. Added index notation.
dropna:{‘any’, ‘all’, None}, default None

Apply the specified dropna operation before counting which row is the nth row. Only supported if n is an int.    Returns
 Series or DataFrame

N-th value within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.    Examples
>>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
...                    'B': [np.nan, 2, 3, 4, 5]}, columns=['A', 'B'])
>>> g = df.groupby('A')
>>> g.nth(0)
     B
A
1  NaN
2  3.0
>>> g.nth(1)
     B
A
1  2.0
2  5.0
>>> g.nth(-1)
     B
A
1  4.0
2  5.0
>>> g.nth([0, 1])
     B
A
1  NaN
1  2.0
2  3.0
2  5.0
>>> g.nth(slice(None, -1))
     B
A
1  NaN
1  2.0
2  3.0
  Index notation may also be used
>>> g.nth[0, 1]
     B
A
1  NaN
1  2.0
2  3.0
2  5.0
>>> g.nth[:-1]
     B
A
1  NaN
1  2.0
2  3.0
  Specifying dropna allows count ignoring NaN
>>> g.nth(0, dropna='any')
     B
A
1  2.0
2  3.0
  NaNs denote group exhausted when using dropna
>>> g.nth(3, dropna='any')
    B
A
1 NaN
2 NaN
  Specifying as_index=False in groupby keeps the original index.
>>> df.groupby('A', as_index=False).nth(1)
   A    B
1  1  2.0
4  2  5.0


pandas.core.groupby.GroupBy.ohlc   finalGroupBy.ohlc()[source]

Compute open, high, low and close values of a group, excluding missing values. For multiple groupings, the result index will be a MultiIndex  Returns
 DataFrame

Open, high, low and close values within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.pad   GroupBy.pad(limit=None)[source]

Forward fill the values.  Parameters

limit:int, optional

Limit of how many values to fill.    Returns
 Series or DataFrame

Object with missing values filled.      See also  Series.ffill

Returns Series with minimum number of char in object.  DataFrame.ffill

Object with missing values filled or None if inplace=True.  Series.fillna

Fill NaN values of a Series.  DataFrame.fillna

Fill NaN values of a DataFrame.


pandas.core.groupby.GroupBy.pct_change   finalGroupBy.pct_change(periods=1, fill_method='ffill', limit=None, freq=None, axis=0)[source]

Calculate pct_change of each value to previous entry in group.  Returns
 Series or DataFrame

Percentage changes within each group.      See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.


pandas.core.groupby.GroupBy.pipe   GroupBy.pipe(func, *args, **kwargs)[source]

Apply a function func with arguments to this GroupBy object and return the function’s result. Use .pipe when you want to improve readability by chaining together functions that expect Series, DataFrames, GroupBy or Resampler objects. Instead of writing
>>> h(g(f(df.groupby('group')), arg1=a), arg2=b, arg3=c)
  You can write
>>> (df.groupby('group')
...    .pipe(f)
...    .pipe(g, arg1=a)
...    .pipe(h, arg2=b, arg3=c))
  which is much more readable.  Parameters

func:callable or tuple of (callable, str)

Function to apply to this GroupBy object or, alternatively, a (callable, data_keyword) tuple where data_keyword is a string indicating the keyword of callable that expects the GroupBy object.
args:iterable, optional

Positional arguments passed into func.
kwargs:dict, optional

A dictionary of keyword arguments passed into func.    Returns

object:the return type of func.

    See also  Series.pipe

Apply a function with arguments to a series.  DataFrame.pipe

Apply a function with arguments to a dataframe.  apply

Apply function to each group instead of to the full GroupBy object.    Notes See more here Examples
>>> df = pd.DataFrame({'A': 'a b a b'.split(), 'B': [1, 2, 3, 4]})
>>> df
   A  B
0  a  1
1  b  2
2  a  3
3  b  4
  To get the difference between each groups maximum and minimum value in one pass, you can do
>>> df.groupby('A').pipe(lambda x: x.max() - x.min())
   B
A
a  2
b  2


pandas.core.groupby.GroupBy.prod   finalGroupBy.prod(numeric_only=NoDefault.no_default, min_count=0)[source]

Compute prod of group values.  Parameters

numeric_only:bool, default True

Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data.
min_count:int, default 0

The required number of valid values to perform the operation. If fewer than min_count non-NA values are present the result will be NA.    Returns
 Series or DataFrame

Computed prod of values within each group.


pandas.core.groupby.GroupBy.rank   finalGroupBy.rank(method='average', ascending=True, na_option='keep', pct=False, axis=0)[source]

Provide the rank of values within each group.  Parameters

method:{‘average’, ‘min’, ‘max’, ‘first’, ‘dense’}, default ‘average’

 average: average rank of group. min: lowest rank in group. max: highest rank in group. first: ranks assigned in order they appear in the array. dense: like ‘min’, but rank always increases by 1 between groups.
ascending:bool, default True

False for ranks by high (1) to low (N).
na_option:{‘keep’, ‘top’, ‘bottom’}, default ‘keep’

 keep: leave NA values where they are. top: smallest rank if ascending. bottom: smallest rank if descending.
pct:bool, default False

Compute percentage rank of data within each group.
axis:int, default 0

The axis of the object over which to compute the rank.    Returns
 DataFrame with ranking of values within each group
    See also  Series.groupby

Apply a function groupby to a Series.  DataFrame.groupby

Apply a function groupby to each row or column of a DataFrame.    Examples
>>> df = pd.DataFrame(
...     {
...         "group": ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"],
...         "value": [2, 4, 2, 3, 5, 1, 2, 4, 1, 5],
...     }
... )
>>> df
  group  value
0     a      2
1     a      4
2     a      2
3     a      3
4     a      5
5     b      1
6     b      2
7     b      4
8     b      1
9     b      5
>>> for method in ['average', 'min', 'max', 'dense', 'first']:
...     df[f'{method}_rank'] = df.groupby('group')['value'].rank(method)
>>> df
  group  value  average_rank  min_rank  max_rank  dense_rank  first_rank
0     a      2           1.5       1.0       2.0         1.0         1.0
1     a      4           4.0       4.0       4.0         3.0         4.0
2     a      2           1.5       1.0       2.0         1.0         2.0
3     a      3           3.0       3.0       3.0         2.0         3.0
4     a      5           5.0       5.0       5.0         4.0         5.0
5     b      1           1.5       1.0       2.0         1.0         1.0
6     b      2           3.0       3.0       3.0         2.0         3.0
7     b      4           4.0       4.0       4.0         3.0         4.0
8     b      1           1.5       1.0       2.0         1.0         2.0
9     b      5           5.0       5.0       5.0         4.0         5.0