Python

Constant dripping wears away a stone

Pandas


Pandasis a Python library that provides Series, DataFrame, and Panel data structures for manipulating and analyzing numerical data and time series, and draw correlations of the data. It is widely used in various fields, and is fast, powerful, and flexible. To use Pandas functions, import the Pandas library first by usingimport pandas.

  • Get Started:
    • Install Pandas: To install Pandas on a PC, you can run the pip commandpip install pandasin terminal. For other installation methods, please go tohttps://pandas.pydata.org/docs/getting_started/install.html for a complete guidance.
    • Check Pandas Version: To check the Pandas version installed in your computer, usepandas.__version__
  • MultiIndex: MultiIndex is a multi-level index object for Pandas objects.
    • Create a MultiIndex: pandas.MultiIndex(levels, codes[, sortorder, names, copy=False, verify_integrity])):
      • levels: sequence of array-likes. Unique labels for each level.
      • codes: sequence of array-likes. Integers designating label locations for each level.
      • sortorder: int, optional. Level of sortedness (must be lexicographically sorted by that level).
      • names: sequence of strings, optional. Names for each of the index levels.
      • copy: bool, default False. Copy the meta-data.
      • verify_integrity: bool, default True. If True, check if the levels/codes are consistent and valid.
    • Attributes:
      • names: Names of levels in the MultiIndex.
      • nlevels: Integer number of levels in the MultiIndex.
      • levshape: A tuple with the length of each level in the MultiIndex.
      • levels: Labels for each level in the MultiIndex.
      • codes: Integers Integers designating label locations for each level in the MultiIndex.
    • Methods:
      • droplevel([level=0]): Return index with the specified level(s) removed.
        • level: int, str, or list-like, default 0. level number(s) or level name(s).
      • from_arrays(arrays[, sortorder=None, names=None]): Convert a sequence of arrays to a MultiIndex.
        • arrays: sequence of array-likes. Each array-like sets values for each level. len(arrays) is the number of levels.
        • sortorder: int or None, optional. Level of sortedness (must be lexicographically sorted by that level).
        • names: sequence of strings, optional. Names for the levels in the index.
      • from_frame(df[, sortorder, names]): Make a MultiIndex from a DataFrame.
      • from_product(iterables[, sortorder, names]): Make a MultiIndex from the cartesian product of multiple iterables.
      • from_tuples(tuples[, sortorder, names]): Convert a list of tuples to a MultiIndex.
      • remove_unused_levels(): Create a new MultiIndex from the current that removes unused levels, meaning that they are not expressed in the labels.
      • reorder_levels(order): Rearrange levels usingorder.May not drop or duplicate levels.
        • order: iterable, required. len(order) is the number of levels.
      • set_codes(codes[, level=None, inplace=False, verify_integrity=True]): Set new codes on a MultiIndex, and return a new index.
        • codes: sequence of array-likes. New codes to apply.
        • level: int, level name, or sequence of int/level names; default None.
        • inplace: bool, default False. If True, mutates the index in place.
        • verify_integrity: bool, default True. If True, check if the levels/codes are consistent and valid.
      • set_levels(levels[, level=None, inplace=False, verify_integrity=True]): Set new levels on a MultiIndex, and return a new index.
        • levels: sequence of array-likes. New levels to apply.
        • level: int, level name, or sequence of int/level names; default None.
        • inplace: bool, default False. If True, mutates the index in place.
        • verify_integrity: bool, default True. If True, check if the levels/codes are consistent and valid.
      • sortlevel([level=0, ascending=True, sort_remaining=True]): Sort a MultiIndex at the specified level. The result will respect the original ordering of the associated factor at that level. Return a new index and an indexer which is a ndarray containing the indices of output values in the original index.
        • level: int, level name, or list like of int/level names; default 0.
        • ascending: bool, default True. If False, sort in descending order. Can also be a list to specify a directed ordering.
        • sort_remaining: bool, default True. sort by the remaining levels after level.
      • swaplevel([i=-2, j=-1]): Swap level i with level j.
      • to_frame([index=True, name=None]): Create a DataFrame with the levels of the MultiIndex as columns.
        • index: bool, default True. Set the index of the returned DataFrame as the original MultiIndex.
        • name: list of strings, optional. Names used to columns that substitute index level names. len(name) is the number of levels.
      • to_flat_index(): Convert a MultiIndex to an index of tuples containing the level values.
  • Series: Pandas Series is a one-dimensional array with axis labels (indexes). It can hold homogeneous data of any type. A Pandas Series is like a column in a table that has row labels (indexes). Pandas Series objects support both integer and label-based indexing, and provide various methods for operations that involve indexes. A Pandas Series is value mutable but size immutable.
    • Create a Series: A Pandas Series (a 1-D ndarray with axis labels) can be created from ndarray, list, tuple, dict, and scarlar, etc. In practice, a Pandas Series usually is created from an existing database, CSV file, or an excel file.
      • pandas.Series(data=None, index=None, dtype=None, name=None, copy=False): Create and return a Pandas Series object fromdata.
        • data: Optional. Can be a list, a ndarray, a scalar value, etc.
        • index: Optional. Array like. Indexes must be unique and hashable, and have the same length as data. If no index is passed, use the values from numpy.arrange(n) as indexes, where n is the size of data.
        • dtype: Optional. Data type. If None, it will be inferred fromdata.
        • name: Optional. String. The name to give to the Series.
        • copy: Optional. Boolean. Copy data from the inputs. Its default is False.
      • Create an Empty Series:
      • Create a Series from a ndarray:
      • Create a Series from a Dictionary: A dictionary can be used as the data to create a Series. If no index is specified, the dictionary's keys will be taken in a sorted order as indexes. Otherwise, if a key is the same as a label in the given index, the corresponding value in the dictionary will be kept as the value to the index label. If an index label is not a key of the dictionary, its corresponding value in the Series will be set to NaN.
      • Create a Series from a Scalar: If a scalar value is used to create a Series, an index must be provided. The scalar value will be repeated to match the length of the index.
    • Access Data from Series: Similar to the accessing methods for ndarrays, a single Series element can be accessed using a single position, and multiple Series elements can be accessed using a slice. Series elements can also be accessed using index labels. In the following, we assume ser is a Pandas Series.
      • Retrieve Data Using a Single Position ser[pos]: Retrieve and return the value that is located at the positonpos. In a Pandas Series, the first element is stored at the 0th position, the second element is stored at the 1th positon, and so on.
      • Retrieve Data Using Slice ser[start: end]: Retrieve the elements between the start position (inclusive) and the end position(exclusive), and return a Pandas Series that contains the elements with same indexes as in the original Series. Ifstartis not given, use 0 as the start position. Ifendis not given, use the length of the Series.
      • Retrieve Data Using Index: For a Pandas Series, each value has a corresponding index. Each time, either a single value can be retrieved and returned using its corresponding index label or a Series of multiple elements can be retrieved and returned using a list of index labels. If the given index label is not in the index of the Series, an exception will be raised.
    • Series Attributes:
      • array: Return the underlying data of the Series as a Pandas array.
      • at[]: Access and return a single value using a label.
      • attrs: Return a dictionary of the global attributes of the underlying data.
      • axes: Return the index of the Series.
      • dtype: Return the dtype object of the underlying data.
      • dtypes: Return the dtype object of the underlying data.
      • empty: Return True if the Series is empty; otherwise, return False.
      • flags: Return the properties associated with the Series.
      • hasnans: Return True if there are any NaNs in the Series.
      • iat[]: Access and return a single value using an integer position.
      • iloc[]: Access and return a single value using an integer position, or return a Series if given a slice of positions or a list of positions.
      • index: Return the index of the Series.
      • is_monotonic: Return True if the values in the object are monotonic_increasing; otherwise, return False.
      • is_monotonic_decreasing: Return True if the values in the object are monotonic_decreasing; otherwise, return False.
      • is_monotonic_increasing: Same as is_monotonic.
      • is_unique: Return True if the values in the object are unique; otherwise, return False.
      • loc: Access and return a single value using a single label, or return a Series if given a list of labels.
      • name: Return the name of the Series. Return None if the Series has no name.
      • nbytes: Return the number of bytes in the underlying data.
      • ndim: Return the number of dimensions of the underlying data of the Series.
      • shape: Return a tuple of the shape of the underlying data.
      • size: Return the number of elements in the underlying data of the Series.
      • values: Return the underlying data of the Series as a ndarray.
      • T: Return the transpose, which is itself.
    • Series Methods:
      • abs(): Return a new Series with the absolute value of each element in the given Series.
      • add(other[, level=None, fill_value=None, axis=0]): Binary operator. Perform element-wise addition of the given Series andother, and return a new Series containing the results.
        • other: a Series or scalar value.
        • level: int or name. Broadcast across a level, matching index values on the passed multiindex level.
        • fill_value: a float value or None. Fill existing missing values and any new element needed for successful Series alignment with this value.
        • axis: For Series, add along axis 0.
      • add_prefix(prefix): Prefix the row labels with the stringprefixand return a new Series with updated labels.
      • add_suffix(suffix): Suffix the row labels with the stringsuffixand return a new Series with updated labels.
      • agg(func[, axis=0, *args, **kwargs]): Aggregate using one or more operations over the specified axis, and return the results.
        • func: a function, a function name, a list of functions and/or function names.
        • axis: For Series, add along axis 0.
        • *args: Positional arguments to pass to func.
        • **args: Keyword arguments to pass to func.
      • aggregate(func[, axis=0, *args, **kwargs]): Aggregate using one or more operations over the specified axis.
      • align(other[, join='outer', axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None]): Align two objects with the specified join method along the specified axis, and return aligned objects.
        • other: a Series or a DataFrame.
        • join: Default 'outer'. One of four join methods: 'outer', 'inner', 'left', 'right'.
        • axis: Allowed axis of the other object. Its default is None. Align along index (0), columns (1), or both (None).
        • level: int or name. Broadcast across a level, matching index values on the passed multiindex level.
        • copy: Boolean, default True; Return new objects. If copy=False and no reindexing is required then original objects are returned.
        • fill_value: a scalar, default np.NaN. Fill existing missing values and any new element needed for successful Series alignment with this value.
        • method: String, default None. One of four filling methods: 'backfill', 'bfill', 'pad', 'ffill'. Method to use for filling missing values in reindexed Series. 'pad'/'ffill': use last valid observation to fill gap; 'backfill'/'bfill': use next valid observation to fill gap.
        • 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.
        • fill_axis: Default 0. Filling axis.
        • broadcast_axis: Default None. Broadcast values along this axis, if aligning two objects of different dimensions
      • all([axis=0, bool_only=None, skipna=True, level=None, **kwargs]): Return True if all elements are True or equivalent (not zero or empty); otherwise, return False.
        • axis: 0/'index', 1/'columns', or None. Default 0. Indicate which axis or axes should be reduced.
          • 0/'index': Reduce the index; Use the original column labels as the index in the returned Series.
          • 1/'columns': Reduce the columns; Use the original index as the index in the returned Series.
          • None: Reduce all axes; return a scalar.
        • bool_only: Boolean, default None. If True, include only boolean columns; otherwise, use everything.
        • skipna: Boolean, default True. If True, exclude NA/null values.
        • level: int or level name, default None. If the axis is a multiindex, count along a particular level, and collapse into a scalar.
        • **kwargs: Additional keywords, default None. Might be accepted for compatibility with NumPy.
      • any([axis, bool_only=None, skipna=True, level=None, **kwargs]): Return True if any element is True or equivalent (not zero or empty); otherwise, return False.
      • apply(func[, convert_dtype=True, args, **kwds]): Invoke function(s) on the values of the given Series, and return a new series (or a DataFrame).
        • func: A single function or a list of multiple functions. The functions can be Python functions or NumPy ufuncs.
        • convert_dtype: Boolean, default True. Try to convert the dtype for the element-wise results returned from functions. If False, leave as dtype=object.
        • args: An iterable. Positional arguments passed to func after the Series value.
        • **kwds: Additional keyword arguments passed to func.
      • argmax([axis=0, skipna=True, *args, **kwargs]): Return the integer position of the largest value in the Series. Return -1 if skipna is set to False and there is NaN in the Series.
      • argmin([axis, skipna]): Return integer position of the smallest value in the Series. Return -1 if skipna is set to False and there is NaN in the Series.
      • argsort([axis=0, kind='quicksort', order=None]): Argsort the values. Omitting NA/null values when sorting. Return a new Series whose values are the positions of the values in a sorted sequence with -1 for NaN values.
        • kind: 'mergesort', 'quicksort', or 'heapsort'; default 'quicksort'. Choice of a sorting algorithm.
        • order: None. Has no effect but is accepted for compatibility with NumPy.
      • astype(dtype[, copy=True, errors='raise', **kwargs]): Cast the given Series to a specified data type, and return a new Series with the new dtype.
        • dtype: Data type, or dict of column name-dtype pairs.
        • copy: Boolean, default True. Return a copy when copy=True.
        • errors: 'raise' (allow exceptions to be raised) or 'ignore' (suppress exceptions); default 'raise'.
        • **kwargs: keyword arguments to pass to the constructor.
      • autocorr([lag=1]): Compute the lag-N autocorrelation. Return the Pearson correlation between the Series and its shifted self.
        • lag: int, default 1. The number of lags to apply before performing autocorrelation.
      • between(left, right[, inclusive='both']): Return a boolean Series in which an element is True if the corresponding element in the given Series is between the boundary valuesleftandright;False otherwise.
        • left: scalar, left boundary.
        • right: scalar, right boundary.
        • inclusive: 'both' or 'neither', default 'both'. If it is 'both', include both boundaries; otherwise, exclude boundaries.
      • clip([lower=None, upper=None, axis=None, inplace=False, *args, **kwargs]): Replace values outside boundaries with their closest boundary value. Thresholds can be singular values or array like. If thresholds are array like, clipping is performed element-wise along the specified axis. Return a new Pandas object with the values outside the boundaries replaced.
        • lower: float or array-like, default None. Minimum threshold value. All values smaller than it will be set to it.
        • upper: float or array-like, default None. Maximum threshold value. All values larger than it will be set to it.
        • axis: int or string (axis name). Align object with lower and upper along this axis.
        • inplace: Boolean, default False. Indicate whether or not perform operations in place.
        • *args, **kwargs: Additional keywords; have no effect but might be accepted for compatibility with NumPy.
      • combine(other, func[, fill_value=None]): Combine the Series with a Series or scalar usingfuncto perform element-wise selection for combined Series, and return the combined Series.
        • other: Series or scalar. Its value(s) is (are) to be combined with the Series.
        • func: A function that takes two scalars as inputs and returns an element.
        • fill_value: scalar, default None. A value to be used when an index is missing from the given Series or the other. If it is not given or None, use NaN.
      • combine_first(other): Combine Series withotherby choosing the calling Series’s values first, and return the combined Series.
      • copy([deep=True]): Make a copy of the given object's indexes and data. deepis a boolean. If deep=True (default), a new object will be created and returned. Any changes to the new object will not affect the original object. If deep=False, only a reference to the data and index of the original object is created. Any changes to the copy will be reflected to the original object and vice versa.
      • corr(other[, method='pearson', min_periods=None]): Compute and return the correlation withother,excluding missing values.
        • other: Series with which to compute the correlation.
        • method: 'pearson', 'kendall', 'spearman', or callable (a function with two 1-D ndarrays as inputs; it returns a float).
        • min_periods: int, default None. Minimum number of observations needed to have a valid result.
      • count([level=None]): Return the number of non-NA/null observations along the specified level in the Series.
        • level: int or level name, default None.
      • cov(other[, min_periods=None]): Covariance between Series and other normalized by N-1 (unbiased estimator), excluding missing values.
      • cummax([axis=None, skipna=True, *args, **kwargs]): Return a Series or a DataFrame of the same size containing the cumulative maximum of a given Series or DataFrame along the specified axis.
      • cummin([axis=None, skipna=True, *args, **kwargs]): Return a Series or a DataFrame of the same size containing the cumulative minimum of a given Series or DataFrame along the specified axis.
      • cumprod([axis=None, skipna=True, *args, **kwargs]): Return a Series or a DataFrame of the same size containing the cumulative product of a given Series or DataFrame along the specified axis.
      • cumsum([axis=None, skipna=True, *args, **kwargs]): Return a Series or a DataFrame of the same size containing the cumulative sum of a given Series or DataFrame along the specified axis.
      • describe([percentiles=None, include=None, exclude=None]): Generate descriptive statistics that summarize the central tendency, dispersion and shape of a dataset’s distribution, excluding NaN values. Its return values includecount, mean, std, min, IQR,andmaxvalues.
        • include: It is used to pass the information regarding what columns will be used for summarizing.
          • 'all': Summarizes all columns together.
          • A list-like dtypes: A list that includes the data types (np.object, np.number, 'category', etc) that should be included in the results.
          • None: Default; the results will include all numeric columns.
        • exclude: Ignored for Series.
          • A list-like dtypes: A list that includes the data types (np.object, np.number, 'category', etc) that should be excluded from the results.
          • None: Default; the results will exclude nothing.
      • diff([periods=1]): For each element in a Series, calculate the difference with another element in the Series, and return a new Series containing the differences. By default, period=1; it is to calculate the difference with its previous element.
      • div(other[, level=None, fill_value=None, axis=0]): Return the float division of the Series and other, element-wise (binary operator truediv).
        • other: A Series or a scalar value.
        • fill_value: None or a float value; Default None. Use this value to fill existing missing values (NaN), and any new element needed for a successful alignment between the Series andother.before computation. If data are missing in both corresponding Series locations, the result for that location will be missing.
        • level: int or name. Broadcast across a level, matching index values on the passed MultiIndex level.
      • divide(other[, level=None, fill_value=None, axis=0]): Same as div().
      • divmod(other[, level=None, fill_value=None, axis=0]): Return a tuple of two Series with the first Series containing the integer division and the second Series containing the modulo of the given Series andother,element-wise (binary operator divmod).
      • dot(other): Computes the dot product between the Series and another oneother,or the Series and each columns of a DataFrame, or the Series and each column of an array.
      • drop([labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise']): Return a Series with the specified index labels removed.
      • drop_duplicates([keep='first', inplace=False]): Return a new Series with duplicate values removed.
        • keep:
          • 'first': Drop duplicates except for the first occurrence.
          • 'last': Drop duplicates except for the last occurrence.
          • False: Drop all duplicates.
        • inplace: Boolean. Default False. If True, performs operations inplace and returns None.
      • dropna([axis=0, inplace=False, **kwargs]): Return a new Series with missing values removed.
      • duplicated([keep='first']): Return a Series of boolean values indicating whether each value has occurred in the preceding values.
      • eq(other[, level=None, fill_value=None, axis=0]): Return a Series of boolean values indicating whether the corresponding values in the Series andotherare equal; it is element-wise (binary operator eq). If data are missing in both corresponding Series locations, the result at that location will be False.
      • equals(other): Test whether two Series or (DataFrames) have the same shapes and elements, and return a boolean value indicating whether they are the same. The elements must be the same dtype. NaNs in both corresponding locations are considered equal. The indexes or column headers do not need to be the same.
      • ewm([com=None, span=None, halflife=None, alpha=None, min_periods=0, adjust=True, ignore_na=False, axis=0]): Provide exponentially weighted (EW) calculations.
        • com: Optional; float; Specify decay in terms of center of mass.
        • span: Optional; float; Specify decay in terms of span.
        • halflife: Optional; float; Specify decay in terms of half-life.
        • alpha: Optional; float; Specify smoothing factor.
        • min_periods: int; default 0; Specify minimum number of observations in window required to have a value.
        • adjust: bool; default True; Divide by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.
        • ignore_na: bool; default False. Ignore missing values when calculating weights.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Specify the axis to use.
      • expanding([min_periods=1, center=False, axis=0]): Provide expanding transformations.
        • min_periods: int; default 1; Specify minimum number of observations in window required to have a value.
        • center: bool; default False; Set the labels at the center of the window.
        • axis: int or str; default 0.
      • explode([ignore_index=False]): Transform each element of a list-like to a row.
        • ignore_index: Optional; boolean; default False. If ignore_index=False, index will be duplicated for the rows derived from the same list. Otherwise, index will not be duplicated for the rows.
      • ffill([axis=None, inplace=False, limit=None, downcast=None]): Synonym for DataFrame.fillna() with method='ffill'. Return a new Series with the missing values filled with the last valid obervation.
        • axis: int or str; default 0. Axis used to fill missing values along.
        • inplace: bool; default False; If True, fill in-place.
        • limit: int; default None; It is the maximum number of entries along the entire axis where NaNs will be filled.
        • downcast: dict; default 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).
      • fillna([value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs]): Fill NA/NaN values using the specified method and return a new Series with NA/NaN values filled.
        • value: scalar, dict, Series, or DataFrame; specifies the value to use for filling missing values.
        • method: 'backfill', 'bfill', 'pad', 'ffill', None. 'backfill' or 'bfill' is to use next valid observation to fill the missing values.
      • floordiv(other[, level=None, fill_value=None, axis=0]): Return a new Series containing the integer division of the given Series andother,element-wise (binary operator floordiv). If data are missing in both corresponding Series locations, the result for that location will be missing.
      • ge(other[, level=None, fill_value=None, axis=0]): Return a new Series of boolean values indicating whether an element in the Series is greater than or equal to the value at the corresponding location inother;it is element-wise (binary operator ge). If data are missing in both corresponding Series locations, the result for that location will be False.
      • get(key[, default=None]): Get the item from the given Series/DataFrame for a given key (ex: a DataFrame column). Return the default valuedefaultif not found.
      • gt(other[, level=None, fill_value=None, axis=0]): Return a new Series of boolean values indicating whether an element in the Series is greater than the value at the corresponding location inother;it is element-wise (binary operator gt). If data are missing in both corresponding Series locations, the result for that location will be False.
      • head([n=5]): Return the first n rows. By default, n is 5.
      • hist([by=None, ax=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, figsize=None, bins=10, **kwds]): Draw a histogram plot of the input Series using matplotlib.
        • by: object, optional. It is used to form histograms for separate groups.
        • ax: matplotlib axis object. If not passed, uses gca().
        • grid: bool, default True. Indicates whether or not to show axis grid lines.
        • xlabelsize: int, default None. It is used to change the x-axis label size.
        • xrot: float, default None. Rotation of x axis labels.
        • ylabelsize: int, default None. It is used to change the y-axis label size.
        • yrot: float, default None. Rotation of y axis labels.
        • figsize: tuple, default None. The figure size in inches by default.
        • bins: integer or sequence, default 10. The 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 the left edge of the first bin and the right edge of the last bin. In this case, bins is returned unmodified.
        • **kwds: keywords, optional. To be passed to the actual plotting function.
      • idxmax([axis=0, skipna=True, *args, **kwargs]): Return the row label of the maximum value. If multiple values equal the maximum, the first row label with that value will be returned. If skipna=False, NaN will be returned if there are NaNs in the Series.
      • idxmin([axis, skipna]): Return the row label of the minimum value. If multiple values equal the minimum, the first row label with that value will be returned. If skipna=False, NaN will be returned if there are NaNs in the Series.
      • infer_objects(): Attempt to infer better dtypes for object-dtyped columns, leaving non-object and unconvertible columns unchanged.
      • interpolate([method='linear', axis=0, limit=None, inplace=False, limit_direction='forward', limit_area=None, downcast=None, **kwargs]): Fill NaN values using an interpolation method.
        • method: str, default 'linear'. The method to use to do interpolation.
          • 'linear': Ignore the index and treat the values as equally spaced. This is the only method supported on MultiIndexes.
          • 'time': Works on daily and higher resolution data to interpolate given length of interval.
          • 'index'/'values': Use the actual numerical values of the index.
          • 'pad': Fill in NaNs using existing values.
          • 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'spline', 'barycentric', 'polynomial': These methods use the numerical values of the index. Both 'polynomial' and 'spline' require that an order (int) is also specified,
          • 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima': Wrappers around the SciPy interpolation methods of similar names.
          • 'from_derivaives':
        • axis: 0 or 'index', or 1 or 'columns', or None; default None. Axis to interpolate along.
        • limit: int, optional. Maximum number of consecutive NaNs to fill. Must be greater than 0.
        • inplace: bool, default False. Update the data in place if possible.
        • limit_direction: 'forward', 'backward', 'both'; default 'forward'. If limit is specified, consecutive NaNs will be filled in this direction.
        • limit_area: If limit is specified, consecutive NaNs will be filled with this restriction.
          • None: No fill restriction.
          • 'inside': Only fill NaNs surrounded by valid values (interpolate).
          • 'outside': Only fill NaNs outside valid values (extrapolate).
        • downcast: Optional; 'infer' or None; default None. Downcast dtypes if possible.
        • **kwargs: Keyword arguments to pass on to the interpolating function.
      • isin(values): Return a new Series of the same size as the given Series. Each element is a boolean value indicating whether the corresponding element in the given Series is contained in the passed sequence ofvalues.It is True if contained; otherwise, it is False.
      • isna(): Return a new Series of the same size as the given Series. Each element is a boolean value indicating whether the corresponding element in the given Series is a missing value. It is True if the element is NA/NaN; otherwise, it is False.
      • isnull(): Alias of isna().
      • item(): Return the first element of the given Series as a Python scalar. This function can only convert an array of size 1 to a Python scalar.
      • items(): Return a zip object containing tuples of index-values.
      • iteritems(): Same as items().
      • keys(): Return the index of the Series.
      • kurt([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the unbiased kurtosis over the specified axis, using Fisher’s definition of kurtosis (kurtosis of normal == 0.0).
        • axis: Optional. 0 or index, or 1 or 'columns'. Axis for the function to be applied along.
        • skipna: bool; default True. Exclude NA/NaN 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 scalar.
        • numeric_only: bool; default None. Include only float, int, or boolean columns. If none, will try to use everything, then use only numeric data. Not a parameter for Series.
        • **kwargs: Optional. Additional keyword arguments to be passed to the function.
      • kurtosis([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Same as kurt().
      • last_valid_index(): Return the index for the last non-NA value, or return None if no non-NA value is found.
      • le(other[, level=None, fill_value=None, axis=0]): Return a new Series of boolean values indicating whether an element in the Series is less than or equal to the value at the corresponding location inother;it is element-wise (binary operator le). If data are missing in both corresponding Series locations, the result for that location will be False.
      • lt(other[, level=None, fill_value=None, axis=0]): Return a new Series of boolean values indicating whether an element in the Series is less than the value at the corresponding location inother;it is element-wise (binary operator lt). If data are missing in both corresponding Series locations, the result for that location will be False.
      • mad([axis=None, skipna=True, level=None]): Return the mean absolute deviation (the average distance between each value and mean) of the values over the specified axis.
      • map(arg[, na_action=None]): Map values of the given Series according to an input mapping (a dict or a Series) or a function.
        • arg:A function, dict, or Series. Mapping correspondence.
        • na_action: None or 'ignore'; default None. If 'ignore', propagate NaN values, without passing them to the mapping correspondence.
      • mask(cond[, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False]): Replace values that satisfy the condition withother, and return a new object with the changes.
        • cond: bool Series/DataFrame, array-like, or callable. Where cond is False, keep the original value. Where True, replace with corresponding value fromother.
        • other: A scalar, Series/DataFrame, or callable. It is used to replace the values where the condition is True. Default is nan.
        • inplace: bool; default False. Whether to perform the operation in place on the data.
        • axis: int; default None. Axis for the operations to perform along.
        • level: int; default None. Alignment level if needed.
        • errors: 'raise' (allow exceptions to be raised), or 'ignore' (suppress exceptions); default 'raise'.
        • try_cast: bool; default False. Try to cast the result back to the input type (if possible).
      • max([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the maximum of the values over the requested axis.
      • mean([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the mean of the values over the requested axis.
      • median([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the median of the values over the requested axis.
      • min([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the minimum of the values over the requested axis.
      • memory_usage([index=True, deep=False]): Return the memory usage of the Series.
        • index: bool; default True. Specifies whether to include the memory usage of the index.
        • deep: bool; default False. If True, introspect the data deeply by interrogating the object dtypes for system-level memory consumption, and include it in the returned value.
      • mod(other[, level=None, fill_value=None, axis=0]): Return a new Series containing the modulos of the given Series andother, element-wise (binary operator mod).
      • mode([dropna=True]): Return a new Series containing the mode(s) of the given Series.
      • mul(other[, level=None, fill_value=None, axis=0]): Return a new Series containing the multiplications of the given Series andother,,element-wise (binary operator mul).
      • multiply(other[, level=None, fill_value=None, axis=0]): Same as mul().
      • ne(other[, level=None, fill_value=None, axis=0]): Return a new Series containing boolean values indicating whether corresponding elements of the given Series andother,are not equal. It is True if not equal and False otherwise. It is element-wise (binary operator ne).
      • nlargest([n=5, keep='first']): Return first n largest elements of descending sorted values.
        • n: Return first n largest values of descending sorted values.
        • keep: 'first' (default; return the first n occurrences in order of apprearances), 'last' (return the last n occurrences in reverse order of apprearances), 'all' (keep all occurrences of top n largest elements. If there are None or numpy.nan, they will be included in the returned Series. The size of the returned Series may be larger than n).
      • notna(): Return a new Series containing boolean values indicating whether the elements are not missing values. The value is True if the corresponding element is not a missing value; it is False otherwise.
      • notnull(): An alias for Series.notna.
      • nsmallest([n=5, keep='first']): Similar to nlargest(), except that it returns first n smallest values of ascending sorted values.
      • nunique([dropna=True]): Return the number of unique elements in the object.
      • pad([axis=None, inplace=False, limit=None, downcast=None]): Synonym for DataFrame.fillna() with method='ffill'. The original Series is unchanged if using default inplace. If inplace=True, return None. The original Series is changed with missing values filled.
      • pct_change([periods=1, fill_method='pad', limit=None, freq=None, **kwargs]): For each element except the first element in the given Series, calculate the percentage change between the element and its prior element, and return a new Series of the percentage changes with the first element set to numpy.nan.
      • plot(*args, **kwargs):
        • plot.area([x=None, y=None, stacked=True, **kwargs]): Make an area plot, or return a ndarray of area plots if subplots=True.
          • x: Optional. Label or position. X coordinates. By default, it is the index.
          • y: Optional. Label or position. Column to plot. By default, use all columns.
          • stacked: bool; default True. Area plots are stacked by default. If set to False, the plot will be unstacked plot.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.bar([x=None, y=None, **kwargs]): Make a bar plot, or return ndarrays or matplotlib.axes.Axes if subplots=True.
        • plot.barh([x=None, y=None, **kwargs]): Make a horizontal bar plot, or return ndarrays of matplotlib.axes.Axes if subplots=True.
        • plot.box([by=None, **kwargs]): Make a box plot, or return ndarrays or matplotlib.axes.Axes if subplots=True.
          • by: Optional; str or sequence. Column in the DataFrame to group by.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.density([bw_method=None, ind=None, **kwargs]): Make a kernel density estimate plot using Gaussian kernels, or return ndarrays or matplotlib.axes.Axes if subplots=True.
          • by: str, scalar, or callable; optinal. Method used to calculate the estimator bandwidth.
          • ind: Optional. ndarray or integer. Evaluation points for the estimated PDF. If None (default), 1000 equally spaced points are used. If ind is a ndarray, the KDE is evaluated at the points passed. If ind is an integer, the ind number of equally spaced points are used.
          • **kwargs: Optional. Additional keyword arguments documented in pandas.%(this-datatype)s.plot().
        • plot.hist([by=None, bins=10, **kwargs]): Make a histogram plot.
          • by: Optional; str or sequence. Column in the DataFrame to group by.
          • bins: int, default 10. Number of histogram bins to be used.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.kde([bw_method=None, ind=None, **kwargs]): Same as plot.density().
        • plot.line([x=None, y=None, **kwargs]): Plot a line for Series or lines using DataFrame's values as coordinates, or return an ndarray or matplotlib.axes.Axes if subplots=True.
        • plot.pie(x=None, y=None, **kwargs): Make a pie plot for a Series/DataFrame.
      • pop(item): Return the value indexed atitemand drops it from the given Series.
        • item: Required. str or position. The corresponding element will be dropped from the Series.
      • pow(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the exponential power of the corresponding elements in Series andother,. It is element-wise (binary operator pow). If both corresponding locations in Series andother,have missing values, the value at that location in the new Series is missing too.
      • prod([axis=None, skipna=None, level=None, numeric_only=None, min_count=0, **kwargs]): Return the product of the values over the specified axis.
        • min_count: int, default 0. The minimum number of valid values required to perform the operation.
      • product([axis=None, skipna=None, level=None, numeric_only=None, min_count=0, **kwargs]): Same as prod().
      • quantile([q=0.5, interpolation='linear']): Return a float (if q is a float) or a Series (if q is an array-like) at the given quantile q.
        • q: float or array-like; default 0.5 (50% quantile). 0<=q<=1, the quantile(s) to compute.
        • interpolation: Optional. Default 'linear'. Specifies the interpolation method to use, when the desired quantile is between two data points i and j:
          • 'linear': i+(j - i)*fraction, where fraction is the fractional part of the index surrounded by i and j.
          • 'lower': i.
          • 'higher': j.
          • 'nearest': i or j whichever is nearest.
          • 'midpoint': (i+j)/2.
      • radd(other[, level=None, fill_value=None, axis=0]): Return a new Series containing the addition of the given Series andother,element-wise (binary operator radd). If the values at both corresponding Series locations are missing, the value at the corresponding location in the returned Series will be missing.
      • rank([axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False]): Return a Series or a Dataframe containing the numerical data ranks (1 through n) of a given Series or a given DataFrame along the specified axis.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Axis along which to rank.
        • method: Method to rank the group of records that have the same value (ties).
          • 'average': Average rank of the tied group.
          • 'min': Lowest rank in the group.
          • 'max': Highest rank in the group.
          • 'first': Ranks assigned in the order they appear in the array.
          • 'dense': Similar to 'min', but rank always increases by 1 between groups.
        • numeric_only: bool, optional. For a DataFrame object, rank only numeric columns if set to True.
        • na_optional: Specifies how to rank NaN values. Default 'keep'.
          • 'keep': Default. Set NaN to NaN values.
          • 'top': Assign the smallest rank to NaN values if ascending.
          • 'bottom': Assgin the highest rank to NaN values if ascending.
        • ascending: bool; default True. Indictate whether or not the elements should be ranked in ascending order.
        • pct: bool; default False. Indicate whether or not display the returned rankings in percentile form.
      • ravel([order='C']): Return the flattened underlying data of the given Series as an ndarray.
        • order: Optional; index order; one of 'C', 'F', 'A', or 'K'.
      • rdiv(other[, level=None, fill_value=None, axis=0]): Return a new Series containing the float division ofother,and the given Series, element-wise (binary operator rdiv). If the values at both corresponding Series locations are missing, the value at the corresponding location in the returned Series will be missing.
      • rdivmod(other[, level=None, fill_value=None, axis=0]): Return a tuple of two Series with the first Series containing the integer division and the second Series containing the module ofother,and the given Series, element-wise (binary operator radd). If the values at both corresponding Series locations are missing, the value at the corresponding location in the returned Series will be missing.
      • reindex([index=None, **kwargs]): Conform a given object to an object with new index. Place NA/NaN at locations that have no value at the same index in the original object. The returned object will be a new one unless the new index is the same as the original one and copy=False.
      • reindex_like(other[, method=None, copy=True, limit=None, tolerance=None]): Conform a given object to the same index ofotheron all axes with an optional filling logic. Place NA/NaN at locations that have no value at the same index in the original object. The returned object will be a new one unless the new index is the same as the original one and copy=False.
        • other: A Series.
        • method: Optional. Filling method.
          • pad/ffill: Fill values forward.
          • bfill/backfill: Fill values backward.
          • nearest: Fill from the nearest index values.
        • copy: Optional; bool; default True. Return a new object, even if the passed indexes are the same.
        • limit: Optional. Specifies the maximum number of consecutive labels to fill for inexact matches.
        • tolerance: Optional. The maximum distance between original and new labels for inexact matches.
      • rename([index=None, copy=True, inplace=False, level=None]): Return a Series with index labels or the name of the given Series altered.
        • index: scalar, hashable sequence, dict-like, or function; optional. To apply the dict-like or function as transformations to the index. Scalar or hashable sequence will alter the name of the Series.
        • copy: bool; default True. Whether or not copy the underlying data.
        • inplace: bool; default False. Whether or not modify the object directly, or create a new object. If True, will not return a new object, and the value of copy will be ignored.
        • level: int or level name; default None. In case of MultiIndex, only rename labels in the specified level.
      • rename_axis([mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False]): Set the name of the axis for the index or columns.
        • mapper: scalar, or list-like; optional. Value to set the axis name.
        • index: scalar, list-like, dict-like, or function; optional. To apply it as transformations to the axis' values.
        • columns: Same as index.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Axis to rename.
        • copy: bool; default True. Whether or not copy the underlying data.
        • inplace: bool; default False. Whether or not modify the object directly, or create a new object. If True, will not return a new object, and the value of copy will be ignored.
      • repeat(repeats[, axis=None]): Returns a new Series where each element of the given Series is repeated consecutively a given number of times.
        • repeats: int or array of integers. The number of repetitions for each element. If it is an array, the size must be the same as the size of the Series.
        • axis: Must be None. It has no effect, but is accepted for compatibility with numpy.
      • replace([to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad']): Replace values given in to_replace with the valuevalue.
        • to_replace: str, regex, list, dict, Series, int, float, or None. Values to be replaced.
        • value: scalar, dict, list, str, regex, default None. Value used to replace any values matching with to_replace.
        • inplace: bool, default False. If True, modify the original Series; otherwise, return a new Series. The original Series is unchanged.
        • limit: int, default None. The maximum gap size to fill.
        • regex: bool, default False, indicate whether to interpret to_replace and/or value as regular expressions. If it is True, to_replace must be a string. It can be a regular expression, a list, dict, or an array of regular expressions. In this case, to_replace must be None.
        • method: 'pad', 'ffill', 'bfill', or None. The method to use when do replacement.
      • reset_index([level=None, drop=False, name=None, inplace=False]): Generate a new Series or DataFrame with the index reset.
      • rfloordiv(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the integer division of the corresponding elements inotherand the given Series. It is element-wise (binary operator). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series will be missing too.
      • rmod(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the module of the corresponding elements inotherand the given Series. It is element-wise (binary operator rmod). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series will be missing too.
      • rmul(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the multiplication of the corresponding elements inotherand the given Series. It is element-wise (binary operator rmul). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series will be missing too.
      • round([decimals=0, *args, **kwargs]): Round each value in a given Series to the given number of decimals.
      • rpow(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the exponential power of the corresponding elements inotherand the given Series. It is element-wise (binary operator rpow). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series will be missing too.
      • rsub(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the subtraction of the corresponding elements inotherand the given Series. It is element-wise (binary operator rsub). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series will be missing too.
      • rtruediv(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the float division of the corresponding elements inotherand the given Series. It is element-wise (binary operator). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series will be missing too.
      • sample([n=None, frac=None, replace=False, weights=None, random_state=None, axis=None]): Return a new object that is of the same type as the caller and contains n randomly sampled items from the caller.
        • n: int, optional. Specifies the number of items to return from the specified axis. If frac=None, its default value is 1. Cannot be used with frac when it is not None.
        • frac: float, optional. Fraction of items to return. Cannot be used with n.
        • replace: bool, default False. Sample with or without replacement.
        • weights: str or ndarray-like, optional, default None meaning equal probability weighting. Missing values will be treated as zeros. Do not allow infinite values.
        • random_state: int or numpy.random.RandomState, optional. Seed for the random number generator if int, or numppy RandomState object.
        • axis: int or str specifying which axis to use for sampling.
      • searchsorted(value[, side='left', sorter=None]): Find indices wherevalueshould be inserted to maintain the sorted order.
        • value: array-like. Values to insert into the given object.
        • side: 'left' or 'right', default 'left'. If ‘left’, return the index of the first found location. If ‘right’, return the index of the last found location. If there is no suitable index, return either 0 or N (where N is the length of the given object).
        • sorter: 1-D array-like, optional. Array of integer indices that sort the given object in ascending order.
      • sem([axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs]): Return the unbiased standard error of the mean over the specified axis.
        • ddof: int, default 1. Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.
        • numeric_only: bool, default None. Include only float, int, and boolean columns. Not implemented for Series.
      • set_axis(labels[, axis=0, inplace=False]): Assign a new index or a list-like to a given axis or a column.
        • labels: like-like, Index. The values for the new index.
      • shift([periods=1, freq=None, axis=0, fill_value=None]): Shift the index by the desired number of periods with an optional timefreq.
        • periods:int, default 1. Number of periods to shift; can be positive or negative.
        • freq: Optional, DateOffset, tseries.offsets, timedelta, or str. Offset to use from the tseries module or time rule (e.g. ‘EOM’).
        • axis: 0 or 'index', or 1 or 'columns'. Default None.
        • fill_value: Optional, float. A scalar value used to fill the newly introduced missing values.
      • sort_index([axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True]): Sort the given object by its index labels.
        • axis: int, default 0. Axis to do the direct sorting on.
        • level: int, optional. If not None, sort on values in the specified index levels.
        • ascending: bool, default False. Sort in ascending or descending order.
        • inplace: bool, default False. If True, perform operations in place.
        • kind: 'quicksort', 'mergesort', or 'heapsort'; default 'quicksort'. The sorting algorithm chosen.
        • na_position:'first' or 'last'. If 'first', put NaNs at the beginning; 'last' put NaNs at the end. Not implemented for MultiIndex.
        • sort_remaining: bool, default True. If True and index is multilevel, sort by level; sort by other levels too after sorting by the specified level.
      • sort_values([axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last']): Sort by the values.
      • squeeze([axis=None]): Return the projection after squeezing the specified axis. If axis=None, all length-1 axes will be squeezed.
      • std([axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs]): Return sample standard deviation over the specified axis.
      • str: Vectorized string functions for Series and Index. NAs stay as NAs unless are handled by a particular method. It's patterned after Python's string methods.
      • sub(other[, level=None, fill_value=None, axis=0]): Return a new Series in which every element is the subtraction of the corresponding elements in the given Series andother. It is element-wise (binary operator pow). If both corresponding locations in Series andother,have missing values, the value at that location in the new Series is missing too.
      • subtract(other[, level=None, fill_value=None, axis=0]): Same as sub().
      • sum([axis=None, skipna=True, level=None, numeric_only=None, min_count=0, **kwargs]): Return a scalar which is the sum of the values from the specified axis.
        • min_count: int, default 0. The required number of valid values to perform the operation. If the number of valid values is less than min_count, the result will be NA.
      • tail([n]): Return the last n rows.
      • take(indices[, axis=0, is_copy=True, **kwargs]): Return the elements in the given positional indices along the specified axis.
        • indices:array-like. An array of ints indicating which position to take.
        • axis: 0 or 'index', 1 or 'columns', None; default 0.
        • is_copy:bool, default True. Whether return a copy of the original object or not.
        • kwargs: For compatibility with numpy.take().
      • to_csv([path_or_buf=None, sep=',', na_rep='', float_format=None, columns, header=True, index=True, index_label=None, mode='w', encoding, compression='infer', quoting, quotechar='"', line_terminator, chunksize=None, date_format=None, doublequote=True, escapechar=None, decimal='.']): Write the object to a comma-separated values (csv) file.
        • path_or_buf: str or file handle, default None. File path or object. If None is provided, the result will be returned as a string. If a file object is passed, it should be opened with newline='' with universal newlines disabled.
        • sep:str, default ','. String of length 1. Field delimiter for the output file.
        • na_rep: str, default ''. Missing data representation.
        • float_format: str, default None. Format string for floating point numbers.
        • columns: sequence, optional. Columns to write.
        • header: bool or list of str, default True. Write out the columns names.
        • index: bool, default True. Write row names (index).
        • index_label: str or sequence, or False, default None. Column label for index column(s) if desired.
        • mode: str. Python write mode, default 'w'.
        • encoding: str, optional. A string representing the encoding to use in the output file; default 'utf-8'.
        • compression: 'infer', 'gzip', 'bz2', 'zip', 'xz', or None, default 'infer'. Compression mode. If 'infer' and path_or_buf is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', or '.xz'; otherwise, no compression.
        • quoting: optional constant from csv module.
        • quotechar: str, default '"'. String of length 1. Character used to quote fields.
        • line_terminator: str, optional. The newline character or character sequence to use in the output file.
        • chunksize: int or None. Rows to write at a time.
        • date_format: str, default None. Format string for datetime objects.
        • doublequote: bool, default True. Control quoting of quotechar inside a field.
        • escapechar: str, default None.
        • decimal: str, default '.'. Character recognized as decimal separator.
      • to_dict([into=]): Convert the given Series to a dict (label:value) or a dict-like object.
        • into: class, default dict.
      • to_excel(excel_writer[, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None]): Write the object to an Excel sheet.
        • excel_writer: str or ExcelWriter object. File path or existing ExcelWriter.
        • sheet_name: str, default 'sheet1'. Name of the excel sheet the object will be written to.
        • startrow: int, default 0. Upper left cell row.
        • startcol: int, default 0. Upper left cell column.
        • engine: Write engine to use. 'openpyxl' or 'xlsxwriter'.
        • merge_cells: bool, default True. Write MultiIndex and Hierarchical rows as merged cells.
        • inf_rep: str, default 'inf'. Representation for infinity (there is no native representation for infinity in excel).
        • verbose: bool, default True. Display more information in the error logs.
        • freeze_panes: tuple of int, optional. Specifies the one-based bottommost row and rightmost column that is to be frozen.
      • to_frame([name=None]): Convert the given Series to a DataFrame.
        • name: object, default None.
      • to_json([path_or_buf=None, orient=None, date_format=None, double_precision=10, force_ascii=True, date_unit='ms', default_handler=None, lines=False, compression='infer', index=True]): Convert the object to a JSON string. If path_or_buf is None, returns the resulting json format as a string. Otherwise, returns None.
        • path_or_buf: str or file handle, optional. File path or object. If not specified, the result will be returned as a string.
        • orient: str. The format of the JSON string.
          • 'split': dict like {'index' -> [index], 'columns' -> [columns], 'data' -> [values]}.
          • 'records': list like [{column -> value}, … , {column -> value}].
          • 'index': dict like {index -> {column -> value}}.
          • 'columns': dict like {column -> {index -> value}}.
          • 'values': Just the values array.
          • 'table': dict like {'schema': {schema}, 'data': {data}}. The data component is like orient='records'.
        • date_format: None, 'epoch', or 'iso'. Type of date conversion. 'epoch' = epoch milliseconds, 'iso' = ISO8601. The default depends on the orient. For orient='table', the default is 'iso'. For all other orients, the default is 'epoch'.
        • double_precision: int, default 10. The number of decimal places to use when encoding floating point values.
        • force_ascii: bool, default True. Force to use ASCII.
        • date_unit: str, 's', 'ms', 'us', 'ns', default 'ms'. The time unit to encode to.
        • default_handler: callable, default None. Handler to call.
        • lines: bool, default False. If 'orient' is 'records', write out line delimited JSON format.
        • compression: 'infer', 'gzip', 'bz2', 'zip', 'xz', or None. A string representing the compression to use in the output file. It is only used when the first argument is a filename. By default, the compression is inferred from the filename.
        • index: bool, default True. Whether to include the index values in the JSON string. Not including the index (index=False) is only supported when 'orient' is 'split' or 'table'.
      • to_latex([buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=False, column_format=None, longtable=None, escape=None, encoding=None, decimal='.', multicolumn=None, multicolumn_format=None, multirow=None]): Render the object to a LaTeX tabular environment table.
        • buf: file descriptor or None. Buffer to write to. If None, the output is returned as a string.
        • columns: list or label,, optional. The subset of columns to write. Write all columns by default.
        • col_space: int, optional. The minimum width of each column.
        • header: bool or list of strings; default True. Write out the column names. if a list of strings is given, it is assumed to be aliases for the column names.
        • index: bool, default True. Write row names (index).
        • na_rep: str, default 'NaN'. Missing data representation.
        • formatters: list of functions or dict of {str: function}, optional. Formatter functions to apply to columns' elements by position or name. The result of each function must be a unicode string. The list must be of the same length as the number of columns.
        • float_format: one-parameter function or str, optional; default None. Formatter for floating point numbers.
        • sparsify: bool, optional. Set to False for a DataFrame with a hierarchical index to print every MultiIndex key at each row. By default, the value will be read from the config module.
        • index_names: bool, default True. Prints the names of the index.
        • bold_rows: bool, default False. Make the row labels bold in the output.
        • column_format: str, optional. Column format as specified inLaTex table format.
        • longtable: bool, optional. By default, the value will be read from the pandas config module. Use a longtable environment instead of tabular.
        • escape: str, optional. By default, the value will be read from the pandas config module. Being set to False will prevent from escaping latex special characters in column names.
        • encoding: str, optional. A string representing the encoding to use in the output file. Default is 'utf-8'.
        • decimal: str, default '.'. Character recognized as decimal separator.
        • multicolumn:bool, default True. Use multicolumn to enhance MultiIndex columns. The default will be read from the config module.
        • multicolumn_format: str, default '1'. The alignment for multicolumns. The default will be read from the config module.
        • multirow: bool, default False. Use multirow to enhance MultiIndex rows.
      • to_list(): Return a list of the values.
      • to_numpy([dtype=None, copy=False]): Return a NumPy ndarray representing the values in this Series or Index.
        • dtype: str or numpy.dtype, optional. The dtype to pass to numpy.asarray().
        • copy: bool, default False. Whether or not the returned value is a view of another array.
      • to_sql(name, con[, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None, method=None]): Write the records stored in a DataFrame to a SQL database.
        • name: str. Name of SQL table.
        • con: sqlalchemy.engine.Engine or sqlite3.Connection. Using SQLAlchemy makes it possible to use any DB supported by that library. Legacy support is provided for sqlite3.Connection objects.
        • schema: str, optional. Specify the schema. If None, use the default schema.
        • if_exists: 'fail', 'replace', or 'append'; default 'fail'. How to behave if the table already exists.
          • 'fail': Raise a ValueError.
          • 'replace': Drop the table before inserting new values.
          • 'append': Insert new values to the existing table.
        • index: bool, default True. Write the index of a DataFrame as a column. Use index_label as the column name in the table.
        • index_label: string or sequence, default None. Column label for index columns.
        • chunksize:int, optional. The batch size of the rows that will be written at once. By default, all rows will be written at once.
        • dtype: dict, optional. Specify the datatype for columns. The keys should be the column names and the values should be the SQLAlchemy types or strings for the sqlite3 legacy mode.
        • method: None, 'multi', or callable; default None.
      • to_string([buf=None, na_rep='NaN', float_format=None, header=True, index=True, length=False, dtype=False, name=False, max_rows=None, min_rows=None]): Render a string representation of the Series.
        • buf: StringIO-like, optional. Buffer to write to.
        • na_rep: str, optional. String representation of NaN to use; default 'NaN'.
        • float_format: one-parameter function, optional. Formatter function to apply to columns' elements if they are floats; default None.
        • header: bool, default True. Add the Series header (index name).
        • index: bool, optional. Add index (row) labels; default True.
        • length: bool, default False. Add the Series length.
        • dtype: bool, default False. Add the Series dtype.
        • name: bool, default False. Add the Series name if not None.
        • max_rows: int, optional. Maximum number of rows to show before truncating. If None, show all.
        • min_rows: int, optional. The number of rows to display in a truncated repr (when the number of rows is above max_rows).
      • to_xarray(): Return an xarray object from the pandas object.
      • transform(func[, axis=0, *args, **kwargs]): Call func on self producing a Series with the same axis shape as self.
        • func: function, str (function name), list of functions/function names, or dict of axis label and function (name) pairs. Function to use for transforming the data.
        • axis: 0 or 'index'.
        • *args: Positional arguments to pass to func.
        • **kwargs: Keyword arguments to pass to func.
      • transpose(*args, **kwargs): Return the transpose.
      • truediv(other[, level=None, fill_value=None, axis=0]): Return a new Series of which every element is the float division of the corresponding elements in the given Series andother. It is element-wise (binary operator truediv). If both corresponding locations in Series andotherhave missing values, the value at that location in the new Series is missing too.
      • truncate([before=None, after=None, axis=None, copy=True]): Truncate a Series or a DataFrame before and after some index value, and return the truncated Series or DataFrame.
        • before: date, str, or int. Truncate all rows before this index value.
        • after: date, str, or int. Truncate all rows after this index value.
        • axis: 0 or 'index', or 1 or 'columns', optional. Axis to truncate. Truncates the index (rows) by default.
        • copy:boolean, default is True. Return a copy of the truncated section.
      • unique(): Return unique values of the given Series.
      • unstack([level=-1, fill_value=None]): Unstack a Series with MultiIndex to produce a DataFrame.
        • level: int, str, or list of integers or strings; default last level (level=-1). Level to unstack; can pass level name.
        • fill_value: scalar, default None. Value to use when replacing NaN values.
      • update(other): Modify the given Series in place using the values passed from another Seriesother. If the Seriesother contains NaNs, the corresponding values in the given Series will not be updated.
      • value_counts([normalize=False, sort=True, ascending=False, bins=None, dropna=True]): Return a Series containing counts of unique values.
        • normalize: bool, default False. If True, then the returned object will contain the relative frequencies of the unique values.
        • sort: bool, default True. Sort by frequencies.
        • ascending: bool, default False. Sort by frequencies in ascending order.
        • bins: int, optional. Rather than count values, group them into half-open bins. Only works for numeric data.
        • dropna: bool, default True. Don't include the counts of NaNs.
      • var([axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs]): Return the unbiased variance over the specified axis.
        • axis: 0 or 'index'.
        • skipna: bool, default True. Exclude NA/null values. If an entire row or columns is NA, the result will be NA.
        • level: int or level name, default None. If the axis is a MultiIndex, count along the particular level.
        • ddof: Delta Degree of Freedom. The divisor used in calculations is N-ddof, where N is the number of elements.
        • numeric_only: bool, default None. Include only float, int, or boolean columns. If None, will attempt to use everything. Then use only numeric data. Not implement for Series.
        • **kwargs: Additonal keyword arguments.
      • view([dtype=None]): Create a new view of the Series.
      • where(cond[, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False]): Replace values where the condition is False.
        • cond: bool Series or DataFrame, array-like, or callable. When a value satisfies the condition, keep it. When a value does not satisfy the condition, replace it with the corresponding value inother.
        • other: scalar, Series/DataFrame, or iterable. If it is an iterable, it needs to be of the same size as the caller.
        • inplace: bool, default False. Whether to perform the operation in place or not.
        • axis: int, default None. Alignment axis.
        • level: int, default None. Alignment level.
        • errors: 'raise' or 'ignore', default 'raise'.
        • try_cast: bool, default False. Try to cast the result back to the input type (if possible).
      • xs(key[, axis=0, level=None, drop_level=True]): Takes a key argument to select data at a particular level of a MultiIndex.
        • key: label or tuple of label. Label contained in the index, or partially in a MultiIndex.
        • axis: 0 or 'index', or 1 or 'columns', default 0. Axis to retrieve cross-section on.
        • level: object, default first n levels (n=1 or len(key)). Levels to be used.
        • drop_level: bool, default True.
  • Pandas DataFrame: A Pandas DataFrame is a two-dimensional array with heterogeneous data. It is both size and value mutable.
    • Create a DataFrame:
      • pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None): Create and return a Pandas DataFrame object fromdata.
        • data: Optional. Can be a Series, a list, a ndarray, a dict, etc.
        • index: Optional, Index or array-like. Must be unique and hashable and be of the same length as data. If no index is passed, use default values numpy.arrange(n), where n is the size of data.
        • columns: Optional, Index or array-like. Column labels. If no index is passed, use default labels numpy.arrange(n), where n is the size of data.
        • dtype: Optional, dtype, default None. If None, the data type will be inferred fromdata.
        • copy: Optional, default False. Copy data from inputs.
      • Create an Empty DataFrame:
      • Create a DataFrame from a List/ndarray:
      • Create a DataFrame from a Dictionary of Lists/ndarrays: A dictionary can be used as the data to create a DataFrame. If no columns is specified, the dictionary's keys will be taken in a sorted order as column labels. Otherwise, the dictionary's values that correspond to the labels in the given index will be pulled out as the values to the columns. If a label in the given index does not correspond to a dictionary value, its corresponding value in the DataFrame will be NaN.
      • Create a DataFrame from a Dictionary of Series: A dictionary of Series can be passed to create a DataFrame. The index of the created DataFrame is the union of the indexes of all the Series.
    • DataFrame Attributes:
      • at[]: Access and return a single value using a row-column label pair.
      • axes: Return a list representing the axes of the DataFrame.
      • columns: Return the column labels of the DataFrame.
      • copy: Return a copy of the DataFrame.
      • dtypes: Return a Series containing the data type of each column in the DataFrame. The index of the returned Series is the column labels of the original DataFrame.
      • empty: Return True if the DataFrame is empty; otherwise, return False.
      • iat[]: Access and return a single value using a pair of integer positions.
      • iloc[]: Access and return a single value using a pair of scalar integers, or return a Series if given a scalar integer, a slice of positions, a list of positions, a boolean array (of the same length as the index), a callable function with one argument.
      • index: Return the index (row labels) of the DataFrame.
      • loc[]: Access and return a group of rows and columns by a single row label/a pair of row and column labels, a list or array of labels, a slice of labels, a boolean array (of the same length as the row axis), or a callable function with one argument.
      • ndim: Return the number of axes or dimensions of the underlying data in the DataFrame.
      • shape: Return a tuple of the shape of the DataFrame.
      • size: Return the number of elements in the underlying data in the DataFrame.
      • style: Return a Styler object containing methods for building a styled HTML representation for the DataFrame.
      • values: Return a NumPy representation of the DataFrame.
      • T: Return the transpose of the DataFrame.
    • DataFrame Methods:
      • abs(): Return a new DataFrame with the absolute value of each element in the given DataFrame.
      • add(other[, axis='columns', level=None, fill_value=None]): Binary operator. Perform element-wise addition of the given DataFrame andother, and return a new DataFrame containing the results.
        • other: a DataFrame or a scalar value.
        • axis: 0 or 'index', 1 or 'columns'; default 'columns'.
        • level: int or label. Broadcast across a level, matching index values on the passed multiindex level.
        • fill_value: a float value or None. Fill existing missing values and any new element needed for successful DataFrame alignment with this value.
      • add_prefix(prefix): Prefix the column labels with the stringprefixand return a new DataFrame with updated labels.
      • add_suffix(suffix): Suffix the column labels with the stringsuffixand return a new DataFrame with updated labels.
      • agg(func[, axis=0, *args, **kwargs]): Aggregate using one or more operations over the specified axis, and return the results.
        • func: a function, a function name, a list of functions and/or function names.
        • axis: 0 or 'index', 1 or 'columns'.
        • *args: Positional arguments to pass to func.
        • **args: Keyword arguments to pass to func.
      • aggregate(func[, axis=0, *args, **kwargs]): Aggregate using one or more operations over the specified axis.
      • align(other[, join='outer', axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None]): Align two objects with the specified join method along the specified axis, and return aligned objects.
        • other: a Series or a DataFrame.
        • join: Default 'outer'. One of four join methods: 'outer', 'inner', 'left', 'right'.
        • axis: Allowed axis of the other object. Its default is None. Align along index (0), columns (1), or both (None).
        • level: int or name. Broadcast across a level, matching index values on the passed multiindex level.
        • copy: Boolean, default True; Return new objects. If copy=False and no reindexing is required then original objects are returned.
        • fill_value: a scalar, default np.NaN. Fill existing missing values and any new element needed for successful Series alignment with this value.
        • method: String, default None. One of four filling methods: 'backfill', 'bfill', 'pad', 'ffill'. Method to use for filling missing values in reindexed Series. 'pad'/'ffill': use last valid observation to fill gap; 'backfill'/'bfill': use next valid observation to fill gap.
        • 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.
        • fill_axis: Default 0. Filling axis.
        • broadcast_axis: Default None. Broadcast values along this axis, if aligning two objects of different dimensions
      • all([axis=0, bool_only=None, skipna=True, level=None, **kwargs]): Return True if all elements are True or equivalent (not zero or empty); otherwise, return False.
        • axis: 0/'index', 1/'columns', or None. Default 0. Indicate which axis or axes should be reduced.
          • 0/'index': Reduce the index. Return a Series whose index is the original column labels.
          • 1/'columns': Reduce the columns. Return a Series whose index is the original index.
          • None: Reduce all axes; return a scalar.
        • bool_only: bool, default None. If True, include only boolean columns; otherwise, use everything.
        • skipna: bool, default True. If True, exclude NA/null values.
        • level: int or level name, default None. If the axis is a MultiIndex, count along a particular level, and collapse into a scalar.
        • **kwargs: Additional keywords, default None. Might be accepted for compatibility with NumPy.
      • any([axis=0, bool_only=None, skipna=True, level=None, **kwargs]): Return True if any element is True or equivalent (not zero or empty); otherwise, return False.
      • apply(func[, convert_dtype=True, args, **kwds]): Invoke a function or functions on the values of the given DataFrame, and return a new DataFrame.
        • func: A single function or a list of multiple functions. The functions can be Python functions or NumPy ufuncs.
        • convert_dtype: Boolean, default True. Try to convert the dtype for the element-wise results returned from functions. If False, leave as dtype=object.
        • args: An iterable. Positional arguments passed to func after the Series value.
        • **kwds: Additional keyword arguments passed to func.
      • applymap(func): Apply a function to a DataFrame, element-wise.
        • func: A single function. The function can be a Python functions or a NumPy ufunc.
      • assign([**kwargs]): Assign new columns to a DataFrame, and return a new object with all original columns in addition to new ones. Existing columns that are reassigned will be overwritten.
      • astype(dtype[, copy=True, errors='raise', **kwargs]): Cast the given Series to a specified data type, and return a new Series with the new dtype.
        • dtype: Data type, or dict of column name-dtype pairs.
        • copy: Boolean, default True. Return a copy when copy=True.
        • errors: 'raise' (allow exceptions to be raised) or 'ignore' (suppress exceptions); default 'raise'.
        • **kwargs: keyword arguments to pass to the constructor.
      • boxplot([column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, **kwds]): Make a box plot from the columns of the given DataFrame.
        • column: str or list of strings, optional. Column name or a list of names, or vector.
        • by: str or array-like, optional. Column(s) in the DataFrame to pandas.DataFrame.groupby(). box-plots will be created per the values of each column inby.
        • ax: The matplotlib axes to be used by boxplot.
        • fontsize: float or str. Font size in points or as a string (e.g., large) of tick labels.
        • rot: int or float, default 0. The rotation angle of labels in degrees with respect to the screen coordinate system.
        • grid: bool, default True. Whether to show the grid or not.
        • figsize: A tuple of (width, height) in inches. The size of the figure to create in matplotlib.
        • layout: A tuple of (rows, columns), optional.
        • return_type: 'axes', 'dict', 'both', or None; default 'axes'. The kind of object to return.
          • 'axes': Returns the matplotlib axes the boxplot is drawn on.
          • 'dict': Returns a dictionary whose values are the matplotlib lines of the boxplot.
          • 'both': Returns a namedtuple with the axes and dict.
          • None: Returns a NumPy array of axes with the same shape aslayout.
        • **kwds: Additional plotting keyword arguments.
      • clip([lower=None, upper=None, axis=None, inplace=False, *args, **kwargs]): Replace values outside boundaries with their closest boundary value. Thresholds can be singular values or array like. If thresholds are array like, clipping is performed element-wise along the specified axis. Return a new Pandas object with the values outside the boundaries replaced.
        • lower: float or array-like, default None. Minimum threshold value. All values smaller than it will be set to it.
        • upper: float or array-like, default None. Maximum threshold value. All values larger than it will be set to it.
        • axis: int or string (axis name). Align object with lower and upper along this axis.
        • inplace: Boolean, default False. Indicate whether or not perform operations in place.
        • *args, **kwargs: Additional keywords; have no effect but might be accepted for compatibility with NumPy.
      • combine(other, func[, fill_value=None, overwrite=True]): Combine the DataFrame with another DataFrame usingfuncto perform element-wise column combining, and return the combined DataFrames.
        • other: DataFrame. The DataFrame to merge via a column-wise operation.
        • func: A function that takes two Series as inputs to combine the two DataFrames column by column, and returns a Series or a scalar.
        • fill_value: scalar, default None. A value to be used to fill missing values prior to passing any column to the function.
        • overwrite: bool, default True. If True, columns in the given DataFrame that do not exist inotherwill be written with NaNs; otherwise, will be put with the original column values in the given DataFrame.
      • combine_first(other): Combine the given DataFrame withotherby filling null values in the given DataFrame with non-null values inother.The row and column labels of the combined DataFrame will be the union of those of the two DataFrames.
      • copy([deep=True]): Make a copy of the given object's indexes and data. deepis a boolean. If deep=True (default), a new object will be created and returned. Any changes to the new object will not affect the original object. If deep=False, only a reference to the data and index of the original object is created. Any changes to the copy will be reflected to the original object and vice versa.
      • corr([method='pearson', min_periods=1]): Compute pairwise correlations of the columns of the given DataFrame, excluding missing values.
        • method: 'pearson', 'kendall', 'spearman', or callable (a function with two 1-D ndarrays as inputs; it returns a float).
        • min_periods: int, default 1. Minimum number of observations needed per pair of columns to have a valid result.
      • corrwith(other[, axis=0, drop=False, method='pearson']): Compute and return pairwise correlations between the rows/columns of the given DataFrame with the rows/columns ofother.DataFrames are first aligned along both axes before computing the correlations.
        • other: A DataFrame/Series with which to compute the correlation.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Axis along which to calculate the correlation.
        • drop: bool, default False. Drop missing indexes from result.
        • method: 'pearson', 'kendall', 'spearman', or callable (a function with two 1-D ndarrays as inputs; it returns a float).
      • count([axis=0, level=None, numeric_only=False]): Return the number of non-NA/null cells along the specified axis in the DataFrame.
        • axis: 0 or 'index', 1 or 'columns', default 0.
        • level: int or str, optional.
        • numeric_only: bool, default False.
      • cov([min_periods=None]): Compute pairwise covariance between columns, excluding missing values.
      • cummax([axis=None, skipna=True, *args, **kwargs]): Return a DataFrame or Series of the same size containing the cumulative maximum of the given DataFrame along the specified axis.
      • cummin([axis=None, skipna=True, *args, **kwargs]): Return a DataFrame or Series of the same size containing the cumulative minimum of the given DataFrame along the specified axis.
      • cumprod([axis=None, skipna=True, *args, **kwargs]): Return a DataFrame or Series of the same size containing the cumulative product of the given DataFrame along the specified axis.
      • cumsum([axis=None, skipna=True, *args, **kwargs]): Return a DataFrame or Series of the same size containing the cumulative sum of the given DataFrame along the specified axis.
      • describe([percentiles=None, include=None, exclude=None]): Generate descriptive statistics that summarize the central tendency, dispersion and shape of a dataset’s distribution, excluding NaN values. Its return values includecount, mean, std, min, IQR,andmaxvalues.
        • percentiles: list-like of numbers, optional. The percentiles to include in the output. All should fall between 0 and 1.
        • include: It is used to pass the information regarding what columns will be used for summarizing.
          • 'all': Summarizes all columns together.
          • A list-like dtypes: A list that includes the data types (np.object, np.number, 'category', etc) that should be included in the results.
          • None: Default; the results will include all numeric columns.
        • exclude: Ignored for Series.
          • A list-like dtypes: A list that includes the data types (np.object, np.number, 'category', etc) that should be excluded from the results.
          • None: Default; the results will exclude nothing.
      • diff([periods=1, axis=0]): For each element in the given DataFrame, calculate the difference with another element in the DataFrame (default is the element of the previous row in the same column), and return a new DataFrame containing the differences. By default, periods=1; it is to calculate the difference with its previous element.
      • div(other[, level=None, fill_value=None, axis=0]): Return the float division of the DataFrame andother,element-wise (binary operator truediv).
        • other: A scalar, sequence, Series or DataFrame.
        • fill_value: None or a float value; default None. Use this value to fill existing missing values (NaN), and any new element needed for a successful alignment between the given DataFrame andother.before computation. If data are missing in both corresponding DataFrame locations, the result for that location will be missing.
        • level: int or label name. Broadcast across a level, matching index values on the passed MultiIndex level.
        • axis: 0 or 'index', 1 or 'columns'. Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
      • divide(other[, level=None, fill_value=None, axis=0]): Same as div().
      • dot(other): Compute the matrix multiplication between the DataFrame andother,which is a Series, DataFrame, or or a numpy array. The number of columns in the given DataFrame needs to be the same as the number of elements in the Series (if other is a Series) or same as the number of rows in the DataFrame (if other is a DataFrame). And the column labels of the given DataFrame need to be the same as the index labels inotherifotheris a Series or a DataFrame.
      • drop([labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise']): Return a DataFrame with the specified index or column labels removed.
        • labels: A single label or a list-like. Index or column labels to drop.
        • axis: 0 or 'index', 1 or 'columns'. Whether to drop labels from the index (0 or 'index') or columns (1 or 'columns').
        • index: A single label or a list-like. An alternative to specifying axis.
        • columns: A single label or a list-like. An alternative to specifying axis.
        • level: int or label name. For MultiIndex, level from which the labels will be removed.
        • inplace: bool, default False. If True, do operations inplace and reture None.
        • errors: 'ignore' or 'raise', default 'raise'. If 'ignore', suppress errors and only drop existing labels.
      • drop_duplicates([subset=None, keep='first', inplace=False]): Return a new DataFrame with duplicate rows removed.
        • subset: column labels or sequence of labels, optional. Columns that will be used to identify duplicates.
        • keep:
          • 'first': Drop duplicates except for the first occurrence.
          • 'last': Drop duplicates except for the last occurrence.
          • False: Drop all duplicates.
        • inplace: bool, default False. If True, performs operations inplace and returns None.
      • droplevel(level[, axis=0]): Return a new DataFrame with requested index or column level(s) removed.
        • level: int, str, or list-like.
          • int: Positional index of a level.
          • str: The name of a level.
          • list-like: A list of elements which are names or positional indexes of levels.
        • axis: 0 or 'index', 1 or 'columns'; default 0.
      • dropna([axis=0, how='any', thresh=None, subset=None, inplace=False]): Return a new DataFrame with missing values removed.
        • axis: 0 or 'index' (drop rows which contain missing values), 1 or 'columns' (drop columns that contain missing values).
        • how: 'any' (if any NA values are present, drop that row or column), or 'all' (if all values are missing values, drop that row or column); default 'any'.
        • thresh: int, optional. Required number of non-NA values. Rows or columns that do not contain this number of non-NA values will be dropped.
        • subset: array-like, optional. Define in which labels along other axis to look for missing values.
        • inplace: bool, default False. If True, do operations inplace and reture None.
      • duplicated([subset=None, keep='first']): Return a Series of boolean values indicating whether the rows are duplicated.
        • subset: column label or sequence of labels, optional. Columns that are used to identify duplicates. By default, use all of the columns.
        • keep: 'first' (mark duplicates as True except for the first occurrence), 'last' (mark duplicates as True except for the last occurrence), or False (mark all duplicates as True); default 'first'.
      • eq(other[, axis='columns', level=None]): Return a DataFrame of boolean values indicating whether the corresponding values in the given DataFrame andotherare equal; it is element-wise (binary operator eq). If data are missing in both corresponding locations, the result for the location will be False.
        • other: scalar, sequence (must have the same number of elements as the DataFrame along the specified axis), or DataFrame.
        • axis: 0 or 'index', 1 or 'columns'; default 'columns'. Whether to compare by the index or columns.
        • level: Broadcast across a level, matching index values on the passed MultiIndex level.
      • equals(other): Test whether two objects have the same shapes and elements, and return a boolean value indicating whether they are the same. The elements must be the same dtype. The index or column headers do not need to be the same type. NaNs in both corresponding locations are considered equal.
      • eval(expr[, inplace=False, **kwargs): Evaluate a string that describes operations on the columns of the given DataFrame, and return the evaluation result.
        • expr: str. The expression string to evaluate.
        • inplace: bool, default False. If the expression contains an assignment, indicate whether to perform the operation inplace and modify the existing DataFrame. Otherwise, return a new DataFrame with the changes. The original DataFrame is unchanged.
        • kwargs: dict.
      • ewm([com=None, span=None, halflife=None, alpha=None, min_periods=0, adjust=True, ignore_na=False, axis=0]): Provide exponentially weighted (EW) calculations.
        • com: Optional; float; Specify decay in terms of center of mass.
        • span: Optional; float; Specify decay in terms of span.
        • halflife: Optional; float; Specify decay in terms of half-life.
        • alpha: Optional; float; Specify smoothing factor.
        • min_periods: int; default 0; Specify minimum number of observations in window required to have a value.
        • adjust: bool; default True; Divide by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.
        • ignore_na: bool; default False. Ignore missing values when calculating weights.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Specify the axis to use.
      • expanding([min_periods=1, center=False, axis=0]): Provide expanding transformations.
        • min_periods: int; default 1; Specify minimum number of observations in window required to have a value.
        • center: bool; default False; Set the labels at the center of the window.
        • axis: int or str; default 0.
      • explode(column): Transform each element of a list-like to a row, replicating the index values.
        • column: str or tuple.
      • ffill([axis=None, inplace=False, limit=None, downcast=None]): Synonym for DataFrame.fillna() with method='ffill'. Return a new object with the missing values filled with the last valid obervation.
        • axis: int or str; default 0. Axis used to fill missing values along.
        • inplace: bool; default False; If True, fill missing values in place.
        • limit: int; default None; It is the maximum number of NaNs along the entire axis to be filled.
        • downcast: dict; default 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).
      • fillna([value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs]): Fill NA/NaN values using the specified method and return a new Series with NA/NaN values filled.
        • value: scalar, dict, Series, or DataFrame; specifies the value to use for filling missing values.
        • method: 'backfill', 'bfill', 'pad', 'ffill', None. 'backfill' or 'bfill' is to use next valid observation to fill the missing values.
      • filter([items=None, like=None, regex=None, axis=None]): Return a subset of rows or columns of the given DataFrame according to the labels in the specified axis. One of the parameters (items, like, regex) must be passed, and they are exclusive.
        • items: list-like. Keep labels from axis which are in items.
        • like: str. Keep labels from axis if the labels contain the substringlike.
        • regex: str (regular expression). Keep labels from axis ifregexcan be searched in the labels.
        • axis: int or str. The axis to filter on.
      • first_valid_index(): Return the index of first non-NA value. Return None if all elements are NA or the DataFrame is empty.
      • floordiv(other[, level=None, fill_value=None, axis='columns']): Return a new DataFrame containing the integer division of the given DataFrame andother,element-wise (binary operator floordiv). If data are missing in both corresponding DataFrame locations, the result for that location will be missing.
      • from_dict([data, orient='columns', dtype=None, columns=None]): Return a DataFrame from a dict.
        • data: dict.
        • orient: 'columns' or 'index', default 'columns'. The orientation of the data.
        • dtype: dtype, default None. Data type to force. Otherwise, infer the data type.
        • columns: list, default None. Column labels to use when orient='index'. Raise a ValueError if used with orient='columns'.
      • ge(other[, level=None, axis='columns']): Return a new DataFrame of boolean values indicating whether an element in the DataFrame is greater than or equal to the value at the corresponding location inother;it is element-wise (binary operator ge). If data is missing in a location of either DataFrame, the result for that location will be False.
      • get(key[, default=None]): Get the item from the given object for a given key (ex: a DataFrame column). Return the default valuedefaultif not found.
      • groupby([by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs]): Group the given DataFrame or Series using a mapper or by a Series of columns.
        • by: mapping, function, label, or a list of labels. It is used to determine the groups for the groupby.
        • axis: 0 or 'index', or 1 or 'columns'; default 0.
        • level: int, level name, or sequence of such; default None. If the axis is a MultiIndex, group by a particular level or levels.
        • as_index: bool; default True. It is for aggregated output.
        • sort: bool; default True. Sort group keys.
        • group_keys: bool; default True. Add group keys to index to identify pieces.
        • squeeze: bool; default False. Reduce the dimensionality of the return type if possible. Otherwise, return a consistent type.
        • observed: bool; default False. This only applies if any of the groupers are Categoricals. If True, only show observed values for categorical groupers. If False, show all values for categorical groupers.
        • **kwargs: Optional. Additional keyword arguments.
      • gt(other[, level=None, axis=0]): Return a new DataFrame of boolean values indicating whether an element in the given DataFrame is greater than the value at the corresponding location inother;it is element-wise (binary operator gt). If data is missing in a location of either DataFrame, the result for that location will be False.
      • head([n=5]): Return the first n rows. By default, n is 5.
      • hist(data[, column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, **kwds]): Draw a histogram plot of the given DataFrame using matplotlib.
        • data: DataFrame. A pandas object holding the data.
        • column: string or sequence. If passed, will be used to limit data to a subset of columns.
        • by: object, optional. It is used to form histograms for separate groups.
        • grid: bool, default True. Indicates whether or not to show axis grid lines.
        • xlabelsize: int, default None. It is used to change the x-axis label size.
        • xrot: float, default None. Rotation of x axis labels.
        • ylabelsize: int, default None. It is used to change the y-axis label size.
        • yrot: float, default None. Rotation of y axis labels.
        • ax: matplotlib axis object. If not passed, uses gca().
        • sharex: bool, default True if ax is None; otherwise, False.
        • sharey: bool, default False. If subplots=True, share y axis and set some y axis labels to invisible.
        • figsize: tuple, default None. The figure size in inches by default.
        • layout: tuple, optional. Tuple of (rows, columns) for the layout of the histograms.
        • bins: integer or sequence, default 10. The 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 the left edge of the first bin and the right edge of the last bin. In this case, bins is returned unmodified.
        • **kwds: keywords, optional. To be passed to the actual plotting function.
      • idxmax([axis=0, skipna=True]): Return a Series containing the indexes of the first occurrences of maximums over the specified axis. If multiple values equal the maximum, the first index with that value will be used. If skipna=False, NaN will be used if there are NaNs along the specified axis in the DataFrame.
      • idxmin([axis=0, skipna=True]): Return a Series containing the indexes of the first occurrences of minimums over the specified axis. If multiple values equal the minimum, the first index with that value will be used. If skipna=False, NaN will be used if there are NaNs along the specified axis in the DataFrame.
      • infer_objects(): Attempt to infer better dtypes for object-dtyped columns, leaving non-object and unconvertible columns unchanged.
      • insert(loc, column, value[, allow_duplicates=False]): Insert a column into the given DataFrame at the specified location.
        • loc: int. Insertion index. Must verify it is in the range [0, len(columns)].
        • column: string, number, or hashable object. Label of the inserted column.
        • value: int, Series, or array-like.
        • allow_duplicates: bool, optional.
      • interpolate([method='linear', axis=0, limit=None, inplace=False, limit_direction='forward', limit_area=None, downcast=None, **kwargs]): Fill NaN values using an interpolation method.
        • method: str, default 'linear'. The method to use to do interpolation.
          • 'linear': Ignore the index and treat the values as equally spaced. This is the only method supported on MultiIndexes.
          • 'time': Works on daily and higher resolution data to interpolate given length of interval.
          • 'index'/'values': Use the actual numerical values of the index.
          • 'pad': Fill in NaNs using existing values.
          • 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'spline', 'barycentric', 'polynomial': These methods use the numerical values of the index. Both 'polynomial' and 'spline' require that an order (int) is also specified,
          • 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima': Wrappers around the SciPy interpolation methods of similar names.
          • 'from_derivatives': Replace 'piecewise_polynomial' interpolation method in SciPy 0.18.
        • axis: 0 or 'index', or 1 or 'columns', or None; default None. Axis to interpolate along.
        • limit: int, optional. Maximum number of consecutive NaNs to fill. Must be greater than 0.
        • inplace: bool, default False. Update the data in place if possible.
        • limit_direction: 'forward', 'backward', 'both'; default 'forward'. If limit is specified, consecutive NaNs will be filled in this direction.
        • limit_area: If limit is specified, consecutive NaNs will be filled with this restriction.
          • None: No fill restriction.
          • 'inside': Only fill NaNs surrounded by valid values (interpolate).
          • 'outside': Only fill NaNs outside valid values (extrapolate).
        • downcast: Optional; 'infer' or None; default None. Downcast dtypes if possible.
        • **kwargs: Keyword arguments to pass on to the interpolating function.
      • isin(values): Return a new object of the same size as the given object. Each element is a boolean value indicating whether the corresponding element in the given object is contained in the passed sequence ofvalues.It is True if contained; otherwise, it is False.
      • isna(): Return a new object of the same size as the given object. Each element is a boolean value indicating whether the corresponding element in the given object is a missing value. It is True if the element is NA/NaN; otherwise, it is False.
      • isnull(): Alias of isna().
      • items(): Return a zip object containing tuples. Each tuple contains the name and the content as a Series of a column.
      • iteritems(): Same as items().
      • iterrows(): Iterate over DataFrame rows as (index, Series) pairs, and return a generator.
      • itertuples([index=True, name='Pandas']): Iterate over DataFrame rows as namedtuples of the values.
        • index: bool, default True.
        • name: str or None, default 'pandas'. The name of the returned namedtuple or None to return regular tuples.
      • join(other[, on=None, how='left', lsuffix='', rsuffix='', sort=False]): Join columns with another DataFrame on either index or a key column. Efficiently join multiple DataFrame objects by index at once by passing a list.
        • other: DataFrame, Series, or list of DataFrames.
        • on: str, list of str, or array-like, optional. Columns or index names in the caller to join on the index inother. Otherwise joins index-on-index. If multiple values are given,othermust have a MultiIndex.
        • how: 'left', 'right', 'outer', 'inner', default 'left'. How to handle the operation of the two objects.
          • 'left': use the index or column of the calling DataFrame.
          • 'right': use the index ofother.
          • 'outer': form union of the caller's index (or column) withother'sindex, and sort it, lexicographically.
          • 'inner': form intersection of the caller's index (or column) withother'sindex, preserving the order of the caller's one.
        • lsuffix: str, default ''. Suffix to use in left frame's overlapping columns.
        • rsuffix: str, default ''. Suffix to use in right frame's overlapping columns.
        • sort: bool, default False. Order the result lexicographically by the join key. If False, the order of the join key depends on the join type (specified by how).
      • keys(): Return the columns of the DataFrame, or the index of the Series.
      • kurt([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return a Series containing unbiased kurtosis over the specified axis, using Fisher’s definition of kurtosis (kurtosis of normal == 0.0).
        • axis: Optional. 0 or index, or 1 or 'columns'. Axis for the function to be applied along.
        • skipna: bool; default True. Exclude NA/NaN 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 scalar.
        • numeric_only: bool; default None. Include only float, int, or boolean columns. If none, will try to use everything, then use only numeric data. Not a parameter for Series.
        • **kwargs: Optional. Additional keyword arguments to be passed to the function.
      • kurtosis([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Same as kurt().
      • last_valid_index(): Return the index for the last non-NA value, or return None if no non-NA value is found.
      • le(other[, axis='columns', level=None]): Return a new DataFrame of boolean values indicating whether an element in the given DataFrame is less than or equal to the value at the corresponding location inother;it is element-wise (binary operator le). If data is missing in either location, the result for that location will be False.
      • lt(other[, axis='columns', level=None]): Return a new DataFrame of boolean values indicating whether an element in the given DataFrame is less than the value at the corresponding location inother;it is element-wise (binary operator le). If data is missing in either location, the result for that location will be False.
      • mad([axis=None, skipna=True, level=None]): Return the mean absolute deviation (the average distance between each value and mean) of the values over the specified axis.
      • map(arg[, na_action=None]): Map the values of a given pandas dataframe column according to an input mapping (a dict or a Series) or a function.
        • arg:A function, dict, or Series. Mapping correspondence.
        • na_action: None or 'ignore'; default None. If 'ignore', propagate NaN values, without passing them to the mapping correspondence.
      • mask(cond[, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False]): Replace values that satisfy the condition withother, and return a new object with the changes.
        • cond: bool Series/DataFrame, array-like, or callable. Where cond is False, keep the original value. Where True, replace with corresponding value fromother.
        • other: A scalar, Series/DataFrame, or callable. It is used to replace the values where the condition is True. Default is nan.
        • inplace: bool; default False. Whether to perform the operation in place on the data.
        • axis: int; default None. Axis for the operations to perform along.
        • level: int; default None. Alignment level if needed.
        • errors: 'raise' (allow exceptions to be raised), or 'ignore' (suppress exceptions); default 'raise'.
        • try_cast: bool; default False. Try to cast the result back to the input type (if possible).
      • max([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the maximum of the values over the requested axis.
      • mean([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the mean of the values over the requested axis.
      • median([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the median of the values over the requested axis.
      • memory_usage([index=True, deep=False]): Return the memory usage of each column in bytes.
        • index: bool; default True. Specifies whether to include the memory usage of the index.
        • deep: bool; default False. If True, introspect the data deeply by interrogating the object dtypes for system-level memory consumption, and include it in the returned value.
      • min([axis=None, skipna=None, level=None, numeric_only=None, **kwargs]): Return the minimum of the values over the requested axis.
      • mod(other[, level=None, fill_value=None, axis='columns']): Return a new object containing the modulos of the given object andother, element-wise (binary operator mod).
      • mode([axis=0, numeric_only=False, dropna=True]): Return a new object containing the mode(s) of the given object.
      • mul(other[, axis='columns', level=None, fill_value=None]): Return a new DataFrame containing the multiplications of the given DataFrame andother,,element-wise (binary operator mul).
      • multiply(other[, axis='columns', level=None, fill_value=None]): Same as mul().
      • ne(other[, axis='columns', level=None]): Return a new DataFrame containing boolean values indicating whether corresponding elements of the given DataFrame andother,are not equal. It is True if not equal and False otherwise. It is element-wise (binary operator ne).
      • nlargest(n, columns[, keep='first']): Return first n rows ordered bycolumnsin descending order.
        • n: int. Number of rows to return.
        • columns: label or list of labels. Column labels to order by.
        • keep: 'first' (default; return the first n occurrences in order of apprearances), 'last' (return the last n occurrences in reverse order of apprearances), 'all' (keep all occurrences of top n largest elements. If there are None or numpy.nan, they will be included in the returned rows. The size of the returned Series may be larger than n).
      • notna(): Return a new DataFrame containing boolean values indicating whether the elements are not missing values. The value is True if the corresponding element is not a missing value; it is False otherwise.
      • notnull(): An alias for Series.notna.
      • nsmallest(n, columns[, keep='first']): Similar to nlargest(), except that it returns first n rows ordered bycolumnsin ascending order.
      • nunique([axis=0, dropna=True]): Return a Series with number of distinct observations along the specified axis of the given DataFrame.
      • pct_change([periods=1, fill_method='pad', limit=None, freq=None, axis=0, **kwargs]): For each element except the first element in the given DataFrame, calculate the percentage change between the element and its prior element, and return a new DataFrame of the percentage changes with the first element set to numpy.nan.
      • plot(*args, **kwargs):
        • plot.area([x=None, y=None, stacked=True, **kwargs]): Make an area plot, or return a ndarray of area plots if subplots=True.
          • x: Optional. Label or position. X coordinates. By default, it is the index.
          • y: Optional. Label or position. Column to plot. By default, use all columns.
          • stacked: bool; default True. Area plots are stacked by default. If set to False, the plot will be unstacked plot.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.bar([x=None, y=None, **kwargs]): Make a bar plot, or return ndarrays or matplotlib.axes.Axes if subplots=True.
        • plot.barh([x=None, y=None, **kwargs]): Make a horizontal bar plot, or return ndarrays of matplotlib.axes.Axes if subplots=True.
        • plot.box([by=None, **kwargs]): Make a box plot, or return ndarrays or matplotlib.axes.Axes if subplots=True.
          • by: Optional; str or sequence. Column in the DataFrame to group by.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.density([bw_method=None, ind=None, **kwargs]): Make a kernel density estimate plot using Gaussian kernels, or return ndarrays or matplotlib.axes.Axes if subplots=True.
          • by: str, scalar, or callable; optinal. Method used to calculate the estimator bandwidth.
          • ind: Optional. ndarray or integer. Evaluation points for the estimated PDF. If None (default), 1000 equally spaced points are used. If ind is a ndarray, the KDE is evaluated at the points passed. If ind is an integer, the ind number of equally spaced points are used.
          • **kwargs: Optional. Additional keyword arguments documented in pandas.%(this-datatype)s.plot().
        • plot.hexbin(x, y[, C=None, reduce_C_function=None, gridsize=None, **kwargs]): Generate a hexagonal binning plot of x versus y. If C is None (the default), this is a histogram of the number of occurrences of the observations at (x[i], y[i]). If C is specified, specifies values at given coordinates (x[i], y[i]). These values are accumulated for each hexagonal bin and then reduced according to reduce_C_function, by default the NumPy’s mean function (numpy.mean()). If C is specified, it must also be a 1-D sequence of the same length as x and y, or a column label.)
          • x: int or str. The column label or position for x points.
          • y: int or str. The column label or position for x points.
          • C: int or str, optional. The column label or position for the value of (x, y) point.
          • reduced_C_function: callable, default np.mean. Function of one argument that reduces all the values in a bin to a single number (e.g. np.mean, np.max, np.sum, np.std).
          • gridsize: int or tuple of (int, int), default 100. The number of hexagons in the x-direction. The corresponding number of hexagons in the y-direction is chosen in a way that the hexagons are approximately regular. Alternatively, gridsize can be a tuple with two elements specifying the number of hexagons in the x-direction and the y-direction.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.hist([by=None, bins=10, **kwargs]): Make a histogram plot.
          • by: Optional; str or sequence. Column in the DataFrame to group by.
          • bins: int, default 10. Number of histogram bins to be used.
          • **kwargs: Optional. Additional keyword arguments documented in DataFrame.plot().
        • plot.kde([bw_method=None, ind=None, **kwargs]): Same as plot.density().
        • plot.line([x=None, y=None, **kwargs]): Plot a line for Series or lines using DataFrame's values as coordinates, or return an ndarray or matplotlib.axes.Axes if subplots=True.
        • plot.pie([y=None, **kwargs]): Make a pie plot for a Series/DataFrame.
        • plot.scatter( x, y[, s=None, c=None, **kwargs]): Create a scatter plot with varying marker point size and color for a DataFrame.
      • pop(item): Return the item and drops it from the given DataFrame. Raise KeyError if not found.
        • item: str, required. Label of the column to be popped.
      • pow(other[, level=None, fill_value=None, axis='columns']): Return a new DataFrame of which every element is the exponential power of the corresponding elements in the given DataFrame andother,It is element-wise (binary operator pow). If data are missing at both corresponding locations in the DataFrame andother,the value at that location in the new DataFrame will be missing too.
      • prod([axis=None, skipna=None, level=None, numeric_only=None, min_count=0, **kwargs]): Return the product of the values over the specified axis.
        • min_count: int, default 0. The minimum number of valid values required to perform the operation.
      • product([axis=None, skipna=None, level=None, numeric_only=None, min_count=0, **kwargs]): Same as prod().
      • quantile([q=0.5, axis=0, numeric_only=True, interpolation='linear']): Return a Series (when q is a float) or a DataFrame (when q is an array) at the given quantile q over the specified axis.
        • q: float or array-like; default 0.5 (50% quantile). 0<=q<=1, the quantile(s) to compute.
        • interpolation: Optional. Default 'linear'. Specifies the interpolation method to use, when the desired quantile is between two data points i and j:
          • 'linear': i+(j - i)*fraction, where fraction is the fractional part of the index surrounded by i and j.
          • 'lower': i.
          • 'higher': j.
          • 'nearest': i or j whichever is nearest.
          • 'midpoint': (i+j)/2.
      • query(expr[, inplace=False, **kwargs]): Query the columns of a DataFrame with a boolean expression.
        • expr: str. The query string to evaluate.
        • inplace: bool, default False. Whether the query should modify the data in place or return a modified copy.
        • **kwargs: Additional keyword arguments accepted by DataFrame.query().
      • radd(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame containing the addition of the given DataFrame andother,element-wise (binary operator radd). If the values at both corresponding locations are missing, the value at the corresponding location in the returned DataFrame will be missing.
      • rank([axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False]): Return a Dataframe containing the numerical data ranks (1 through n) of a given DataFrame along the specified axis.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Axis along which to rank.
        • method: Method to rank the group of records that have the same value (ties).
          • 'average': Average rank of the tied group.
          • 'min': Lowest rank in the group.
          • 'max': Highest rank in the group.
          • 'first': Ranks assigned in the order they appear in the array.
          • 'dense': Similar to 'min', but rank always increases by 1 between groups.
        • numeric_only: bool, optional. For a DataFrame object, rank only numeric columns if set to True.
        • na_optional: Specifies how to rank NaN values. Default 'keep'.
          • 'keep': Default. Set NaN to NaN values.
          • 'top': Assign the smallest rank to NaN values if ascending.
          • 'bottom': Assgin the highest rank to NaN values if ascending.
        • ascending: bool; default True. Indictate whether or not the elements should be ranked in ascending order.
        • pct: bool; default False. Indicate whether or not display the returned rankings in percentile form.
      • rdiv(other[, level=None, fill_value=None, axis='columns']): Return a new DataFrame containing the float division ofotherand the given DataFrame, element-wise (binary operator rdiv). If the values at both corresponding Series locations are missing, the value at the corresponding location in the returned DataFrame will be missing.
      • reindex([labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None]): Conform the given object to an object with new index. Place NA/NaN at locations that have no value at the same index in the original object. The returned object will be a new one unless the new index is the same as the original one and copy=False.
        • labels: array-like, optional. New labels / index to conform the axis specified by 'axis' to.
        • index, columns: array-like, optional. New labels / index to conform to; should be specified using keywords. Preferably an Index object to avoid duplicating data.
        • axis: int or str, optional. Axis to target.
        • method: None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'. Method to use for filling gaps in the reindexed DataFrame.
        • copy: bool, default True. Return a new object, even if the passed indexes are the same.
        • level: int or name. Broadcast across a level, matching index values on the passed MultiIndex level.
        • fill_value: scalar, default np.nan. Value used to replace missing values.
        • limit: int, default None. Maximum number of consecutive elements to forward or backward fill.
        • tolerance: scalar or array-like, optional. Maximum distance between original and new labels for inexact matches.
      • reindex_like(other[, method=None, copy=True, limit=None, tolerance=None]): Conform a given object to the same index ofotheron all axes with an optional filling logic. Place NA/NaN at locations that have no value at the same index in the original object. The returned object will be a new one unless the new index is the same as the original one and copy=False.
        • other: A Series.
        • method: Optional. Filling method.
          • pad/ffill: Fill values forward.
          • bfill/backfill: Fill values backward.
          • nearest: Fill from the nearest index values.
        • copy: Optional; bool; default True. Return a new object, even if the passed indexes are the same.
        • limit: Optional. Specifies the maximum number of consecutive labels to fill for inexact matches.
        • tolerance: Optional. The maximum distance between original and new labels for inexact matches.
      • rename([mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore']): Return a DataFrame with renamed axis labels.
        • mapper: dict-like or function. Transformations to apply to the values of the specified axis.
        • index: dict-like or function. Alternative to specifying axis (mapper, axis=0 is equivalent to index=mapper).
        • columns: dict-like or function. Alternative to specifying axis (mapper, axis=1 is equivalent to columns=mapper).
        • axis: int or str. Axis to target with mapper. Can be 0 or 'index', 1 or 'columns'.
        • copy: bool, default True. Whether or not copy the underlying data.
        • inplace: bool; default False. Whether or not modify the object directly, or create a new object. If True, will not return a new object, and the value of copy will be ignored.
        • level: int or level name; default None. In case of MultiIndex, only rename labels in the specified level.
        • errors: 'ignore' or 'raise', default 'ignore'. If 'raise', raise a KeyError when a dict-like mapper, index, or columns contains labels that are not present in the Index being transformed. If 'ignore', existing keys will be renamed and extra keys will be ignored.
      • rename_axis([mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False]): Set the name of the axis for the index or columns.
        • mapper: scalar, or list-like; optional. Value to set the axis name.
        • index, columns: scalar, list-like, dict-like, or function; optional. To apply it as transformations to that axis' names.
        • axis: 0 or 'index', or 1 or 'columns'; default 0. Axis to rename.
        • copy: bool; default True. Whether or not copy the underlying data.
        • inplace: bool; default False. Whether or not modify the object directly, or create a new object. If True, will not return a new object, and the value of copy will be ignored.
      • replace([to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad']): Replace values given in to_replace with the valuevalue.
        • to_replace: str, regex, list, dict, Series, int, float, or None. Values to be replaced.
        • value: scalar, dict, list, str, regex, default None. Value used to replace any values matching with to_replace.
        • inplace: bool, default False. If True, modify the original Series; otherwise, return a new Series. The original Series is unchanged.
        • limit: int, default None. The maximum gap size to fill.
        • regex: bool, default False, indicate whether to interpret to_replace and/or value as regular expressions. If it is True, to_replace must be a string. It can be a regular expression, a list, dict, or an array of regular expressions. In this case, to_replace must be None.
        • method: 'pad', 'ffill', 'bfill', or None. The method to use when do replacement, when to_replace is a scalar, list or tuple, and value is None.
      • reset_index([level=None, drop=False, inplace=False, col_level=0, col_fill='']): Generate a new Series or DataFrame with the index reset as a column.
        • level: int, str, tuple, or list, default None. Only remove the given levels from the index. Remove all levels by default.
        • drop: bool, default False. Do not try to insert index into DataFrame columns. This resets the index to the default integer index.
        • inplace: bool, default False. If True, modify the original DataFrame; otherwise, return a new DataFrame, and the original DataFrame is unchanged.
        • col_level: int or str, default 0. If the columns have multiple levels, determines which level the labels are inserted into. By default it is inserted into the first level.
        • col_fill: object, default ''. If the columns have multiple levels, determines how the other levels are named. If None then the index name is repeated.
      • rfloordiv(other[, axis='columns', level=None, fill_value=None]): Return a new DataFrame of which every element is the integer division of the corresponding elements inotherand the given DataFrame. It is element-wise (binary operator). If both corresponding locations in the given DataFrame andotherhave missing values, the value at that location in the returned DataFrame will be missing too.
      • rmod(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame of which every element is the module of the corresponding elements inotherand the given DataFrame. It is element-wise (binary operator). If both corresponding locations in the given DataFrame andotherhave missing values, the value at that location in the new DataFrame will be missing too.
      • rmul(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame of which every element is the multiplication of the corresponding elements inotherand the given DataFrame. It is element-wise (binary operator). If both corresponding locations in the given DataFrame andotherhave missing values, the value at that location in the new DataFrame will be missing too.
      • round([decimals=0, *args, **kwargs]): Round each value in a given DataFrame to the given number of decimals.
      • rpow(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame of which every element is the exponential power of the corresponding elements inotherand the given DataFrame. It is element-wise (binary operator). If data are missing at both corresponding locations in the given DataFrame andother,the value at that location in the new DataFrame will be missing too.
      • rsub(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame of which every element is the subtraction of the corresponding elements inotherand the given Series. It is element-wise (binary operator). If both corresponding locations in the given DataFrame andotherhave missing values, the value at that location in the new DataFrame will be missing too.
      • rtruediv(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame of which every element is the float division of the corresponding elements inotherand the given DataFrame. It is element-wise (binary operator). If both corresponding locations in the given DataFrame andotherhave missing values, the value at that location in the new DataFrame will be missing too.
      • sample([n=None, frac=None, replace=False, weights=None, random_state=None, axis=None]): Return a new object that is of the same type as the caller and contains n randomly sampled items from the caller.
        • n: int, optional. Specifies the number of items to return from the specified axis. If frac=None, its default value is 1. Cannot be used with frac when it is not None.
        • frac: float, optional. Fraction of items to return. Cannot be used with n.
        • replace: bool, default False. Sample with or without replacement.
        • weights: str or ndarray-like, optional, default None meaning equal probability weighting. Missing values will be treated as zeros. Do not allow infinite values.
        • random_state: int or numpy.random.RandomState, optional. Seed for the random number generator if int, or numppy RandomState object.
        • axis: int or str specifying which axis to use for sampling.
      • select_dtypes(include=None, exclude=None): Return a subset of the columns of the given DataFrame based on the column dtypes.
        • include, exclude: scalar or list-like. A selection of dtypes or strings to be included/excluded. At least one of these parameters must be supplied.
      • sem([axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs]): Return a Series containing the unbiased standard error of the mean over the specified axis.
        • ddof: int, default 1. Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements.
        • numeric_only: bool, default None. Include only float, int, and boolean columns. Not implemented for Series.
      • set_axis(labels[, axis=0, inplace=None]): Assign a new index or a list-like to a given row or a column.
        • labels: like-like, Index. The values for the new index.
      • set_index([keys[, drop=True, append=False, inplace=False, verify_integrity=False]): Set the DataFrame index using existing columns.
        • keys: label or array-like, or list of labels/arrays.
        • drop: bool, default True. Delete columns to be used as the new index.
        • append: bool, default False. Whether to append columns to existing index.
        • inplace: bool, default False. Modify the DataFrame in place (do not create a new object).
        • verify_integrity: bool, default False. Check the new index for duplicates. Otherwise defer the check until necessary. Setting to False will improve the performance of this method.
      • shift([periods=1, freq=None, axis=0, fill_value=None]): Shift the index by the desired number of periods with an optional timefreq.
        • periods:int, default 1. Number of periods to shift; can be positive or negative.
        • freq: Optional, DateOffset, tseries.offsets, timedelta, or str. Offset to use from the tseries module or time rule (e.g. ‘EOM’).
        • axis: 0 or 'index', or 1 or 'columns'. Default None.
        • fill_value: Optional, float. A scalar value used to fill the newly introduced missing values.
      • sort_index([axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None]): Sort the given object by labels along the specified axis.
        • axis: int, default 0. Axis to do the direct sorting on.
        • level: int, optional. If not None, sort on values in the specified index levels.
        • ascending: bool, default False. Sort in ascending or descending order.
        • inplace: bool, default False. If True, perform operations in place.
        • kind: 'quicksort', 'mergesort', or 'heapsort'; default 'quicksort'. The sorting algorithm chosen.
        • na_position:'first' or 'last'. If 'first', put NaNs at the beginning; 'last' put NaNs at the end. Not implemented for MultiIndex.
        • sort_remaining: bool, default True. If True and index is multilevel, sort by level; sort by other levels too after sorting by the specified level.
      • sort_values(by[, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last']): Sort by the values along the specified axis.
      • squeeze([axis=None]): Return the projection after squeezing the specified axis. If axis=None, all length-1 axes will be squeezed. Series or DataFrames with a single element are squeezed to a scalar. DataFrames with a single column or a single row are squeezed to a Series.
      • stack([level=-1, dropna=True]): Stack the specified level(s) from columns to index. Return a reshaped DataFrame or Series that contains a multi-level index with one or more new inner-most levels compared to the current DataFrame. The new inner-most levels are created by pivoting the columns of the current DataFrame. If the columns have a single level, the output is a Series; if the columns have multiple levels, the new index level(s) is (are) taken from the specified level(s) and the output is a DataFrame.
        • level: int, str, list, default -1. Level(s) to stack from the column axis onto the index axis, defined as one index or label, or a list of indices or labels.
        • dropna:bool, default True. Whether to drop rows in the resulting DataFrame/Series with missing values. Stacking a column level onto the index axis can create combinations of index and column values that are missing from the original DataFrame.
      • std([axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs]): Return a Series containing the standard deviation over the specified axis.
      • sub(other[, axis='columns', level=None, fill_value=None]): Return a new DataFrame in which every element is the subtraction of the corresponding elements in the given DataFrame andother. It is element-wise (binary operator). If both corresponding locations in the given DataFrame andotherhave missing values, the value at the location in the new DataFrame will be missing too.
      • subtract(other[, axis='columns', level=None, fill_value=None]): Same as sub().
      • sum([axis=None, skipna=True, level=None, numeric_only=None, min_count=0, **kwargs]): Return a Series containing the sum of the values from the specified axis.
        • min_count: int, default 0. The required number of valid values to perform the operation. If the number of valid values is less than min_count, the result will be NA.
      • tail([n]): Return the last n rows.
      • take(indices[, axis=0, is_copy=True, **kwargs]): Return the elements in the given positional indices along the specified axis.
        • indices:array-like. An array of ints indicating which position to take.
        • axis: 0 or 'index', 1 or 'columns', None; default 0.
        • is_copy:bool, default True. Whether return a copy of the original object or not.
        • kwargs: For compatibility with numpy.take().
      • to_clipboard([excel=True, sep=None, **kwargs]): Copy the object to the system clipboard.
        • excel: bool, default True. If True, use the provided separator, and write in a csv format for allowing easy pasting into excel. If False, write a string representation of the object to the clipboard.
        • sep: str, default '\t'. Field delimiter.
      • to_csv([path_or_buf=None, sep=',', na_rep='', float_format=None, columns, header=True, index=True, index_label=None, mode='w', encoding, compression='infer', quoting, quotechar='"', line_terminator, chunksize=None, date_format=None, doublequote=True, escapechar=None, decimal='.']): Write the object to a comma-separated values (csv) file.
        • path_or_buf: str or file handle, default None. File path or object. If None is provided, the result will be returned as a string. If a file object is passed, it should be opened with newline='' with universal newlines disabled.
        • sep:str, default ','. String of length 1. Field delimiter for the output file.
        • na_rep: str, default ''. Missing data representation.
        • float_format: str, default None. Format string for floating point numbers.
        • columns: sequence, optional. Columns to write.
        • header: bool or list of str, default True. Write out the columns names.
        • index: bool, default True. Write row names (index).
        • index_label: str or sequence, or False, default None. Column label for index column(s) if desired.
        • mode: str. Python write mode, default 'w'.
        • encoding: str, optional. A string representing the encoding to use in the output file; default 'utf-8'.
        • compression: 'infer', 'gzip', 'bz2', 'zip', 'xz', or None, default 'infer'. Compression mode. If 'infer' and path_or_buf is path-like, then detect compression from the following extensions: '.gz', '.bz2', '.zip', or '.xz'; otherwise, no compression.
        • quoting: optional constant from csv module.
        • quotechar: str, default '"'. String of length 1. Character used to quote fields.
        • line_terminator: str, optional. The newline character or character sequence to use in the output file.
        • chunksize: int or None. Rows to write at a time.
        • date_format: str, default None. Format string for datetime objects.
        • doublequote: bool, default True. Control quoting of quotechar inside a field.
        • escapechar: str, default None.
        • decimal: str, default '.'. Character recognized as decimal separator.
      • to_dict([orient='dict', into=]): Convert the given DataFrame to a dict (label:value) or a dict-like object.
        • orient: 'dict', 'list', 'series', 'split', 'records', 'index'; default dict.
          • dict: dict like {column: {index: value}}.
          • list: dict like {column: [values]}.
          • series: dict like {column: Series of column values}.
          • split: dict like {'index': [index], 'columns': [columns], 'data': [row values]}.
          • records: list like [{column: value},..., {column: value}]. The length of the list is the number of rows in the DataFrame.
          • index: dict like {index: {column: value}}.
        • into: class, default dict.
      • to_excel(excel_writer[, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None]): Write the object to an Excel sheet.
        • excel_writer: str or ExcelWriter object. File path or existing ExcelWriter.
        • sheet_name: str, default 'sheet1'. Name of the excel sheet the object will be written to.
        • startrow: int, default 0. Upper left cell row.
        • startcol: int, default 0. Upper left cell column.
        • engine: Write engine to use. 'openpyxl' or 'xlsxwriter'.
        • merge_cells: bool, default True. Write MultiIndex and Hierarchical rows as merged cells.
        • inf_rep: str, default 'inf'. Representation for infinity (there is no native representation for infinity in excel).
        • verbose: bool, default True. Display more information in the error logs.
        • freeze_panes: tuple of int, optional. Specifies the one-based bottommost row and rightmost column that is to be frozen.
      • to_json([path_or_buf=None, orient=None, date_format=None, double_precision=10, force_ascii=True, date_unit='ms', default_handler=None, lines=False, compression='infer', index=True]): Convert the object to a JSON string. If path_or_buf is None, returns the resulting json format as a string. Otherwise, returns None.
        • path_or_buf: str or file handle, optional. File path or object. If not specified, the result will be returned as a string.
        • orient: str. The format of the JSON string.
          • 'split': dict like {'index' -> [index], 'columns' -> [columns], 'data' -> [values]}.
          • 'records': list like [{column -> value}, … , {column -> value}].
          • 'index': dict like {index -> {column -> value}}.
          • 'columns': dict like {column -> {index -> value}}.
          • 'values': Just the values array.
          • 'table': dict like {'schema': {schema}, 'data': {data}}. The data component is like orient='records'.
        • date_format: None, 'epoch', or 'iso'. Type of date conversion. 'epoch' = epoch milliseconds, 'iso' = ISO8601. The default depends on the orient. For orient='table', the default is 'iso'. For all other orients, the default is 'epoch'.
        • double_precision: int, default 10. The number of decimal places to use when encoding floating point values.
        • force_ascii: bool, default True. Force to use ASCII.
        • date_unit: str, 's', 'ms', 'us', 'ns', default 'ms'. The time unit to encode to.
        • default_handler: callable, default None. Handler to call.
        • lines: bool, default False. If 'orient' is 'records', write out line delimited JSON format.
        • compression: 'infer', 'gzip', 'bz2', 'zip', 'xz', or None. A string representing the compression to use in the output file. It is only used when the first argument is a filename. By default, the compression is inferred from the filename.
        • index: bool, default True. Whether to include the index values in the JSON string. Not including the index (index=False) is only supported when 'orient' is 'split' or 'table'.
      • to_latex([buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=False, column_format=None, longtable=None, escape=None, encoding=None, decimal='.', multicolumn=None, multicolumn_format=None, multirow=None]): Render the object to a LaTeX tabular environment table.
        • buf: file descriptor or None. Buffer to write to. If None, the output is returned as a string.
        • columns: list or label,, optional. The subset of columns to write. Write all columns by default.
        • col_space: int, optional. The minimum width of each column.
        • header: bool or list of strings; default True. Write out the column names. if a list of strings is given, it is assumed to be aliases for the column names.
        • index: bool, default True. Write row names (index).
        • na_rep: str, default 'NaN'. Missing data representation.
        • formatters: list of functions or dict of {str: function}, optional. Formatter functions to apply to columns' elements by position or name. The result of each function must be a unicode string. The list must be of the same length as the number of columns.
        • float_format: one-parameter function or str, optional; default None. Formatter for floating point numbers.
        • sparsify: bool, optional. Set to False for a DataFrame with a hierarchical index to print every MultiIndex key at each row. By default, the value will be read from the config module.
        • index_names: bool, default True. Prints the names of the index.
        • bold_rows: bool, default False. Make the row labels bold in the output.
        • column_format: str, optional. Column format as specified inLaTex table format.
        • longtable: bool, optional. By default, the value will be read from the pandas config module. Use a longtable environment instead of tabular.
        • escape: str, optional. By default, the value will be read from the pandas config module. Being set to False will prevent from escaping latex special characters in column names.
        • encoding: str, optional. A string representing the encoding to use in the output file. Default is 'utf-8'.
        • decimal: str, default '.'. Character recognized as decimal separator.
        • multicolumn:bool, default True. Use multicolumn to enhance MultiIndex columns. The default will be read from the config module.
        • multicolumn_format: str, default '1'. The alignment for multicolumns. The default will be read from the config module.
        • multirow: bool, default False. Use multirow to enhance MultiIndex rows.
      • to_numpy([dtype=None, copy=False]): Return a NumPy ndarray representing the values in the DataFrame.
        • dtype: str or numpy.dtype, optional. The dtype to pass to numpy.asarray().
        • copy: bool, default False. Whether or not the returned value is a view of another array.
      • to_sql(name, con[, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None, method=None]): Write the records stored in a DataFrame to a SQL database.
        • name: str. Name of SQL table.
        • con: sqlalchemy.engine.Engine or sqlite3.Connection. Using SQLAlchemy makes it possible to use any DB supported by that library. Legacy support is provided for sqlite3.Connection objects.
        • schema: str, optional. Specify the schema. If None, use the default schema.
        • if_exists: 'fail', 'replace', or 'append'; default 'fail'. How to behave if the table already exists.
          • 'fail': Raise a ValueError.
          • 'replace': Drop the table before inserting new values.
          • 'append': Insert new values to the existing table.
        • index: bool, default True. Write the index of a DataFrame as a column. Use index_label as the column name in the table.
        • index_label: string or sequence, default None. Column label for index columns.
        • chunksize:int, optional. The batch size of the rows that will be written at once. By default, all rows will be written at once.
        • dtype: dict, optional. Specify the datatype for columns. The keys should be the column names and the values should be the SQLAlchemy types or strings for the sqlite3 legacy mode.
        • method: None, 'multi', or callable; default None.
      • to_string([buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, max_rows=None, min_rows=None, max_cols=None, show_dimensions=False, decimal='.', line_width=None]): Render a DataFrame to a console-friendly tabular output, and return a string representation of the DataFrame.
        • buf: StringIO-like, optional. Buffer to write to.
        • columns: sequence, optional, default None. The subset of columns to write. Writes all columns by default.
        • col_space: int, optional. The minimum width of each column.
        • header: bool, default True. Write the column names. If a list of strings is given, it is assumed to be aliases for the column names.
        • index: bool, optional, default True. Whether or not to print index (row) labels.
        • na_rep: str, optional. String representation of NaN to use; default 'NaN'.
        • formatters: list or dict of one-param. functions, optional. Formatter function to apply to columns' elements by position or name. The result of each function must be a unicode string.
        • float_format: one-parameter function, optional, default None. Formatter function to apply to columns’ elements if they are floats. The result of this function must be a unicode string.
        • sparsify: bool, optional, default True. Set to False for a DataFrame with a hierarchical index to print every multiindex key at each row.
        • index_names: bool, optional, default True. Prints the names of the indexes.
        • justify: str, default None. How to justify the column labels.
        • max_rows: int, optional. Maximum number of rows to show before truncating. If None, show all.
        • min_rows: int, optional. The number of rows to display in a truncated repr (when the number of rows is above max_rows).
        • max_cols: int, optional. Maximum number of columns to display in the console.
        • show_dimensions: bool, optional, default False. Display DataFrame dimensions (number of rows by number of columns).
        • decimal: str, default '.'. Character recognized as decimal separator.
        • line_width: int, optional. Width to wrap a line in characters.
      • to_xarray(): Return an xarray object from the pandas object.
      • transform(func[, axis=0, *args, **kwargs]): Call func on the given DataFrame. It produces a DataFrame with the same axis shape as the given DataFrame.
        • func: function, str (function name), list of functions/function names, or dict of axis label and function (name) pairs. Function to use for transforming the data.
        • axis: 0 or 'index', 1 or 'columns'.
        • *args: Positional arguments to pass to func.
        • **kwargs: Keyword arguments to pass to func.
      • transpose(*args, **kwargs): Transpose index and columns, and return the transposed DataFrame.
      • truediv(other[, level=None, fill_value=None, axis=0]): Return a new DataFrame of which every element is the float division of the corresponding elements in the given DataFrame andother. It is element-wise (binary operator). If data are missing at both corresponding locations in the given Dataframe andother,the value at that location in the returned DataFrame will be missing too.
      • truncate([before=None, after=None, axis=None, copy=True]): Truncate a Series or a DataFrame before and after some index value, and return the truncated Series or DataFrame.
        • before: date, str, or int. Truncate all rows before this index value.
        • after: date, str, or int. Truncate all rows after this index value.
        • axis: 0 or 'index', or 1 or 'columns', optional. Axis to truncate. Truncates the index (rows) by default.
        • copy:boolean, default is True. Return a copy of the truncated section.
      • unstack([level=-1, fill_value=None]): Unstack a DataFrame level of the index labels, and return a DataFrame containing a new level of column labels whose inner-most level consists of the unstacked index labels. If the index is not a MultiIndex, the output will be a Series. The level involved will automatically get sorted.
        • level: int, str, or list of integers or strings; default last level (level=-1). Level to unstack; can pass level name.
        • fill_value: scalar, default None. Value to use when replacing NaN values.
      • update(other[, join='left', overwrite=True, filter_func=None, errors='ignore']): Modify the given DataFrame in place using the values passed fromother.Ifothercontains NaNs, the corresponding values in the given DataFrame will not be updated.
        • other: DataFrame, or object coercible into a DataFrame. Should have at least one matching index/column label with the original DataFrame. If a Series is passed, its name attribute must be set, and that will be used as the column name to align with the original DataFrame.
        • join: 'left', default 'left'. Only left join is implemented, keeping the index and columns of the original object. Will raise 'NotImplementError' if join is not 'left'.
        • overwrite: bool, default True. How to handle non-NA values for overlapping keys. True: overwrite the values of the original DataFrame with the values fromother.
        • filter_func: Return a 1-D boolean array, optional. Choose to replace values other than NA. True for values that should be updated.
        • errors: 'raise' or 'ignore', default 'ignore'. If 'raise', will raise a ValueError if data are missing at both corresponding locations in the given DataFrame andother.
      • var([axis=None, skipna=True, level=None, ddof=1, numeric_only=None, **kwargs]): Return the unbiased variance over the specified axis.
        • axis: 0 or 'index', 1 or 'columns'.
        • skipna: bool, default True. Exclude NA/null values. If an entire row or columns is NA, the result will be NA.
        • level: int or level name, default None. If the axis is a MultiIndex, count along the particular level.
        • ddof: Delta Degree of Freedom. The divisor used in calculations is N-ddof, where N is the number of elements.
        • numeric_only: bool, default None. Include only float, int, or boolean columns. If None, will attempt to use everything. Then use only numeric data. Not implement for Series.
        • **kwargs: Additonal keyword arguments.
      • where(cond[, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False]): Replace values where the condition is False.
        • cond: bool Series or DataFrame, array-like, or callable. A value in the original object will be kept if it satisfies the condition. When a value does not satisfy the condition, it will be replaced with the corresponding value inother.
        • other: scalar, Series/DataFrame, or callable. Entries that do not satisfy the condition will be replaced with the corresponding values fromother.
        • inplace: bool, default False. Whether to perform the operation in place or not.
        • axis: int or str, default None. Alignment axis.
        • level: int or level name, default None. Alignment level.
        • errors: str, 'raise' or 'ignore', default 'raise'.
        • try_cast: bool, default False. Try to cast the result back to the input type (if possible).
      • xs(key[, axis=0, level=None, drop_level=True]): Takes a key argument to select data at a particular level of a MultiIndex.
        • key: row label or tuple of row labels. Label contained in the index, or partially in a MultiIndex.
        • axis: 0 or 'index', or 1 or 'columns', default 0. Axis to retrieve cross-section on.
        • level: object, default first n levels (n=1 or len(key)). Levels to be used.
        • drop_level: bool, default True.