neulab/docprompting-conala huggingface dataset:
pandas.core.window.rolling.Rolling.sem   Rolling.sem(ddof=1, *args, **kwargs)[source]
 
Calculate the rolling standard error of mean.  Parameters 
 
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  *args

For NumPy compatibility and will not have an effect on the result.  **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.sem

Aggregating sem for Series.  pandas.DataFrame.sem

Aggregating sem for DataFrame.    Notes A minimum of one period is required for the calculation. Examples 
>>> s = pd.Series([0, 1, 2, 3])
>>> s.rolling(2, min_periods=1).sem()
0         NaN
1    0.707107
2    0.707107
3    0.707107
dtype: float64
pandas.core.window.rolling.Rolling.skew   Rolling.skew(**kwargs)[source]
 
Calculate the rolling unbiased skewness.  Parameters 
 **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  scipy.stats.skew

Third moment of a probability density.  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.skew

Aggregating skew for Series.  pandas.DataFrame.skew

Aggregating skew for DataFrame.    Notes A minimum of three periods is required for the rolling calculation.
pandas.core.window.rolling.Rolling.std   Rolling.std(ddof=1, *args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling standard deviation.  Parameters 
 
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  *args

For NumPy compatibility and will not have an effect on the result.  
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.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  numpy.std

Equivalent method for NumPy array.  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.std

Aggregating std for Series.  pandas.DataFrame.std

Aggregating std for DataFrame.    Notes The default ddof of 1 used in Series.std() is different than the default ddof of 0 in numpy.std(). A minimum of one period is required for the rolling calculation. The implementation is susceptible to floating point imprecision as shown in the example below. Examples 
>>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
>>> s.rolling(3).std()
0             NaN
1             NaN
2    5.773503e-01
3    1.000000e+00
4    1.000000e+00
5    1.154701e+00
6    2.580957e-08
dtype: float64
pandas.core.window.rolling.Rolling.sum   Rolling.sum(*args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling sum.  Parameters 
 *args

For NumPy compatibility and will not have an effect on the result.  
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.3.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.3.0.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.sum

Aggregating sum for Series.  pandas.DataFrame.sum

Aggregating sum for DataFrame.    Notes See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine. Examples 
>>> s = pd.Series([1, 2, 3, 4, 5])
>>> s
0    1
1    2
2    3
3    4
4    5
dtype: int64
  
>>> s.rolling(3).sum()
0     NaN
1     NaN
2     6.0
3     9.0
4    12.0
dtype: float64
  
>>> s.rolling(3, center=True).sum()
0     NaN
1     6.0
2     9.0
3    12.0
4     NaN
dtype: float64
  For DataFrame, each sum is computed column-wise. 
>>> df = pd.DataFrame({"A": s, "B": s ** 2})
>>> df
   A   B
0  1   1
1  2   4
2  3   9
3  4  16
4  5  25
  
>>> df.rolling(3).sum()
      A     B
0   NaN   NaN
1   NaN   NaN
2   6.0  14.0
3   9.0  29.0
4  12.0  50.0
pandas.core.window.rolling.Rolling.var   Rolling.var(ddof=1, *args, engine=None, engine_kwargs=None, **kwargs)[source]
 
Calculate the rolling variance.  Parameters 
 
ddof:int, default 1


Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.  *args

For NumPy compatibility and will not have an effect on the result.  
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.     **kwargs

For NumPy compatibility and will not have an effect on the result.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  numpy.var

Equivalent method for NumPy array.  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.var

Aggregating var for Series.  pandas.DataFrame.var

Aggregating var for DataFrame.    Notes The default ddof of 1 used in Series.var() is different than the default ddof of 0 in numpy.var(). A minimum of one period is required for the rolling calculation. The implementation is susceptible to floating point imprecision as shown in the example below. Examples 
>>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])
>>> s.rolling(3).var()
0             NaN
1             NaN
2    3.333333e-01
3    1.000000e+00
4    1.000000e+00
5    1.333333e+00
6    6.661338e-16
dtype: float64
pandas.core.window.rolling.Window.mean   Window.mean(*args, **kwargs)[source]
 
Calculate the rolling weighted window mean.  Parameters 
 **kwargs

Keyword arguments to configure the SciPy weighted window type.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.mean

Aggregating mean for Series.  pandas.DataFrame.mean

Aggregating mean for DataFrame.
pandas.core.window.rolling.Window.std   Window.std(ddof=1, *args, **kwargs)[source]
 
Calculate the rolling weighted window standard deviation.  New in version 1.0.0.   Parameters 
 **kwargs

Keyword arguments to configure the SciPy weighted window type.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.std

Aggregating std for Series.  pandas.DataFrame.std

Aggregating std for DataFrame.
pandas.core.window.rolling.Window.sum   Window.sum(*args, **kwargs)[source]
 
Calculate the rolling weighted window sum.  Parameters 
 **kwargs

Keyword arguments to configure the SciPy weighted window type.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.sum

Aggregating sum for Series.  pandas.DataFrame.sum

Aggregating sum for DataFrame.
pandas.core.window.rolling.Window.var   Window.var(ddof=1, *args, **kwargs)[source]
 
Calculate the rolling weighted window variance.  New in version 1.0.0.   Parameters 
 **kwargs

Keyword arguments to configure the SciPy weighted window type.    Returns 
 Series or DataFrame

Return type is the same as the original object with np.float64 dtype.      See also  pandas.Series.rolling

Calling rolling with Series data.  pandas.DataFrame.rolling

Calling rolling with DataFrames.  pandas.Series.var

Aggregating var for Series.  pandas.DataFrame.var

Aggregating var for DataFrame.
pandas.crosstab   pandas.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, margins_name='All', dropna=True, normalize=False)[source]
 
Compute a simple cross tabulation of two (or more) factors. By default computes a frequency table of the factors unless an array of values and an aggregation function are passed.  Parameters 
 
index:array-like, Series, or list of arrays/Series


Values to group by in the rows.  
columns:array-like, Series, or list of arrays/Series


Values to group by in the columns.  
values:array-like, optional


Array of values to aggregate according to the factors. Requires aggfunc be specified.  
rownames:sequence, default None


If passed, must match number of row arrays passed.  
colnames:sequence, default None


If passed, must match number of column arrays passed.  
aggfunc:function, optional


If specified, requires values be specified as well.  
margins:bool, default False


Add row/column margins (subtotals).  
margins_name:str, default ‘All’


Name of the row/column that will contain the totals when margins is True.  
dropna:bool, default True


Do not include columns whose entries are all NaN.  
normalize:bool, {‘all’, ‘index’, ‘columns’}, or {0,1}, default False


Normalize by dividing all values by the sum of values.  If passed ‘all’ or True, will normalize over all values. If passed ‘index’ will normalize over each row. If passed ‘columns’ will normalize over each column. If margins is True, will also normalize margin values.     Returns 
 DataFrame

Cross tabulation of the data.      See also  DataFrame.pivot

Reshape data based on column values.  pivot_table

Create a pivot table as a DataFrame.    Notes Any Series passed will have their name attributes used unless row or column names for the cross-tabulation are specified. Any input passed containing Categorical data will have all of its categories included in the cross-tabulation, even if the actual data does not contain any instances of a particular category. In the event that there aren’t overlapping indexes an empty DataFrame will be returned. Examples 
>>> a = np.array(["foo", "foo", "foo", "foo", "bar", "bar",
...               "bar", "bar", "foo", "foo", "foo"], dtype=object)
>>> b = np.array(["one", "one", "one", "two", "one", "one",
...               "one", "two", "two", "two", "one"], dtype=object)
>>> c = np.array(["dull", "dull", "shiny", "dull", "dull", "shiny",
...               "shiny", "dull", "shiny", "shiny", "shiny"],
...              dtype=object)
>>> pd.crosstab(a, [b, c], rownames=['a'], colnames=['b', 'c'])
b   one        two
c   dull shiny dull shiny
a
bar    1     2    1     0
foo    2     2    1     2
  Here ‘c’ and ‘f’ are not represented in the data and will not be shown in the output because dropna is True by default. Set dropna=False to preserve categories with no data. 
>>> foo = pd.Categorical(['a', 'b'], categories=['a', 'b', 'c'])
>>> bar = pd.Categorical(['d', 'e'], categories=['d', 'e', 'f'])
>>> pd.crosstab(foo, bar)
col_0  d  e
row_0
a      1  0
b      0  1
>>> pd.crosstab(foo, bar, dropna=False)
col_0  d  e  f
row_0
a      1  0  0
b      0  1  0
c      0  0  0
pandas.DataFrame.__iter__   DataFrame.__iter__()[source]
 
Iterate over info axis.  Returns 
 iterator

Info axis as iterator.
pandas.DataFrame.abs   DataFrame.abs()[source]
 
Return a Series/DataFrame with absolute numeric value of each element. This function only applies to elements that are all numeric.  Returns 
 abs

Series/DataFrame containing the absolute value of each element.      See also  numpy.absolute

Calculate the absolute value element-wise.    Notes For complex inputs, 1.2 + 1j, the absolute value is \(\sqrt{ a^2 + b^2 }\). Examples Absolute numeric values in a Series. 
>>> s = pd.Series([-1.10, 2, -3.33, 4])
>>> s.abs()
0    1.10
1    2.00
2    3.33
3    4.00
dtype: float64
  Absolute numeric values in a Series with complex numbers. 
>>> s = pd.Series([1.2 + 1j])
>>> s.abs()
0    1.56205
dtype: float64
  Absolute numeric values in a Series with a Timedelta element. 
>>> s = pd.Series([pd.Timedelta('1 days')])
>>> s.abs()
0   1 days
dtype: timedelta64[ns]
  Select rows with data closest to certain value using argsort (from StackOverflow). 
>>> df = pd.DataFrame({
...     'a': [4, 5, 6, 7],
...     'b': [10, 20, 30, 40],
...     'c': [100, 50, -30, -50]
... })
>>> df
     a    b    c
0    4   10  100
1    5   20   50
2    6   30  -30
3    7   40  -50
>>> df.loc[(df.c - 43).abs().argsort()]
     a    b    c
1    5   20   50
0    4   10  100
2    6   30  -30
3    7   40  -50
pandas.DataFrame.add_prefix   DataFrame.add_prefix(prefix)[source]
 
Prefix labels with string prefix. For Series, the row labels are prefixed. For DataFrame, the column labels are prefixed.  Parameters 
 
prefix:str


The string to add before each label.    Returns 
 Series or DataFrame

New Series or DataFrame with updated labels.      See also  Series.add_suffix

Suffix row labels with string suffix.  DataFrame.add_suffix

Suffix column labels with string suffix.    Examples 
>>> s = pd.Series([1, 2, 3, 4])
>>> s
0    1
1    2
2    3
3    4
dtype: int64
  
>>> s.add_prefix('item_')
item_0    1
item_1    2
item_2    3
item_3    4
dtype: int64
  
>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df
   A  B
0  1  3
1  2  4
2  3  5
3  4  6
  
>>> df.add_prefix('col_')
     col_A  col_B
0       1       3
1       2       4
2       3       5
3       4       6
pandas.DataFrame.add_suffix   DataFrame.add_suffix(suffix)[source]
 
Suffix labels with string suffix. For Series, the row labels are suffixed. For DataFrame, the column labels are suffixed.  Parameters 
 
suffix:str


The string to add after each label.    Returns 
 Series or DataFrame

New Series or DataFrame with updated labels.      See also  Series.add_prefix

Prefix row labels with string prefix.  DataFrame.add_prefix

Prefix column labels with string prefix.    Examples 
>>> s = pd.Series([1, 2, 3, 4])
>>> s
0    1
1    2
2    3
3    4
dtype: int64
  
>>> s.add_suffix('_item')
0_item    1
1_item    2
2_item    3
3_item    4
dtype: int64
  
>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df
   A  B
0  1  3
1  2  4
2  3  5
3  4  6
  
>>> df.add_suffix('_col')
     A_col  B_col
0       1       3
1       2       4
2       3       5
3       4       6
pandas.DataFrame.agg   DataFrame.agg(func=None, axis=0, *args, **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.   
axis:{0 or ‘index’, 1 or ‘columns’}, default 0


If 0 or ‘index’: apply function to each column. If 1 or ‘columns’: apply function to each row.  *args

Positional arguments to pass to func.  **kwargs

Keyword arguments to pass to func.    Returns 
 scalar, Series or DataFrame

The return can be:  scalar : when Series.agg is called with single function Series : when DataFrame.agg is called with a single function DataFrame : when DataFrame.agg is called with several functions  Return scalar, Series or DataFrame.  The aggregation operations are always performed over an axis, either the
index (default) or the column axis. This behavior is different from

numpy aggregation functions (mean, median, prod, sum, std,

var), where the default is to compute the aggregation of the flattened
array, e.g., numpy.mean(arr_2d) as opposed to

numpy.mean(arr_2d, axis=0).

agg is an alias for aggregate. Use the alias.
    See also  DataFrame.apply

Perform any type of operations.  DataFrame.transform

Perform transformation type operations.  core.groupby.GroupBy

Perform operations over groups.  core.resample.Resampler

Perform operations over resampled bins.  core.window.Rolling

Perform operations over rolling window.  core.window.Expanding

Perform operations over expanding window.  core.window.ExponentialMovingWindow

Perform operation over exponential weighted window.    Notes agg is an alias for aggregate. Use the alias. 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. A passed user-defined-function will be passed a Series for evaluation. Examples 
>>> df = pd.DataFrame([[1, 2, 3],
...                    [4, 5, 6],
...                    [7, 8, 9],
...                    [np.nan, np.nan, np.nan]],
...                   columns=['A', 'B', 'C'])
  Aggregate these functions over the rows. 
>>> df.agg(['sum', 'min'])
        A     B     C
sum  12.0  15.0  18.0
min   1.0   2.0   3.0
  Different aggregations per column. 
>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
        A    B
sum  12.0  NaN
min   1.0  2.0
max   NaN  8.0
  Aggregate different functions over the columns and rename the index of the resulting DataFrame. 
>>> df.agg(x=('A', max), y=('B', 'min'), z=('C', np.mean))
     A    B    C
x  7.0  NaN  NaN
y  NaN  2.0  NaN
z  NaN  NaN  6.0
  Aggregate over the columns. 
>>> df.agg("mean", axis="columns")
0    2.0
1    5.0
2    8.0
3    NaN
dtype: float64
pandas.DataFrame.aggregate   DataFrame.aggregate(func=None, axis=0, *args, **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.   
axis:{0 or ‘index’, 1 or ‘columns’}, default 0


If 0 or ‘index’: apply function to each column. If 1 or ‘columns’: apply function to each row.  *args

Positional arguments to pass to func.  **kwargs

Keyword arguments to pass to func.    Returns 
 scalar, Series or DataFrame

The return can be:  scalar : when Series.agg is called with single function Series : when DataFrame.agg is called with a single function DataFrame : when DataFrame.agg is called with several functions  Return scalar, Series or DataFrame.  The aggregation operations are always performed over an axis, either the
index (default) or the column axis. This behavior is different from

numpy aggregation functions (mean, median, prod, sum, std,

var), where the default is to compute the aggregation of the flattened
array, e.g., numpy.mean(arr_2d) as opposed to

numpy.mean(arr_2d, axis=0).

agg is an alias for aggregate. Use the alias.
    See also  DataFrame.apply

Perform any type of operations.  DataFrame.transform

Perform transformation type operations.  core.groupby.GroupBy

Perform operations over groups.  core.resample.Resampler

Perform operations over resampled bins.  core.window.Rolling

Perform operations over rolling window.  core.window.Expanding

Perform operations over expanding window.  core.window.ExponentialMovingWindow

Perform operation over exponential weighted window.    Notes agg is an alias for aggregate. Use the alias. 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. A passed user-defined-function will be passed a Series for evaluation. Examples 
>>> df = pd.DataFrame([[1, 2, 3],
...                    [4, 5, 6],
...                    [7, 8, 9],
...                    [np.nan, np.nan, np.nan]],
...                   columns=['A', 'B', 'C'])
  Aggregate these functions over the rows. 
>>> df.agg(['sum', 'min'])
        A     B     C
sum  12.0  15.0  18.0
min   1.0   2.0   3.0
  Different aggregations per column. 
>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
        A    B
sum  12.0  NaN
min   1.0  2.0
max   NaN  8.0
  Aggregate different functions over the columns and rename the index of the resulting DataFrame. 
>>> df.agg(x=('A', max), y=('B', 'min'), z=('C', np.mean))
     A    B    C
x  7.0  NaN  NaN
y  NaN  2.0  NaN
z  NaN  NaN  6.0
  Aggregate over the columns. 
>>> df.agg("mean", axis="columns")
0    2.0
1    5.0
2    8.0
3    NaN
dtype: float64