Pandas_InClass_1 (Series & DataFrames) 14.03.24.ipynb

{
 "cells": [
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image-2.png](attachment:image-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='green'> <b>Importing Libraries </b><font color='black'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-04T19:06:15.654368Z",
     "start_time": "2023-04-04T19:06:10.963607Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "#For those who does not want to see warnings\n",
    "# import warnings\n",
    "# warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ArrowDtype',\n",
       " 'BooleanDtype',\n",
       " 'Categorical',\n",
       " 'CategoricalDtype',\n",
       " 'CategoricalIndex',\n",
       " 'DataFrame',\n",
       " 'DateOffset',\n",
       " 'DatetimeIndex',\n",
       " 'DatetimeTZDtype',\n",
       " 'ExcelFile',\n",
       " 'ExcelWriter',\n",
       " 'Flags',\n",
       " 'Float32Dtype',\n",
       " 'Float64Dtype',\n",
       " 'Grouper',\n",
       " 'HDFStore',\n",
       " 'Index',\n",
       " 'IndexSlice',\n",
       " 'Int16Dtype',\n",
       " 'Int32Dtype',\n",
       " 'Int64Dtype',\n",
       " 'Int8Dtype',\n",
       " 'Interval',\n",
       " 'IntervalDtype',\n",
       " 'IntervalIndex',\n",
       " 'MultiIndex',\n",
       " 'NA',\n",
       " 'NaT',\n",
       " 'NamedAgg',\n",
       " 'Period',\n",
       " 'PeriodDtype',\n",
       " 'PeriodIndex',\n",
       " 'RangeIndex',\n",
       " 'Series',\n",
       " 'SparseDtype',\n",
       " 'StringDtype',\n",
       " 'Timedelta',\n",
       " 'TimedeltaIndex',\n",
       " 'Timestamp',\n",
       " 'UInt16Dtype',\n",
       " 'UInt32Dtype',\n",
       " 'UInt64Dtype',\n",
       " 'UInt8Dtype',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__docformat__',\n",
       " '__file__',\n",
       " '__git_version__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " '_built_with_meson',\n",
       " '_config',\n",
       " '_is_numpy_dev',\n",
       " '_libs',\n",
       " '_pandas_datetime_CAPI',\n",
       " '_pandas_parser_CAPI',\n",
       " '_testing',\n",
       " '_typing',\n",
       " '_version_meson',\n",
       " 'annotations',\n",
       " 'api',\n",
       " 'array',\n",
       " 'arrays',\n",
       " 'bdate_range',\n",
       " 'compat',\n",
       " 'concat',\n",
       " 'core',\n",
       " 'crosstab',\n",
       " 'cut',\n",
       " 'date_range',\n",
       " 'describe_option',\n",
       " 'errors',\n",
       " 'eval',\n",
       " 'factorize',\n",
       " 'from_dummies',\n",
       " 'get_dummies',\n",
       " 'get_option',\n",
       " 'infer_freq',\n",
       " 'interval_range',\n",
       " 'io',\n",
       " 'isna',\n",
       " 'isnull',\n",
       " 'json_normalize',\n",
       " 'lreshape',\n",
       " 'melt',\n",
       " 'merge',\n",
       " 'merge_asof',\n",
       " 'merge_ordered',\n",
       " 'notna',\n",
       " 'notnull',\n",
       " 'offsets',\n",
       " 'option_context',\n",
       " 'options',\n",
       " 'pandas',\n",
       " 'period_range',\n",
       " 'pivot',\n",
       " 'pivot_table',\n",
       " 'plotting',\n",
       " 'qcut',\n",
       " 'read_clipboard',\n",
       " 'read_csv',\n",
       " 'read_excel',\n",
       " 'read_feather',\n",
       " 'read_fwf',\n",
       " 'read_gbq',\n",
       " 'read_hdf',\n",
       " 'read_html',\n",
       " 'read_json',\n",
       " 'read_orc',\n",
       " 'read_parquet',\n",
       " 'read_pickle',\n",
       " 'read_sas',\n",
       " 'read_spss',\n",
       " 'read_sql',\n",
       " 'read_sql_query',\n",
       " 'read_sql_table',\n",
       " 'read_stata',\n",
       " 'read_table',\n",
       " 'read_xml',\n",
       " 'reset_option',\n",
       " 'set_eng_float_format',\n",
       " 'set_option',\n",
       " 'show_versions',\n",
       " 'test',\n",
       " 'testing',\n",
       " 'timedelta_range',\n",
       " 'to_datetime',\n",
       " 'to_numeric',\n",
       " 'to_pickle',\n",
       " 'to_timedelta',\n",
       " 'tseries',\n",
       " 'unique',\n",
       " 'util',\n",
       " 'value_counts',\n",
       " 'wide_to_long']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(pd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Series in module pandas.core.series:\n",
      "\n",
      "class Series(pandas.core.base.IndexOpsMixin, pandas.core.generic.NDFrame)\n",
      " |  Series(data=None, index=None, dtype: 'Dtype | None' = None, name=None, copy: 'bool | None' = None, fastpath: 'bool | lib.NoDefault' = <no_default>) -> 'None'\n",
      " |  \n",
      " |  One-dimensional ndarray with axis labels (including time series).\n",
      " |  \n",
      " |  Labels need not be unique but must be a hashable type. The object\n",
      " |  supports both integer- and label-based indexing and provides a host of\n",
      " |  methods for performing operations involving the index. Statistical\n",
      " |  methods from ndarray have been overridden to automatically exclude\n",
      " |  missing data (currently represented as NaN).\n",
      " |  \n",
      " |  Operations between Series (+, -, /, \\*, \\*\\*) align values based on their\n",
      " |  associated index values-- they need not be the same length. The result\n",
      " |  index will be the sorted union of the two indexes.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  data : array-like, Iterable, dict, or scalar value\n",
      " |      Contains data stored in Series. If data is a dict, argument order is\n",
      " |      maintained.\n",
      " |  index : array-like or Index (1d)\n",
      " |      Values must be hashable and have the same length as `data`.\n",
      " |      Non-unique index values are allowed. Will default to\n",
      " |      RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like\n",
      " |      and index is None, then the keys in the data are used as the index. If the\n",
      " |      index is not None, the resulting Series is reindexed with the index values.\n",
      " |  dtype : str, numpy.dtype, or ExtensionDtype, optional\n",
      " |      Data type for the output Series. If not specified, this will be\n",
      " |      inferred from `data`.\n",
      " |      See the :ref:`user guide <basics.dtypes>` for more usages.\n",
      " |  name : Hashable, default None\n",
      " |      The name to give to the Series.\n",
      " |  copy : bool, default False\n",
      " |      Copy input data. Only affects Series or 1d ndarray input. See examples.\n",
      " |  \n",
      " |  Notes\n",
      " |  -----\n",
      " |  Please reference the :ref:`User Guide <basics.series>` for more information.\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  Constructing Series from a dictionary with an Index specified\n",
      " |  \n",
      " |  >>> d = {'a': 1, 'b': 2, 'c': 3}\n",
      " |  >>> ser = pd.Series(data=d, index=['a', 'b', 'c'])\n",
      " |  >>> ser\n",
      " |  a   1\n",
      " |  b   2\n",
      " |  c   3\n",
      " |  dtype: int64\n",
      " |  \n",
      " |  The keys of the dictionary match with the Index values, hence the Index\n",
      " |  values have no effect.\n",
      " |  \n",
      " |  >>> d = {'a': 1, 'b': 2, 'c': 3}\n",
      " |  >>> ser = pd.Series(data=d, index=['x', 'y', 'z'])\n",
      " |  >>> ser\n",
      " |  x   NaN\n",
      " |  y   NaN\n",
      " |  z   NaN\n",
      " |  dtype: float64\n",
      " |  \n",
      " |  Note that the Index is first build with the keys from the dictionary.\n",
      " |  After this the Series is reindexed with the given Index values, hence we\n",
      " |  get all NaN as a result.\n",
      " |  \n",
      " |  Constructing Series from a list with `copy=False`.\n",
      " |  \n",
      " |  >>> r = [1, 2]\n",
      " |  >>> ser = pd.Series(r, copy=False)\n",
      " |  >>> ser.iloc[0] = 999\n",
      " |  >>> r\n",
      " |  [1, 2]\n",
      " |  >>> ser\n",
      " |  0    999\n",
      " |  1      2\n",
      " |  dtype: int64\n",
      " |  \n",
      " |  Due to input data type the Series has a `copy` of\n",
      " |  the original data even though `copy=False`, so\n",
      " |  the data is unchanged.\n",
      " |  \n",
      " |  Constructing Series from a 1d ndarray with `copy=False`.\n",
      " |  \n",
      " |  >>> r = np.array([1, 2])\n",
      " |  >>> ser = pd.Series(r, copy=False)\n",
      " |  >>> ser.iloc[0] = 999\n",
      " |  >>> r\n",
      " |  array([999,   2])\n",
      " |  >>> ser\n",
      " |  0    999\n",
      " |  1      2\n",
      " |  dtype: int64\n",
      " |  \n",
      " |  Due to input data type the Series has a `view` on\n",
      " |  the original data, so\n",
      " |  the data is changed as well.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Series\n",
      " |      pandas.core.base.IndexOpsMixin\n",
      " |      pandas.core.arraylike.OpsMixin\n",
      " |      pandas.core.generic.NDFrame\n",
      " |      pandas.core.base.PandasObject\n",
      " |      pandas.core.accessor.DirNamesMixin\n",
      " |      pandas.core.indexing.IndexingMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __array__(self, dtype: 'npt.DTypeLike | None' = None) -> 'np.ndarray'\n",
      " |      Return the values as a NumPy array.\n",
      " |      \n",
      " |      Users should not call this directly. Rather, it is invoked by\n",
      " |      :func:`numpy.array` and :func:`numpy.asarray`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : str or numpy.dtype, optional\n",
      " |          The dtype to use for the resulting NumPy array. By default,\n",
      " |          the dtype is inferred from the data.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      numpy.ndarray\n",
      " |          The values in the series converted to a :class:`numpy.ndarray`\n",
      " |          with the specified `dtype`.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      array : Create a new array from data.\n",
      " |      Series.array : Zero-copy view to the array backing the Series.\n",
      " |      Series.to_numpy : Series method for similar behavior.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([1, 2, 3])\n",
      " |      >>> np.asarray(ser)\n",
      " |      array([1, 2, 3])\n",
      " |      \n",
      " |      For timezone-aware data, the timezones may be retained with\n",
      " |      ``dtype='object'``\n",
      " |      \n",
      " |      >>> tzser = pd.Series(pd.date_range('2000', periods=2, tz=\"CET\"))\n",
      " |      >>> np.asarray(tzser, dtype=\"object\")\n",
      " |      array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'),\n",
      " |             Timestamp('2000-01-02 00:00:00+0100', tz='CET')],\n",
      " |            dtype=object)\n",
      " |      \n",
      " |      Or the values may be localized to UTC and the tzinfo discarded with\n",
      " |      ``dtype='datetime64[ns]'``\n",
      " |      \n",
      " |      >>> np.asarray(tzser, dtype=\"datetime64[ns]\")  # doctest: +ELLIPSIS\n",
      " |      array(['1999-12-31T23:00:00.000000000', ...],\n",
      " |            dtype='datetime64[ns]')\n",
      " |  \n",
      " |  __column_consortium_standard__(self, *, api_version: 'str | None' = None) -> 'Any'\n",
      " |      Provide entry point to the Consortium DataFrame Standard API.\n",
      " |      \n",
      " |      This is developed and maintained outside of pandas.\n",
      " |      Please report any issues to https://github.com/data-apis/dataframe-api-compat.\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __getitem__(self, key)\n",
      " |  \n",
      " |  __init__(self, data=None, index=None, dtype: 'Dtype | None' = None, name=None, copy: 'bool | None' = None, fastpath: 'bool | lib.NoDefault' = <no_default>) -> 'None'\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __len__(self) -> 'int'\n",
      " |      Return the length of the Series.\n",
      " |  \n",
      " |  __matmul__(self, other)\n",
      " |      Matrix multiplication using binary `@` operator.\n",
      " |  \n",
      " |  __repr__(self) -> 'str'\n",
      " |      Return a string representation for a particular Series.\n",
      " |  \n",
      " |  __rmatmul__(self, other)\n",
      " |      Matrix multiplication using binary `@` operator.\n",
      " |  \n",
      " |  __setitem__(self, key, value) -> 'None'\n",
      " |  \n",
      " |  add(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Addition of series and other, element-wise (binary operator `add`).\n",
      " |      \n",
      " |      Equivalent to ``series + other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.radd : Reverse of the Addition operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.add(b, fill_value=0)\n",
      " |      a    2.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  agg = aggregate(self, func=None, axis: 'Axis' = 0, *args, **kwargs)\n",
      " |  \n",
      " |  aggregate(self, func=None, axis: 'Axis' = 0, *args, **kwargs)\n",
      " |      Aggregate using one or more operations over the specified axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      func : function, str, list or dict\n",
      " |          Function to use for aggregating the data. If a function, must either\n",
      " |          work when passed a Series or when passed to Series.apply.\n",
      " |      \n",
      " |          Accepted combinations are:\n",
      " |      \n",
      " |          - function\n",
      " |          - string function name\n",
      " |          - list of functions and/or function names, e.g. ``[np.sum, 'mean']``\n",
      " |          - dict of axis labels -> functions, function names or list of such.\n",
      " |      axis : {0 or 'index'}\n",
      " |              Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      *args\n",
      " |          Positional arguments to pass to `func`.\n",
      " |      **kwargs\n",
      " |          Keyword arguments to pass to `func`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar, Series or DataFrame\n",
      " |      \n",
      " |          The return can be:\n",
      " |      \n",
      " |          * scalar : when Series.agg is called with single function\n",
      " |          * Series : when DataFrame.agg is called with a single function\n",
      " |          * DataFrame : when DataFrame.agg is called with several functions\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.apply : Invoke function on a Series.\n",
      " |      Series.transform : Transform function producing a Series with like indexes.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The aggregation operations are always performed over an axis, either the\n",
      " |      index (default) or the column axis. This behavior is different from\n",
      " |      `numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`,\n",
      " |      `var`), where the default is to compute the aggregation of the flattened\n",
      " |      array, e.g., ``numpy.mean(arr_2d)`` as opposed to\n",
      " |      ``numpy.mean(arr_2d, axis=0)``.\n",
      " |      \n",
      " |      `agg` is an alias for `aggregate`. Use the alias.\n",
      " |      \n",
      " |      Functions that mutate the passed object can produce unexpected\n",
      " |      behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\n",
      " |      for more details.\n",
      " |      \n",
      " |      A passed user-defined-function will be passed a Series for evaluation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4])\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.agg('min')\n",
      " |      1\n",
      " |      \n",
      " |      >>> s.agg(['min', 'max'])\n",
      " |      min   1\n",
      " |      max   4\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  all(self, axis: 'Axis' = 0, bool_only: 'bool' = False, skipna: 'bool' = True, **kwargs) -> 'bool'\n",
      " |      Return whether all elements are True, potentially over an axis.\n",
      " |      \n",
      " |      Returns True unless there at least one element within a series or\n",
      " |      along a Dataframe axis that is False or equivalent (e.g. zero or\n",
      " |      empty).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default 0\n",
      " |          Indicate which axis or axes should be reduced. For `Series` this parameter\n",
      " |          is unused and defaults to 0.\n",
      " |      \n",
      " |          * 0 / 'index' : reduce the index, return a Series whose index is the\n",
      " |            original column labels.\n",
      " |          * 1 / 'columns' : reduce the columns, return a Series whose index is the\n",
      " |            original index.\n",
      " |          * None : reduce all axes, return a scalar.\n",
      " |      \n",
      " |      bool_only : bool, default False\n",
      " |          Include only boolean columns. Not implemented for Series.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If the entire row/column is NA and skipna is\n",
      " |          True, then the result will be True, as for an empty row/column.\n",
      " |          If skipna is False, then NA are treated as True, because these are not\n",
      " |          equal to zero.\n",
      " |      **kwargs : any, default None\n",
      " |          Additional keywords have no effect but might be accepted for\n",
      " |          compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series\n",
      " |          If level is specified, then, Series is returned; otherwise, scalar\n",
      " |          is returned.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.all : Return True if all elements are True.\n",
      " |      DataFrame.any : Return True if one (or more) elements are True.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> pd.Series([True, True]).all()\n",
      " |      True\n",
      " |      >>> pd.Series([True, False]).all()\n",
      " |      False\n",
      " |      >>> pd.Series([], dtype=\"float64\").all()\n",
      " |      True\n",
      " |      >>> pd.Series([np.nan]).all()\n",
      " |      True\n",
      " |      >>> pd.Series([np.nan]).all(skipna=False)\n",
      " |      True\n",
      " |      \n",
      " |      **DataFrames**\n",
      " |      \n",
      " |      Create a dataframe from a dictionary.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'col1': [True, True], 'col2': [True, False]})\n",
      " |      >>> df\n",
      " |         col1   col2\n",
      " |      0  True   True\n",
      " |      1  True  False\n",
      " |      \n",
      " |      Default behaviour checks if values in each column all return True.\n",
      " |      \n",
      " |      >>> df.all()\n",
      " |      col1     True\n",
      " |      col2    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      Specify ``axis='columns'`` to check if values in each row all return True.\n",
      " |      \n",
      " |      >>> df.all(axis='columns')\n",
      " |      0     True\n",
      " |      1    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      Or ``axis=None`` for whether every value is True.\n",
      " |      \n",
      " |      >>> df.all(axis=None)\n",
      " |      False\n",
      " |  \n",
      " |  any(self, *, axis: 'Axis' = 0, bool_only: 'bool' = False, skipna: 'bool' = True, **kwargs) -> 'bool'\n",
      " |      Return whether any element is True, potentially over an axis.\n",
      " |      \n",
      " |      Returns False unless there is at least one element within a series or\n",
      " |      along a Dataframe axis that is True or equivalent (e.g. non-zero or\n",
      " |      non-empty).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default 0\n",
      " |          Indicate which axis or axes should be reduced. For `Series` this parameter\n",
      " |          is unused and defaults to 0.\n",
      " |      \n",
      " |          * 0 / 'index' : reduce the index, return a Series whose index is the\n",
      " |            original column labels.\n",
      " |          * 1 / 'columns' : reduce the columns, return a Series whose index is the\n",
      " |            original index.\n",
      " |          * None : reduce all axes, return a scalar.\n",
      " |      \n",
      " |      bool_only : bool, default False\n",
      " |          Include only boolean columns. Not implemented for Series.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If the entire row/column is NA and skipna is\n",
      " |          True, then the result will be False, as for an empty row/column.\n",
      " |          If skipna is False, then NA are treated as True, because these are not\n",
      " |          equal to zero.\n",
      " |      **kwargs : any, default None\n",
      " |          Additional keywords have no effect but might be accepted for\n",
      " |          compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series\n",
      " |          If level is specified, then, Series is returned; otherwise, scalar\n",
      " |          is returned.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.any : Numpy version of this method.\n",
      " |      Series.any : Return whether any element is True.\n",
      " |      Series.all : Return whether all elements are True.\n",
      " |      DataFrame.any : Return whether any element is True over requested axis.\n",
      " |      DataFrame.all : Return whether all elements are True over requested axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      For Series input, the output is a scalar indicating whether any element\n",
      " |      is True.\n",
      " |      \n",
      " |      >>> pd.Series([False, False]).any()\n",
      " |      False\n",
      " |      >>> pd.Series([True, False]).any()\n",
      " |      True\n",
      " |      >>> pd.Series([], dtype=\"float64\").any()\n",
      " |      False\n",
      " |      >>> pd.Series([np.nan]).any()\n",
      " |      False\n",
      " |      >>> pd.Series([np.nan]).any(skipna=False)\n",
      " |      True\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      Whether each column contains at least one True element (the default).\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\"A\": [1, 2], \"B\": [0, 2], \"C\": [0, 0]})\n",
      " |      >>> df\n",
      " |         A  B  C\n",
      " |      0  1  0  0\n",
      " |      1  2  2  0\n",
      " |      \n",
      " |      >>> df.any()\n",
      " |      A     True\n",
      " |      B     True\n",
      " |      C    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      Aggregating over the columns.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\"A\": [True, False], \"B\": [1, 2]})\n",
      " |      >>> df\n",
      " |             A  B\n",
      " |      0   True  1\n",
      " |      1  False  2\n",
      " |      \n",
      " |      >>> df.any(axis='columns')\n",
      " |      0    True\n",
      " |      1    True\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\"A\": [True, False], \"B\": [1, 0]})\n",
      " |      >>> df\n",
      " |             A  B\n",
      " |      0   True  1\n",
      " |      1  False  0\n",
      " |      \n",
      " |      >>> df.any(axis='columns')\n",
      " |      0    True\n",
      " |      1    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      Aggregating over the entire DataFrame with ``axis=None``.\n",
      " |      \n",
      " |      >>> df.any(axis=None)\n",
      " |      True\n",
      " |      \n",
      " |      `any` for an empty DataFrame is an empty Series.\n",
      " |      \n",
      " |      >>> pd.DataFrame([]).any()\n",
      " |      Series([], dtype: bool)\n",
      " |  \n",
      " |  apply(self, func: 'AggFuncType', convert_dtype: 'bool | lib.NoDefault' = <no_default>, args: 'tuple[Any, ...]' = (), *, by_row: \"Literal[False, 'compat']\" = 'compat', **kwargs) -> 'DataFrame | Series'\n",
      " |      Invoke function on values of Series.\n",
      " |      \n",
      " |      Can be ufunc (a NumPy function that applies to the entire Series)\n",
      " |      or a Python function that only works on single values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      func : function\n",
      " |          Python function or NumPy ufunc to apply.\n",
      " |      convert_dtype : bool, default True\n",
      " |          Try to find better dtype for elementwise function results. If\n",
      " |          False, leave as dtype=object. Note that the dtype is always\n",
      " |          preserved for some extension array dtypes, such as Categorical.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |              ``convert_dtype`` has been deprecated. Do ``ser.astype(object).apply()``\n",
      " |              instead if you want ``convert_dtype=False``.\n",
      " |      args : tuple\n",
      " |          Positional arguments passed to func after the series value.\n",
      " |      by_row : False or \"compat\", default \"compat\"\n",
      " |          If ``\"compat\"`` and func is a callable, func will be passed each element of\n",
      " |          the Series, like ``Series.map``. If func is a list or dict of\n",
      " |          callables, will first try to translate each func into pandas methods. If\n",
      " |          that doesn't work, will try call to apply again with ``by_row=\"compat\"``\n",
      " |          and if that fails, will call apply again with ``by_row=False``\n",
      " |          (backward compatible).\n",
      " |          If False, the func will be passed the whole Series at once.\n",
      " |      \n",
      " |          ``by_row`` has no effect when ``func`` is a string.\n",
      " |      \n",
      " |          .. versionadded:: 2.1.0\n",
      " |      **kwargs\n",
      " |          Additional keyword arguments passed to func.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          If func returns a Series object the result will be a DataFrame.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.map: For element-wise operations.\n",
      " |      Series.agg: Only perform aggregating type operations.\n",
      " |      Series.transform: Only perform transforming type operations.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Functions that mutate the passed object can produce unexpected\n",
      " |      behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\n",
      " |      for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Create a series with typical summer temperatures for each city.\n",
      " |      \n",
      " |      >>> s = pd.Series([20, 21, 12],\n",
      " |      ...               index=['London', 'New York', 'Helsinki'])\n",
      " |      >>> s\n",
      " |      London      20\n",
      " |      New York    21\n",
      " |      Helsinki    12\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Square the values by defining a function and passing it as an\n",
      " |      argument to ``apply()``.\n",
      " |      \n",
      " |      >>> def square(x):\n",
      " |      ...     return x ** 2\n",
      " |      >>> s.apply(square)\n",
      " |      London      400\n",
      " |      New York    441\n",
      " |      Helsinki    144\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Square the values by passing an anonymous function as an\n",
      " |      argument to ``apply()``.\n",
      " |      \n",
      " |      >>> s.apply(lambda x: x ** 2)\n",
      " |      London      400\n",
      " |      New York    441\n",
      " |      Helsinki    144\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Define a custom function that needs additional positional\n",
      " |      arguments and pass these additional arguments using the\n",
      " |      ``args`` keyword.\n",
      " |      \n",
      " |      >>> def subtract_custom_value(x, custom_value):\n",
      " |      ...     return x - custom_value\n",
      " |      \n",
      " |      >>> s.apply(subtract_custom_value, args=(5,))\n",
      " |      London      15\n",
      " |      New York    16\n",
      " |      Helsinki     7\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Define a custom function that takes keyword arguments\n",
      " |      and pass these arguments to ``apply``.\n",
      " |      \n",
      " |      >>> def add_custom_values(x, **kwargs):\n",
      " |      ...     for month in kwargs:\n",
      " |      ...         x += kwargs[month]\n",
      " |      ...     return x\n",
      " |      \n",
      " |      >>> s.apply(add_custom_values, june=30, july=20, august=25)\n",
      " |      London      95\n",
      " |      New York    96\n",
      " |      Helsinki    87\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Use a function from the Numpy library.\n",
      " |      \n",
      " |      >>> s.apply(np.log)\n",
      " |      London      2.995732\n",
      " |      New York    3.044522\n",
      " |      Helsinki    2.484907\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  argsort(self, axis: 'Axis' = 0, kind: 'SortKind' = 'quicksort', order: 'None' = None, stable: 'None' = None) -> 'Series'\n",
      " |      Return the integer indices that would sort the Series values.\n",
      " |      \n",
      " |      Override ndarray.argsort. Argsorts the value, omitting NA/null values,\n",
      " |      and places the result in the same locations as the non-NA values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      kind : {'mergesort', 'quicksort', 'heapsort', 'stable'}, default 'quicksort'\n",
      " |          Choice of sorting algorithm. See :func:`numpy.sort` for more\n",
      " |          information. 'mergesort' and 'stable' are the only stable algorithms.\n",
      " |      order : None\n",
      " |          Has no effect but is accepted for compatibility with numpy.\n",
      " |      stable : None\n",
      " |          Has no effect but is accepted for compatibility with numpy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series[np.intp]\n",
      " |          Positions of values within the sort order with -1 indicating\n",
      " |          nan values.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ndarray.argsort : Returns the indices that would sort this array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([3, 2, 1])\n",
      " |      >>> s.argsort()\n",
      " |      0    2\n",
      " |      1    1\n",
      " |      2    0\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  autocorr(self, lag: 'int' = 1) -> 'float'\n",
      " |      Compute the lag-N autocorrelation.\n",
      " |      \n",
      " |      This method computes the Pearson correlation between\n",
      " |      the Series and its shifted self.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      lag : int, default 1\n",
      " |          Number of lags to apply before performing autocorrelation.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      float\n",
      " |          The Pearson correlation between self and self.shift(lag).\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.corr : Compute the correlation between two Series.\n",
      " |      Series.shift : Shift index by desired number of periods.\n",
      " |      DataFrame.corr : Compute pairwise correlation of columns.\n",
      " |      DataFrame.corrwith : Compute pairwise correlation between rows or\n",
      " |          columns of two DataFrame objects.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      If the Pearson correlation is not well defined return 'NaN'.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([0.25, 0.5, 0.2, -0.05])\n",
      " |      >>> s.autocorr()  # doctest: +ELLIPSIS\n",
      " |      0.10355...\n",
      " |      >>> s.autocorr(lag=2)  # doctest: +ELLIPSIS\n",
      " |      -0.99999...\n",
      " |      \n",
      " |      If the Pearson correlation is not well defined, then 'NaN' is returned.\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 0, 0, 0])\n",
      " |      >>> s.autocorr()\n",
      " |      nan\n",
      " |  \n",
      " |  between(self, left, right, inclusive: \"Literal['both', 'neither', 'left', 'right']\" = 'both') -> 'Series'\n",
      " |      Return boolean Series equivalent to left <= series <= right.\n",
      " |      \n",
      " |      This function returns a boolean vector containing `True` wherever the\n",
      " |      corresponding Series element is between the boundary values `left` and\n",
      " |      `right`. NA values are treated as `False`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      left : scalar or list-like\n",
      " |          Left boundary.\n",
      " |      right : scalar or list-like\n",
      " |          Right boundary.\n",
      " |      inclusive : {\"both\", \"neither\", \"left\", \"right\"}\n",
      " |          Include boundaries. Whether to set each bound as closed or open.\n",
      " |      \n",
      " |          .. versionchanged:: 1.3.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Series representing whether each element is between left and\n",
      " |          right (inclusive).\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.gt : Greater than of series and other.\n",
      " |      Series.lt : Less than of series and other.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This function is equivalent to ``(left <= ser) & (ser <= right)``\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([2, 0, 4, 8, np.nan])\n",
      " |      \n",
      " |      Boundary values are included by default:\n",
      " |      \n",
      " |      >>> s.between(1, 4)\n",
      " |      0     True\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      With `inclusive` set to ``\"neither\"`` boundary values are excluded:\n",
      " |      \n",
      " |      >>> s.between(1, 4, inclusive=\"neither\")\n",
      " |      0     True\n",
      " |      1    False\n",
      " |      2    False\n",
      " |      3    False\n",
      " |      4    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      `left` and `right` can be any scalar value:\n",
      " |      \n",
      " |      >>> s = pd.Series(['Alice', 'Bob', 'Carol', 'Eve'])\n",
      " |      >>> s.between('Anna', 'Daniel')\n",
      " |      0    False\n",
      " |      1     True\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  case_when(self, caselist: 'list[tuple[ArrayLike | Callable[[Series], Series | np.ndarray | Sequence[bool]], ArrayLike | Scalar | Callable[[Series], Series | np.ndarray]],]') -> 'Series'\n",
      " |      Replace values where the conditions are True.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      caselist : A list of tuples of conditions and expected replacements\n",
      " |          Takes the form:  ``(condition0, replacement0)``,\n",
      " |          ``(condition1, replacement1)``, ... .\n",
      " |          ``condition`` should be a 1-D boolean array-like object\n",
      " |          or a callable. If ``condition`` is a callable,\n",
      " |          it is computed on the Series\n",
      " |          and should return a boolean Series or array.\n",
      " |          The callable must not change the input Series\n",
      " |          (though pandas doesn`t check it). ``replacement`` should be a\n",
      " |          1-D array-like object, a scalar or a callable.\n",
      " |          If ``replacement`` is a callable, it is computed on the Series\n",
      " |          and should return a scalar or Series. The callable\n",
      " |          must not change the input Series\n",
      " |          (though pandas doesn`t check it).\n",
      " |      \n",
      " |          .. versionadded:: 2.2.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.mask : Replace values where the condition is True.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> c = pd.Series([6, 7, 8, 9], name='c')\n",
      " |      >>> a = pd.Series([0, 0, 1, 2])\n",
      " |      >>> b = pd.Series([0, 3, 4, 5])\n",
      " |      \n",
      " |      >>> c.case_when(caselist=[(a.gt(0), a),  # condition, replacement\n",
      " |      ...                       (b.gt(0), b)])\n",
      " |      0    6\n",
      " |      1    3\n",
      " |      2    1\n",
      " |      3    2\n",
      " |      Name: c, dtype: int64\n",
      " |  \n",
      " |  combine(self, other: 'Series | Hashable', func: 'Callable[[Hashable, Hashable], Hashable]', fill_value: 'Hashable | None' = None) -> 'Series'\n",
      " |      Combine the Series with a Series or scalar according to `func`.\n",
      " |      \n",
      " |      Combine the Series and `other` using `func` to perform elementwise\n",
      " |      selection for combined Series.\n",
      " |      `fill_value` is assumed when value is missing at some index\n",
      " |      from one of the two objects being combined.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar\n",
      " |          The value(s) to be combined with the `Series`.\n",
      " |      func : function\n",
      " |          Function that takes two scalars as inputs and returns an element.\n",
      " |      fill_value : scalar, optional\n",
      " |          The value to assume when an index is missing from\n",
      " |          one Series or the other. The default specifies to use the\n",
      " |          appropriate NaN value for the underlying dtype of the Series.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of combining the Series with the other object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.combine_first : Combine Series values, choosing the calling\n",
      " |          Series' values first.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Consider 2 Datasets ``s1`` and ``s2`` containing\n",
      " |      highest clocked speeds of different birds.\n",
      " |      \n",
      " |      >>> s1 = pd.Series({'falcon': 330.0, 'eagle': 160.0})\n",
      " |      >>> s1\n",
      " |      falcon    330.0\n",
      " |      eagle     160.0\n",
      " |      dtype: float64\n",
      " |      >>> s2 = pd.Series({'falcon': 345.0, 'eagle': 200.0, 'duck': 30.0})\n",
      " |      >>> s2\n",
      " |      falcon    345.0\n",
      " |      eagle     200.0\n",
      " |      duck       30.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Now, to combine the two datasets and view the highest speeds\n",
      " |      of the birds across the two datasets\n",
      " |      \n",
      " |      >>> s1.combine(s2, max)\n",
      " |      duck        NaN\n",
      " |      eagle     200.0\n",
      " |      falcon    345.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      In the previous example, the resulting value for duck is missing,\n",
      " |      because the maximum of a NaN and a float is a NaN.\n",
      " |      So, in the example, we set ``fill_value=0``,\n",
      " |      so the maximum value returned will be the value from some dataset.\n",
      " |      \n",
      " |      >>> s1.combine(s2, max, fill_value=0)\n",
      " |      duck       30.0\n",
      " |      eagle     200.0\n",
      " |      falcon    345.0\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  combine_first(self, other) -> 'Series'\n",
      " |      Update null elements with value in the same location in 'other'.\n",
      " |      \n",
      " |      Combine two Series objects by filling null values in one Series with\n",
      " |      non-null values from the other Series. Result index will be the union\n",
      " |      of the two indexes.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series\n",
      " |          The value(s) to be used for filling null values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of combining the provided Series with the other object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.combine : Perform element-wise operation on two Series\n",
      " |          using a given function.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s1 = pd.Series([1, np.nan])\n",
      " |      >>> s2 = pd.Series([3, 4, 5])\n",
      " |      >>> s1.combine_first(s2)\n",
      " |      0    1.0\n",
      " |      1    4.0\n",
      " |      2    5.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Null values still persist if the location of that null value\n",
      " |      does not exist in `other`\n",
      " |      \n",
      " |      >>> s1 = pd.Series({'falcon': np.nan, 'eagle': 160.0})\n",
      " |      >>> s2 = pd.Series({'eagle': 200.0, 'duck': 30.0})\n",
      " |      >>> s1.combine_first(s2)\n",
      " |      duck       30.0\n",
      " |      eagle     160.0\n",
      " |      falcon      NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  compare(self, other: 'Series', align_axis: 'Axis' = 1, keep_shape: 'bool' = False, keep_equal: 'bool' = False, result_names: 'Suffixes' = ('self', 'other')) -> 'DataFrame | Series'\n",
      " |      Compare to another Series and show the differences.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series\n",
      " |          Object to compare with.\n",
      " |      \n",
      " |      align_axis : {0 or 'index', 1 or 'columns'}, default 1\n",
      " |          Determine which axis to align the comparison on.\n",
      " |      \n",
      " |          * 0, or 'index' : Resulting differences are stacked vertically\n",
      " |              with rows drawn alternately from self and other.\n",
      " |          * 1, or 'columns' : Resulting differences are aligned horizontally\n",
      " |              with columns drawn alternately from self and other.\n",
      " |      \n",
      " |      keep_shape : bool, default False\n",
      " |          If true, all rows and columns are kept.\n",
      " |          Otherwise, only the ones with different values are kept.\n",
      " |      \n",
      " |      keep_equal : bool, default False\n",
      " |          If true, the result keeps values that are equal.\n",
      " |          Otherwise, equal values are shown as NaNs.\n",
      " |      \n",
      " |      result_names : tuple, default ('self', 'other')\n",
      " |          Set the dataframes names in the comparison.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          If axis is 0 or 'index' the result will be a Series.\n",
      " |          The resulting index will be a MultiIndex with 'self' and 'other'\n",
      " |          stacked alternately at the inner level.\n",
      " |      \n",
      " |          If axis is 1 or 'columns' the result will be a DataFrame.\n",
      " |          It will have two columns namely 'self' and 'other'.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.compare : Compare with another DataFrame and show differences.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Matching NaNs will not appear as a difference.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s1 = pd.Series([\"a\", \"b\", \"c\", \"d\", \"e\"])\n",
      " |      >>> s2 = pd.Series([\"a\", \"a\", \"c\", \"b\", \"e\"])\n",
      " |      \n",
      " |      Align the differences on columns\n",
      " |      \n",
      " |      >>> s1.compare(s2)\n",
      " |        self other\n",
      " |      1    b     a\n",
      " |      3    d     b\n",
      " |      \n",
      " |      Stack the differences on indices\n",
      " |      \n",
      " |      >>> s1.compare(s2, align_axis=0)\n",
      " |      1  self     b\n",
      " |         other    a\n",
      " |      3  self     d\n",
      " |         other    b\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Keep all original rows\n",
      " |      \n",
      " |      >>> s1.compare(s2, keep_shape=True)\n",
      " |        self other\n",
      " |      0  NaN   NaN\n",
      " |      1    b     a\n",
      " |      2  NaN   NaN\n",
      " |      3    d     b\n",
      " |      4  NaN   NaN\n",
      " |      \n",
      " |      Keep all original rows and also all original values\n",
      " |      \n",
      " |      >>> s1.compare(s2, keep_shape=True, keep_equal=True)\n",
      " |        self other\n",
      " |      0    a     a\n",
      " |      1    b     a\n",
      " |      2    c     c\n",
      " |      3    d     b\n",
      " |      4    e     e\n",
      " |  \n",
      " |  corr(self, other: 'Series', method: 'CorrelationMethod' = 'pearson', min_periods: 'int | None' = None) -> 'float'\n",
      " |      Compute correlation with `other` Series, excluding missing values.\n",
      " |      \n",
      " |      The two `Series` objects are not required to be the same length and will be\n",
      " |      aligned internally before the correlation function is applied.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series\n",
      " |          Series with which to compute the correlation.\n",
      " |      method : {'pearson', 'kendall', 'spearman'} or callable\n",
      " |          Method used to compute correlation:\n",
      " |      \n",
      " |          - pearson : Standard correlation coefficient\n",
      " |          - kendall : Kendall Tau correlation coefficient\n",
      " |          - spearman : Spearman rank correlation\n",
      " |          - callable: Callable with input two 1d ndarrays and returning a float.\n",
      " |      \n",
      " |          .. warning::\n",
      " |              Note that the returned matrix from corr will have 1 along the\n",
      " |              diagonals and will be symmetric regardless of the callable's\n",
      " |              behavior.\n",
      " |      min_periods : int, optional\n",
      " |          Minimum number of observations needed to have a valid result.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      float\n",
      " |          Correlation with other.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.corr : Compute pairwise correlation between columns.\n",
      " |      DataFrame.corrwith : Compute pairwise correlation with another\n",
      " |          DataFrame or Series.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Pearson, Kendall and Spearman correlation are currently computed using pairwise complete observations.\n",
      " |      \n",
      " |      * `Pearson correlation coefficient <https://en.wikipedia.org/wiki/Pearson_correlation_coefficient>`_\n",
      " |      * `Kendall rank correlation coefficient <https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient>`_\n",
      " |      * `Spearman's rank correlation coefficient <https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient>`_\n",
      " |      \n",
      " |      Automatic data alignment: as with all pandas operations, automatic data alignment is performed for this method.\n",
      " |      ``corr()`` automatically considers values with matching indices.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> def histogram_intersection(a, b):\n",
      " |      ...     v = np.minimum(a, b).sum().round(decimals=1)\n",
      " |      ...     return v\n",
      " |      >>> s1 = pd.Series([.2, .0, .6, .2])\n",
      " |      >>> s2 = pd.Series([.3, .6, .0, .1])\n",
      " |      >>> s1.corr(s2, method=histogram_intersection)\n",
      " |      0.3\n",
      " |      \n",
      " |      Pandas auto-aligns the values with matching indices\n",
      " |      \n",
      " |      >>> s1 = pd.Series([1, 2, 3], index=[0, 1, 2])\n",
      " |      >>> s2 = pd.Series([1, 2, 3], index=[2, 1, 0])\n",
      " |      >>> s1.corr(s2)\n",
      " |      -1.0\n",
      " |  \n",
      " |  count(self) -> 'int'\n",
      " |      Return number of non-NA/null observations in the Series.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int\n",
      " |          Number of non-null values in the Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.count : Count non-NA cells for each column or row.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([0.0, 1.0, np.nan])\n",
      " |      >>> s.count()\n",
      " |      2\n",
      " |  \n",
      " |  cov(self, other: 'Series', min_periods: 'int | None' = None, ddof: 'int | None' = 1) -> 'float'\n",
      " |      Compute covariance with Series, excluding missing values.\n",
      " |      \n",
      " |      The two `Series` objects are not required to be the same length and\n",
      " |      will be aligned internally before the covariance is calculated.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series\n",
      " |          Series with which to compute the covariance.\n",
      " |      min_periods : int, optional\n",
      " |          Minimum number of observations needed to have a valid result.\n",
      " |      ddof : int, default 1\n",
      " |          Delta degrees of freedom.  The divisor used in calculations\n",
      " |          is ``N - ddof``, where ``N`` represents the number of elements.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      float\n",
      " |          Covariance between Series and other normalized by N-1\n",
      " |          (unbiased estimator).\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.cov : Compute pairwise covariance of columns.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s1 = pd.Series([0.90010907, 0.13484424, 0.62036035])\n",
      " |      >>> s2 = pd.Series([0.12528585, 0.26962463, 0.51111198])\n",
      " |      >>> s1.cov(s2)\n",
      " |      -0.01685762652715874\n",
      " |  \n",
      " |  cummax(self, axis: 'Axis | None' = None, skipna: 'bool' = True, *args, **kwargs)\n",
      " |      Return cumulative maximum over a DataFrame or Series axis.\n",
      " |      \n",
      " |      Returns a DataFrame or Series of the same size containing the cumulative\n",
      " |      maximum.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The index or the name of the axis. 0 is equivalent to None or 'index'.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      *args, **kwargs\n",
      " |          Additional keywords have no effect but might be accepted for\n",
      " |          compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series\n",
      " |          Return cumulative maximum of scalar or Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      core.window.expanding.Expanding.max : Similar functionality\n",
      " |          but ignores ``NaN`` values.\n",
      " |      Series.max : Return the maximum over\n",
      " |          Series axis.\n",
      " |      Series.cummax : Return cumulative maximum over Series axis.\n",
      " |      Series.cummin : Return cumulative minimum over Series axis.\n",
      " |      Series.cumsum : Return cumulative sum over Series axis.\n",
      " |      Series.cumprod : Return cumulative product over Series axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> s = pd.Series([2, np.nan, 5, -1, 0])\n",
      " |      >>> s\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    5.0\n",
      " |      3   -1.0\n",
      " |      4    0.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      By default, NA values are ignored.\n",
      " |      \n",
      " |      >>> s.cummax()\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    5.0\n",
      " |      3    5.0\n",
      " |      4    5.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      To include NA values in the operation, use ``skipna=False``\n",
      " |      \n",
      " |      >>> s.cummax(skipna=False)\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[2.0, 1.0],\n",
      " |      ...                    [3.0, np.nan],\n",
      " |      ...                    [1.0, 0.0]],\n",
      " |      ...                   columns=list('AB'))\n",
      " |      >>> df\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |      \n",
      " |      By default, iterates over rows and finds the maximum\n",
      " |      in each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n",
      " |      \n",
      " |      >>> df.cummax()\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  3.0  NaN\n",
      " |      2  3.0  1.0\n",
      " |      \n",
      " |      To iterate over columns and find the maximum in each row,\n",
      " |      use ``axis=1``\n",
      " |      \n",
      " |      >>> df.cummax(axis=1)\n",
      " |           A    B\n",
      " |      0  2.0  2.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  1.0\n",
      " |  \n",
      " |  cummin(self, axis: 'Axis | None' = None, skipna: 'bool' = True, *args, **kwargs)\n",
      " |      Return cumulative minimum over a DataFrame or Series axis.\n",
      " |      \n",
      " |      Returns a DataFrame or Series of the same size containing the cumulative\n",
      " |      minimum.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The index or the name of the axis. 0 is equivalent to None or 'index'.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      *args, **kwargs\n",
      " |          Additional keywords have no effect but might be accepted for\n",
      " |          compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series\n",
      " |          Return cumulative minimum of scalar or Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      core.window.expanding.Expanding.min : Similar functionality\n",
      " |          but ignores ``NaN`` values.\n",
      " |      Series.min : Return the minimum over\n",
      " |          Series axis.\n",
      " |      Series.cummax : Return cumulative maximum over Series axis.\n",
      " |      Series.cummin : Return cumulative minimum over Series axis.\n",
      " |      Series.cumsum : Return cumulative sum over Series axis.\n",
      " |      Series.cumprod : Return cumulative product over Series axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> s = pd.Series([2, np.nan, 5, -1, 0])\n",
      " |      >>> s\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    5.0\n",
      " |      3   -1.0\n",
      " |      4    0.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      By default, NA values are ignored.\n",
      " |      \n",
      " |      >>> s.cummin()\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    2.0\n",
      " |      3   -1.0\n",
      " |      4   -1.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      To include NA values in the operation, use ``skipna=False``\n",
      " |      \n",
      " |      >>> s.cummin(skipna=False)\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[2.0, 1.0],\n",
      " |      ...                    [3.0, np.nan],\n",
      " |      ...                    [1.0, 0.0]],\n",
      " |      ...                   columns=list('AB'))\n",
      " |      >>> df\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |      \n",
      " |      By default, iterates over rows and finds the minimum\n",
      " |      in each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n",
      " |      \n",
      " |      >>> df.cummin()\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  2.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |      \n",
      " |      To iterate over columns and find the minimum in each row,\n",
      " |      use ``axis=1``\n",
      " |      \n",
      " |      >>> df.cummin(axis=1)\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |  \n",
      " |  cumprod(self, axis: 'Axis | None' = None, skipna: 'bool' = True, *args, **kwargs)\n",
      " |      Return cumulative product over a DataFrame or Series axis.\n",
      " |      \n",
      " |      Returns a DataFrame or Series of the same size containing the cumulative\n",
      " |      product.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The index or the name of the axis. 0 is equivalent to None or 'index'.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      *args, **kwargs\n",
      " |          Additional keywords have no effect but might be accepted for\n",
      " |          compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series\n",
      " |          Return cumulative product of scalar or Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      core.window.expanding.Expanding.prod : Similar functionality\n",
      " |          but ignores ``NaN`` values.\n",
      " |      Series.prod : Return the product over\n",
      " |          Series axis.\n",
      " |      Series.cummax : Return cumulative maximum over Series axis.\n",
      " |      Series.cummin : Return cumulative minimum over Series axis.\n",
      " |      Series.cumsum : Return cumulative sum over Series axis.\n",
      " |      Series.cumprod : Return cumulative product over Series axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> s = pd.Series([2, np.nan, 5, -1, 0])\n",
      " |      >>> s\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    5.0\n",
      " |      3   -1.0\n",
      " |      4    0.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      By default, NA values are ignored.\n",
      " |      \n",
      " |      >>> s.cumprod()\n",
      " |      0     2.0\n",
      " |      1     NaN\n",
      " |      2    10.0\n",
      " |      3   -10.0\n",
      " |      4    -0.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      To include NA values in the operation, use ``skipna=False``\n",
      " |      \n",
      " |      >>> s.cumprod(skipna=False)\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[2.0, 1.0],\n",
      " |      ...                    [3.0, np.nan],\n",
      " |      ...                    [1.0, 0.0]],\n",
      " |      ...                   columns=list('AB'))\n",
      " |      >>> df\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |      \n",
      " |      By default, iterates over rows and finds the product\n",
      " |      in each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n",
      " |      \n",
      " |      >>> df.cumprod()\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  6.0  NaN\n",
      " |      2  6.0  0.0\n",
      " |      \n",
      " |      To iterate over columns and find the product in each row,\n",
      " |      use ``axis=1``\n",
      " |      \n",
      " |      >>> df.cumprod(axis=1)\n",
      " |           A    B\n",
      " |      0  2.0  2.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |  \n",
      " |  cumsum(self, axis: 'Axis | None' = None, skipna: 'bool' = True, *args, **kwargs)\n",
      " |      Return cumulative sum over a DataFrame or Series axis.\n",
      " |      \n",
      " |      Returns a DataFrame or Series of the same size containing the cumulative\n",
      " |      sum.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The index or the name of the axis. 0 is equivalent to None or 'index'.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      *args, **kwargs\n",
      " |          Additional keywords have no effect but might be accepted for\n",
      " |          compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series\n",
      " |          Return cumulative sum of scalar or Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      core.window.expanding.Expanding.sum : Similar functionality\n",
      " |          but ignores ``NaN`` values.\n",
      " |      Series.sum : Return the sum over\n",
      " |          Series axis.\n",
      " |      Series.cummax : Return cumulative maximum over Series axis.\n",
      " |      Series.cummin : Return cumulative minimum over Series axis.\n",
      " |      Series.cumsum : Return cumulative sum over Series axis.\n",
      " |      Series.cumprod : Return cumulative product over Series axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> s = pd.Series([2, np.nan, 5, -1, 0])\n",
      " |      >>> s\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    5.0\n",
      " |      3   -1.0\n",
      " |      4    0.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      By default, NA values are ignored.\n",
      " |      \n",
      " |      >>> s.cumsum()\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    7.0\n",
      " |      3    6.0\n",
      " |      4    6.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      To include NA values in the operation, use ``skipna=False``\n",
      " |      \n",
      " |      >>> s.cumsum(skipna=False)\n",
      " |      0    2.0\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[2.0, 1.0],\n",
      " |      ...                    [3.0, np.nan],\n",
      " |      ...                    [1.0, 0.0]],\n",
      " |      ...                   columns=list('AB'))\n",
      " |      >>> df\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  0.0\n",
      " |      \n",
      " |      By default, iterates over rows and finds the sum\n",
      " |      in each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n",
      " |      \n",
      " |      >>> df.cumsum()\n",
      " |           A    B\n",
      " |      0  2.0  1.0\n",
      " |      1  5.0  NaN\n",
      " |      2  6.0  1.0\n",
      " |      \n",
      " |      To iterate over columns and find the sum in each row,\n",
      " |      use ``axis=1``\n",
      " |      \n",
      " |      >>> df.cumsum(axis=1)\n",
      " |           A    B\n",
      " |      0  2.0  3.0\n",
      " |      1  3.0  NaN\n",
      " |      2  1.0  1.0\n",
      " |  \n",
      " |  diff(self, periods: 'int' = 1) -> 'Series'\n",
      " |      First discrete difference of element.\n",
      " |      \n",
      " |      Calculates the difference of a Series element compared with another\n",
      " |      element in the Series (default is element in previous row).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      periods : int, default 1\n",
      " |          Periods to shift for calculating difference, accepts negative\n",
      " |          values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          First differences of the Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.pct_change: Percent change over given number of periods.\n",
      " |      Series.shift: Shift index by desired number of periods with an\n",
      " |          optional time freq.\n",
      " |      DataFrame.diff: First discrete difference of object.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For boolean dtypes, this uses :meth:`operator.xor` rather than\n",
      " |      :meth:`operator.sub`.\n",
      " |      The result is calculated according to current dtype in Series,\n",
      " |      however dtype of the result is always float64.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      \n",
      " |      Difference with previous row\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 1, 2, 3, 5, 8])\n",
      " |      >>> s.diff()\n",
      " |      0    NaN\n",
      " |      1    0.0\n",
      " |      2    1.0\n",
      " |      3    1.0\n",
      " |      4    2.0\n",
      " |      5    3.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Difference with 3rd previous row\n",
      " |      \n",
      " |      >>> s.diff(periods=3)\n",
      " |      0    NaN\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    2.0\n",
      " |      4    4.0\n",
      " |      5    6.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Difference with following row\n",
      " |      \n",
      " |      >>> s.diff(periods=-1)\n",
      " |      0    0.0\n",
      " |      1   -1.0\n",
      " |      2   -1.0\n",
      " |      3   -2.0\n",
      " |      4   -3.0\n",
      " |      5    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Overflow in input dtype\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 0], dtype=np.uint8)\n",
      " |      >>> s.diff()\n",
      " |      0      NaN\n",
      " |      1    255.0\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  div = truediv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |  \n",
      " |  divide = truediv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |  \n",
      " |  divmod(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Integer division and modulo of series and other, element-wise (binary operator `divmod`).\n",
      " |      \n",
      " |      Equivalent to ``divmod(series, other)``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      2-Tuple of Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rdivmod : Reverse of the Integer division and modulo operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.divmod(b, fill_value=0)\n",
      " |      (a    1.0\n",
      " |       b    inf\n",
      " |       c    inf\n",
      " |       d    0.0\n",
      " |       e    NaN\n",
      " |       dtype: float64,\n",
      " |       a    0.0\n",
      " |       b    NaN\n",
      " |       c    NaN\n",
      " |       d    0.0\n",
      " |       e    NaN\n",
      " |       dtype: float64)\n",
      " |  \n",
      " |  dot(self, other: 'AnyArrayLike') -> 'Series | np.ndarray'\n",
      " |      Compute the dot product between the Series and the columns of other.\n",
      " |      \n",
      " |      This method computes the dot product between the Series and another\n",
      " |      one, or the Series and each columns of a DataFrame, or the Series and\n",
      " |      each columns of an array.\n",
      " |      \n",
      " |      It can also be called using `self @ other`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series, DataFrame or array-like\n",
      " |          The other object to compute the dot product with its columns.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar, Series or numpy.ndarray\n",
      " |          Return the dot product of the Series and other if other is a\n",
      " |          Series, the Series of the dot product of Series and each rows of\n",
      " |          other if other is a DataFrame or a numpy.ndarray between the Series\n",
      " |          and each columns of the numpy array.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.dot: Compute the matrix product with the DataFrame.\n",
      " |      Series.mul: Multiplication of series and other, element-wise.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The Series and other has to share the same index if other is a Series\n",
      " |      or a DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([0, 1, 2, 3])\n",
      " |      >>> other = pd.Series([-1, 2, -3, 4])\n",
      " |      >>> s.dot(other)\n",
      " |      8\n",
      " |      >>> s @ other\n",
      " |      8\n",
      " |      >>> df = pd.DataFrame([[0, 1], [-2, 3], [4, -5], [6, 7]])\n",
      " |      >>> s.dot(df)\n",
      " |      0    24\n",
      " |      1    14\n",
      " |      dtype: int64\n",
      " |      >>> arr = np.array([[0, 1], [-2, 3], [4, -5], [6, 7]])\n",
      " |      >>> s.dot(arr)\n",
      " |      array([24, 14])\n",
      " |  \n",
      " |  drop(self, labels: 'IndexLabel | None' = None, *, axis: 'Axis' = 0, index: 'IndexLabel | None' = None, columns: 'IndexLabel | None' = None, level: 'Level | None' = None, inplace: 'bool' = False, errors: 'IgnoreRaise' = 'raise') -> 'Series | None'\n",
      " |      Return Series with specified index labels removed.\n",
      " |      \n",
      " |      Remove elements of a Series based on specifying the index labels.\n",
      " |      When using a multi-index, labels on different levels can be removed\n",
      " |      by specifying the level.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      labels : single label or list-like\n",
      " |          Index labels to drop.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      index : single label or list-like\n",
      " |          Redundant for application on Series, but 'index' can be used instead\n",
      " |          of 'labels'.\n",
      " |      columns : single label or list-like\n",
      " |          No change is made to the Series; use 'index' or 'labels' instead.\n",
      " |      level : int or level name, optional\n",
      " |          For MultiIndex, level for which the labels will be removed.\n",
      " |      inplace : bool, default False\n",
      " |          If True, do operation inplace and return None.\n",
      " |      errors : {'ignore', 'raise'}, default 'raise'\n",
      " |          If 'ignore', suppress error and only existing labels are dropped.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or None\n",
      " |          Series with specified index labels removed or None if ``inplace=True``.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      KeyError\n",
      " |          If none of the labels are found in the index.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.reindex : Return only specified index labels of Series.\n",
      " |      Series.dropna : Return series without null values.\n",
      " |      Series.drop_duplicates : Return Series with duplicate values removed.\n",
      " |      DataFrame.drop : Drop specified labels from rows or columns.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(data=np.arange(3), index=['A', 'B', 'C'])\n",
      " |      >>> s\n",
      " |      A  0\n",
      " |      B  1\n",
      " |      C  2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Drop labels B en C\n",
      " |      \n",
      " |      >>> s.drop(labels=['B', 'C'])\n",
      " |      A  0\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Drop 2nd level label in MultiIndex Series\n",
      " |      \n",
      " |      >>> midx = pd.MultiIndex(levels=[['llama', 'cow', 'falcon'],\n",
      " |      ...                              ['speed', 'weight', 'length']],\n",
      " |      ...                      codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],\n",
      " |      ...                             [0, 1, 2, 0, 1, 2, 0, 1, 2]])\n",
      " |      >>> s = pd.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3],\n",
      " |      ...               index=midx)\n",
      " |      >>> s\n",
      " |      llama   speed      45.0\n",
      " |              weight    200.0\n",
      " |              length      1.2\n",
      " |      cow     speed      30.0\n",
      " |              weight    250.0\n",
      " |              length      1.5\n",
      " |      falcon  speed     320.0\n",
      " |              weight      1.0\n",
      " |              length      0.3\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.drop(labels='weight', level=1)\n",
      " |      llama   speed      45.0\n",
      " |              length      1.2\n",
      " |      cow     speed      30.0\n",
      " |              length      1.5\n",
      " |      falcon  speed     320.0\n",
      " |              length      0.3\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  drop_duplicates(self, *, keep: 'DropKeep' = 'first', inplace: 'bool' = False, ignore_index: 'bool' = False) -> 'Series | None'\n",
      " |      Return Series with duplicate values removed.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      keep : {'first', 'last', ``False``}, default 'first'\n",
      " |          Method to handle dropping duplicates:\n",
      " |      \n",
      " |          - 'first' : Drop duplicates except for the first occurrence.\n",
      " |          - 'last' : Drop duplicates except for the last occurrence.\n",
      " |          - ``False`` : Drop all duplicates.\n",
      " |      \n",
      " |      inplace : bool, default ``False``\n",
      " |          If ``True``, performs operation inplace and returns None.\n",
      " |      \n",
      " |      ignore_index : bool, default ``False``\n",
      " |          If ``True``, the resulting axis will be labeled 0, 1, …, n - 1.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or None\n",
      " |          Series with duplicates dropped or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Index.drop_duplicates : Equivalent method on Index.\n",
      " |      DataFrame.drop_duplicates : Equivalent method on DataFrame.\n",
      " |      Series.duplicated : Related method on Series, indicating duplicate\n",
      " |          Series values.\n",
      " |      Series.unique : Return unique values as an array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Generate a Series with duplicated entries.\n",
      " |      \n",
      " |      >>> s = pd.Series(['llama', 'cow', 'llama', 'beetle', 'llama', 'hippo'],\n",
      " |      ...               name='animal')\n",
      " |      >>> s\n",
      " |      0     llama\n",
      " |      1       cow\n",
      " |      2     llama\n",
      " |      3    beetle\n",
      " |      4     llama\n",
      " |      5     hippo\n",
      " |      Name: animal, dtype: object\n",
      " |      \n",
      " |      With the 'keep' parameter, the selection behaviour of duplicated values\n",
      " |      can be changed. The value 'first' keeps the first occurrence for each\n",
      " |      set of duplicated entries. The default value of keep is 'first'.\n",
      " |      \n",
      " |      >>> s.drop_duplicates()\n",
      " |      0     llama\n",
      " |      1       cow\n",
      " |      3    beetle\n",
      " |      5     hippo\n",
      " |      Name: animal, dtype: object\n",
      " |      \n",
      " |      The value 'last' for parameter 'keep' keeps the last occurrence for\n",
      " |      each set of duplicated entries.\n",
      " |      \n",
      " |      >>> s.drop_duplicates(keep='last')\n",
      " |      1       cow\n",
      " |      3    beetle\n",
      " |      4     llama\n",
      " |      5     hippo\n",
      " |      Name: animal, dtype: object\n",
      " |      \n",
      " |      The value ``False`` for parameter 'keep' discards all sets of\n",
      " |      duplicated entries.\n",
      " |      \n",
      " |      >>> s.drop_duplicates(keep=False)\n",
      " |      1       cow\n",
      " |      3    beetle\n",
      " |      5     hippo\n",
      " |      Name: animal, dtype: object\n",
      " |  \n",
      " |  dropna(self, *, axis: 'Axis' = 0, inplace: 'bool' = False, how: 'AnyAll | None' = None, ignore_index: 'bool' = False) -> 'Series | None'\n",
      " |      Return a new Series with missing values removed.\n",
      " |      \n",
      " |      See the :ref:`User Guide <missing_data>` for more on which values are\n",
      " |      considered missing, and how to work with missing data.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      inplace : bool, default False\n",
      " |          If True, do operation inplace and return None.\n",
      " |      how : str, optional\n",
      " |          Not in use. Kept for compatibility.\n",
      " |      ignore_index : bool, default ``False``\n",
      " |          If ``True``, the resulting axis will be labeled 0, 1, …, n - 1.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or None\n",
      " |          Series with NA entries dropped from it or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.isna: Indicate missing values.\n",
      " |      Series.notna : Indicate existing (non-missing) values.\n",
      " |      Series.fillna : Replace missing values.\n",
      " |      DataFrame.dropna : Drop rows or columns which contain NA values.\n",
      " |      Index.dropna : Drop missing indices.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([1., 2., np.nan])\n",
      " |      >>> ser\n",
      " |      0    1.0\n",
      " |      1    2.0\n",
      " |      2    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Drop NA values from a Series.\n",
      " |      \n",
      " |      >>> ser.dropna()\n",
      " |      0    1.0\n",
      " |      1    2.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Empty strings are not considered NA values. ``None`` is considered an\n",
      " |      NA value.\n",
      " |      \n",
      " |      >>> ser = pd.Series([np.nan, 2, pd.NaT, '', None, 'I stay'])\n",
      " |      >>> ser\n",
      " |      0       NaN\n",
      " |      1         2\n",
      " |      2       NaT\n",
      " |      3\n",
      " |      4      None\n",
      " |      5    I stay\n",
      " |      dtype: object\n",
      " |      >>> ser.dropna()\n",
      " |      1         2\n",
      " |      3\n",
      " |      5    I stay\n",
      " |      dtype: object\n",
      " |  \n",
      " |  duplicated(self, keep: 'DropKeep' = 'first') -> 'Series'\n",
      " |      Indicate duplicate Series values.\n",
      " |      \n",
      " |      Duplicated values are indicated as ``True`` values in the resulting\n",
      " |      Series. Either all duplicates, all except the first or all except the\n",
      " |      last occurrence of duplicates can be indicated.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      keep : {'first', 'last', False}, default 'first'\n",
      " |          Method to handle dropping duplicates:\n",
      " |      \n",
      " |          - 'first' : Mark duplicates as ``True`` except for the first\n",
      " |            occurrence.\n",
      " |          - 'last' : Mark duplicates as ``True`` except for the last\n",
      " |            occurrence.\n",
      " |          - ``False`` : Mark all duplicates as ``True``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series[bool]\n",
      " |          Series indicating whether each value has occurred in the\n",
      " |          preceding values.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Index.duplicated : Equivalent method on pandas.Index.\n",
      " |      DataFrame.duplicated : Equivalent method on pandas.DataFrame.\n",
      " |      Series.drop_duplicates : Remove duplicate values from Series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      By default, for each set of duplicated values, the first occurrence is\n",
      " |      set on False and all others on True:\n",
      " |      \n",
      " |      >>> animals = pd.Series(['llama', 'cow', 'llama', 'beetle', 'llama'])\n",
      " |      >>> animals.duplicated()\n",
      " |      0    False\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4     True\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      which is equivalent to\n",
      " |      \n",
      " |      >>> animals.duplicated(keep='first')\n",
      " |      0    False\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4     True\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      By using 'last', the last occurrence of each set of duplicated values\n",
      " |      is set on False and all others on True:\n",
      " |      \n",
      " |      >>> animals.duplicated(keep='last')\n",
      " |      0     True\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4    False\n",
      " |      dtype: bool\n",
      " |      \n",
      " |      By setting keep on ``False``, all duplicates are True:\n",
      " |      \n",
      " |      >>> animals.duplicated(keep=False)\n",
      " |      0     True\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4     True\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  eq(self, other, level: 'Level | None' = None, fill_value: 'float | None' = None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Equal to of series and other, element-wise (binary operator `eq`).\n",
      " |      \n",
      " |      Equivalent to ``series == other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.eq(b, fill_value=0)\n",
      " |      a     True\n",
      " |      b    False\n",
      " |      c    False\n",
      " |      d    False\n",
      " |      e    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  explode(self, ignore_index: 'bool' = False) -> 'Series'\n",
      " |      Transform each element of a list-like to a row.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      ignore_index : bool, default False\n",
      " |          If True, the resulting index will be labeled 0, 1, …, n - 1.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Exploded lists to rows; index will be duplicated for these rows.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.str.split : Split string values on specified separator.\n",
      " |      Series.unstack : Unstack, a.k.a. pivot, Series with MultiIndex\n",
      " |          to produce DataFrame.\n",
      " |      DataFrame.melt : Unpivot a DataFrame from wide format to long format.\n",
      " |      DataFrame.explode : Explode a DataFrame from list-like\n",
      " |          columns to long format.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This routine will explode list-likes including lists, tuples, sets,\n",
      " |      Series, and np.ndarray. The result dtype of the subset rows will\n",
      " |      be object. Scalars will be returned unchanged, and empty list-likes will\n",
      " |      result in a np.nan for that row. In addition, the ordering of elements in\n",
      " |      the output will be non-deterministic when exploding sets.\n",
      " |      \n",
      " |      Reference :ref:`the user guide <reshaping.explode>` for more examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([[1, 2, 3], 'foo', [], [3, 4]])\n",
      " |      >>> s\n",
      " |      0    [1, 2, 3]\n",
      " |      1          foo\n",
      " |      2           []\n",
      " |      3       [3, 4]\n",
      " |      dtype: object\n",
      " |      \n",
      " |      >>> s.explode()\n",
      " |      0      1\n",
      " |      0      2\n",
      " |      0      3\n",
      " |      1    foo\n",
      " |      2    NaN\n",
      " |      3      3\n",
      " |      3      4\n",
      " |      dtype: object\n",
      " |  \n",
      " |  floordiv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Integer division of series and other, element-wise (binary operator `floordiv`).\n",
      " |      \n",
      " |      Equivalent to ``series // other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rfloordiv : Reverse of the Integer division operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.floordiv(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    inf\n",
      " |      c    inf\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  ge(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Greater than or equal to of series and other, element-wise (binary operator `ge`).\n",
      " |      \n",
      " |      Equivalent to ``series >= other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan, 1], index=['a', 'b', 'c', 'd', 'e'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      e    1.0\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([0, 1, 2, np.nan, 1], index=['a', 'b', 'c', 'd', 'f'])\n",
      " |      >>> b\n",
      " |      a    0.0\n",
      " |      b    1.0\n",
      " |      c    2.0\n",
      " |      d    NaN\n",
      " |      f    1.0\n",
      " |      dtype: float64\n",
      " |      >>> a.ge(b, fill_value=0)\n",
      " |      a     True\n",
      " |      b     True\n",
      " |      c    False\n",
      " |      d    False\n",
      " |      e     True\n",
      " |      f    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  groupby(self, by=None, axis: 'Axis' = 0, level: 'IndexLabel | None' = None, as_index: 'bool' = True, sort: 'bool' = True, group_keys: 'bool' = True, observed: 'bool | lib.NoDefault' = <no_default>, dropna: 'bool' = True) -> 'SeriesGroupBy'\n",
      " |      Group Series using a mapper or by a Series of columns.\n",
      " |      \n",
      " |      A groupby operation involves some combination of splitting the\n",
      " |      object, applying a function, and combining the results. This can be\n",
      " |      used to group large amounts of data and compute operations on these\n",
      " |      groups.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      by : mapping, function, label, pd.Grouper or list of such\n",
      " |          Used to determine the groups for the groupby.\n",
      " |          If ``by`` is a function, it's called on each value of the object's\n",
      " |          index. If a dict or Series is passed, the Series or dict VALUES\n",
      " |          will be used to determine the groups (the Series' values are first\n",
      " |          aligned; see ``.align()`` method). If a list or ndarray of length\n",
      " |          equal to the selected axis is passed (see the `groupby user guide\n",
      " |          <https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups>`_),\n",
      " |          the values are used as-is to determine the groups. A label or list\n",
      " |          of labels may be passed to group by the columns in ``self``.\n",
      " |          Notice that a tuple is interpreted as a (single) key.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          Split along rows (0) or columns (1). For `Series` this parameter\n",
      " |          is unused and defaults to 0.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |      \n",
      " |              Will be removed and behave like axis=0 in a future version.\n",
      " |              For ``axis=1``, do ``frame.T.groupby(...)`` instead.\n",
      " |      \n",
      " |      level : int, level name, or sequence of such, default None\n",
      " |          If the axis is a MultiIndex (hierarchical), group by a particular\n",
      " |          level or levels. Do not specify both ``by`` and ``level``.\n",
      " |      as_index : bool, default True\n",
      " |          Return object with group labels as the\n",
      " |          index. Only relevant for DataFrame input. as_index=False is\n",
      " |          effectively \"SQL-style\" grouped output. This argument has no effect\n",
      " |          on filtrations (see the `filtrations in the user guide\n",
      " |          <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration>`_),\n",
      " |          such as ``head()``, ``tail()``, ``nth()`` and in transformations\n",
      " |          (see the `transformations in the user guide\n",
      " |          <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation>`_).\n",
      " |      sort : bool, default True\n",
      " |          Sort group keys. Get better performance by turning this off.\n",
      " |          Note this does not influence the order of observations within each\n",
      " |          group. Groupby preserves the order of rows within each group. If False,\n",
      " |          the groups will appear in the same order as they did in the original DataFrame.\n",
      " |          This argument has no effect on filtrations (see the `filtrations in the user guide\n",
      " |          <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration>`_),\n",
      " |          such as ``head()``, ``tail()``, ``nth()`` and in transformations\n",
      " |          (see the `transformations in the user guide\n",
      " |          <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation>`_).\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |      \n",
      " |              Specifying ``sort=False`` with an ordered categorical grouper will no\n",
      " |              longer sort the values.\n",
      " |      \n",
      " |      group_keys : bool, default True\n",
      " |          When calling apply and the ``by`` argument produces a like-indexed\n",
      " |          (i.e. :ref:`a transform <groupby.transform>`) result, add group keys to\n",
      " |          index to identify pieces. By default group keys are not included\n",
      " |          when the result's index (and column) labels match the inputs, and\n",
      " |          are included otherwise.\n",
      " |      \n",
      " |          .. versionchanged:: 1.5.0\n",
      " |      \n",
      " |             Warns that ``group_keys`` will no longer be ignored when the\n",
      " |             result from ``apply`` is a like-indexed Series or DataFrame.\n",
      " |             Specify ``group_keys`` explicitly to include the group keys or\n",
      " |             not.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |      \n",
      " |             ``group_keys`` now defaults to ``True``.\n",
      " |      \n",
      " |      observed : bool, default False\n",
      " |          This only applies if any of the groupers are Categoricals.\n",
      " |          If True: only show observed values for categorical groupers.\n",
      " |          If False: show all values for categorical groupers.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |      \n",
      " |              The default value will change to True in a future version of pandas.\n",
      " |      \n",
      " |      dropna : bool, default True\n",
      " |          If True, and if group keys contain NA values, NA values together\n",
      " |          with row/column will be dropped.\n",
      " |          If False, NA values will also be treated as the key in groups.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      pandas.api.typing.SeriesGroupBy\n",
      " |          Returns a groupby object that contains information about the groups.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      resample : Convenience method for frequency conversion and resampling\n",
      " |          of time series.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See the `user guide\n",
      " |      <https://pandas.pydata.org/pandas-docs/stable/groupby.html>`__ for more\n",
      " |      detailed usage and examples, including splitting an object into groups,\n",
      " |      iterating through groups, selecting a group, aggregation, and more.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([390., 350., 30., 20.],\n",
      " |      ...                 index=['Falcon', 'Falcon', 'Parrot', 'Parrot'],\n",
      " |      ...                 name=\"Max Speed\")\n",
      " |      >>> ser\n",
      " |      Falcon    390.0\n",
      " |      Falcon    350.0\n",
      " |      Parrot     30.0\n",
      " |      Parrot     20.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      >>> ser.groupby([\"a\", \"b\", \"a\", \"b\"]).mean()\n",
      " |      a    210.0\n",
      " |      b    185.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      >>> ser.groupby(level=0).mean()\n",
      " |      Falcon    370.0\n",
      " |      Parrot     25.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      >>> ser.groupby(ser > 100).mean()\n",
      " |      Max Speed\n",
      " |      False     25.0\n",
      " |      True     370.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      \n",
      " |      **Grouping by Indexes**\n",
      " |      \n",
      " |      We can groupby different levels of a hierarchical index\n",
      " |      using the `level` parameter:\n",
      " |      \n",
      " |      >>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],\n",
      " |      ...           ['Captive', 'Wild', 'Captive', 'Wild']]\n",
      " |      >>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))\n",
      " |      >>> ser = pd.Series([390., 350., 30., 20.], index=index, name=\"Max Speed\")\n",
      " |      >>> ser\n",
      " |      Animal  Type\n",
      " |      Falcon  Captive    390.0\n",
      " |              Wild       350.0\n",
      " |      Parrot  Captive     30.0\n",
      " |              Wild        20.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      >>> ser.groupby(level=0).mean()\n",
      " |      Animal\n",
      " |      Falcon    370.0\n",
      " |      Parrot     25.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      >>> ser.groupby(level=\"Type\").mean()\n",
      " |      Type\n",
      " |      Captive    210.0\n",
      " |      Wild       185.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      \n",
      " |      We can also choose to include `NA` in group keys or not by defining\n",
      " |      `dropna` parameter, the default setting is `True`.\n",
      " |      \n",
      " |      >>> ser = pd.Series([1, 2, 3, 3], index=[\"a\", 'a', 'b', np.nan])\n",
      " |      >>> ser.groupby(level=0).sum()\n",
      " |      a    3\n",
      " |      b    3\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> ser.groupby(level=0, dropna=False).sum()\n",
      " |      a    3\n",
      " |      b    3\n",
      " |      NaN  3\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> arrays = ['Falcon', 'Falcon', 'Parrot', 'Parrot']\n",
      " |      >>> ser = pd.Series([390., 350., 30., 20.], index=arrays, name=\"Max Speed\")\n",
      " |      >>> ser.groupby([\"a\", \"b\", \"a\", np.nan]).mean()\n",
      " |      a    210.0\n",
      " |      b    350.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |      \n",
      " |      >>> ser.groupby([\"a\", \"b\", \"a\", np.nan], dropna=False).mean()\n",
      " |      a    210.0\n",
      " |      b    350.0\n",
      " |      NaN   20.0\n",
      " |      Name: Max Speed, dtype: float64\n",
      " |  \n",
      " |  gt(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Greater than of series and other, element-wise (binary operator `gt`).\n",
      " |      \n",
      " |      Equivalent to ``series > other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan, 1], index=['a', 'b', 'c', 'd', 'e'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      e    1.0\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([0, 1, 2, np.nan, 1], index=['a', 'b', 'c', 'd', 'f'])\n",
      " |      >>> b\n",
      " |      a    0.0\n",
      " |      b    1.0\n",
      " |      c    2.0\n",
      " |      d    NaN\n",
      " |      f    1.0\n",
      " |      dtype: float64\n",
      " |      >>> a.gt(b, fill_value=0)\n",
      " |      a     True\n",
      " |      b    False\n",
      " |      c    False\n",
      " |      d    False\n",
      " |      e     True\n",
      " |      f    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  hist = hist_series(self: 'Series', by=None, ax=None, grid: 'bool' = True, xlabelsize: 'int | None' = None, xrot: 'float | None' = None, ylabelsize: 'int | None' = None, yrot: 'float | None' = None, figsize: 'tuple[int, int] | None' = None, bins: 'int | Sequence[int]' = 10, backend: 'str | None' = None, legend: 'bool' = False, **kwargs)\n",
      " |      Draw histogram of the input series using matplotlib.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      by : object, optional\n",
      " |          If passed, then used to form histograms for separate groups.\n",
      " |      ax : matplotlib axis object\n",
      " |          If not passed, uses gca().\n",
      " |      grid : bool, default True\n",
      " |          Whether to show axis grid lines.\n",
      " |      xlabelsize : int, default None\n",
      " |          If specified changes the x-axis label size.\n",
      " |      xrot : float, default None\n",
      " |          Rotation of x axis labels.\n",
      " |      ylabelsize : int, default None\n",
      " |          If specified changes the y-axis label size.\n",
      " |      yrot : float, default None\n",
      " |          Rotation of y axis labels.\n",
      " |      figsize : tuple, default None\n",
      " |          Figure size in inches by default.\n",
      " |      bins : int or sequence, default 10\n",
      " |          Number of histogram bins to be used. If an integer is given, bins + 1\n",
      " |          bin edges are calculated and returned. If bins is a sequence, gives\n",
      " |          bin edges, including left edge of first bin and right edge of last\n",
      " |          bin. In this case, bins is returned unmodified.\n",
      " |      backend : str, default None\n",
      " |          Backend to use instead of the backend specified in the option\n",
      " |          ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to\n",
      " |          specify the ``plotting.backend`` for the whole session, set\n",
      " |          ``pd.options.plotting.backend``.\n",
      " |      legend : bool, default False\n",
      " |          Whether to show the legend.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          To be passed to the actual plotting function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      matplotlib.AxesSubplot\n",
      " |          A histogram plot.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      matplotlib.axes.Axes.hist : Plot a histogram using matplotlib.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      .. plot::\n",
      " |          :context: close-figs\n",
      " |      \n",
      " |          >>> lst = ['a', 'a', 'a', 'b', 'b', 'b']\n",
      " |          >>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)\n",
      " |          >>> hist = ser.hist()\n",
      " |      \n",
      " |      For Groupby:\n",
      " |      \n",
      " |      .. plot::\n",
      " |          :context: close-figs\n",
      " |      \n",
      " |          >>> lst = ['a', 'a', 'a', 'b', 'b', 'b']\n",
      " |          >>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)\n",
      " |          >>> hist = ser.groupby(level=0).hist()\n",
      " |  \n",
      " |  idxmax(self, axis: 'Axis' = 0, skipna: 'bool' = True, *args, **kwargs) -> 'Hashable'\n",
      " |      Return the row label of the maximum value.\n",
      " |      \n",
      " |      If multiple values equal the maximum, the first row label with that\n",
      " |      value is returned.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If the entire Series is NA, the result\n",
      " |          will be NA.\n",
      " |      *args, **kwargs\n",
      " |          Additional arguments and keywords have no effect but might be\n",
      " |          accepted for compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Index\n",
      " |          Label of the maximum value.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ValueError\n",
      " |          If the Series is empty.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.argmax : Return indices of the maximum values\n",
      " |          along the given axis.\n",
      " |      DataFrame.idxmax : Return index of first occurrence of maximum\n",
      " |          over requested axis.\n",
      " |      Series.idxmin : Return index *label* of the first occurrence\n",
      " |          of minimum of values.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This method is the Series version of ``ndarray.argmax``. This method\n",
      " |      returns the label of the maximum, while ``ndarray.argmax`` returns\n",
      " |      the position. To get the position, use ``series.values.argmax()``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(data=[1, None, 4, 3, 4],\n",
      " |      ...               index=['A', 'B', 'C', 'D', 'E'])\n",
      " |      >>> s\n",
      " |      A    1.0\n",
      " |      B    NaN\n",
      " |      C    4.0\n",
      " |      D    3.0\n",
      " |      E    4.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.idxmax()\n",
      " |      'C'\n",
      " |      \n",
      " |      If `skipna` is False and there is an NA value in the data,\n",
      " |      the function returns ``nan``.\n",
      " |      \n",
      " |      >>> s.idxmax(skipna=False)\n",
      " |      nan\n",
      " |  \n",
      " |  idxmin(self, axis: 'Axis' = 0, skipna: 'bool' = True, *args, **kwargs) -> 'Hashable'\n",
      " |      Return the row label of the minimum value.\n",
      " |      \n",
      " |      If multiple values equal the minimum, the first row label with that\n",
      " |      value is returned.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If the entire Series is NA, the result\n",
      " |          will be NA.\n",
      " |      *args, **kwargs\n",
      " |          Additional arguments and keywords have no effect but might be\n",
      " |          accepted for compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Index\n",
      " |          Label of the minimum value.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ValueError\n",
      " |          If the Series is empty.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.argmin : Return indices of the minimum values\n",
      " |          along the given axis.\n",
      " |      DataFrame.idxmin : Return index of first occurrence of minimum\n",
      " |          over requested axis.\n",
      " |      Series.idxmax : Return index *label* of the first occurrence\n",
      " |          of maximum of values.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This method is the Series version of ``ndarray.argmin``. This method\n",
      " |      returns the label of the minimum, while ``ndarray.argmin`` returns\n",
      " |      the position. To get the position, use ``series.values.argmin()``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(data=[1, None, 4, 1],\n",
      " |      ...               index=['A', 'B', 'C', 'D'])\n",
      " |      >>> s\n",
      " |      A    1.0\n",
      " |      B    NaN\n",
      " |      C    4.0\n",
      " |      D    1.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.idxmin()\n",
      " |      'A'\n",
      " |      \n",
      " |      If `skipna` is False and there is an NA value in the data,\n",
      " |      the function returns ``nan``.\n",
      " |      \n",
      " |      >>> s.idxmin(skipna=False)\n",
      " |      nan\n",
      " |  \n",
      " |  info(self, verbose: 'bool | None' = None, buf: 'IO[str] | None' = None, max_cols: 'int | None' = None, memory_usage: 'bool | str | None' = None, show_counts: 'bool' = True) -> 'None'\n",
      " |      Print a concise summary of a Series.\n",
      " |      \n",
      " |      This method prints information about a Series including\n",
      " |      the index dtype, non-null values and memory usage.\n",
      " |      \n",
      " |      .. versionadded:: 1.4.0\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      verbose : bool, optional\n",
      " |          Whether to print the full summary. By default, the setting in\n",
      " |          ``pandas.options.display.max_info_columns`` is followed.\n",
      " |      buf : writable buffer, defaults to sys.stdout\n",
      " |          Where to send the output. By default, the output is printed to\n",
      " |          sys.stdout. Pass a writable buffer if you need to further process\n",
      " |          the output.\n",
      " |      \n",
      " |      memory_usage : bool, str, optional\n",
      " |          Specifies whether total memory usage of the Series\n",
      " |          elements (including the index) should be displayed. By default,\n",
      " |          this follows the ``pandas.options.display.memory_usage`` setting.\n",
      " |      \n",
      " |          True always show memory usage. False never shows memory usage.\n",
      " |          A value of 'deep' is equivalent to \"True with deep introspection\".\n",
      " |          Memory usage is shown in human-readable units (base-2\n",
      " |          representation). Without deep introspection a memory estimation is\n",
      " |          made based in column dtype and number of rows assuming values\n",
      " |          consume the same memory amount for corresponding dtypes. With deep\n",
      " |          memory introspection, a real memory usage calculation is performed\n",
      " |          at the cost of computational resources. See the\n",
      " |          :ref:`Frequently Asked Questions <df-memory-usage>` for more\n",
      " |          details.\n",
      " |      show_counts : bool, optional\n",
      " |          Whether to show the non-null counts. By default, this is shown\n",
      " |          only if the DataFrame is smaller than\n",
      " |          ``pandas.options.display.max_info_rows`` and\n",
      " |          ``pandas.options.display.max_info_columns``. A value of True always\n",
      " |          shows the counts, and False never shows the counts.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None\n",
      " |          This method prints a summary of a Series and returns None.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.describe: Generate descriptive statistics of Series.\n",
      " |      Series.memory_usage: Memory usage of Series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> int_values = [1, 2, 3, 4, 5]\n",
      " |      >>> text_values = ['alpha', 'beta', 'gamma', 'delta', 'epsilon']\n",
      " |      >>> s = pd.Series(text_values, index=int_values)\n",
      " |      >>> s.info()\n",
      " |      <class 'pandas.core.series.Series'>\n",
      " |      Index: 5 entries, 1 to 5\n",
      " |      Series name: None\n",
      " |      Non-Null Count  Dtype\n",
      " |      --------------  -----\n",
      " |      5 non-null      object\n",
      " |      dtypes: object(1)\n",
      " |      memory usage: 80.0+ bytes\n",
      " |      \n",
      " |      Prints a summary excluding information about its values:\n",
      " |      \n",
      " |      >>> s.info(verbose=False)\n",
      " |      <class 'pandas.core.series.Series'>\n",
      " |      Index: 5 entries, 1 to 5\n",
      " |      dtypes: object(1)\n",
      " |      memory usage: 80.0+ bytes\n",
      " |      \n",
      " |      Pipe output of Series.info to buffer instead of sys.stdout, get\n",
      " |      buffer content and writes to a text file:\n",
      " |      \n",
      " |      >>> import io\n",
      " |      >>> buffer = io.StringIO()\n",
      " |      >>> s.info(buf=buffer)\n",
      " |      >>> s = buffer.getvalue()\n",
      " |      >>> with open(\"df_info.txt\", \"w\",\n",
      " |      ...           encoding=\"utf-8\") as f:  # doctest: +SKIP\n",
      " |      ...     f.write(s)\n",
      " |      260\n",
      " |      \n",
      " |      The `memory_usage` parameter allows deep introspection mode, specially\n",
      " |      useful for big Series and fine-tune memory optimization:\n",
      " |      \n",
      " |      >>> random_strings_array = np.random.choice(['a', 'b', 'c'], 10 ** 6)\n",
      " |      >>> s = pd.Series(np.random.choice(['a', 'b', 'c'], 10 ** 6))\n",
      " |      >>> s.info()\n",
      " |      <class 'pandas.core.series.Series'>\n",
      " |      RangeIndex: 1000000 entries, 0 to 999999\n",
      " |      Series name: None\n",
      " |      Non-Null Count    Dtype\n",
      " |      --------------    -----\n",
      " |      1000000 non-null  object\n",
      " |      dtypes: object(1)\n",
      " |      memory usage: 7.6+ MB\n",
      " |      \n",
      " |      >>> s.info(memory_usage='deep')\n",
      " |      <class 'pandas.core.series.Series'>\n",
      " |      RangeIndex: 1000000 entries, 0 to 999999\n",
      " |      Series name: None\n",
      " |      Non-Null Count    Dtype\n",
      " |      --------------    -----\n",
      " |      1000000 non-null  object\n",
      " |      dtypes: object(1)\n",
      " |      memory usage: 55.3 MB\n",
      " |  \n",
      " |  isin(self, values) -> 'Series'\n",
      " |      Whether elements in Series are contained in `values`.\n",
      " |      \n",
      " |      Return a boolean Series showing whether each element in the Series\n",
      " |      matches an element in the passed sequence of `values` exactly.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      values : set or list-like\n",
      " |          The sequence of values to test. Passing in a single string will\n",
      " |          raise a ``TypeError``. Instead, turn a single string into a\n",
      " |          list of one element.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Series of booleans indicating if each element is in values.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |        * If `values` is a string\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.isin : Equivalent method on DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(['llama', 'cow', 'llama', 'beetle', 'llama',\n",
      " |      ...                'hippo'], name='animal')\n",
      " |      >>> s.isin(['cow', 'llama'])\n",
      " |      0     True\n",
      " |      1     True\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4     True\n",
      " |      5    False\n",
      " |      Name: animal, dtype: bool\n",
      " |      \n",
      " |      To invert the boolean values, use the ``~`` operator:\n",
      " |      \n",
      " |      >>> ~s.isin(['cow', 'llama'])\n",
      " |      0    False\n",
      " |      1    False\n",
      " |      2    False\n",
      " |      3     True\n",
      " |      4    False\n",
      " |      5     True\n",
      " |      Name: animal, dtype: bool\n",
      " |      \n",
      " |      Passing a single string as ``s.isin('llama')`` will raise an error. Use\n",
      " |      a list of one element instead:\n",
      " |      \n",
      " |      >>> s.isin(['llama'])\n",
      " |      0     True\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      3    False\n",
      " |      4     True\n",
      " |      5    False\n",
      " |      Name: animal, dtype: bool\n",
      " |      \n",
      " |      Strings and integers are distinct and are therefore not comparable:\n",
      " |      \n",
      " |      >>> pd.Series([1]).isin(['1'])\n",
      " |      0    False\n",
      " |      dtype: bool\n",
      " |      >>> pd.Series([1.1]).isin(['1.1'])\n",
      " |      0    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  isna(self) -> 'Series'\n",
      " |      Detect missing values.\n",
      " |      \n",
      " |      Return a boolean same-sized object indicating if the values are NA.\n",
      " |      NA values, such as None or :attr:`numpy.NaN`, gets mapped to True\n",
      " |      values.\n",
      " |      Everything else gets mapped to False values. Characters such as empty\n",
      " |      strings ``''`` or :attr:`numpy.inf` are not considered NA values\n",
      " |      (unless you set ``pandas.options.mode.use_inf_as_na = True``).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Mask of bool values for each element in Series that\n",
      " |          indicates whether an element is an NA value.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.isnull : Alias of isna.\n",
      " |      Series.notna : Boolean inverse of isna.\n",
      " |      Series.dropna : Omit axes labels with missing values.\n",
      " |      isna : Top-level isna.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Show which entries in a DataFrame are NA.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(dict(age=[5, 6, np.nan],\n",
      " |      ...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),\n",
      " |      ...                              pd.Timestamp('1940-04-25')],\n",
      " |      ...                        name=['Alfred', 'Batman', ''],\n",
      " |      ...                        toy=[None, 'Batmobile', 'Joker']))\n",
      " |      >>> df\n",
      " |         age       born    name        toy\n",
      " |      0  5.0        NaT  Alfred       None\n",
      " |      1  6.0 1939-05-27  Batman  Batmobile\n",
      " |      2  NaN 1940-04-25              Joker\n",
      " |      \n",
      " |      >>> df.isna()\n",
      " |           age   born   name    toy\n",
      " |      0  False   True  False   True\n",
      " |      1  False  False  False  False\n",
      " |      2   True  False  False  False\n",
      " |      \n",
      " |      Show which entries in a Series are NA.\n",
      " |      \n",
      " |      >>> ser = pd.Series([5, 6, np.nan])\n",
      " |      >>> ser\n",
      " |      0    5.0\n",
      " |      1    6.0\n",
      " |      2    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> ser.isna()\n",
      " |      0    False\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  isnull(self) -> 'Series'\n",
      " |      Series.isnull is an alias for Series.isna.\n",
      " |      \n",
      " |      Detect missing values.\n",
      " |      \n",
      " |      Return a boolean same-sized object indicating if the values are NA.\n",
      " |      NA values, such as None or :attr:`numpy.NaN`, gets mapped to True\n",
      " |      values.\n",
      " |      Everything else gets mapped to False values. Characters such as empty\n",
      " |      strings ``''`` or :attr:`numpy.inf` are not considered NA values\n",
      " |      (unless you set ``pandas.options.mode.use_inf_as_na = True``).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Mask of bool values for each element in Series that\n",
      " |          indicates whether an element is an NA value.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.isnull : Alias of isna.\n",
      " |      Series.notna : Boolean inverse of isna.\n",
      " |      Series.dropna : Omit axes labels with missing values.\n",
      " |      isna : Top-level isna.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Show which entries in a DataFrame are NA.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(dict(age=[5, 6, np.nan],\n",
      " |      ...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),\n",
      " |      ...                              pd.Timestamp('1940-04-25')],\n",
      " |      ...                        name=['Alfred', 'Batman', ''],\n",
      " |      ...                        toy=[None, 'Batmobile', 'Joker']))\n",
      " |      >>> df\n",
      " |         age       born    name        toy\n",
      " |      0  5.0        NaT  Alfred       None\n",
      " |      1  6.0 1939-05-27  Batman  Batmobile\n",
      " |      2  NaN 1940-04-25              Joker\n",
      " |      \n",
      " |      >>> df.isna()\n",
      " |           age   born   name    toy\n",
      " |      0  False   True  False   True\n",
      " |      1  False  False  False  False\n",
      " |      2   True  False  False  False\n",
      " |      \n",
      " |      Show which entries in a Series are NA.\n",
      " |      \n",
      " |      >>> ser = pd.Series([5, 6, np.nan])\n",
      " |      >>> ser\n",
      " |      0    5.0\n",
      " |      1    6.0\n",
      " |      2    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> ser.isna()\n",
      " |      0    False\n",
      " |      1    False\n",
      " |      2     True\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  items(self) -> 'Iterable[tuple[Hashable, Any]]'\n",
      " |      Lazily iterate over (index, value) tuples.\n",
      " |      \n",
      " |      This method returns an iterable tuple (index, value). This is\n",
      " |      convenient if you want to create a lazy iterator.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      iterable\n",
      " |          Iterable of tuples containing the (index, value) pairs from a\n",
      " |          Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.items : Iterate over (column name, Series) pairs.\n",
      " |      DataFrame.iterrows : Iterate over DataFrame rows as (index, Series) pairs.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(['A', 'B', 'C'])\n",
      " |      >>> for index, value in s.items():\n",
      " |      ...     print(f\"Index : {index}, Value : {value}\")\n",
      " |      Index : 0, Value : A\n",
      " |      Index : 1, Value : B\n",
      " |      Index : 2, Value : C\n",
      " |  \n",
      " |  keys(self) -> 'Index'\n",
      " |      Return alias for index.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Index\n",
      " |          Index of the Series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3], index=[0, 1, 2])\n",
      " |      >>> s.keys()\n",
      " |      Index([0, 1, 2], dtype='int64')\n",
      " |  \n",
      " |  kurt(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return unbiased kurtosis over requested axis.\n",
      " |      \n",
      " |      Kurtosis obtained using Fisher's definition of\n",
      " |      kurtosis (kurtosis of normal == 0.0). Normalized by N-1.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          For DataFrames, specifying ``axis=None`` will apply the aggregation\n",
      " |          across both axes.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |                  Examples\n",
      " |                  --------\n",
      " |                  >>> s = pd.Series([1, 2, 2, 3], index=['cat', 'dog', 'dog', 'mouse'])\n",
      " |                  >>> s\n",
      " |                  cat    1\n",
      " |                  dog    2\n",
      " |                  dog    2\n",
      " |                  mouse  3\n",
      " |                  dtype: int64\n",
      " |                  >>> s.kurt()\n",
      " |                  1.5\n",
      " |      \n",
      " |                  With a DataFrame\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2, 2, 3], 'b': [3, 4, 4, 4]},\n",
      " |                  ...                   index=['cat', 'dog', 'dog', 'mouse'])\n",
      " |                  >>> df\n",
      " |                         a   b\n",
      " |                    cat  1   3\n",
      " |                    dog  2   4\n",
      " |                    dog  2   4\n",
      " |                  mouse  3   4\n",
      " |                  >>> df.kurt()\n",
      " |                  a   1.5\n",
      " |                  b   4.0\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  With axis=None\n",
      " |      \n",
      " |                  >>> df.kurt(axis=None).round(6)\n",
      " |                  -0.988693\n",
      " |      \n",
      " |                  Using axis=1\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [3, 4], 'd': [1, 2]},\n",
      " |                  ...                   index=['cat', 'dog'])\n",
      " |                  >>> df.kurt(axis=1)\n",
      " |                  cat   -6.0\n",
      " |                  dog   -6.0\n",
      " |                  dtype: float64\n",
      " |  \n",
      " |  kurtosis = kurt(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |  \n",
      " |  le(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Less than or equal to of series and other, element-wise (binary operator `le`).\n",
      " |      \n",
      " |      Equivalent to ``series <= other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan, 1], index=['a', 'b', 'c', 'd', 'e'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      e    1.0\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([0, 1, 2, np.nan, 1], index=['a', 'b', 'c', 'd', 'f'])\n",
      " |      >>> b\n",
      " |      a    0.0\n",
      " |      b    1.0\n",
      " |      c    2.0\n",
      " |      d    NaN\n",
      " |      f    1.0\n",
      " |      dtype: float64\n",
      " |      >>> a.le(b, fill_value=0)\n",
      " |      a    False\n",
      " |      b     True\n",
      " |      c     True\n",
      " |      d    False\n",
      " |      e    False\n",
      " |      f     True\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  lt(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Less than of series and other, element-wise (binary operator `lt`).\n",
      " |      \n",
      " |      Equivalent to ``series < other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan, 1], index=['a', 'b', 'c', 'd', 'e'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      e    1.0\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([0, 1, 2, np.nan, 1], index=['a', 'b', 'c', 'd', 'f'])\n",
      " |      >>> b\n",
      " |      a    0.0\n",
      " |      b    1.0\n",
      " |      c    2.0\n",
      " |      d    NaN\n",
      " |      f    1.0\n",
      " |      dtype: float64\n",
      " |      >>> a.lt(b, fill_value=0)\n",
      " |      a    False\n",
      " |      b    False\n",
      " |      c     True\n",
      " |      d    False\n",
      " |      e    False\n",
      " |      f     True\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  map(self, arg: 'Callable | Mapping | Series', na_action: \"Literal['ignore'] | None\" = None) -> 'Series'\n",
      " |      Map values of Series according to an input mapping or function.\n",
      " |      \n",
      " |      Used for substituting each value in a Series with another value,\n",
      " |      that may be derived from a function, a ``dict`` or\n",
      " |      a :class:`Series`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      arg : function, collections.abc.Mapping subclass or Series\n",
      " |          Mapping correspondence.\n",
      " |      na_action : {None, 'ignore'}, default None\n",
      " |          If 'ignore', propagate NaN values, without passing them to the\n",
      " |          mapping correspondence.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Same index as caller.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.apply : For applying more complex functions on a Series.\n",
      " |      Series.replace: Replace values given in `to_replace` with `value`.\n",
      " |      DataFrame.apply : Apply a function row-/column-wise.\n",
      " |      DataFrame.map : Apply a function elementwise on a whole DataFrame.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      When ``arg`` is a dictionary, values in Series that are not in the\n",
      " |      dictionary (as keys) are converted to ``NaN``. However, if the\n",
      " |      dictionary is a ``dict`` subclass that defines ``__missing__`` (i.e.\n",
      " |      provides a method for default values), then this default is used\n",
      " |      rather than ``NaN``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(['cat', 'dog', np.nan, 'rabbit'])\n",
      " |      >>> s\n",
      " |      0      cat\n",
      " |      1      dog\n",
      " |      2      NaN\n",
      " |      3   rabbit\n",
      " |      dtype: object\n",
      " |      \n",
      " |      ``map`` accepts a ``dict`` or a ``Series``. Values that are not found\n",
      " |      in the ``dict`` are converted to ``NaN``, unless the dict has a default\n",
      " |      value (e.g. ``defaultdict``):\n",
      " |      \n",
      " |      >>> s.map({'cat': 'kitten', 'dog': 'puppy'})\n",
      " |      0   kitten\n",
      " |      1    puppy\n",
      " |      2      NaN\n",
      " |      3      NaN\n",
      " |      dtype: object\n",
      " |      \n",
      " |      It also accepts a function:\n",
      " |      \n",
      " |      >>> s.map('I am a {}'.format)\n",
      " |      0       I am a cat\n",
      " |      1       I am a dog\n",
      " |      2       I am a nan\n",
      " |      3    I am a rabbit\n",
      " |      dtype: object\n",
      " |      \n",
      " |      To avoid applying the function to missing values (and keep them as\n",
      " |      ``NaN``) ``na_action='ignore'`` can be used:\n",
      " |      \n",
      " |      >>> s.map('I am a {}'.format, na_action='ignore')\n",
      " |      0     I am a cat\n",
      " |      1     I am a dog\n",
      " |      2            NaN\n",
      " |      3  I am a rabbit\n",
      " |      dtype: object\n",
      " |  \n",
      " |  max(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return the maximum of the values over the requested axis.\n",
      " |      \n",
      " |      If you want the *index* of the maximum, use ``idxmax``. This is the equivalent of the ``numpy.ndarray`` method ``argmax``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          For DataFrames, specifying ``axis=None`` will apply the aggregation\n",
      " |          across both axes.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.sum : Return the sum.\n",
      " |      Series.min : Return the minimum.\n",
      " |      Series.max : Return the maximum.\n",
      " |      Series.idxmin : Return the index of the minimum.\n",
      " |      Series.idxmax : Return the index of the maximum.\n",
      " |      DataFrame.sum : Return the sum over the requested axis.\n",
      " |      DataFrame.min : Return the minimum over the requested axis.\n",
      " |      DataFrame.max : Return the maximum over the requested axis.\n",
      " |      DataFrame.idxmin : Return the index of the minimum over the requested axis.\n",
      " |      DataFrame.idxmax : Return the index of the maximum over the requested axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> idx = pd.MultiIndex.from_arrays([\n",
      " |      ...     ['warm', 'warm', 'cold', 'cold'],\n",
      " |      ...     ['dog', 'falcon', 'fish', 'spider']],\n",
      " |      ...     names=['blooded', 'animal'])\n",
      " |      >>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx)\n",
      " |      >>> s\n",
      " |      blooded  animal\n",
      " |      warm     dog       4\n",
      " |               falcon    2\n",
      " |      cold     fish      0\n",
      " |               spider    8\n",
      " |      Name: legs, dtype: int64\n",
      " |      \n",
      " |      >>> s.max()\n",
      " |      8\n",
      " |  \n",
      " |  mean(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return the mean of the values over the requested axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          For DataFrames, specifying ``axis=None`` will apply the aggregation\n",
      " |          across both axes.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |                  Examples\n",
      " |                  --------\n",
      " |                  >>> s = pd.Series([1, 2, 3])\n",
      " |                  >>> s.mean()\n",
      " |                  2.0\n",
      " |      \n",
      " |                  With a DataFrame\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])\n",
      " |                  >>> df\n",
      " |                         a   b\n",
      " |                  tiger  1   2\n",
      " |                  zebra  2   3\n",
      " |                  >>> df.mean()\n",
      " |                  a   1.5\n",
      " |                  b   2.5\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  Using axis=1\n",
      " |      \n",
      " |                  >>> df.mean(axis=1)\n",
      " |                  tiger   1.5\n",
      " |                  zebra   2.5\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  In this case, `numeric_only` should be set to `True` to avoid\n",
      " |                  getting an error.\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},\n",
      " |                  ...                   index=['tiger', 'zebra'])\n",
      " |                  >>> df.mean(numeric_only=True)\n",
      " |                  a   1.5\n",
      " |                  dtype: float64\n",
      " |  \n",
      " |  median(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return the median of the values over the requested axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          For DataFrames, specifying ``axis=None`` will apply the aggregation\n",
      " |          across both axes.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |                  Examples\n",
      " |                  --------\n",
      " |                  >>> s = pd.Series([1, 2, 3])\n",
      " |                  >>> s.median()\n",
      " |                  2.0\n",
      " |      \n",
      " |                  With a DataFrame\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])\n",
      " |                  >>> df\n",
      " |                         a   b\n",
      " |                  tiger  1   2\n",
      " |                  zebra  2   3\n",
      " |                  >>> df.median()\n",
      " |                  a   1.5\n",
      " |                  b   2.5\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  Using axis=1\n",
      " |      \n",
      " |                  >>> df.median(axis=1)\n",
      " |                  tiger   1.5\n",
      " |                  zebra   2.5\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  In this case, `numeric_only` should be set to `True`\n",
      " |                  to avoid getting an error.\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},\n",
      " |                  ...                   index=['tiger', 'zebra'])\n",
      " |                  >>> df.median(numeric_only=True)\n",
      " |                  a   1.5\n",
      " |                  dtype: float64\n",
      " |  \n",
      " |  memory_usage(self, index: 'bool' = True, deep: 'bool' = False) -> 'int'\n",
      " |      Return the memory usage of the Series.\n",
      " |      \n",
      " |      The memory usage can optionally include the contribution of\n",
      " |      the index and of elements of `object` dtype.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      index : bool, default True\n",
      " |          Specifies whether to include the memory usage of the Series index.\n",
      " |      deep : bool, default False\n",
      " |          If True, introspect the data deeply by interrogating\n",
      " |          `object` dtypes for system-level memory consumption, and include\n",
      " |          it in the returned value.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int\n",
      " |          Bytes of memory consumed.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ndarray.nbytes : Total bytes consumed by the elements of the\n",
      " |          array.\n",
      " |      DataFrame.memory_usage : Bytes consumed by a DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(range(3))\n",
      " |      >>> s.memory_usage()\n",
      " |      152\n",
      " |      \n",
      " |      Not including the index gives the size of the rest of the data, which\n",
      " |      is necessarily smaller:\n",
      " |      \n",
      " |      >>> s.memory_usage(index=False)\n",
      " |      24\n",
      " |      \n",
      " |      The memory footprint of `object` values is ignored by default:\n",
      " |      \n",
      " |      >>> s = pd.Series([\"a\", \"b\"])\n",
      " |      >>> s.values\n",
      " |      array(['a', 'b'], dtype=object)\n",
      " |      >>> s.memory_usage()\n",
      " |      144\n",
      " |      >>> s.memory_usage(deep=True)\n",
      " |      244\n",
      " |  \n",
      " |  min(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return the minimum of the values over the requested axis.\n",
      " |      \n",
      " |      If you want the *index* of the minimum, use ``idxmin``. This is the equivalent of the ``numpy.ndarray`` method ``argmin``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          For DataFrames, specifying ``axis=None`` will apply the aggregation\n",
      " |          across both axes.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.sum : Return the sum.\n",
      " |      Series.min : Return the minimum.\n",
      " |      Series.max : Return the maximum.\n",
      " |      Series.idxmin : Return the index of the minimum.\n",
      " |      Series.idxmax : Return the index of the maximum.\n",
      " |      DataFrame.sum : Return the sum over the requested axis.\n",
      " |      DataFrame.min : Return the minimum over the requested axis.\n",
      " |      DataFrame.max : Return the maximum over the requested axis.\n",
      " |      DataFrame.idxmin : Return the index of the minimum over the requested axis.\n",
      " |      DataFrame.idxmax : Return the index of the maximum over the requested axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> idx = pd.MultiIndex.from_arrays([\n",
      " |      ...     ['warm', 'warm', 'cold', 'cold'],\n",
      " |      ...     ['dog', 'falcon', 'fish', 'spider']],\n",
      " |      ...     names=['blooded', 'animal'])\n",
      " |      >>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx)\n",
      " |      >>> s\n",
      " |      blooded  animal\n",
      " |      warm     dog       4\n",
      " |               falcon    2\n",
      " |      cold     fish      0\n",
      " |               spider    8\n",
      " |      Name: legs, dtype: int64\n",
      " |      \n",
      " |      >>> s.min()\n",
      " |      0\n",
      " |  \n",
      " |  mod(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Modulo of series and other, element-wise (binary operator `mod`).\n",
      " |      \n",
      " |      Equivalent to ``series % other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rmod : Reverse of the Modulo operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.mod(b, fill_value=0)\n",
      " |      a    0.0\n",
      " |      b    NaN\n",
      " |      c    NaN\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  mode(self, dropna: 'bool' = True) -> 'Series'\n",
      " |      Return the mode(s) of the Series.\n",
      " |      \n",
      " |      The mode is the value that appears most often. There can be multiple modes.\n",
      " |      \n",
      " |      Always returns Series even if only one value is returned.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dropna : bool, default True\n",
      " |          Don't consider counts of NaN/NaT.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Modes of the Series in sorted order.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([2, 4, 2, 2, 4, None])\n",
      " |      >>> s.mode()\n",
      " |      0    2.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      More than one mode:\n",
      " |      \n",
      " |      >>> s = pd.Series([2, 4, 8, 2, 4, None])\n",
      " |      >>> s.mode()\n",
      " |      0    2.0\n",
      " |      1    4.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      With and without considering null value:\n",
      " |      \n",
      " |      >>> s = pd.Series([2, 4, None, None, 4, None])\n",
      " |      >>> s.mode(dropna=False)\n",
      " |      0   NaN\n",
      " |      dtype: float64\n",
      " |      >>> s = pd.Series([2, 4, None, None, 4, None])\n",
      " |      >>> s.mode()\n",
      " |      0    4.0\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  mul(self, other, level: 'Level | None' = None, fill_value: 'float | None' = None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Multiplication of series and other, element-wise (binary operator `mul`).\n",
      " |      \n",
      " |      Equivalent to ``series * other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rmul : Reverse of the Multiplication operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.multiply(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    0.0\n",
      " |      c    0.0\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  multiply = mul(self, other, level: 'Level | None' = None, fill_value: 'float | None' = None, axis: 'Axis' = 0) -> 'Series'\n",
      " |  \n",
      " |  ne(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Not equal to of series and other, element-wise (binary operator `ne`).\n",
      " |      \n",
      " |      Equivalent to ``series != other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.ne(b, fill_value=0)\n",
      " |      a    False\n",
      " |      b     True\n",
      " |      c     True\n",
      " |      d     True\n",
      " |      e     True\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  nlargest(self, n: 'int' = 5, keep: \"Literal['first', 'last', 'all']\" = 'first') -> 'Series'\n",
      " |      Return the largest `n` elements.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      n : int, default 5\n",
      " |          Return this many descending sorted values.\n",
      " |      keep : {'first', 'last', 'all'}, default 'first'\n",
      " |          When there are duplicate values that cannot all fit in a\n",
      " |          Series of `n` elements:\n",
      " |      \n",
      " |          - ``first`` : return the first `n` occurrences in order\n",
      " |            of appearance.\n",
      " |          - ``last`` : return the last `n` occurrences in reverse\n",
      " |            order of appearance.\n",
      " |          - ``all`` : keep all occurrences. This can result in a Series of\n",
      " |            size larger than `n`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The `n` largest values in the Series, sorted in decreasing order.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.nsmallest: Get the `n` smallest elements.\n",
      " |      Series.sort_values: Sort Series by values.\n",
      " |      Series.head: Return the first `n` rows.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Faster than ``.sort_values(ascending=False).head(n)`` for small `n`\n",
      " |      relative to the size of the ``Series`` object.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> countries_population = {\"Italy\": 59000000, \"France\": 65000000,\n",
      " |      ...                         \"Malta\": 434000, \"Maldives\": 434000,\n",
      " |      ...                         \"Brunei\": 434000, \"Iceland\": 337000,\n",
      " |      ...                         \"Nauru\": 11300, \"Tuvalu\": 11300,\n",
      " |      ...                         \"Anguilla\": 11300, \"Montserrat\": 5200}\n",
      " |      >>> s = pd.Series(countries_population)\n",
      " |      >>> s\n",
      " |      Italy       59000000\n",
      " |      France      65000000\n",
      " |      Malta         434000\n",
      " |      Maldives      434000\n",
      " |      Brunei        434000\n",
      " |      Iceland       337000\n",
      " |      Nauru          11300\n",
      " |      Tuvalu         11300\n",
      " |      Anguilla       11300\n",
      " |      Montserrat      5200\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` largest elements where ``n=5`` by default.\n",
      " |      \n",
      " |      >>> s.nlargest()\n",
      " |      France      65000000\n",
      " |      Italy       59000000\n",
      " |      Malta         434000\n",
      " |      Maldives      434000\n",
      " |      Brunei        434000\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` largest elements where ``n=3``. Default `keep` value is 'first'\n",
      " |      so Malta will be kept.\n",
      " |      \n",
      " |      >>> s.nlargest(3)\n",
      " |      France    65000000\n",
      " |      Italy     59000000\n",
      " |      Malta       434000\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` largest elements where ``n=3`` and keeping the last duplicates.\n",
      " |      Brunei will be kept since it is the last with value 434000 based on\n",
      " |      the index order.\n",
      " |      \n",
      " |      >>> s.nlargest(3, keep='last')\n",
      " |      France      65000000\n",
      " |      Italy       59000000\n",
      " |      Brunei        434000\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` largest elements where ``n=3`` with all duplicates kept. Note\n",
      " |      that the returned Series has five elements due to the three duplicates.\n",
      " |      \n",
      " |      >>> s.nlargest(3, keep='all')\n",
      " |      France      65000000\n",
      " |      Italy       59000000\n",
      " |      Malta         434000\n",
      " |      Maldives      434000\n",
      " |      Brunei        434000\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  notna(self) -> 'Series'\n",
      " |      Detect existing (non-missing) values.\n",
      " |      \n",
      " |      Return a boolean same-sized object indicating if the values are not NA.\n",
      " |      Non-missing values get mapped to True. Characters such as empty\n",
      " |      strings ``''`` or :attr:`numpy.inf` are not considered NA values\n",
      " |      (unless you set ``pandas.options.mode.use_inf_as_na = True``).\n",
      " |      NA values, such as None or :attr:`numpy.NaN`, get mapped to False\n",
      " |      values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Mask of bool values for each element in Series that\n",
      " |          indicates whether an element is not an NA value.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.notnull : Alias of notna.\n",
      " |      Series.isna : Boolean inverse of notna.\n",
      " |      Series.dropna : Omit axes labels with missing values.\n",
      " |      notna : Top-level notna.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Show which entries in a DataFrame are not NA.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(dict(age=[5, 6, np.nan],\n",
      " |      ...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),\n",
      " |      ...                              pd.Timestamp('1940-04-25')],\n",
      " |      ...                        name=['Alfred', 'Batman', ''],\n",
      " |      ...                        toy=[None, 'Batmobile', 'Joker']))\n",
      " |      >>> df\n",
      " |         age       born    name        toy\n",
      " |      0  5.0        NaT  Alfred       None\n",
      " |      1  6.0 1939-05-27  Batman  Batmobile\n",
      " |      2  NaN 1940-04-25              Joker\n",
      " |      \n",
      " |      >>> df.notna()\n",
      " |           age   born  name    toy\n",
      " |      0   True  False  True  False\n",
      " |      1   True   True  True   True\n",
      " |      2  False   True  True   True\n",
      " |      \n",
      " |      Show which entries in a Series are not NA.\n",
      " |      \n",
      " |      >>> ser = pd.Series([5, 6, np.nan])\n",
      " |      >>> ser\n",
      " |      0    5.0\n",
      " |      1    6.0\n",
      " |      2    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> ser.notna()\n",
      " |      0     True\n",
      " |      1     True\n",
      " |      2    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  notnull(self) -> 'Series'\n",
      " |      Series.notnull is an alias for Series.notna.\n",
      " |      \n",
      " |      Detect existing (non-missing) values.\n",
      " |      \n",
      " |      Return a boolean same-sized object indicating if the values are not NA.\n",
      " |      Non-missing values get mapped to True. Characters such as empty\n",
      " |      strings ``''`` or :attr:`numpy.inf` are not considered NA values\n",
      " |      (unless you set ``pandas.options.mode.use_inf_as_na = True``).\n",
      " |      NA values, such as None or :attr:`numpy.NaN`, get mapped to False\n",
      " |      values.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Mask of bool values for each element in Series that\n",
      " |          indicates whether an element is not an NA value.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.notnull : Alias of notna.\n",
      " |      Series.isna : Boolean inverse of notna.\n",
      " |      Series.dropna : Omit axes labels with missing values.\n",
      " |      notna : Top-level notna.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Show which entries in a DataFrame are not NA.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(dict(age=[5, 6, np.nan],\n",
      " |      ...                        born=[pd.NaT, pd.Timestamp('1939-05-27'),\n",
      " |      ...                              pd.Timestamp('1940-04-25')],\n",
      " |      ...                        name=['Alfred', 'Batman', ''],\n",
      " |      ...                        toy=[None, 'Batmobile', 'Joker']))\n",
      " |      >>> df\n",
      " |         age       born    name        toy\n",
      " |      0  5.0        NaT  Alfred       None\n",
      " |      1  6.0 1939-05-27  Batman  Batmobile\n",
      " |      2  NaN 1940-04-25              Joker\n",
      " |      \n",
      " |      >>> df.notna()\n",
      " |           age   born  name    toy\n",
      " |      0   True  False  True  False\n",
      " |      1   True   True  True   True\n",
      " |      2  False   True  True   True\n",
      " |      \n",
      " |      Show which entries in a Series are not NA.\n",
      " |      \n",
      " |      >>> ser = pd.Series([5, 6, np.nan])\n",
      " |      >>> ser\n",
      " |      0    5.0\n",
      " |      1    6.0\n",
      " |      2    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> ser.notna()\n",
      " |      0     True\n",
      " |      1     True\n",
      " |      2    False\n",
      " |      dtype: bool\n",
      " |  \n",
      " |  nsmallest(self, n: 'int' = 5, keep: \"Literal['first', 'last', 'all']\" = 'first') -> 'Series'\n",
      " |      Return the smallest `n` elements.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      n : int, default 5\n",
      " |          Return this many ascending sorted values.\n",
      " |      keep : {'first', 'last', 'all'}, default 'first'\n",
      " |          When there are duplicate values that cannot all fit in a\n",
      " |          Series of `n` elements:\n",
      " |      \n",
      " |          - ``first`` : return the first `n` occurrences in order\n",
      " |            of appearance.\n",
      " |          - ``last`` : return the last `n` occurrences in reverse\n",
      " |            order of appearance.\n",
      " |          - ``all`` : keep all occurrences. This can result in a Series of\n",
      " |            size larger than `n`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The `n` smallest values in the Series, sorted in increasing order.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.nlargest: Get the `n` largest elements.\n",
      " |      Series.sort_values: Sort Series by values.\n",
      " |      Series.head: Return the first `n` rows.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Faster than ``.sort_values().head(n)`` for small `n` relative to\n",
      " |      the size of the ``Series`` object.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> countries_population = {\"Italy\": 59000000, \"France\": 65000000,\n",
      " |      ...                         \"Brunei\": 434000, \"Malta\": 434000,\n",
      " |      ...                         \"Maldives\": 434000, \"Iceland\": 337000,\n",
      " |      ...                         \"Nauru\": 11300, \"Tuvalu\": 11300,\n",
      " |      ...                         \"Anguilla\": 11300, \"Montserrat\": 5200}\n",
      " |      >>> s = pd.Series(countries_population)\n",
      " |      >>> s\n",
      " |      Italy       59000000\n",
      " |      France      65000000\n",
      " |      Brunei        434000\n",
      " |      Malta         434000\n",
      " |      Maldives      434000\n",
      " |      Iceland       337000\n",
      " |      Nauru          11300\n",
      " |      Tuvalu         11300\n",
      " |      Anguilla       11300\n",
      " |      Montserrat      5200\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` smallest elements where ``n=5`` by default.\n",
      " |      \n",
      " |      >>> s.nsmallest()\n",
      " |      Montserrat    5200\n",
      " |      Nauru        11300\n",
      " |      Tuvalu       11300\n",
      " |      Anguilla     11300\n",
      " |      Iceland     337000\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` smallest elements where ``n=3``. Default `keep` value is\n",
      " |      'first' so Nauru and Tuvalu will be kept.\n",
      " |      \n",
      " |      >>> s.nsmallest(3)\n",
      " |      Montserrat   5200\n",
      " |      Nauru       11300\n",
      " |      Tuvalu      11300\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` smallest elements where ``n=3`` and keeping the last\n",
      " |      duplicates. Anguilla and Tuvalu will be kept since they are the last\n",
      " |      with value 11300 based on the index order.\n",
      " |      \n",
      " |      >>> s.nsmallest(3, keep='last')\n",
      " |      Montserrat   5200\n",
      " |      Anguilla    11300\n",
      " |      Tuvalu      11300\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      The `n` smallest elements where ``n=3`` with all duplicates kept. Note\n",
      " |      that the returned Series has four elements due to the three duplicates.\n",
      " |      \n",
      " |      >>> s.nsmallest(3, keep='all')\n",
      " |      Montserrat   5200\n",
      " |      Nauru       11300\n",
      " |      Tuvalu      11300\n",
      " |      Anguilla    11300\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  pop(self, item: 'Hashable') -> 'Any'\n",
      " |      Return item and drops from series. Raise KeyError if not found.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      item : label\n",
      " |          Index of the element that needs to be removed.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Value that is popped from series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([1, 2, 3])\n",
      " |      \n",
      " |      >>> ser.pop(0)\n",
      " |      1\n",
      " |      \n",
      " |      >>> ser\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  pow(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Exponential power of series and other, element-wise (binary operator `pow`).\n",
      " |      \n",
      " |      Equivalent to ``series ** other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rpow : Reverse of the Exponential power operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.pow(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  prod(self, axis: 'Axis | None' = None, skipna: 'bool' = True, numeric_only: 'bool' = False, min_count: 'int' = 0, **kwargs)\n",
      " |      Return the product of the values over the requested axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          .. warning::\n",
      " |      \n",
      " |              The behavior of DataFrame.prod with ``axis=None`` is deprecated,\n",
      " |              in a future version this will reduce over both axes and return a scalar\n",
      " |              To retain the old behavior, pass axis=0 (or do not pass axis).\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      min_count : int, default 0\n",
      " |          The required number of valid values to perform the operation. If fewer than\n",
      " |          ``min_count`` non-NA values are present the result will be NA.\n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.sum : Return the sum.\n",
      " |      Series.min : Return the minimum.\n",
      " |      Series.max : Return the maximum.\n",
      " |      Series.idxmin : Return the index of the minimum.\n",
      " |      Series.idxmax : Return the index of the maximum.\n",
      " |      DataFrame.sum : Return the sum over the requested axis.\n",
      " |      DataFrame.min : Return the minimum over the requested axis.\n",
      " |      DataFrame.max : Return the maximum over the requested axis.\n",
      " |      DataFrame.idxmin : Return the index of the minimum over the requested axis.\n",
      " |      DataFrame.idxmax : Return the index of the maximum over the requested axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      By default, the product of an empty or all-NA Series is ``1``\n",
      " |      \n",
      " |      >>> pd.Series([], dtype=\"float64\").prod()\n",
      " |      1.0\n",
      " |      \n",
      " |      This can be controlled with the ``min_count`` parameter\n",
      " |      \n",
      " |      >>> pd.Series([], dtype=\"float64\").prod(min_count=1)\n",
      " |      nan\n",
      " |      \n",
      " |      Thanks to the ``skipna`` parameter, ``min_count`` handles all-NA and\n",
      " |      empty series identically.\n",
      " |      \n",
      " |      >>> pd.Series([np.nan]).prod()\n",
      " |      1.0\n",
      " |      \n",
      " |      >>> pd.Series([np.nan]).prod(min_count=1)\n",
      " |      nan\n",
      " |  \n",
      " |  product = prod(self, axis: 'Axis | None' = None, skipna: 'bool' = True, numeric_only: 'bool' = False, min_count: 'int' = 0, **kwargs)\n",
      " |  \n",
      " |  quantile(self, q: 'float | Sequence[float] | AnyArrayLike' = 0.5, interpolation: 'QuantileInterpolation' = 'linear') -> 'float | Series'\n",
      " |      Return value at the given quantile.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      q : float or array-like, default 0.5 (50% quantile)\n",
      " |          The quantile(s) to compute, which can lie in range: 0 <= q <= 1.\n",
      " |      interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\n",
      " |          This optional parameter specifies the interpolation method to use,\n",
      " |          when the desired quantile lies between two data points `i` and `j`:\n",
      " |      \n",
      " |              * linear: `i + (j - i) * (x-i)/(j-i)`, where `(x-i)/(j-i)` is\n",
      " |                the fractional part of the index surrounded by `i > j`.\n",
      " |              * lower: `i`.\n",
      " |              * higher: `j`.\n",
      " |              * nearest: `i` or `j` whichever is nearest.\n",
      " |              * midpoint: (`i` + `j`) / 2.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      float or Series\n",
      " |          If ``q`` is an array, a Series will be returned where the\n",
      " |          index is ``q`` and the values are the quantiles, otherwise\n",
      " |          a float will be returned.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      core.window.Rolling.quantile : Calculate the rolling quantile.\n",
      " |      numpy.percentile : Returns the q-th percentile(s) of the array elements.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4])\n",
      " |      >>> s.quantile(.5)\n",
      " |      2.5\n",
      " |      >>> s.quantile([.25, .5, .75])\n",
      " |      0.25    1.75\n",
      " |      0.50    2.50\n",
      " |      0.75    3.25\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  radd(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Addition of series and other, element-wise (binary operator `radd`).\n",
      " |      \n",
      " |      Equivalent to ``other + series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.add : Element-wise Addition, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.add(b, fill_value=0)\n",
      " |      a    2.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  ravel(self, order: 'str' = 'C') -> 'ArrayLike'\n",
      " |      Return the flattened underlying data as an ndarray or ExtensionArray.\n",
      " |      \n",
      " |      .. deprecated:: 2.2.0\n",
      " |          Series.ravel is deprecated. The underlying array is already 1D, so\n",
      " |          ravel is not necessary.  Use :meth:`to_numpy` for conversion to a numpy\n",
      " |          array instead.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      numpy.ndarray or ExtensionArray\n",
      " |          Flattened data of the Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ndarray.ravel : Return a flattened array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.ravel()  # doctest: +SKIP\n",
      " |      array([1, 2, 3])\n",
      " |  \n",
      " |  rdiv = rtruediv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |  \n",
      " |  rdivmod(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Integer division and modulo of series and other, element-wise (binary operator `rdivmod`).\n",
      " |      \n",
      " |      Equivalent to ``other divmod series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      2-Tuple of Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.divmod : Element-wise Integer division and modulo, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.divmod(b, fill_value=0)\n",
      " |      (a    1.0\n",
      " |       b    inf\n",
      " |       c    inf\n",
      " |       d    0.0\n",
      " |       e    NaN\n",
      " |       dtype: float64,\n",
      " |       a    0.0\n",
      " |       b    NaN\n",
      " |       c    NaN\n",
      " |       d    0.0\n",
      " |       e    NaN\n",
      " |       dtype: float64)\n",
      " |  \n",
      " |  reindex(self, index=None, *, axis: 'Axis | None' = None, method: 'ReindexMethod | None' = None, copy: 'bool | None' = None, level: 'Level | None' = None, fill_value: 'Scalar | None' = None, limit: 'int | None' = None, tolerance=None) -> 'Series'\n",
      " |      Conform Series to new index with optional filling logic.\n",
      " |      \n",
      " |      Places NA/NaN in locations having no value in the previous index. A new object\n",
      " |      is produced unless the new index is equivalent to the current one and\n",
      " |      ``copy=False``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      \n",
      " |      index : array-like, optional\n",
      " |          New labels for the index. Preferably an Index object to avoid\n",
      " |          duplicating data.\n",
      " |      axis : int or str, optional\n",
      " |          Unused.\n",
      " |      method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}\n",
      " |          Method to use for filling holes in reindexed DataFrame.\n",
      " |          Please note: this is only applicable to DataFrames/Series with a\n",
      " |          monotonically increasing/decreasing index.\n",
      " |      \n",
      " |          * None (default): don't fill gaps\n",
      " |          * pad / ffill: Propagate last valid observation forward to next\n",
      " |            valid.\n",
      " |          * backfill / bfill: Use next valid observation to fill gap.\n",
      " |          * nearest: Use nearest valid observations to fill gap.\n",
      " |      \n",
      " |      copy : bool, default True\n",
      " |          Return a new object, even if the passed indexes are the same.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : scalar, default np.nan\n",
      " |          Value to use for missing values. Defaults to NaN, but can be any\n",
      " |          \"compatible\" value.\n",
      " |      limit : int, default None\n",
      " |          Maximum number of consecutive elements to forward or backward fill.\n",
      " |      tolerance : optional\n",
      " |          Maximum distance between original and new labels for inexact\n",
      " |          matches. The values of the index at the matching locations most\n",
      " |          satisfy the equation ``abs(index[indexer] - target) <= tolerance``.\n",
      " |      \n",
      " |          Tolerance may be a scalar value, which applies the same tolerance\n",
      " |          to all values, or list-like, which applies variable tolerance per\n",
      " |          element. List-like includes list, tuple, array, Series, and must be\n",
      " |          the same size as the index and its dtype must exactly match the\n",
      " |          index's type.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series with changed index.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.set_index : Set row labels.\n",
      " |      DataFrame.reset_index : Remove row labels or move them to new columns.\n",
      " |      DataFrame.reindex_like : Change to same indices as other DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      ``DataFrame.reindex`` supports two calling conventions\n",
      " |      \n",
      " |      * ``(index=index_labels, columns=column_labels, ...)``\n",
      " |      * ``(labels, axis={'index', 'columns'}, ...)``\n",
      " |      \n",
      " |      We *highly* recommend using keyword arguments to clarify your\n",
      " |      intent.\n",
      " |      \n",
      " |      Create a dataframe with some fictional data.\n",
      " |      \n",
      " |      >>> index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']\n",
      " |      >>> df = pd.DataFrame({'http_status': [200, 200, 404, 404, 301],\n",
      " |      ...                   'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},\n",
      " |      ...                   index=index)\n",
      " |      >>> df\n",
      " |                 http_status  response_time\n",
      " |      Firefox            200           0.04\n",
      " |      Chrome             200           0.02\n",
      " |      Safari             404           0.07\n",
      " |      IE10               404           0.08\n",
      " |      Konqueror          301           1.00\n",
      " |      \n",
      " |      Create a new index and reindex the dataframe. By default\n",
      " |      values in the new index that do not have corresponding\n",
      " |      records in the dataframe are assigned ``NaN``.\n",
      " |      \n",
      " |      >>> new_index = ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',\n",
      " |      ...              'Chrome']\n",
      " |      >>> df.reindex(new_index)\n",
      " |                     http_status  response_time\n",
      " |      Safari               404.0           0.07\n",
      " |      Iceweasel              NaN            NaN\n",
      " |      Comodo Dragon          NaN            NaN\n",
      " |      IE10                 404.0           0.08\n",
      " |      Chrome               200.0           0.02\n",
      " |      \n",
      " |      We can fill in the missing values by passing a value to\n",
      " |      the keyword ``fill_value``. Because the index is not monotonically\n",
      " |      increasing or decreasing, we cannot use arguments to the keyword\n",
      " |      ``method`` to fill the ``NaN`` values.\n",
      " |      \n",
      " |      >>> df.reindex(new_index, fill_value=0)\n",
      " |                     http_status  response_time\n",
      " |      Safari                 404           0.07\n",
      " |      Iceweasel                0           0.00\n",
      " |      Comodo Dragon            0           0.00\n",
      " |      IE10                   404           0.08\n",
      " |      Chrome                 200           0.02\n",
      " |      \n",
      " |      >>> df.reindex(new_index, fill_value='missing')\n",
      " |                    http_status response_time\n",
      " |      Safari                404          0.07\n",
      " |      Iceweasel         missing       missing\n",
      " |      Comodo Dragon     missing       missing\n",
      " |      IE10                  404          0.08\n",
      " |      Chrome                200          0.02\n",
      " |      \n",
      " |      We can also reindex the columns.\n",
      " |      \n",
      " |      >>> df.reindex(columns=['http_status', 'user_agent'])\n",
      " |                 http_status  user_agent\n",
      " |      Firefox            200         NaN\n",
      " |      Chrome             200         NaN\n",
      " |      Safari             404         NaN\n",
      " |      IE10               404         NaN\n",
      " |      Konqueror          301         NaN\n",
      " |      \n",
      " |      Or we can use \"axis-style\" keyword arguments\n",
      " |      \n",
      " |      >>> df.reindex(['http_status', 'user_agent'], axis=\"columns\")\n",
      " |                 http_status  user_agent\n",
      " |      Firefox            200         NaN\n",
      " |      Chrome             200         NaN\n",
      " |      Safari             404         NaN\n",
      " |      IE10               404         NaN\n",
      " |      Konqueror          301         NaN\n",
      " |      \n",
      " |      To further illustrate the filling functionality in\n",
      " |      ``reindex``, we will create a dataframe with a\n",
      " |      monotonically increasing index (for example, a sequence\n",
      " |      of dates).\n",
      " |      \n",
      " |      >>> date_index = pd.date_range('1/1/2010', periods=6, freq='D')\n",
      " |      >>> df2 = pd.DataFrame({\"prices\": [100, 101, np.nan, 100, 89, 88]},\n",
      " |      ...                    index=date_index)\n",
      " |      >>> df2\n",
      " |                  prices\n",
      " |      2010-01-01   100.0\n",
      " |      2010-01-02   101.0\n",
      " |      2010-01-03     NaN\n",
      " |      2010-01-04   100.0\n",
      " |      2010-01-05    89.0\n",
      " |      2010-01-06    88.0\n",
      " |      \n",
      " |      Suppose we decide to expand the dataframe to cover a wider\n",
      " |      date range.\n",
      " |      \n",
      " |      >>> date_index2 = pd.date_range('12/29/2009', periods=10, freq='D')\n",
      " |      >>> df2.reindex(date_index2)\n",
      " |                  prices\n",
      " |      2009-12-29     NaN\n",
      " |      2009-12-30     NaN\n",
      " |      2009-12-31     NaN\n",
      " |      2010-01-01   100.0\n",
      " |      2010-01-02   101.0\n",
      " |      2010-01-03     NaN\n",
      " |      2010-01-04   100.0\n",
      " |      2010-01-05    89.0\n",
      " |      2010-01-06    88.0\n",
      " |      2010-01-07     NaN\n",
      " |      \n",
      " |      The index entries that did not have a value in the original data frame\n",
      " |      (for example, '2009-12-29') are by default filled with ``NaN``.\n",
      " |      If desired, we can fill in the missing values using one of several\n",
      " |      options.\n",
      " |      \n",
      " |      For example, to back-propagate the last valid value to fill the ``NaN``\n",
      " |      values, pass ``bfill`` as an argument to the ``method`` keyword.\n",
      " |      \n",
      " |      >>> df2.reindex(date_index2, method='bfill')\n",
      " |                  prices\n",
      " |      2009-12-29   100.0\n",
      " |      2009-12-30   100.0\n",
      " |      2009-12-31   100.0\n",
      " |      2010-01-01   100.0\n",
      " |      2010-01-02   101.0\n",
      " |      2010-01-03     NaN\n",
      " |      2010-01-04   100.0\n",
      " |      2010-01-05    89.0\n",
      " |      2010-01-06    88.0\n",
      " |      2010-01-07     NaN\n",
      " |      \n",
      " |      Please note that the ``NaN`` value present in the original dataframe\n",
      " |      (at index value 2010-01-03) will not be filled by any of the\n",
      " |      value propagation schemes. This is because filling while reindexing\n",
      " |      does not look at dataframe values, but only compares the original and\n",
      " |      desired indexes. If you do want to fill in the ``NaN`` values present\n",
      " |      in the original dataframe, use the ``fillna()`` method.\n",
      " |      \n",
      " |      See the :ref:`user guide <basics.reindexing>` for more.\n",
      " |  \n",
      " |  rename(self, index: 'Renamer | Hashable | None' = None, *, axis: 'Axis | None' = None, copy: 'bool | None' = None, inplace: 'bool' = False, level: 'Level | None' = None, errors: 'IgnoreRaise' = 'ignore') -> 'Series | None'\n",
      " |      Alter Series index labels or name.\n",
      " |      \n",
      " |      Function / dict values must be unique (1-to-1). Labels not contained in\n",
      " |      a dict / Series will be left as-is. Extra labels listed don't throw an\n",
      " |      error.\n",
      " |      \n",
      " |      Alternatively, change ``Series.name`` with a scalar value.\n",
      " |      \n",
      " |      See the :ref:`user guide <basics.rename>` for more.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      index : scalar, hashable sequence, dict-like or function optional\n",
      " |          Functions or dict-like are transformations to apply to\n",
      " |          the index.\n",
      " |          Scalar or hashable sequence-like will alter the ``Series.name``\n",
      " |          attribute.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      copy : bool, default True\n",
      " |          Also copy underlying data.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      inplace : bool, default False\n",
      " |          Whether to return a new Series. If True the value of copy is ignored.\n",
      " |      level : int or level name, default None\n",
      " |          In case of MultiIndex, only rename labels in the specified level.\n",
      " |      errors : {'ignore', 'raise'}, default 'ignore'\n",
      " |          If 'raise', raise `KeyError` when a `dict-like mapper` or\n",
      " |          `index` contains labels that are not present in the index being transformed.\n",
      " |          If 'ignore', existing keys will be renamed and extra keys will be ignored.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or None\n",
      " |          Series with index labels or name altered or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.rename : Corresponding DataFrame method.\n",
      " |      Series.rename_axis : Set the name of the axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      dtype: int64\n",
      " |      >>> s.rename(\"my_name\")  # scalar, changes Series.name\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      Name: my_name, dtype: int64\n",
      " |      >>> s.rename(lambda x: x ** 2)  # function, changes labels\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      4    3\n",
      " |      dtype: int64\n",
      " |      >>> s.rename({1: 3, 2: 5})  # mapping, changes labels\n",
      " |      0    1\n",
      " |      3    2\n",
      " |      5    3\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  rename_axis(self, mapper: 'IndexLabel | lib.NoDefault' = <no_default>, *, index=<no_default>, axis: 'Axis' = 0, copy: 'bool' = True, inplace: 'bool' = False) -> 'Self | None'\n",
      " |      Set the name of the axis for the index or columns.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      mapper : scalar, list-like, optional\n",
      " |          Value to set the axis name attribute.\n",
      " |      index, columns : scalar, list-like, dict-like or function, optional\n",
      " |          A scalar, list-like, dict-like or functions transformations to\n",
      " |          apply to that axis' values.\n",
      " |          Note that the ``columns`` parameter is not allowed if the\n",
      " |          object is a Series. This parameter only apply for DataFrame\n",
      " |          type objects.\n",
      " |      \n",
      " |          Use either ``mapper`` and ``axis`` to\n",
      " |          specify the axis to target with ``mapper``, or ``index``\n",
      " |          and/or ``columns``.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The axis to rename. For `Series` this parameter is unused and defaults to 0.\n",
      " |      copy : bool, default None\n",
      " |          Also copy underlying data.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      inplace : bool, default False\n",
      " |          Modifies the object directly, instead of creating a new Series\n",
      " |          or DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series, DataFrame, or None\n",
      " |          The same type as the caller or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rename : Alter Series index labels or name.\n",
      " |      DataFrame.rename : Alter DataFrame index labels or name.\n",
      " |      Index.rename : Set new names on index.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      ``DataFrame.rename_axis`` supports two calling conventions\n",
      " |      \n",
      " |      * ``(index=index_mapper, columns=columns_mapper, ...)``\n",
      " |      * ``(mapper, axis={'index', 'columns'}, ...)``\n",
      " |      \n",
      " |      The first calling convention will only modify the names of\n",
      " |      the index and/or the names of the Index object that is the columns.\n",
      " |      In this case, the parameter ``copy`` is ignored.\n",
      " |      \n",
      " |      The second calling convention will modify the names of the\n",
      " |      corresponding index if mapper is a list or a scalar.\n",
      " |      However, if mapper is dict-like or a function, it will use the\n",
      " |      deprecated behavior of modifying the axis *labels*.\n",
      " |      \n",
      " |      We *highly* recommend using keyword arguments to clarify your\n",
      " |      intent.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> s = pd.Series([\"dog\", \"cat\", \"monkey\"])\n",
      " |      >>> s\n",
      " |      0       dog\n",
      " |      1       cat\n",
      " |      2    monkey\n",
      " |      dtype: object\n",
      " |      >>> s.rename_axis(\"animal\")\n",
      " |      animal\n",
      " |      0    dog\n",
      " |      1    cat\n",
      " |      2    monkey\n",
      " |      dtype: object\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\"num_legs\": [4, 4, 2],\n",
      " |      ...                    \"num_arms\": [0, 0, 2]},\n",
      " |      ...                   [\"dog\", \"cat\", \"monkey\"])\n",
      " |      >>> df\n",
      " |              num_legs  num_arms\n",
      " |      dog            4         0\n",
      " |      cat            4         0\n",
      " |      monkey         2         2\n",
      " |      >>> df = df.rename_axis(\"animal\")\n",
      " |      >>> df\n",
      " |              num_legs  num_arms\n",
      " |      animal\n",
      " |      dog            4         0\n",
      " |      cat            4         0\n",
      " |      monkey         2         2\n",
      " |      >>> df = df.rename_axis(\"limbs\", axis=\"columns\")\n",
      " |      >>> df\n",
      " |      limbs   num_legs  num_arms\n",
      " |      animal\n",
      " |      dog            4         0\n",
      " |      cat            4         0\n",
      " |      monkey         2         2\n",
      " |      \n",
      " |      **MultiIndex**\n",
      " |      \n",
      " |      >>> df.index = pd.MultiIndex.from_product([['mammal'],\n",
      " |      ...                                        ['dog', 'cat', 'monkey']],\n",
      " |      ...                                       names=['type', 'name'])\n",
      " |      >>> df\n",
      " |      limbs          num_legs  num_arms\n",
      " |      type   name\n",
      " |      mammal dog            4         0\n",
      " |             cat            4         0\n",
      " |             monkey         2         2\n",
      " |      \n",
      " |      >>> df.rename_axis(index={'type': 'class'})\n",
      " |      limbs          num_legs  num_arms\n",
      " |      class  name\n",
      " |      mammal dog            4         0\n",
      " |             cat            4         0\n",
      " |             monkey         2         2\n",
      " |      \n",
      " |      >>> df.rename_axis(columns=str.upper)\n",
      " |      LIMBS          num_legs  num_arms\n",
      " |      type   name\n",
      " |      mammal dog            4         0\n",
      " |             cat            4         0\n",
      " |             monkey         2         2\n",
      " |  \n",
      " |  reorder_levels(self, order: 'Sequence[Level]') -> 'Series'\n",
      " |      Rearrange index levels using input order.\n",
      " |      \n",
      " |      May not drop or duplicate levels.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      order : list of int representing new level order\n",
      " |          Reference level by number or key.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      type of caller (new object)\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> arrays = [np.array([\"dog\", \"dog\", \"cat\", \"cat\", \"bird\", \"bird\"]),\n",
      " |      ...           np.array([\"white\", \"black\", \"white\", \"black\", \"white\", \"black\"])]\n",
      " |      >>> s = pd.Series([1, 2, 3, 3, 5, 2], index=arrays)\n",
      " |      >>> s\n",
      " |      dog   white    1\n",
      " |            black    2\n",
      " |      cat   white    3\n",
      " |            black    3\n",
      " |      bird  white    5\n",
      " |            black    2\n",
      " |      dtype: int64\n",
      " |      >>> s.reorder_levels([1, 0])\n",
      " |      white  dog     1\n",
      " |      black  dog     2\n",
      " |      white  cat     3\n",
      " |      black  cat     3\n",
      " |      white  bird    5\n",
      " |      black  bird    2\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  repeat(self, repeats: 'int | Sequence[int]', axis: 'None' = None) -> 'Series'\n",
      " |      Repeat elements of a Series.\n",
      " |      \n",
      " |      Returns a new Series where each element of the current Series\n",
      " |      is repeated consecutively a given number of times.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      repeats : int or array of ints\n",
      " |          The number of repetitions for each element. This should be a\n",
      " |          non-negative integer. Repeating 0 times will return an empty\n",
      " |          Series.\n",
      " |      axis : None\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Newly created Series with repeated elements.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Index.repeat : Equivalent function for Index.\n",
      " |      numpy.repeat : Similar method for :class:`numpy.ndarray`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(['a', 'b', 'c'])\n",
      " |      >>> s\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    c\n",
      " |      dtype: object\n",
      " |      >>> s.repeat(2)\n",
      " |      0    a\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      1    b\n",
      " |      2    c\n",
      " |      2    c\n",
      " |      dtype: object\n",
      " |      >>> s.repeat([1, 2, 3])\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      1    b\n",
      " |      2    c\n",
      " |      2    c\n",
      " |      2    c\n",
      " |      dtype: object\n",
      " |  \n",
      " |  reset_index(self, level: 'IndexLabel | None' = None, *, drop: 'bool' = False, name: 'Level' = <no_default>, inplace: 'bool' = False, allow_duplicates: 'bool' = False) -> 'DataFrame | Series | None'\n",
      " |      Generate a new DataFrame or Series with the index reset.\n",
      " |      \n",
      " |      This is useful when the index needs to be treated as a column, or\n",
      " |      when the index is meaningless and needs to be reset to the default\n",
      " |      before another operation.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      level : int, str, tuple, or list, default optional\n",
      " |          For a Series with a MultiIndex, only remove the specified levels\n",
      " |          from the index. Removes all levels by default.\n",
      " |      drop : bool, default False\n",
      " |          Just reset the index, without inserting it as a column in\n",
      " |          the new DataFrame.\n",
      " |      name : object, optional\n",
      " |          The name to use for the column containing the original Series\n",
      " |          values. Uses ``self.name`` by default. This argument is ignored\n",
      " |          when `drop` is True.\n",
      " |      inplace : bool, default False\n",
      " |          Modify the Series in place (do not create a new object).\n",
      " |      allow_duplicates : bool, default False\n",
      " |          Allow duplicate column labels to be created.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame or None\n",
      " |          When `drop` is False (the default), a DataFrame is returned.\n",
      " |          The newly created columns will come first in the DataFrame,\n",
      " |          followed by the original Series values.\n",
      " |          When `drop` is True, a `Series` is returned.\n",
      " |          In either case, if ``inplace=True``, no value is returned.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.reset_index: Analogous function for DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4], name='foo',\n",
      " |      ...               index=pd.Index(['a', 'b', 'c', 'd'], name='idx'))\n",
      " |      \n",
      " |      Generate a DataFrame with default index.\n",
      " |      \n",
      " |      >>> s.reset_index()\n",
      " |        idx  foo\n",
      " |      0   a    1\n",
      " |      1   b    2\n",
      " |      2   c    3\n",
      " |      3   d    4\n",
      " |      \n",
      " |      To specify the name of the new column use `name`.\n",
      " |      \n",
      " |      >>> s.reset_index(name='values')\n",
      " |        idx  values\n",
      " |      0   a       1\n",
      " |      1   b       2\n",
      " |      2   c       3\n",
      " |      3   d       4\n",
      " |      \n",
      " |      To generate a new Series with the default set `drop` to True.\n",
      " |      \n",
      " |      >>> s.reset_index(drop=True)\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      Name: foo, dtype: int64\n",
      " |      \n",
      " |      The `level` parameter is interesting for Series with a multi-level\n",
      " |      index.\n",
      " |      \n",
      " |      >>> arrays = [np.array(['bar', 'bar', 'baz', 'baz']),\n",
      " |      ...           np.array(['one', 'two', 'one', 'two'])]\n",
      " |      >>> s2 = pd.Series(\n",
      " |      ...     range(4), name='foo',\n",
      " |      ...     index=pd.MultiIndex.from_arrays(arrays,\n",
      " |      ...                                     names=['a', 'b']))\n",
      " |      \n",
      " |      To remove a specific level from the Index, use `level`.\n",
      " |      \n",
      " |      >>> s2.reset_index(level='a')\n",
      " |             a  foo\n",
      " |      b\n",
      " |      one  bar    0\n",
      " |      two  bar    1\n",
      " |      one  baz    2\n",
      " |      two  baz    3\n",
      " |      \n",
      " |      If `level` is not set, all levels are removed from the Index.\n",
      " |      \n",
      " |      >>> s2.reset_index()\n",
      " |           a    b  foo\n",
      " |      0  bar  one    0\n",
      " |      1  bar  two    1\n",
      " |      2  baz  one    2\n",
      " |      3  baz  two    3\n",
      " |  \n",
      " |  rfloordiv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Integer division of series and other, element-wise (binary operator `rfloordiv`).\n",
      " |      \n",
      " |      Equivalent to ``other // series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.floordiv : Element-wise Integer division, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.floordiv(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    inf\n",
      " |      c    inf\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  rmod(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Modulo of series and other, element-wise (binary operator `rmod`).\n",
      " |      \n",
      " |      Equivalent to ``other % series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.mod : Element-wise Modulo, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.mod(b, fill_value=0)\n",
      " |      a    0.0\n",
      " |      b    NaN\n",
      " |      c    NaN\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  rmul(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Multiplication of series and other, element-wise (binary operator `rmul`).\n",
      " |      \n",
      " |      Equivalent to ``other * series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.mul : Element-wise Multiplication, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.multiply(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    0.0\n",
      " |      c    0.0\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  round(self, decimals: 'int' = 0, *args, **kwargs) -> 'Series'\n",
      " |      Round each value in a Series to the given number of decimals.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      decimals : int, default 0\n",
      " |          Number of decimal places to round to. If decimals is negative,\n",
      " |          it specifies the number of positions to the left of the decimal point.\n",
      " |      *args, **kwargs\n",
      " |          Additional arguments and keywords have no effect but might be\n",
      " |          accepted for compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Rounded values of the Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.around : Round values of an np.array.\n",
      " |      DataFrame.round : Round values of a DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([0.1, 1.3, 2.7])\n",
      " |      >>> s.round()\n",
      " |      0    0.0\n",
      " |      1    1.0\n",
      " |      2    3.0\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  rpow(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Exponential power of series and other, element-wise (binary operator `rpow`).\n",
      " |      \n",
      " |      Equivalent to ``other ** series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.pow : Element-wise Exponential power, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.pow(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  rsub(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Subtraction of series and other, element-wise (binary operator `rsub`).\n",
      " |      \n",
      " |      Equivalent to ``other - series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.sub : Element-wise Subtraction, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.subtract(b, fill_value=0)\n",
      " |      a    0.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d   -1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  rtruediv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Floating division of series and other, element-wise (binary operator `rtruediv`).\n",
      " |      \n",
      " |      Equivalent to ``other / series``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.truediv : Element-wise Floating division, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.divide(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    inf\n",
      " |      c    inf\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  searchsorted(self, value: 'NumpyValueArrayLike | ExtensionArray', side: \"Literal['left', 'right']\" = 'left', sorter: 'NumpySorter | None' = None) -> 'npt.NDArray[np.intp] | np.intp'\n",
      " |      Find indices where elements should be inserted to maintain order.\n",
      " |      \n",
      " |      Find the indices into a sorted Series `self` such that, if the\n",
      " |      corresponding elements in `value` were inserted before the indices,\n",
      " |      the order of `self` would be preserved.\n",
      " |      \n",
      " |      .. note::\n",
      " |      \n",
      " |          The Series *must* be monotonically sorted, otherwise\n",
      " |          wrong locations will likely be returned. Pandas does *not*\n",
      " |          check this for you.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      value : array-like or scalar\n",
      " |          Values to insert into `self`.\n",
      " |      side : {'left', 'right'}, optional\n",
      " |          If 'left', the index of the first suitable location found is given.\n",
      " |          If 'right', return the last such index.  If there is no suitable\n",
      " |          index, return either 0 or N (where N is the length of `self`).\n",
      " |      sorter : 1-D array-like, optional\n",
      " |          Optional array of integer indices that sort `self` into ascending\n",
      " |          order. They are typically the result of ``np.argsort``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int or array of int\n",
      " |          A scalar or array of insertion points with the\n",
      " |          same shape as `value`.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      sort_values : Sort by the values along either axis.\n",
      " |      numpy.searchsorted : Similar method from NumPy.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Binary search is used to find the required insertion points.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([1, 2, 3])\n",
      " |      >>> ser\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> ser.searchsorted(4)\n",
      " |      3\n",
      " |      \n",
      " |      >>> ser.searchsorted([0, 4])\n",
      " |      array([0, 3])\n",
      " |      \n",
      " |      >>> ser.searchsorted([1, 3], side='left')\n",
      " |      array([0, 2])\n",
      " |      \n",
      " |      >>> ser.searchsorted([1, 3], side='right')\n",
      " |      array([1, 3])\n",
      " |      \n",
      " |      >>> ser = pd.Series(pd.to_datetime(['3/11/2000', '3/12/2000', '3/13/2000']))\n",
      " |      >>> ser\n",
      " |      0   2000-03-11\n",
      " |      1   2000-03-12\n",
      " |      2   2000-03-13\n",
      " |      dtype: datetime64[ns]\n",
      " |      \n",
      " |      >>> ser.searchsorted('3/14/2000')\n",
      " |      3\n",
      " |      \n",
      " |      >>> ser = pd.Categorical(\n",
      " |      ...     ['apple', 'bread', 'bread', 'cheese', 'milk'], ordered=True\n",
      " |      ... )\n",
      " |      >>> ser\n",
      " |      ['apple', 'bread', 'bread', 'cheese', 'milk']\n",
      " |      Categories (4, object): ['apple' < 'bread' < 'cheese' < 'milk']\n",
      " |      \n",
      " |      >>> ser.searchsorted('bread')\n",
      " |      1\n",
      " |      \n",
      " |      >>> ser.searchsorted(['bread'], side='right')\n",
      " |      array([3])\n",
      " |      \n",
      " |      If the values are not monotonically sorted, wrong locations\n",
      " |      may be returned:\n",
      " |      \n",
      " |      >>> ser = pd.Series([2, 1, 3])\n",
      " |      >>> ser\n",
      " |      0    2\n",
      " |      1    1\n",
      " |      2    3\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> ser.searchsorted(1)  # doctest: +SKIP\n",
      " |      0  # wrong result, correct would be 1\n",
      " |  \n",
      " |  sem(self, axis: 'Axis | None' = None, skipna: 'bool' = True, ddof: 'int' = 1, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return unbiased standard error of the mean over requested axis.\n",
      " |      \n",
      " |      Normalized by N-1 by default. This can be changed using the ddof argument\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          .. warning::\n",
      " |      \n",
      " |              The behavior of DataFrame.sem with ``axis=None`` is deprecated,\n",
      " |              in a future version this will reduce over both axes and return a scalar\n",
      " |              To retain the old behavior, pass axis=0 (or do not pass axis).\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      ddof : int, default 1\n",
      " |          Delta Degrees of Freedom. The divisor used in calculations is N - ddof,\n",
      " |          where N represents the number of elements.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series (if level specified) \n",
      " |      \n",
      " |                  Examples\n",
      " |                  --------\n",
      " |                  >>> s = pd.Series([1, 2, 3])\n",
      " |                  >>> s.sem().round(6)\n",
      " |                  0.57735\n",
      " |      \n",
      " |                  With a DataFrame\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])\n",
      " |                  >>> df\n",
      " |                         a   b\n",
      " |                  tiger  1   2\n",
      " |                  zebra  2   3\n",
      " |                  >>> df.sem()\n",
      " |                  a   0.5\n",
      " |                  b   0.5\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  Using axis=1\n",
      " |      \n",
      " |                  >>> df.sem(axis=1)\n",
      " |                  tiger   0.5\n",
      " |                  zebra   0.5\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  In this case, `numeric_only` should be set to `True`\n",
      " |                  to avoid getting an error.\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},\n",
      " |                  ...                   index=['tiger', 'zebra'])\n",
      " |                  >>> df.sem(numeric_only=True)\n",
      " |                  a   0.5\n",
      " |                  dtype: float64\n",
      " |  \n",
      " |  set_axis(self, labels, *, axis: 'Axis' = 0, copy: 'bool | None' = None) -> 'Series'\n",
      " |      Assign desired index to given axis.\n",
      " |      \n",
      " |      Indexes for row labels can be changed by assigning\n",
      " |      a list-like or Index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      labels : list-like, Index\n",
      " |          The values for the new index.\n",
      " |      \n",
      " |      axis : {0 or 'index'}, default 0\n",
      " |          The axis to update. The value 0 identifies the rows. For `Series`\n",
      " |          this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |      copy : bool, default True\n",
      " |          Whether to make a copy of the underlying data.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          An object of type Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rename_axis : Alter the name of the index.\n",
      " |      \n",
      " |              Examples\n",
      " |              --------\n",
      " |              >>> s = pd.Series([1, 2, 3])\n",
      " |              >>> s\n",
      " |              0    1\n",
      " |              1    2\n",
      " |              2    3\n",
      " |              dtype: int64\n",
      " |      \n",
      " |              >>> s.set_axis(['a', 'b', 'c'], axis=0)\n",
      " |              a    1\n",
      " |              b    2\n",
      " |              c    3\n",
      " |              dtype: int64\n",
      " |  \n",
      " |  skew(self, axis: 'Axis | None' = 0, skipna: 'bool' = True, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return unbiased skew over requested axis.\n",
      " |      \n",
      " |      Normalized by N-1.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          For DataFrames, specifying ``axis=None`` will apply the aggregation\n",
      " |          across both axes.\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |                  Examples\n",
      " |                  --------\n",
      " |                  >>> s = pd.Series([1, 2, 3])\n",
      " |                  >>> s.skew()\n",
      " |                  0.0\n",
      " |      \n",
      " |                  With a DataFrame\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2, 3], 'b': [2, 3, 4], 'c': [1, 3, 5]},\n",
      " |                  ...                   index=['tiger', 'zebra', 'cow'])\n",
      " |                  >>> df\n",
      " |                          a   b   c\n",
      " |                  tiger   1   2   1\n",
      " |                  zebra   2   3   3\n",
      " |                  cow     3   4   5\n",
      " |                  >>> df.skew()\n",
      " |                  a   0.0\n",
      " |                  b   0.0\n",
      " |                  c   0.0\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  Using axis=1\n",
      " |      \n",
      " |                  >>> df.skew(axis=1)\n",
      " |                  tiger   1.732051\n",
      " |                  zebra  -1.732051\n",
      " |                  cow     0.000000\n",
      " |                  dtype: float64\n",
      " |      \n",
      " |                  In this case, `numeric_only` should be set to `True` to avoid\n",
      " |                  getting an error.\n",
      " |      \n",
      " |                  >>> df = pd.DataFrame({'a': [1, 2, 3], 'b': ['T', 'Z', 'X']},\n",
      " |                  ...                   index=['tiger', 'zebra', 'cow'])\n",
      " |                  >>> df.skew(numeric_only=True)\n",
      " |                  a   0.0\n",
      " |                  dtype: float64\n",
      " |  \n",
      " |  sort_index(self, *, axis: 'Axis' = 0, level: 'IndexLabel | None' = None, ascending: 'bool | Sequence[bool]' = True, inplace: 'bool' = False, kind: 'SortKind' = 'quicksort', na_position: 'NaPosition' = 'last', sort_remaining: 'bool' = True, ignore_index: 'bool' = False, key: 'IndexKeyFunc | None' = None) -> 'Series | None'\n",
      " |      Sort Series by index labels.\n",
      " |      \n",
      " |      Returns a new Series sorted by label if `inplace` argument is\n",
      " |      ``False``, otherwise updates the original series and returns None.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      level : int, optional\n",
      " |          If not None, sort on values in specified index level(s).\n",
      " |      ascending : bool or list-like of bools, default True\n",
      " |          Sort ascending vs. descending. When the index is a MultiIndex the\n",
      " |          sort direction can be controlled for each level individually.\n",
      " |      inplace : bool, default False\n",
      " |          If True, perform operation in-place.\n",
      " |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'\n",
      " |          Choice of sorting algorithm. See also :func:`numpy.sort` for more\n",
      " |          information. 'mergesort' and 'stable' are the only stable algorithms. For\n",
      " |          DataFrames, this option is only applied when sorting on a single\n",
      " |          column or label.\n",
      " |      na_position : {'first', 'last'}, default 'last'\n",
      " |          If 'first' puts NaNs at the beginning, 'last' puts NaNs at the end.\n",
      " |          Not implemented for MultiIndex.\n",
      " |      sort_remaining : bool, default True\n",
      " |          If True and sorting by level and index is multilevel, sort by other\n",
      " |          levels too (in order) after sorting by specified level.\n",
      " |      ignore_index : bool, default False\n",
      " |          If True, the resulting axis will be labeled 0, 1, …, n - 1.\n",
      " |      key : callable, optional\n",
      " |          If not None, apply the key function to the index values\n",
      " |          before sorting. This is similar to the `key` argument in the\n",
      " |          builtin :meth:`sorted` function, with the notable difference that\n",
      " |          this `key` function should be *vectorized*. It should expect an\n",
      " |          ``Index`` and return an ``Index`` of the same shape.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or None\n",
      " |          The original Series sorted by the labels or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.sort_index: Sort DataFrame by the index.\n",
      " |      DataFrame.sort_values: Sort DataFrame by the value.\n",
      " |      Series.sort_values : Sort Series by the value.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, 4])\n",
      " |      >>> s.sort_index()\n",
      " |      1    c\n",
      " |      2    b\n",
      " |      3    a\n",
      " |      4    d\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Sort Descending\n",
      " |      \n",
      " |      >>> s.sort_index(ascending=False)\n",
      " |      4    d\n",
      " |      3    a\n",
      " |      2    b\n",
      " |      1    c\n",
      " |      dtype: object\n",
      " |      \n",
      " |      By default NaNs are put at the end, but use `na_position` to place\n",
      " |      them at the beginning\n",
      " |      \n",
      " |      >>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, np.nan])\n",
      " |      >>> s.sort_index(na_position='first')\n",
      " |      NaN     d\n",
      " |       1.0    c\n",
      " |       2.0    b\n",
      " |       3.0    a\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Specify index level to sort\n",
      " |      \n",
      " |      >>> arrays = [np.array(['qux', 'qux', 'foo', 'foo',\n",
      " |      ...                     'baz', 'baz', 'bar', 'bar']),\n",
      " |      ...           np.array(['two', 'one', 'two', 'one',\n",
      " |      ...                     'two', 'one', 'two', 'one'])]\n",
      " |      >>> s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays)\n",
      " |      >>> s.sort_index(level=1)\n",
      " |      bar  one    8\n",
      " |      baz  one    6\n",
      " |      foo  one    4\n",
      " |      qux  one    2\n",
      " |      bar  two    7\n",
      " |      baz  two    5\n",
      " |      foo  two    3\n",
      " |      qux  two    1\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Does not sort by remaining levels when sorting by levels\n",
      " |      \n",
      " |      >>> s.sort_index(level=1, sort_remaining=False)\n",
      " |      qux  one    2\n",
      " |      foo  one    4\n",
      " |      baz  one    6\n",
      " |      bar  one    8\n",
      " |      qux  two    1\n",
      " |      foo  two    3\n",
      " |      baz  two    5\n",
      " |      bar  two    7\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Apply a key function before sorting\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3, 4], index=['A', 'b', 'C', 'd'])\n",
      " |      >>> s.sort_index(key=lambda x : x.str.lower())\n",
      " |      A    1\n",
      " |      b    2\n",
      " |      C    3\n",
      " |      d    4\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  sort_values(self, *, axis: 'Axis' = 0, ascending: 'bool | Sequence[bool]' = True, inplace: 'bool' = False, kind: 'SortKind' = 'quicksort', na_position: 'NaPosition' = 'last', ignore_index: 'bool' = False, key: 'ValueKeyFunc | None' = None) -> 'Series | None'\n",
      " |      Sort by the values.\n",
      " |      \n",
      " |      Sort a Series in ascending or descending order by some\n",
      " |      criterion.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      ascending : bool or list of bools, default True\n",
      " |          If True, sort values in ascending order, otherwise descending.\n",
      " |      inplace : bool, default False\n",
      " |          If True, perform operation in-place.\n",
      " |      kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, default 'quicksort'\n",
      " |          Choice of sorting algorithm. See also :func:`numpy.sort` for more\n",
      " |          information. 'mergesort' and 'stable' are the only stable  algorithms.\n",
      " |      na_position : {'first' or 'last'}, default 'last'\n",
      " |          Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at\n",
      " |          the end.\n",
      " |      ignore_index : bool, default False\n",
      " |          If True, the resulting axis will be labeled 0, 1, …, n - 1.\n",
      " |      key : callable, optional\n",
      " |          If not None, apply the key function to the series values\n",
      " |          before sorting. This is similar to the `key` argument in the\n",
      " |          builtin :meth:`sorted` function, with the notable difference that\n",
      " |          this `key` function should be *vectorized*. It should expect a\n",
      " |          ``Series`` and return an array-like.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or None\n",
      " |          Series ordered by values or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.sort_index : Sort by the Series indices.\n",
      " |      DataFrame.sort_values : Sort DataFrame by the values along either axis.\n",
      " |      DataFrame.sort_index : Sort DataFrame by indices.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([np.nan, 1, 3, 10, 5])\n",
      " |      >>> s\n",
      " |      0     NaN\n",
      " |      1     1.0\n",
      " |      2     3.0\n",
      " |      3     10.0\n",
      " |      4     5.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Sort values ascending order (default behaviour)\n",
      " |      \n",
      " |      >>> s.sort_values(ascending=True)\n",
      " |      1     1.0\n",
      " |      2     3.0\n",
      " |      4     5.0\n",
      " |      3    10.0\n",
      " |      0     NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Sort values descending order\n",
      " |      \n",
      " |      >>> s.sort_values(ascending=False)\n",
      " |      3    10.0\n",
      " |      4     5.0\n",
      " |      2     3.0\n",
      " |      1     1.0\n",
      " |      0     NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Sort values putting NAs first\n",
      " |      \n",
      " |      >>> s.sort_values(na_position='first')\n",
      " |      0     NaN\n",
      " |      1     1.0\n",
      " |      2     3.0\n",
      " |      4     5.0\n",
      " |      3    10.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Sort a series of strings\n",
      " |      \n",
      " |      >>> s = pd.Series(['z', 'b', 'd', 'a', 'c'])\n",
      " |      >>> s\n",
      " |      0    z\n",
      " |      1    b\n",
      " |      2    d\n",
      " |      3    a\n",
      " |      4    c\n",
      " |      dtype: object\n",
      " |      \n",
      " |      >>> s.sort_values()\n",
      " |      3    a\n",
      " |      1    b\n",
      " |      4    c\n",
      " |      2    d\n",
      " |      0    z\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Sort using a key function. Your `key` function will be\n",
      " |      given the ``Series`` of values and should return an array-like.\n",
      " |      \n",
      " |      >>> s = pd.Series(['a', 'B', 'c', 'D', 'e'])\n",
      " |      >>> s.sort_values()\n",
      " |      1    B\n",
      " |      3    D\n",
      " |      0    a\n",
      " |      2    c\n",
      " |      4    e\n",
      " |      dtype: object\n",
      " |      >>> s.sort_values(key=lambda x: x.str.lower())\n",
      " |      0    a\n",
      " |      1    B\n",
      " |      2    c\n",
      " |      3    D\n",
      " |      4    e\n",
      " |      dtype: object\n",
      " |      \n",
      " |      NumPy ufuncs work well here. For example, we can\n",
      " |      sort by the ``sin`` of the value\n",
      " |      \n",
      " |      >>> s = pd.Series([-4, -2, 0, 2, 4])\n",
      " |      >>> s.sort_values(key=np.sin)\n",
      " |      1   -2\n",
      " |      4    4\n",
      " |      2    0\n",
      " |      0   -4\n",
      " |      3    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      More complicated user-defined functions can be used,\n",
      " |      as long as they expect a Series and return an array-like\n",
      " |      \n",
      " |      >>> s.sort_values(key=lambda x: (np.tan(x.cumsum())))\n",
      " |      0   -4\n",
      " |      3    2\n",
      " |      4    4\n",
      " |      1   -2\n",
      " |      2    0\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  std(self, axis: 'Axis | None' = None, skipna: 'bool' = True, ddof: 'int' = 1, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return sample standard deviation over requested axis.\n",
      " |      \n",
      " |      Normalized by N-1 by default. This can be changed using the ddof argument.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          .. warning::\n",
      " |      \n",
      " |              The behavior of DataFrame.std with ``axis=None`` is deprecated,\n",
      " |              in a future version this will reduce over both axes and return a scalar\n",
      " |              To retain the old behavior, pass axis=0 (or do not pass axis).\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      ddof : int, default 1\n",
      " |          Delta Degrees of Freedom. The divisor used in calculations is N - ddof,\n",
      " |          where N represents the number of elements.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series (if level specified) \n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      To have the same behaviour as `numpy.std`, use `ddof=0` (instead of the\n",
      " |      default `ddof=1`)\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'person_id': [0, 1, 2, 3],\n",
      " |      ...                    'age': [21, 25, 62, 43],\n",
      " |      ...                    'height': [1.61, 1.87, 1.49, 2.01]}\n",
      " |      ...                   ).set_index('person_id')\n",
      " |      >>> df\n",
      " |                 age  height\n",
      " |      person_id\n",
      " |      0           21    1.61\n",
      " |      1           25    1.87\n",
      " |      2           62    1.49\n",
      " |      3           43    2.01\n",
      " |      \n",
      " |      The standard deviation of the columns can be found as follows:\n",
      " |      \n",
      " |      >>> df.std()\n",
      " |      age       18.786076\n",
      " |      height     0.237417\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Alternatively, `ddof=0` can be set to normalize by N instead of N-1:\n",
      " |      \n",
      " |      >>> df.std(ddof=0)\n",
      " |      age       16.269219\n",
      " |      height     0.205609\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  sub(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Subtraction of series and other, element-wise (binary operator `sub`).\n",
      " |      \n",
      " |      Equivalent to ``series - other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rsub : Reverse of the Subtraction operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.subtract(b, fill_value=0)\n",
      " |      a    0.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d   -1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  subtract = sub(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |  \n",
      " |  sum(self, axis: 'Axis | None' = None, skipna: 'bool' = True, numeric_only: 'bool' = False, min_count: 'int' = 0, **kwargs)\n",
      " |      Return the sum of the values over the requested axis.\n",
      " |      \n",
      " |      This is equivalent to the method ``numpy.sum``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          Axis for the function to be applied on.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          .. warning::\n",
      " |      \n",
      " |              The behavior of DataFrame.sum with ``axis=None`` is deprecated,\n",
      " |              in a future version this will reduce over both axes and return a scalar\n",
      " |              To retain the old behavior, pass axis=0 (or do not pass axis).\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when computing the result.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      min_count : int, default 0\n",
      " |          The required number of valid values to perform the operation. If fewer than\n",
      " |          ``min_count`` non-NA values are present the result will be NA.\n",
      " |      **kwargs\n",
      " |          Additional keyword arguments to be passed to the function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or scalar\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.sum : Return the sum.\n",
      " |      Series.min : Return the minimum.\n",
      " |      Series.max : Return the maximum.\n",
      " |      Series.idxmin : Return the index of the minimum.\n",
      " |      Series.idxmax : Return the index of the maximum.\n",
      " |      DataFrame.sum : Return the sum over the requested axis.\n",
      " |      DataFrame.min : Return the minimum over the requested axis.\n",
      " |      DataFrame.max : Return the maximum over the requested axis.\n",
      " |      DataFrame.idxmin : Return the index of the minimum over the requested axis.\n",
      " |      DataFrame.idxmax : Return the index of the maximum over the requested axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> idx = pd.MultiIndex.from_arrays([\n",
      " |      ...     ['warm', 'warm', 'cold', 'cold'],\n",
      " |      ...     ['dog', 'falcon', 'fish', 'spider']],\n",
      " |      ...     names=['blooded', 'animal'])\n",
      " |      >>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx)\n",
      " |      >>> s\n",
      " |      blooded  animal\n",
      " |      warm     dog       4\n",
      " |               falcon    2\n",
      " |      cold     fish      0\n",
      " |               spider    8\n",
      " |      Name: legs, dtype: int64\n",
      " |      \n",
      " |      >>> s.sum()\n",
      " |      14\n",
      " |      \n",
      " |      By default, the sum of an empty or all-NA Series is ``0``.\n",
      " |      \n",
      " |      >>> pd.Series([], dtype=\"float64\").sum()  # min_count=0 is the default\n",
      " |      0.0\n",
      " |      \n",
      " |      This can be controlled with the ``min_count`` parameter. For example, if\n",
      " |      you'd like the sum of an empty series to be NaN, pass ``min_count=1``.\n",
      " |      \n",
      " |      >>> pd.Series([], dtype=\"float64\").sum(min_count=1)\n",
      " |      nan\n",
      " |      \n",
      " |      Thanks to the ``skipna`` parameter, ``min_count`` handles all-NA and\n",
      " |      empty series identically.\n",
      " |      \n",
      " |      >>> pd.Series([np.nan]).sum()\n",
      " |      0.0\n",
      " |      \n",
      " |      >>> pd.Series([np.nan]).sum(min_count=1)\n",
      " |      nan\n",
      " |  \n",
      " |  swaplevel(self, i: 'Level' = -2, j: 'Level' = -1, copy: 'bool | None' = None) -> 'Series'\n",
      " |      Swap levels i and j in a :class:`MultiIndex`.\n",
      " |      \n",
      " |      Default is to swap the two innermost levels of the index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      i, j : int or str\n",
      " |          Levels of the indices to be swapped. Can pass level name as string.\n",
      " |      copy : bool, default True\n",
      " |                  Whether to copy underlying data.\n",
      " |      \n",
      " |                  .. note::\n",
      " |                      The `copy` keyword will change behavior in pandas 3.0.\n",
      " |                      `Copy-on-Write\n",
      " |                      <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |                      will be enabled by default, which means that all methods with a\n",
      " |                      `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |                      ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |                      future version of pandas.\n",
      " |      \n",
      " |                      You can already get the future behavior and improvements through\n",
      " |                      enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Series with levels swapped in MultiIndex.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(\n",
      " |      ...     [\"A\", \"B\", \"A\", \"C\"],\n",
      " |      ...     index=[\n",
      " |      ...         [\"Final exam\", \"Final exam\", \"Coursework\", \"Coursework\"],\n",
      " |      ...         [\"History\", \"Geography\", \"History\", \"Geography\"],\n",
      " |      ...         [\"January\", \"February\", \"March\", \"April\"],\n",
      " |      ...     ],\n",
      " |      ... )\n",
      " |      >>> s\n",
      " |      Final exam  History     January      A\n",
      " |                  Geography   February     B\n",
      " |      Coursework  History     March        A\n",
      " |                  Geography   April        C\n",
      " |      dtype: object\n",
      " |      \n",
      " |      In the following example, we will swap the levels of the indices.\n",
      " |      Here, we will swap the levels column-wise, but levels can be swapped row-wise\n",
      " |      in a similar manner. Note that column-wise is the default behaviour.\n",
      " |      By not supplying any arguments for i and j, we swap the last and second to\n",
      " |      last indices.\n",
      " |      \n",
      " |      >>> s.swaplevel()\n",
      " |      Final exam  January     History         A\n",
      " |                  February    Geography       B\n",
      " |      Coursework  March       History         A\n",
      " |                  April       Geography       C\n",
      " |      dtype: object\n",
      " |      \n",
      " |      By supplying one argument, we can choose which index to swap the last\n",
      " |      index with. We can for example swap the first index with the last one as\n",
      " |      follows.\n",
      " |      \n",
      " |      >>> s.swaplevel(0)\n",
      " |      January     History     Final exam      A\n",
      " |      February    Geography   Final exam      B\n",
      " |      March       History     Coursework      A\n",
      " |      April       Geography   Coursework      C\n",
      " |      dtype: object\n",
      " |      \n",
      " |      We can also define explicitly which indices we want to swap by supplying values\n",
      " |      for both i and j. Here, we for example swap the first and second indices.\n",
      " |      \n",
      " |      >>> s.swaplevel(0, 1)\n",
      " |      History     Final exam  January         A\n",
      " |      Geography   Final exam  February        B\n",
      " |      History     Coursework  March           A\n",
      " |      Geography   Coursework  April           C\n",
      " |      dtype: object\n",
      " |  \n",
      " |  to_dict(self, *, into: 'type[MutableMappingT] | MutableMappingT' = <class 'dict'>) -> 'MutableMappingT'\n",
      " |      Convert Series to {label -> value} dict or dict-like object.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      into : class, default dict\n",
      " |          The collections.abc.MutableMapping subclass to use as the return\n",
      " |          object. Can be the actual class or an empty instance of the mapping\n",
      " |          type you want.  If you want a collections.defaultdict, you must\n",
      " |          pass it initialized.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      collections.abc.MutableMapping\n",
      " |          Key-value representation of Series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4])\n",
      " |      >>> s.to_dict()\n",
      " |      {0: 1, 1: 2, 2: 3, 3: 4}\n",
      " |      >>> from collections import OrderedDict, defaultdict\n",
      " |      >>> s.to_dict(into=OrderedDict)\n",
      " |      OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])\n",
      " |      >>> dd = defaultdict(list)\n",
      " |      >>> s.to_dict(into=dd)\n",
      " |      defaultdict(<class 'list'>, {0: 1, 1: 2, 2: 3, 3: 4})\n",
      " |  \n",
      " |  to_frame(self, name: 'Hashable' = <no_default>) -> 'DataFrame'\n",
      " |      Convert Series to DataFrame.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      name : object, optional\n",
      " |          The passed name should substitute for the series name (if it has\n",
      " |          one).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      DataFrame\n",
      " |          DataFrame representation of Series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([\"a\", \"b\", \"c\"],\n",
      " |      ...               name=\"vals\")\n",
      " |      >>> s.to_frame()\n",
      " |        vals\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    c\n",
      " |  \n",
      " |  to_markdown(self, buf: 'IO[str] | None' = None, mode: 'str' = 'wt', index: 'bool' = True, storage_options: 'StorageOptions | None' = None, **kwargs) -> 'str | None'\n",
      " |      Print Series in Markdown-friendly format.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      buf : str, Path or StringIO-like, optional, default None\n",
      " |          Buffer to write to. If None, the output is returned as a string.\n",
      " |      mode : str, optional\n",
      " |          Mode in which file is opened, \"wt\" by default.\n",
      " |      index : bool, optional, default True\n",
      " |          Add index (row) labels.\n",
      " |      \n",
      " |      storage_options : dict, optional\n",
      " |          Extra options that make sense for a particular storage connection, e.g.\n",
      " |          host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n",
      " |          are forwarded to ``urllib.request.Request`` as header options. For other\n",
      " |          URLs (e.g. starting with \"s3://\", and \"gcs://\") the key-value pairs are\n",
      " |          forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n",
      " |          details, and for more examples on storage options refer `here\n",
      " |          <https://pandas.pydata.org/docs/user_guide/io.html?\n",
      " |          highlight=storage_options#reading-writing-remote-files>`_.\n",
      " |      \n",
      " |      **kwargs\n",
      " |          These parameters will be passed to `tabulate                 <https://pypi.org/project/tabulate>`_.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      str\n",
      " |          Series in Markdown-friendly format.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Requires the `tabulate <https://pypi.org/project/tabulate>`_ package.\n",
      " |      \n",
      " |      Examples\n",
      " |                  --------\n",
      " |                  >>> s = pd.Series([\"elk\", \"pig\", \"dog\", \"quetzal\"], name=\"animal\")\n",
      " |                  >>> print(s.to_markdown())\n",
      " |                  |    | animal   |\n",
      " |                  |---:|:---------|\n",
      " |                  |  0 | elk      |\n",
      " |                  |  1 | pig      |\n",
      " |                  |  2 | dog      |\n",
      " |                  |  3 | quetzal  |\n",
      " |      \n",
      " |                  Output markdown with a tabulate option.\n",
      " |      \n",
      " |                  >>> print(s.to_markdown(tablefmt=\"grid\"))\n",
      " |                  +----+----------+\n",
      " |                  |    | animal   |\n",
      " |                  +====+==========+\n",
      " |                  |  0 | elk      |\n",
      " |                  +----+----------+\n",
      " |                  |  1 | pig      |\n",
      " |                  +----+----------+\n",
      " |                  |  2 | dog      |\n",
      " |                  +----+----------+\n",
      " |                  |  3 | quetzal  |\n",
      " |                  +----+----------+\n",
      " |  \n",
      " |  to_period(self, freq: 'str | None' = None, copy: 'bool | None' = None) -> 'Series'\n",
      " |      Convert Series from DatetimeIndex to PeriodIndex.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      freq : str, default None\n",
      " |          Frequency associated with the PeriodIndex.\n",
      " |      copy : bool, default True\n",
      " |          Whether or not to return a copy.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          Series with index converted to PeriodIndex.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> idx = pd.DatetimeIndex(['2023', '2024', '2025'])\n",
      " |      >>> s = pd.Series([1, 2, 3], index=idx)\n",
      " |      >>> s = s.to_period()\n",
      " |      >>> s\n",
      " |      2023    1\n",
      " |      2024    2\n",
      " |      2025    3\n",
      " |      Freq: Y-DEC, dtype: int64\n",
      " |      \n",
      " |      Viewing the index\n",
      " |      \n",
      " |      >>> s.index\n",
      " |      PeriodIndex(['2023', '2024', '2025'], dtype='period[Y-DEC]')\n",
      " |  \n",
      " |  to_string(self, buf: 'FilePath | WriteBuffer[str] | None' = None, na_rep: 'str' = 'NaN', float_format: 'str | None' = None, header: 'bool' = True, index: 'bool' = True, length: 'bool' = False, dtype: 'bool' = False, name: 'bool' = False, max_rows: 'int | None' = None, min_rows: 'int | None' = None) -> 'str | None'\n",
      " |      Render a string representation of the Series.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      buf : StringIO-like, optional\n",
      " |          Buffer to write to.\n",
      " |      na_rep : str, optional\n",
      " |          String representation of NaN to use, default 'NaN'.\n",
      " |      float_format : one-parameter function, optional\n",
      " |          Formatter function to apply to columns' elements if they are\n",
      " |          floats, default None.\n",
      " |      header : bool, default True\n",
      " |          Add the Series header (index name).\n",
      " |      index : bool, optional\n",
      " |          Add index (row) labels, default True.\n",
      " |      length : bool, default False\n",
      " |          Add the Series length.\n",
      " |      dtype : bool, default False\n",
      " |          Add the Series dtype.\n",
      " |      name : bool, default False\n",
      " |          Add the Series name if not None.\n",
      " |      max_rows : int, optional\n",
      " |          Maximum number of rows to show before truncating. If None, show\n",
      " |          all.\n",
      " |      min_rows : int, optional\n",
      " |          The number of rows to display in a truncated repr (when number\n",
      " |          of rows is above `max_rows`).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      str or None\n",
      " |          String representation of Series if ``buf=None``, otherwise None.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([1, 2, 3]).to_string()\n",
      " |      >>> ser\n",
      " |      '0    1\\n1    2\\n2    3'\n",
      " |  \n",
      " |  to_timestamp(self, freq: 'Frequency | None' = None, how: \"Literal['s', 'e', 'start', 'end']\" = 'start', copy: 'bool | None' = None) -> 'Series'\n",
      " |      Cast to DatetimeIndex of Timestamps, at *beginning* of period.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      freq : str, default frequency of PeriodIndex\n",
      " |          Desired frequency.\n",
      " |      how : {'s', 'e', 'start', 'end'}\n",
      " |          Convention for converting period to timestamp; start of period\n",
      " |          vs. end.\n",
      " |      copy : bool, default True\n",
      " |          Whether or not to return a copy.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series with DatetimeIndex\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> idx = pd.PeriodIndex(['2023', '2024', '2025'], freq='Y')\n",
      " |      >>> s1 = pd.Series([1, 2, 3], index=idx)\n",
      " |      >>> s1\n",
      " |      2023    1\n",
      " |      2024    2\n",
      " |      2025    3\n",
      " |      Freq: Y-DEC, dtype: int64\n",
      " |      \n",
      " |      The resulting frequency of the Timestamps is `YearBegin`\n",
      " |      \n",
      " |      >>> s1 = s1.to_timestamp()\n",
      " |      >>> s1\n",
      " |      2023-01-01    1\n",
      " |      2024-01-01    2\n",
      " |      2025-01-01    3\n",
      " |      Freq: YS-JAN, dtype: int64\n",
      " |      \n",
      " |      Using `freq` which is the offset that the Timestamps will have\n",
      " |      \n",
      " |      >>> s2 = pd.Series([1, 2, 3], index=idx)\n",
      " |      >>> s2 = s2.to_timestamp(freq='M')\n",
      " |      >>> s2\n",
      " |      2023-01-31    1\n",
      " |      2024-01-31    2\n",
      " |      2025-01-31    3\n",
      " |      Freq: YE-JAN, dtype: int64\n",
      " |  \n",
      " |  transform(self, func: 'AggFuncType', axis: 'Axis' = 0, *args, **kwargs) -> 'DataFrame | Series'\n",
      " |      Call ``func`` on self producing a Series with the same axis shape as self.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      func : function, str, list-like or dict-like\n",
      " |          Function to use for transforming the data. If a function, must either\n",
      " |          work when passed a Series or when passed to Series.apply. If func\n",
      " |          is both list-like and dict-like, dict-like behavior takes precedence.\n",
      " |      \n",
      " |          Accepted combinations are:\n",
      " |      \n",
      " |          - function\n",
      " |          - string function name\n",
      " |          - list-like of functions and/or function names, e.g. ``[np.exp, 'sqrt']``\n",
      " |          - dict-like of axis labels -> functions, function names or list-like of such.\n",
      " |      axis : {0 or 'index'}\n",
      " |              Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      *args\n",
      " |          Positional arguments to pass to `func`.\n",
      " |      **kwargs\n",
      " |          Keyword arguments to pass to `func`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          A Series that must have the same length as self.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ValueError : If the returned Series has a different length than self.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.agg : Only perform aggregating type operations.\n",
      " |      Series.apply : Invoke function on a Series.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Functions that mutate the passed object can produce unexpected\n",
      " |      behavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\n",
      " |      for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'A': range(3), 'B': range(1, 4)})\n",
      " |      >>> df\n",
      " |         A  B\n",
      " |      0  0  1\n",
      " |      1  1  2\n",
      " |      2  2  3\n",
      " |      >>> df.transform(lambda x: x + 1)\n",
      " |         A  B\n",
      " |      0  1  2\n",
      " |      1  2  3\n",
      " |      2  3  4\n",
      " |      \n",
      " |      Even though the resulting Series must have the same length as the\n",
      " |      input Series, it is possible to provide several input functions:\n",
      " |      \n",
      " |      >>> s = pd.Series(range(3))\n",
      " |      >>> s\n",
      " |      0    0\n",
      " |      1    1\n",
      " |      2    2\n",
      " |      dtype: int64\n",
      " |      >>> s.transform([np.sqrt, np.exp])\n",
      " |             sqrt        exp\n",
      " |      0  0.000000   1.000000\n",
      " |      1  1.000000   2.718282\n",
      " |      2  1.414214   7.389056\n",
      " |      \n",
      " |      You can call transform on a GroupBy object:\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\n",
      " |      ...     \"Date\": [\n",
      " |      ...         \"2015-05-08\", \"2015-05-07\", \"2015-05-06\", \"2015-05-05\",\n",
      " |      ...         \"2015-05-08\", \"2015-05-07\", \"2015-05-06\", \"2015-05-05\"],\n",
      " |      ...     \"Data\": [5, 8, 6, 1, 50, 100, 60, 120],\n",
      " |      ... })\n",
      " |      >>> df\n",
      " |               Date  Data\n",
      " |      0  2015-05-08     5\n",
      " |      1  2015-05-07     8\n",
      " |      2  2015-05-06     6\n",
      " |      3  2015-05-05     1\n",
      " |      4  2015-05-08    50\n",
      " |      5  2015-05-07   100\n",
      " |      6  2015-05-06    60\n",
      " |      7  2015-05-05   120\n",
      " |      >>> df.groupby('Date')['Data'].transform('sum')\n",
      " |      0     55\n",
      " |      1    108\n",
      " |      2     66\n",
      " |      3    121\n",
      " |      4     55\n",
      " |      5    108\n",
      " |      6     66\n",
      " |      7    121\n",
      " |      Name: Data, dtype: int64\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\n",
      " |      ...     \"c\": [1, 1, 1, 2, 2, 2, 2],\n",
      " |      ...     \"type\": [\"m\", \"n\", \"o\", \"m\", \"m\", \"n\", \"n\"]\n",
      " |      ... })\n",
      " |      >>> df\n",
      " |         c type\n",
      " |      0  1    m\n",
      " |      1  1    n\n",
      " |      2  1    o\n",
      " |      3  2    m\n",
      " |      4  2    m\n",
      " |      5  2    n\n",
      " |      6  2    n\n",
      " |      >>> df['size'] = df.groupby('c')['type'].transform(len)\n",
      " |      >>> df\n",
      " |         c type size\n",
      " |      0  1    m    3\n",
      " |      1  1    n    3\n",
      " |      2  1    o    3\n",
      " |      3  2    m    4\n",
      " |      4  2    m    4\n",
      " |      5  2    n    4\n",
      " |      6  2    n    4\n",
      " |  \n",
      " |  truediv(self, other, level=None, fill_value=None, axis: 'Axis' = 0) -> 'Series'\n",
      " |      Return Floating division of series and other, element-wise (binary operator `truediv`).\n",
      " |      \n",
      " |      Equivalent to ``series / other``, but with support to substitute a fill_value for\n",
      " |      missing data in either one of the inputs.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or scalar value\n",
      " |      level : int or name\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      fill_value : None or float value, default None (NaN)\n",
      " |          Fill existing missing (NaN) values, and any new element needed for\n",
      " |          successful Series alignment, with this value before computation.\n",
      " |          If data in both corresponding Series locations is missing\n",
      " |          the result of filling (at that location) will be missing.\n",
      " |      axis : {0 or 'index'}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          The result of the operation.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rtruediv : Reverse of the Floating division operator, see\n",
      " |          `Python documentation\n",
      " |          <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n",
      " |          for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n",
      " |      >>> a\n",
      " |      a    1.0\n",
      " |      b    1.0\n",
      " |      c    1.0\n",
      " |      d    NaN\n",
      " |      dtype: float64\n",
      " |      >>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n",
      " |      >>> b\n",
      " |      a    1.0\n",
      " |      b    NaN\n",
      " |      d    1.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |      >>> a.divide(b, fill_value=0)\n",
      " |      a    1.0\n",
      " |      b    inf\n",
      " |      c    inf\n",
      " |      d    0.0\n",
      " |      e    NaN\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  unique(self) -> 'ArrayLike'\n",
      " |      Return unique values of Series object.\n",
      " |      \n",
      " |      Uniques are returned in order of appearance. Hash table-based unique,\n",
      " |      therefore does NOT sort.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      ndarray or ExtensionArray\n",
      " |          The unique values returned as a NumPy array. See Notes.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.drop_duplicates : Return Series with duplicate values removed.\n",
      " |      unique : Top-level unique method for any 1-d array-like object.\n",
      " |      Index.unique : Return Index with unique values from an Index object.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Returns the unique values as a NumPy array. In case of an\n",
      " |      extension-array backed Series, a new\n",
      " |      :class:`~api.extensions.ExtensionArray` of that type with just\n",
      " |      the unique values is returned. This includes\n",
      " |      \n",
      " |          * Categorical\n",
      " |          * Period\n",
      " |          * Datetime with Timezone\n",
      " |          * Datetime without Timezone\n",
      " |          * Timedelta\n",
      " |          * Interval\n",
      " |          * Sparse\n",
      " |          * IntegerNA\n",
      " |      \n",
      " |      See Examples section.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> pd.Series([2, 1, 3, 3], name='A').unique()\n",
      " |      array([2, 1, 3])\n",
      " |      \n",
      " |      >>> pd.Series([pd.Timestamp('2016-01-01') for _ in range(3)]).unique()\n",
      " |      <DatetimeArray>\n",
      " |      ['2016-01-01 00:00:00']\n",
      " |      Length: 1, dtype: datetime64[ns]\n",
      " |      \n",
      " |      >>> pd.Series([pd.Timestamp('2016-01-01', tz='US/Eastern')\n",
      " |      ...            for _ in range(3)]).unique()\n",
      " |      <DatetimeArray>\n",
      " |      ['2016-01-01 00:00:00-05:00']\n",
      " |      Length: 1, dtype: datetime64[ns, US/Eastern]\n",
      " |      \n",
      " |      An Categorical will return categories in the order of\n",
      " |      appearance and with the same dtype.\n",
      " |      \n",
      " |      >>> pd.Series(pd.Categorical(list('baabc'))).unique()\n",
      " |      ['b', 'a', 'c']\n",
      " |      Categories (3, object): ['a', 'b', 'c']\n",
      " |      >>> pd.Series(pd.Categorical(list('baabc'), categories=list('abc'),\n",
      " |      ...                          ordered=True)).unique()\n",
      " |      ['b', 'a', 'c']\n",
      " |      Categories (3, object): ['a' < 'b' < 'c']\n",
      " |  \n",
      " |  unstack(self, level: 'IndexLabel' = -1, fill_value: 'Hashable | None' = None, sort: 'bool' = True) -> 'DataFrame'\n",
      " |      Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      level : int, str, or list of these, default last level\n",
      " |          Level(s) to unstack, can pass level name.\n",
      " |      fill_value : scalar value, default None\n",
      " |          Value to use when replacing NaN values.\n",
      " |      sort : bool, default True\n",
      " |          Sort the level(s) in the resulting MultiIndex columns.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      DataFrame\n",
      " |          Unstacked Series.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Reference :ref:`the user guide <reshaping.stacking>` for more examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4],\n",
      " |      ...               index=pd.MultiIndex.from_product([['one', 'two'],\n",
      " |      ...                                                 ['a', 'b']]))\n",
      " |      >>> s\n",
      " |      one  a    1\n",
      " |           b    2\n",
      " |      two  a    3\n",
      " |           b    4\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.unstack(level=-1)\n",
      " |           a  b\n",
      " |      one  1  2\n",
      " |      two  3  4\n",
      " |      \n",
      " |      >>> s.unstack(level=0)\n",
      " |         one  two\n",
      " |      a    1    3\n",
      " |      b    2    4\n",
      " |  \n",
      " |  update(self, other: 'Series | Sequence | Mapping') -> 'None'\n",
      " |      Modify Series in place using values from passed Series.\n",
      " |      \n",
      " |      Uses non-NA values from passed Series to make updates. Aligns\n",
      " |      on index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series, or object coercible into Series\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.update(pd.Series([4, 5, 6]))\n",
      " |      >>> s\n",
      " |      0    4\n",
      " |      1    5\n",
      " |      2    6\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s = pd.Series(['a', 'b', 'c'])\n",
      " |      >>> s.update(pd.Series(['d', 'e'], index=[0, 2]))\n",
      " |      >>> s\n",
      " |      0    d\n",
      " |      1    b\n",
      " |      2    e\n",
      " |      dtype: object\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.update(pd.Series([4, 5, 6, 7, 8]))\n",
      " |      >>> s\n",
      " |      0    4\n",
      " |      1    5\n",
      " |      2    6\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      If ``other`` contains NaNs the corresponding values are not updated\n",
      " |      in the original Series.\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.update(pd.Series([4, np.nan, 6]))\n",
      " |      >>> s\n",
      " |      0    4\n",
      " |      1    2\n",
      " |      2    6\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      ``other`` can also be a non-Series object type\n",
      " |      that is coercible into a Series\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.update([4, np.nan, 6])\n",
      " |      >>> s\n",
      " |      0    4\n",
      " |      1    2\n",
      " |      2    6\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.update({1: 9})\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    9\n",
      " |      2    3\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  var(self, axis: 'Axis | None' = None, skipna: 'bool' = True, ddof: 'int' = 1, numeric_only: 'bool' = False, **kwargs)\n",
      " |      Return unbiased variance over requested axis.\n",
      " |      \n",
      " |      Normalized by N-1 by default. This can be changed using the ddof argument.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {index (0)}\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          .. warning::\n",
      " |      \n",
      " |              The behavior of DataFrame.var with ``axis=None`` is deprecated,\n",
      " |              in a future version this will reduce over both axes and return a scalar\n",
      " |              To retain the old behavior, pass axis=0 (or do not pass axis).\n",
      " |      \n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values. If an entire row/column is NA, the result\n",
      " |          will be NA.\n",
      " |      ddof : int, default 1\n",
      " |          Delta Degrees of Freedom. The divisor used in calculations is N - ddof,\n",
      " |          where N represents the number of elements.\n",
      " |      numeric_only : bool, default False\n",
      " |          Include only float, int, boolean columns. Not implemented for Series.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar or Series (if level specified) \n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'person_id': [0, 1, 2, 3],\n",
      " |      ...                    'age': [21, 25, 62, 43],\n",
      " |      ...                    'height': [1.61, 1.87, 1.49, 2.01]}\n",
      " |      ...                   ).set_index('person_id')\n",
      " |      >>> df\n",
      " |                 age  height\n",
      " |      person_id\n",
      " |      0           21    1.61\n",
      " |      1           25    1.87\n",
      " |      2           62    1.49\n",
      " |      3           43    2.01\n",
      " |      \n",
      " |      >>> df.var()\n",
      " |      age       352.916667\n",
      " |      height      0.056367\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Alternatively, ``ddof=0`` can be set to normalize by N instead of N-1:\n",
      " |      \n",
      " |      >>> df.var(ddof=0)\n",
      " |      age       264.687500\n",
      " |      height      0.042275\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  view(self, dtype: 'Dtype | None' = None) -> 'Series'\n",
      " |      Create a new view of the Series.\n",
      " |      \n",
      " |      .. deprecated:: 2.2.0\n",
      " |          ``Series.view`` is deprecated and will be removed in a future version.\n",
      " |          Use :meth:`Series.astype` as an alternative to change the dtype.\n",
      " |      \n",
      " |      This function will return a new Series with a view of the same\n",
      " |      underlying values in memory, optionally reinterpreted with a new data\n",
      " |      type. The new data type must preserve the same size in bytes as to not\n",
      " |      cause index misalignment.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : data type\n",
      " |          Data type object or one of their string representations.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |          A new Series object as a view of the same data in memory.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ndarray.view : Equivalent numpy function to create a new view of\n",
      " |          the same data in memory.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Series are instantiated with ``dtype=float64`` by default. While\n",
      " |      ``numpy.ndarray.view()`` will return a view with the same data type as\n",
      " |      the original array, ``Series.view()`` (without specified dtype)\n",
      " |      will try using ``float64`` and may fail if the original data type size\n",
      " |      in bytes is not the same.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Use ``astype`` to change the dtype instead.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  array\n",
      " |      The ExtensionArray of the data backing this Series or Index.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      ExtensionArray\n",
      " |          An ExtensionArray of the values stored within. For extension\n",
      " |          types, this is the actual array. For NumPy native types, this\n",
      " |          is a thin (no copy) wrapper around :class:`numpy.ndarray`.\n",
      " |      \n",
      " |          ``.array`` differs from ``.values``, which may require converting\n",
      " |          the data to a different form.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Index.to_numpy : Similar method that always returns a NumPy array.\n",
      " |      Series.to_numpy : Similar method that always returns a NumPy array.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This table lays out the different array types for each extension\n",
      " |      dtype within pandas.\n",
      " |      \n",
      " |      ================== =============================\n",
      " |      dtype              array type\n",
      " |      ================== =============================\n",
      " |      category           Categorical\n",
      " |      period             PeriodArray\n",
      " |      interval           IntervalArray\n",
      " |      IntegerNA          IntegerArray\n",
      " |      string             StringArray\n",
      " |      boolean            BooleanArray\n",
      " |      datetime64[ns, tz] DatetimeArray\n",
      " |      ================== =============================\n",
      " |      \n",
      " |      For any 3rd-party extension types, the array type will be an\n",
      " |      ExtensionArray.\n",
      " |      \n",
      " |      For all remaining dtypes ``.array`` will be a\n",
      " |      :class:`arrays.NumpyExtensionArray` wrapping the actual ndarray\n",
      " |      stored within. If you absolutely need a NumPy array (possibly with\n",
      " |      copying / coercing data), then use :meth:`Series.to_numpy` instead.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For regular NumPy types like int, and float, a NumpyExtensionArray\n",
      " |      is returned.\n",
      " |      \n",
      " |      >>> pd.Series([1, 2, 3]).array\n",
      " |      <NumpyExtensionArray>\n",
      " |      [1, 2, 3]\n",
      " |      Length: 3, dtype: int64\n",
      " |      \n",
      " |      For extension types, like Categorical, the actual ExtensionArray\n",
      " |      is returned\n",
      " |      \n",
      " |      >>> ser = pd.Series(pd.Categorical(['a', 'b', 'a']))\n",
      " |      >>> ser.array\n",
      " |      ['a', 'b', 'a']\n",
      " |      Categories (2, object): ['a', 'b']\n",
      " |  \n",
      " |  axes\n",
      " |      Return a list of the row axis labels.\n",
      " |  \n",
      " |  dtype\n",
      " |      Return the dtype object of the underlying data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.dtype\n",
      " |      dtype('int64')\n",
      " |  \n",
      " |  dtypes\n",
      " |      Return the dtype object of the underlying data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.dtypes\n",
      " |      dtype('int64')\n",
      " |  \n",
      " |  hasnans\n",
      " |      Return True if there are any NaNs.\n",
      " |      \n",
      " |      Enables various performance speedups.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, None])\n",
      " |      >>> s\n",
      " |      0    1.0\n",
      " |      1    2.0\n",
      " |      2    3.0\n",
      " |      3    NaN\n",
      " |      dtype: float64\n",
      " |      >>> s.hasnans\n",
      " |      True\n",
      " |  \n",
      " |  values\n",
      " |      Return Series as ndarray or ndarray-like depending on the dtype.\n",
      " |      \n",
      " |      .. warning::\n",
      " |      \n",
      " |         We recommend using :attr:`Series.array` or\n",
      " |         :meth:`Series.to_numpy`, depending on whether you need\n",
      " |         a reference to the underlying data or a NumPy array.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      numpy.ndarray or ndarray-like\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.array : Reference to the underlying data.\n",
      " |      Series.to_numpy : A NumPy array representing the underlying data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> pd.Series([1, 2, 3]).values\n",
      " |      array([1, 2, 3])\n",
      " |      \n",
      " |      >>> pd.Series(list('aabc')).values\n",
      " |      array(['a', 'a', 'b', 'c'], dtype=object)\n",
      " |      \n",
      " |      >>> pd.Series(list('aabc')).astype('category').values\n",
      " |      ['a', 'a', 'b', 'c']\n",
      " |      Categories (3, object): ['a', 'b', 'c']\n",
      " |      \n",
      " |      Timezone aware datetime data is converted to UTC:\n",
      " |      \n",
      " |      >>> pd.Series(pd.date_range('20130101', periods=3,\n",
      " |      ...                         tz='US/Eastern')).values\n",
      " |      array(['2013-01-01T05:00:00.000000000',\n",
      " |             '2013-01-02T05:00:00.000000000',\n",
      " |             '2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]')\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  index\n",
      " |      The index (axis labels) of the Series.\n",
      " |      \n",
      " |      The index of a Series is used to label and identify each element of the\n",
      " |      underlying data. The index can be thought of as an immutable ordered set\n",
      " |      (technically a multi-set, as it may contain duplicate labels), and is\n",
      " |      used to index and align data in pandas.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Index\n",
      " |          The index labels of the Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.reindex : Conform Series to new index.\n",
      " |      Index : The base pandas index type.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For more information on pandas indexing, see the `indexing user guide\n",
      " |      <https://pandas.pydata.org/docs/user_guide/indexing.html>`__.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      To create a Series with a custom index and view the index labels:\n",
      " |      \n",
      " |      >>> cities = ['Kolkata', 'Chicago', 'Toronto', 'Lisbon']\n",
      " |      >>> populations = [14.85, 2.71, 2.93, 0.51]\n",
      " |      >>> city_series = pd.Series(populations, index=cities)\n",
      " |      >>> city_series.index\n",
      " |      Index(['Kolkata', 'Chicago', 'Toronto', 'Lisbon'], dtype='object')\n",
      " |      \n",
      " |      To change the index labels of an existing Series:\n",
      " |      \n",
      " |      >>> city_series.index = ['KOL', 'CHI', 'TOR', 'LIS']\n",
      " |      >>> city_series.index\n",
      " |      Index(['KOL', 'CHI', 'TOR', 'LIS'], dtype='object')\n",
      " |  \n",
      " |  name\n",
      " |      Return the name of the Series.\n",
      " |      \n",
      " |      The name of a Series becomes its index or column name if it is used\n",
      " |      to form a DataFrame. It is also used whenever displaying the Series\n",
      " |      using the interpreter.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      label (hashable object)\n",
      " |          The name of the Series, also the column name if part of a DataFrame.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.rename : Sets the Series name when given a scalar input.\n",
      " |      Index.name : Corresponding Index property.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      The Series name can be set initially when calling the constructor.\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3], dtype=np.int64, name='Numbers')\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      Name: Numbers, dtype: int64\n",
      " |      >>> s.name = \"Integers\"\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      Name: Integers, dtype: int64\n",
      " |      \n",
      " |      The name of a Series within a DataFrame is its column name.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[1, 2], [3, 4], [5, 6]],\n",
      " |      ...                   columns=[\"Odd Numbers\", \"Even Numbers\"])\n",
      " |      >>> df\n",
      " |         Odd Numbers  Even Numbers\n",
      " |      0            1             2\n",
      " |      1            3             4\n",
      " |      2            5             6\n",
      " |      >>> df[\"Even Numbers\"].name\n",
      " |      'Even Numbers'\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {'_AXIS_ORDERS': \"list[Literal['index', 'columns']]\"...\n",
      " |  \n",
      " |  __pandas_priority__ = 3000\n",
      " |  \n",
      " |  cat = <class 'pandas.core.arrays.categorical.CategoricalAccessor'>\n",
      " |      Accessor object for categorical properties of the Series values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      data : Series or CategoricalIndex\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(list(\"abbccc\")).astype(\"category\")\n",
      " |      >>> s\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (3, object): ['a', 'b', 'c']\n",
      " |      \n",
      " |      >>> s.cat.categories\n",
      " |      Index(['a', 'b', 'c'], dtype='object')\n",
      " |      \n",
      " |      >>> s.cat.rename_categories(list(\"cba\"))\n",
      " |      0    c\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    a\n",
      " |      4    a\n",
      " |      5    a\n",
      " |      dtype: category\n",
      " |      Categories (3, object): ['c', 'b', 'a']\n",
      " |      \n",
      " |      >>> s.cat.reorder_categories(list(\"cba\"))\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (3, object): ['c', 'b', 'a']\n",
      " |      \n",
      " |      >>> s.cat.add_categories([\"d\", \"e\"])\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (5, object): ['a', 'b', 'c', 'd', 'e']\n",
      " |      \n",
      " |      >>> s.cat.remove_categories([\"a\", \"c\"])\n",
      " |      0    NaN\n",
      " |      1      b\n",
      " |      2      b\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      5    NaN\n",
      " |      dtype: category\n",
      " |      Categories (1, object): ['b']\n",
      " |      \n",
      " |      >>> s1 = s.cat.add_categories([\"d\", \"e\"])\n",
      " |      >>> s1.cat.remove_unused_categories()\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (3, object): ['a', 'b', 'c']\n",
      " |      \n",
      " |      >>> s.cat.set_categories(list(\"abcde\"))\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (5, object): ['a', 'b', 'c', 'd', 'e']\n",
      " |      \n",
      " |      >>> s.cat.as_ordered()\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (3, object): ['a' < 'b' < 'c']\n",
      " |      \n",
      " |      >>> s.cat.as_unordered()\n",
      " |      0    a\n",
      " |      1    b\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    c\n",
      " |      5    c\n",
      " |      dtype: category\n",
      " |      Categories (3, object): ['a', 'b', 'c']\n",
      " |  \n",
      " |  \n",
      " |  dt = <class 'pandas.core.indexes.accessors.CombinedDatetimelikePropert...\n",
      " |  \n",
      " |  list = <class 'pandas.core.arrays.arrow.accessors.ListAccessor'>\n",
      " |      Accessor object for list data properties of the Series values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      data : Series\n",
      " |          Series containing Arrow list data.\n",
      " |  \n",
      " |  \n",
      " |  plot = <class 'pandas.plotting._core.PlotAccessor'>\n",
      " |      Make plots of Series or DataFrame.\n",
      " |      \n",
      " |      Uses the backend specified by the\n",
      " |      option ``plotting.backend``. By default, matplotlib is used.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      data : Series or DataFrame\n",
      " |          The object for which the method is called.\n",
      " |      x : label or position, default None\n",
      " |          Only used if data is a DataFrame.\n",
      " |      y : label, position or list of label, positions, default None\n",
      " |          Allows plotting of one column versus another. Only used if data is a\n",
      " |          DataFrame.\n",
      " |      kind : str\n",
      " |          The kind of plot to produce:\n",
      " |      \n",
      " |          - 'line' : line plot (default)\n",
      " |          - 'bar' : vertical bar plot\n",
      " |          - 'barh' : horizontal bar plot\n",
      " |          - 'hist' : histogram\n",
      " |          - 'box' : boxplot\n",
      " |          - 'kde' : Kernel Density Estimation plot\n",
      " |          - 'density' : same as 'kde'\n",
      " |          - 'area' : area plot\n",
      " |          - 'pie' : pie plot\n",
      " |          - 'scatter' : scatter plot (DataFrame only)\n",
      " |          - 'hexbin' : hexbin plot (DataFrame only)\n",
      " |      ax : matplotlib axes object, default None\n",
      " |          An axes of the current figure.\n",
      " |      subplots : bool or sequence of iterables, default False\n",
      " |          Whether to group columns into subplots:\n",
      " |      \n",
      " |          - ``False`` : No subplots will be used\n",
      " |          - ``True`` : Make separate subplots for each column.\n",
      " |          - sequence of iterables of column labels: Create a subplot for each\n",
      " |            group of columns. For example `[('a', 'c'), ('b', 'd')]` will\n",
      " |            create 2 subplots: one with columns 'a' and 'c', and one\n",
      " |            with columns 'b' and 'd'. Remaining columns that aren't specified\n",
      " |            will be plotted in additional subplots (one per column).\n",
      " |      \n",
      " |            .. versionadded:: 1.5.0\n",
      " |      \n",
      " |      sharex : bool, default True if ax is None else False\n",
      " |          In case ``subplots=True``, share x axis and set some x axis labels\n",
      " |          to invisible; defaults to True if ax is None otherwise False if\n",
      " |          an ax is passed in; Be aware, that passing in both an ax and\n",
      " |          ``sharex=True`` will alter all x axis labels for all axis in a figure.\n",
      " |      sharey : bool, default False\n",
      " |          In case ``subplots=True``, share y axis and set some y axis labels to invisible.\n",
      " |      layout : tuple, optional\n",
      " |          (rows, columns) for the layout of subplots.\n",
      " |      figsize : a tuple (width, height) in inches\n",
      " |          Size of a figure object.\n",
      " |      use_index : bool, default True\n",
      " |          Use index as ticks for x axis.\n",
      " |      title : str or list\n",
      " |          Title to use for the plot. If a string is passed, print the string\n",
      " |          at the top of the figure. If a list is passed and `subplots` is\n",
      " |          True, print each item in the list above the corresponding subplot.\n",
      " |      grid : bool, default None (matlab style default)\n",
      " |          Axis grid lines.\n",
      " |      legend : bool or {'reverse'}\n",
      " |          Place legend on axis subplots.\n",
      " |      style : list or dict\n",
      " |          The matplotlib line style per column.\n",
      " |      logx : bool or 'sym', default False\n",
      " |          Use log scaling or symlog scaling on x axis.\n",
      " |      \n",
      " |      logy : bool or 'sym' default False\n",
      " |          Use log scaling or symlog scaling on y axis.\n",
      " |      \n",
      " |      loglog : bool or 'sym', default False\n",
      " |          Use log scaling or symlog scaling on both x and y axes.\n",
      " |      \n",
      " |      xticks : sequence\n",
      " |          Values to use for the xticks.\n",
      " |      yticks : sequence\n",
      " |          Values to use for the yticks.\n",
      " |      xlim : 2-tuple/list\n",
      " |          Set the x limits of the current axes.\n",
      " |      ylim : 2-tuple/list\n",
      " |          Set the y limits of the current axes.\n",
      " |      xlabel : label, optional\n",
      " |          Name to use for the xlabel on x-axis. Default uses index name as xlabel, or the\n",
      " |          x-column name for planar plots.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |      \n",
      " |              Now applicable to histograms.\n",
      " |      \n",
      " |      ylabel : label, optional\n",
      " |          Name to use for the ylabel on y-axis. Default will show no ylabel, or the\n",
      " |          y-column name for planar plots.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |      \n",
      " |              Now applicable to histograms.\n",
      " |      \n",
      " |      rot : float, default None\n",
      " |          Rotation for ticks (xticks for vertical, yticks for horizontal\n",
      " |          plots).\n",
      " |      fontsize : float, default None\n",
      " |          Font size for xticks and yticks.\n",
      " |      colormap : str or matplotlib colormap object, default None\n",
      " |          Colormap to select colors from. If string, load colormap with that\n",
      " |          name from matplotlib.\n",
      " |      colorbar : bool, optional\n",
      " |          If True, plot colorbar (only relevant for 'scatter' and 'hexbin'\n",
      " |          plots).\n",
      " |      position : float\n",
      " |          Specify relative alignments for bar plot layout.\n",
      " |          From 0 (left/bottom-end) to 1 (right/top-end). Default is 0.5\n",
      " |          (center).\n",
      " |      table : bool, Series or DataFrame, default False\n",
      " |          If True, draw a table using the data in the DataFrame and the data\n",
      " |          will be transposed to meet matplotlib's default layout.\n",
      " |          If a Series or DataFrame is passed, use passed data to draw a\n",
      " |          table.\n",
      " |      yerr : DataFrame, Series, array-like, dict and str\n",
      " |          See :ref:`Plotting with Error Bars <visualization.errorbars>` for\n",
      " |          detail.\n",
      " |      xerr : DataFrame, Series, array-like, dict and str\n",
      " |          Equivalent to yerr.\n",
      " |      stacked : bool, default False in line and bar plots, and True in area plot\n",
      " |          If True, create stacked plot.\n",
      " |      secondary_y : bool or sequence, default False\n",
      " |          Whether to plot on the secondary y-axis if a list/tuple, which\n",
      " |          columns to plot on secondary y-axis.\n",
      " |      mark_right : bool, default True\n",
      " |          When using a secondary_y axis, automatically mark the column\n",
      " |          labels with \"(right)\" in the legend.\n",
      " |      include_bool : bool, default is False\n",
      " |          If True, boolean values can be plotted.\n",
      " |      backend : str, default None\n",
      " |          Backend to use instead of the backend specified in the option\n",
      " |          ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to\n",
      " |          specify the ``plotting.backend`` for the whole session, set\n",
      " |          ``pd.options.plotting.backend``.\n",
      " |      **kwargs\n",
      " |          Options to pass to matplotlib plotting method.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      :class:`matplotlib.axes.Axes` or numpy.ndarray of them\n",
      " |          If the backend is not the default matplotlib one, the return value\n",
      " |          will be the object returned by the backend.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      - See matplotlib documentation online for more on this subject\n",
      " |      - If `kind` = 'bar' or 'barh', you can specify relative alignments\n",
      " |        for bar plot layout by `position` keyword.\n",
      " |        From 0 (left/bottom-end) to 1 (right/top-end). Default is 0.5\n",
      " |        (center)\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      .. plot::\n",
      " |          :context: close-figs\n",
      " |      \n",
      " |          >>> ser = pd.Series([1, 2, 3, 3])\n",
      " |          >>> plot = ser.plot(kind='hist', title=\"My plot\")\n",
      " |      \n",
      " |      For DataFrame:\n",
      " |      \n",
      " |      .. plot::\n",
      " |          :context: close-figs\n",
      " |      \n",
      " |          >>> df = pd.DataFrame({'length': [1.5, 0.5, 1.2, 0.9, 3],\n",
      " |          ...                   'width': [0.7, 0.2, 0.15, 0.2, 1.1]},\n",
      " |          ...                   index=['pig', 'rabbit', 'duck', 'chicken', 'horse'])\n",
      " |          >>> plot = df.plot(title=\"DataFrame Plot\")\n",
      " |      \n",
      " |      For SeriesGroupBy:\n",
      " |      \n",
      " |      .. plot::\n",
      " |          :context: close-figs\n",
      " |      \n",
      " |          >>> lst = [-1, -2, -3, 1, 2, 3]\n",
      " |          >>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)\n",
      " |          >>> plot = ser.groupby(lambda x: x > 0).plot(title=\"SeriesGroupBy Plot\")\n",
      " |      \n",
      " |      For DataFrameGroupBy:\n",
      " |      \n",
      " |      .. plot::\n",
      " |          :context: close-figs\n",
      " |      \n",
      " |          >>> df = pd.DataFrame({\"col1\" : [1, 2, 3, 4],\n",
      " |          ...                   \"col2\" : [\"A\", \"B\", \"A\", \"B\"]})\n",
      " |          >>> plot = df.groupby(\"col2\").plot(kind=\"bar\", title=\"DataFrameGroupBy Plot\")\n",
      " |  \n",
      " |  \n",
      " |  sparse = <class 'pandas.core.arrays.sparse.accessor.SparseAccessor'>\n",
      " |      Accessor for SparseSparse from other sparse matrix data types.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series([0, 0, 2, 2, 2], dtype=\"Sparse[int]\")\n",
      " |      >>> ser.sparse.density\n",
      " |      0.6\n",
      " |      >>> ser.sparse.sp_values\n",
      " |      array([2, 2, 2])\n",
      " |  \n",
      " |  \n",
      " |  str = <class 'pandas.core.strings.accessor.StringMethods'>\n",
      " |      Vectorized string functions for Series and Index.\n",
      " |      \n",
      " |      NAs stay NA unless handled otherwise by a particular method.\n",
      " |      Patterned after Python's string methods, with some inspiration from\n",
      " |      R's stringr package.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([\"A_Str_Series\"])\n",
      " |      >>> s\n",
      " |      0    A_Str_Series\n",
      " |      dtype: object\n",
      " |      \n",
      " |      >>> s.str.split(\"_\")\n",
      " |      0    [A, Str, Series]\n",
      " |      dtype: object\n",
      " |      \n",
      " |      >>> s.str.replace(\"_\", \"\")\n",
      " |      0    AStrSeries\n",
      " |      dtype: object\n",
      " |  \n",
      " |  \n",
      " |  struct = <class 'pandas.core.arrays.arrow.accessors.StructAccessor'>\n",
      " |      Accessor object for structured data properties of the Series values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      data : Series\n",
      " |          Series containing Arrow struct data.\n",
      " |  \n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from pandas.core.base.IndexOpsMixin:\n",
      " |  \n",
      " |  __iter__(self) -> 'Iterator'\n",
      " |      Return an iterator of the values.\n",
      " |      \n",
      " |      These are each a scalar type, which is a Python scalar\n",
      " |      (for str, int, float) or a pandas scalar\n",
      " |      (for Timestamp/Timedelta/Interval/Period)\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      iterator\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> for x in s:\n",
      " |      ...     print(x)\n",
      " |      1\n",
      " |      2\n",
      " |      3\n",
      " |  \n",
      " |  argmax(self, axis: 'AxisInt | None' = None, skipna: 'bool' = True, *args, **kwargs) -> 'int'\n",
      " |      Return int position of the largest value in the Series.\n",
      " |      \n",
      " |      If the maximum is achieved in multiple locations,\n",
      " |      the first row position is returned.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {None}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when showing the result.\n",
      " |      *args, **kwargs\n",
      " |          Additional arguments and keywords for compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int\n",
      " |          Row position of the maximum value.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.argmax : Return position of the maximum value.\n",
      " |      Series.argmin : Return position of the minimum value.\n",
      " |      numpy.ndarray.argmax : Equivalent method for numpy arrays.\n",
      " |      Series.idxmax : Return index label of the maximum values.\n",
      " |      Series.idxmin : Return index label of the minimum values.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Consider dataset containing cereal calories\n",
      " |      \n",
      " |      >>> s = pd.Series({'Corn Flakes': 100.0, 'Almond Delight': 110.0,\n",
      " |      ...                'Cinnamon Toast Crunch': 120.0, 'Cocoa Puff': 110.0})\n",
      " |      >>> s\n",
      " |      Corn Flakes              100.0\n",
      " |      Almond Delight           110.0\n",
      " |      Cinnamon Toast Crunch    120.0\n",
      " |      Cocoa Puff               110.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.argmax()\n",
      " |      2\n",
      " |      >>> s.argmin()\n",
      " |      0\n",
      " |      \n",
      " |      The maximum cereal calories is the third element and\n",
      " |      the minimum cereal calories is the first element,\n",
      " |      since series is zero-indexed.\n",
      " |  \n",
      " |  argmin(self, axis: 'AxisInt | None' = None, skipna: 'bool' = True, *args, **kwargs) -> 'int'\n",
      " |      Return int position of the smallest value in the Series.\n",
      " |      \n",
      " |      If the minimum is achieved in multiple locations,\n",
      " |      the first row position is returned.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {None}\n",
      " |          Unused. Parameter needed for compatibility with DataFrame.\n",
      " |      skipna : bool, default True\n",
      " |          Exclude NA/null values when showing the result.\n",
      " |      *args, **kwargs\n",
      " |          Additional arguments and keywords for compatibility with NumPy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int\n",
      " |          Row position of the minimum value.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.argmin : Return position of the minimum value.\n",
      " |      Series.argmax : Return position of the maximum value.\n",
      " |      numpy.ndarray.argmin : Equivalent method for numpy arrays.\n",
      " |      Series.idxmax : Return index label of the maximum values.\n",
      " |      Series.idxmin : Return index label of the minimum values.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Consider dataset containing cereal calories\n",
      " |      \n",
      " |      >>> s = pd.Series({'Corn Flakes': 100.0, 'Almond Delight': 110.0,\n",
      " |      ...                'Cinnamon Toast Crunch': 120.0, 'Cocoa Puff': 110.0})\n",
      " |      >>> s\n",
      " |      Corn Flakes              100.0\n",
      " |      Almond Delight           110.0\n",
      " |      Cinnamon Toast Crunch    120.0\n",
      " |      Cocoa Puff               110.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.argmax()\n",
      " |      2\n",
      " |      >>> s.argmin()\n",
      " |      0\n",
      " |      \n",
      " |      The maximum cereal calories is the third element and\n",
      " |      the minimum cereal calories is the first element,\n",
      " |      since series is zero-indexed.\n",
      " |  \n",
      " |  factorize(self, sort: 'bool' = False, use_na_sentinel: 'bool' = True) -> 'tuple[npt.NDArray[np.intp], Index]'\n",
      " |      Encode the object as an enumerated type or categorical variable.\n",
      " |      \n",
      " |      This method is useful for obtaining a numeric representation of an\n",
      " |      array when all that matters is identifying distinct values. `factorize`\n",
      " |      is available as both a top-level function :func:`pandas.factorize`,\n",
      " |      and as a method :meth:`Series.factorize` and :meth:`Index.factorize`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      sort : bool, default False\n",
      " |          Sort `uniques` and shuffle `codes` to maintain the\n",
      " |          relationship.\n",
      " |      \n",
      " |      use_na_sentinel : bool, default True\n",
      " |          If True, the sentinel -1 will be used for NaN values. If False,\n",
      " |          NaN values will be encoded as non-negative integers and will not drop the\n",
      " |          NaN from the uniques of the values.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      codes : ndarray\n",
      " |          An integer ndarray that's an indexer into `uniques`.\n",
      " |          ``uniques.take(codes)`` will have the same values as `values`.\n",
      " |      uniques : ndarray, Index, or Categorical\n",
      " |          The unique valid values. When `values` is Categorical, `uniques`\n",
      " |          is a Categorical. When `values` is some other pandas object, an\n",
      " |          `Index` is returned. Otherwise, a 1-D ndarray is returned.\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |             Even if there's a missing value in `values`, `uniques` will\n",
      " |             *not* contain an entry for it.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      cut : Discretize continuous-valued array.\n",
      " |      unique : Find the unique value in an array.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Reference :ref:`the user guide <reshaping.factorize>` for more examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      These examples all show factorize as a top-level method like\n",
      " |      ``pd.factorize(values)``. The results are identical for methods like\n",
      " |      :meth:`Series.factorize`.\n",
      " |      \n",
      " |      >>> codes, uniques = pd.factorize(np.array(['b', 'b', 'a', 'c', 'b'], dtype=\"O\"))\n",
      " |      >>> codes\n",
      " |      array([0, 0, 1, 2, 0])\n",
      " |      >>> uniques\n",
      " |      array(['b', 'a', 'c'], dtype=object)\n",
      " |      \n",
      " |      With ``sort=True``, the `uniques` will be sorted, and `codes` will be\n",
      " |      shuffled so that the relationship is the maintained.\n",
      " |      \n",
      " |      >>> codes, uniques = pd.factorize(np.array(['b', 'b', 'a', 'c', 'b'], dtype=\"O\"),\n",
      " |      ...                               sort=True)\n",
      " |      >>> codes\n",
      " |      array([1, 1, 0, 2, 1])\n",
      " |      >>> uniques\n",
      " |      array(['a', 'b', 'c'], dtype=object)\n",
      " |      \n",
      " |      When ``use_na_sentinel=True`` (the default), missing values are indicated in\n",
      " |      the `codes` with the sentinel value ``-1`` and missing values are not\n",
      " |      included in `uniques`.\n",
      " |      \n",
      " |      >>> codes, uniques = pd.factorize(np.array(['b', None, 'a', 'c', 'b'], dtype=\"O\"))\n",
      " |      >>> codes\n",
      " |      array([ 0, -1,  1,  2,  0])\n",
      " |      >>> uniques\n",
      " |      array(['b', 'a', 'c'], dtype=object)\n",
      " |      \n",
      " |      Thus far, we've only factorized lists (which are internally coerced to\n",
      " |      NumPy arrays). When factorizing pandas objects, the type of `uniques`\n",
      " |      will differ. For Categoricals, a `Categorical` is returned.\n",
      " |      \n",
      " |      >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c'])\n",
      " |      >>> codes, uniques = pd.factorize(cat)\n",
      " |      >>> codes\n",
      " |      array([0, 0, 1])\n",
      " |      >>> uniques\n",
      " |      ['a', 'c']\n",
      " |      Categories (3, object): ['a', 'b', 'c']\n",
      " |      \n",
      " |      Notice that ``'b'`` is in ``uniques.categories``, despite not being\n",
      " |      present in ``cat.values``.\n",
      " |      \n",
      " |      For all other pandas objects, an Index of the appropriate type is\n",
      " |      returned.\n",
      " |      \n",
      " |      >>> cat = pd.Series(['a', 'a', 'c'])\n",
      " |      >>> codes, uniques = pd.factorize(cat)\n",
      " |      >>> codes\n",
      " |      array([0, 0, 1])\n",
      " |      >>> uniques\n",
      " |      Index(['a', 'c'], dtype='object')\n",
      " |      \n",
      " |      If NaN is in the values, and we want to include NaN in the uniques of the\n",
      " |      values, it can be achieved by setting ``use_na_sentinel=False``.\n",
      " |      \n",
      " |      >>> values = np.array([1, 2, 1, np.nan])\n",
      " |      >>> codes, uniques = pd.factorize(values)  # default: use_na_sentinel=True\n",
      " |      >>> codes\n",
      " |      array([ 0,  1,  0, -1])\n",
      " |      >>> uniques\n",
      " |      array([1., 2.])\n",
      " |      \n",
      " |      >>> codes, uniques = pd.factorize(values, use_na_sentinel=False)\n",
      " |      >>> codes\n",
      " |      array([0, 1, 0, 2])\n",
      " |      >>> uniques\n",
      " |      array([ 1.,  2., nan])\n",
      " |  \n",
      " |  item(self)\n",
      " |      Return the first element of the underlying data as a Python scalar.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar\n",
      " |          The first element of Series or Index.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ValueError\n",
      " |          If the data is not length = 1.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1])\n",
      " |      >>> s.item()\n",
      " |      1\n",
      " |      \n",
      " |      For an index:\n",
      " |      \n",
      " |      >>> s = pd.Series([1], index=['a'])\n",
      " |      >>> s.index.item()\n",
      " |      'a'\n",
      " |  \n",
      " |  nunique(self, dropna: 'bool' = True) -> 'int'\n",
      " |      Return number of unique elements in the object.\n",
      " |      \n",
      " |      Excludes NA values by default.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dropna : bool, default True\n",
      " |          Don't include NaN in the count.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      int\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.nunique: Method nunique for DataFrame.\n",
      " |      Series.count: Count non-NA/null observations in the Series.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 3, 5, 7, 7])\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    3\n",
      " |      2    5\n",
      " |      3    7\n",
      " |      4    7\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.nunique()\n",
      " |      4\n",
      " |  \n",
      " |  to_list = tolist(self)\n",
      " |  \n",
      " |  to_numpy(self, dtype: 'npt.DTypeLike | None' = None, copy: 'bool' = False, na_value: 'object' = <no_default>, **kwargs) -> 'np.ndarray'\n",
      " |      A NumPy ndarray representing the values in this Series or Index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : str or numpy.dtype, optional\n",
      " |          The dtype to pass to :meth:`numpy.asarray`.\n",
      " |      copy : bool, default False\n",
      " |          Whether to ensure that the returned value is not a view on\n",
      " |          another array. Note that ``copy=False`` does not *ensure* that\n",
      " |          ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that\n",
      " |          a copy is made, even if not strictly necessary.\n",
      " |      na_value : Any, optional\n",
      " |          The value to use for missing values. The default value depends\n",
      " |          on `dtype` and the type of the array.\n",
      " |      **kwargs\n",
      " |          Additional keywords passed through to the ``to_numpy`` method\n",
      " |          of the underlying array (for extension arrays).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      numpy.ndarray\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.array : Get the actual data stored within.\n",
      " |      Index.array : Get the actual data stored within.\n",
      " |      DataFrame.to_numpy : Similar method for DataFrame.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The returned array will be the same up to equality (values equal\n",
      " |      in `self` will be equal in the returned array; likewise for values\n",
      " |      that are not equal). When `self` contains an ExtensionArray, the\n",
      " |      dtype may be different. For example, for a category-dtype Series,\n",
      " |      ``to_numpy()`` will return a NumPy array and the categorical dtype\n",
      " |      will be lost.\n",
      " |      \n",
      " |      For NumPy dtypes, this will be a reference to the actual data stored\n",
      " |      in this Series or Index (assuming ``copy=False``). Modifying the result\n",
      " |      in place will modify the data stored in the Series or Index (not that\n",
      " |      we recommend doing that).\n",
      " |      \n",
      " |      For extension types, ``to_numpy()`` *may* require copying data and\n",
      " |      coercing the result to a NumPy type (possibly object), which may be\n",
      " |      expensive. When you need a no-copy reference to the underlying data,\n",
      " |      :attr:`Series.array` should be used instead.\n",
      " |      \n",
      " |      This table lays out the different dtypes and default return types of\n",
      " |      ``to_numpy()`` for various dtypes within pandas.\n",
      " |      \n",
      " |      ================== ================================\n",
      " |      dtype              array type\n",
      " |      ================== ================================\n",
      " |      category[T]        ndarray[T] (same dtype as input)\n",
      " |      period             ndarray[object] (Periods)\n",
      " |      interval           ndarray[object] (Intervals)\n",
      " |      IntegerNA          ndarray[object]\n",
      " |      datetime64[ns]     datetime64[ns]\n",
      " |      datetime64[ns, tz] ndarray[object] (Timestamps)\n",
      " |      ================== ================================\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> ser = pd.Series(pd.Categorical(['a', 'b', 'a']))\n",
      " |      >>> ser.to_numpy()\n",
      " |      array(['a', 'b', 'a'], dtype=object)\n",
      " |      \n",
      " |      Specify the `dtype` to control how datetime-aware data is represented.\n",
      " |      Use ``dtype=object`` to return an ndarray of pandas :class:`Timestamp`\n",
      " |      objects, each with the correct ``tz``.\n",
      " |      \n",
      " |      >>> ser = pd.Series(pd.date_range('2000', periods=2, tz=\"CET\"))\n",
      " |      >>> ser.to_numpy(dtype=object)\n",
      " |      array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'),\n",
      " |             Timestamp('2000-01-02 00:00:00+0100', tz='CET')],\n",
      " |            dtype=object)\n",
      " |      \n",
      " |      Or ``dtype='datetime64[ns]'`` to return an ndarray of native\n",
      " |      datetime64 values. The values are converted to UTC and the timezone\n",
      " |      info is dropped.\n",
      " |      \n",
      " |      >>> ser.to_numpy(dtype=\"datetime64[ns]\")\n",
      " |      ... # doctest: +ELLIPSIS\n",
      " |      array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00...'],\n",
      " |            dtype='datetime64[ns]')\n",
      " |  \n",
      " |  tolist(self)\n",
      " |      Return a list of the values.\n",
      " |      \n",
      " |      These are each a scalar type, which is a Python scalar\n",
      " |      (for str, int, float) or a pandas scalar\n",
      " |      (for Timestamp/Timedelta/Interval/Period)\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      list\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.ndarray.tolist : Return the array as an a.ndim-levels deep\n",
      " |          nested list of Python scalars.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.to_list()\n",
      " |      [1, 2, 3]\n",
      " |      \n",
      " |      For Index:\n",
      " |      \n",
      " |      >>> idx = pd.Index([1, 2, 3])\n",
      " |      >>> idx\n",
      " |      Index([1, 2, 3], dtype='int64')\n",
      " |      \n",
      " |      >>> idx.to_list()\n",
      " |      [1, 2, 3]\n",
      " |  \n",
      " |  transpose(self, *args, **kwargs) -> 'Self'\n",
      " |      Return the transpose, which is by definition self.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      %(klass)s\n",
      " |  \n",
      " |  value_counts(self, normalize: 'bool' = False, sort: 'bool' = True, ascending: 'bool' = False, bins=None, dropna: 'bool' = True) -> 'Series'\n",
      " |      Return a Series containing counts of unique values.\n",
      " |      \n",
      " |      The resulting object will be in descending order so that the\n",
      " |      first element is the most frequently-occurring element.\n",
      " |      Excludes NA values by default.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      normalize : bool, default False\n",
      " |          If True then the object returned will contain the relative\n",
      " |          frequencies of the unique values.\n",
      " |      sort : bool, default True\n",
      " |          Sort by frequencies when True. Preserve the order of the data when False.\n",
      " |      ascending : bool, default False\n",
      " |          Sort in ascending order.\n",
      " |      bins : int, optional\n",
      " |          Rather than count values, group them into half-open bins,\n",
      " |          a convenience for ``pd.cut``, only works with numeric data.\n",
      " |      dropna : bool, default True\n",
      " |          Don't include counts of NaN.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.count: Number of non-NA elements in a Series.\n",
      " |      DataFrame.count: Number of non-NA elements in a DataFrame.\n",
      " |      DataFrame.value_counts: Equivalent method on DataFrames.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> index = pd.Index([3, 1, 2, 3, 4, np.nan])\n",
      " |      >>> index.value_counts()\n",
      " |      3.0    2\n",
      " |      1.0    1\n",
      " |      2.0    1\n",
      " |      4.0    1\n",
      " |      Name: count, dtype: int64\n",
      " |      \n",
      " |      With `normalize` set to `True`, returns the relative frequency by\n",
      " |      dividing all values by the sum of values.\n",
      " |      \n",
      " |      >>> s = pd.Series([3, 1, 2, 3, 4, np.nan])\n",
      " |      >>> s.value_counts(normalize=True)\n",
      " |      3.0    0.4\n",
      " |      1.0    0.2\n",
      " |      2.0    0.2\n",
      " |      4.0    0.2\n",
      " |      Name: proportion, dtype: float64\n",
      " |      \n",
      " |      **bins**\n",
      " |      \n",
      " |      Bins can be useful for going from a continuous variable to a\n",
      " |      categorical variable; instead of counting unique\n",
      " |      apparitions of values, divide the index in the specified\n",
      " |      number of half-open bins.\n",
      " |      \n",
      " |      >>> s.value_counts(bins=3)\n",
      " |      (0.996, 2.0]    2\n",
      " |      (2.0, 3.0]      2\n",
      " |      (3.0, 4.0]      1\n",
      " |      Name: count, dtype: int64\n",
      " |      \n",
      " |      **dropna**\n",
      " |      \n",
      " |      With `dropna` set to `False` we can also see NaN index values.\n",
      " |      \n",
      " |      >>> s.value_counts(dropna=False)\n",
      " |      3.0    2\n",
      " |      1.0    1\n",
      " |      2.0    1\n",
      " |      4.0    1\n",
      " |      NaN    1\n",
      " |      Name: count, dtype: int64\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from pandas.core.base.IndexOpsMixin:\n",
      " |  \n",
      " |  T\n",
      " |      Return the transpose, which is by definition self.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> s = pd.Series(['Ant', 'Bear', 'Cow'])\n",
      " |      >>> s\n",
      " |      0     Ant\n",
      " |      1    Bear\n",
      " |      2     Cow\n",
      " |      dtype: object\n",
      " |      >>> s.T\n",
      " |      0     Ant\n",
      " |      1    Bear\n",
      " |      2     Cow\n",
      " |      dtype: object\n",
      " |      \n",
      " |      For Index:\n",
      " |      \n",
      " |      >>> idx = pd.Index([1, 2, 3])\n",
      " |      >>> idx.T\n",
      " |      Index([1, 2, 3], dtype='int64')\n",
      " |  \n",
      " |  empty\n",
      " |  \n",
      " |  is_monotonic_decreasing\n",
      " |      Return boolean if values in the object are monotonically decreasing.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([3, 2, 2, 1])\n",
      " |      >>> s.is_monotonic_decreasing\n",
      " |      True\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.is_monotonic_decreasing\n",
      " |      False\n",
      " |  \n",
      " |  is_monotonic_increasing\n",
      " |      Return boolean if values in the object are monotonically increasing.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 2])\n",
      " |      >>> s.is_monotonic_increasing\n",
      " |      True\n",
      " |      \n",
      " |      >>> s = pd.Series([3, 2, 1])\n",
      " |      >>> s.is_monotonic_increasing\n",
      " |      False\n",
      " |  \n",
      " |  is_unique\n",
      " |      Return boolean if values in the object are unique.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.is_unique\n",
      " |      True\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3, 1])\n",
      " |      >>> s.is_unique\n",
      " |      False\n",
      " |  \n",
      " |  nbytes\n",
      " |      Return the number of bytes in the underlying data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> s = pd.Series(['Ant', 'Bear', 'Cow'])\n",
      " |      >>> s\n",
      " |      0     Ant\n",
      " |      1    Bear\n",
      " |      2     Cow\n",
      " |      dtype: object\n",
      " |      >>> s.nbytes\n",
      " |      24\n",
      " |      \n",
      " |      For Index:\n",
      " |      \n",
      " |      >>> idx = pd.Index([1, 2, 3])\n",
      " |      >>> idx\n",
      " |      Index([1, 2, 3], dtype='int64')\n",
      " |      >>> idx.nbytes\n",
      " |      24\n",
      " |  \n",
      " |  ndim\n",
      " |      Number of dimensions of the underlying data, by definition 1.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(['Ant', 'Bear', 'Cow'])\n",
      " |      >>> s\n",
      " |      0     Ant\n",
      " |      1    Bear\n",
      " |      2     Cow\n",
      " |      dtype: object\n",
      " |      >>> s.ndim\n",
      " |      1\n",
      " |      \n",
      " |      For Index:\n",
      " |      \n",
      " |      >>> idx = pd.Index([1, 2, 3])\n",
      " |      >>> idx\n",
      " |      Index([1, 2, 3], dtype='int64')\n",
      " |      >>> idx.ndim\n",
      " |      1\n",
      " |  \n",
      " |  shape\n",
      " |      Return a tuple of the shape of the underlying data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.shape\n",
      " |      (3,)\n",
      " |  \n",
      " |  size\n",
      " |      Return the number of elements in the underlying data.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> s = pd.Series(['Ant', 'Bear', 'Cow'])\n",
      " |      >>> s\n",
      " |      0     Ant\n",
      " |      1    Bear\n",
      " |      2     Cow\n",
      " |      dtype: object\n",
      " |      >>> s.size\n",
      " |      3\n",
      " |      \n",
      " |      For Index:\n",
      " |      \n",
      " |      >>> idx = pd.Index([1, 2, 3])\n",
      " |      >>> idx\n",
      " |      Index([1, 2, 3], dtype='int64')\n",
      " |      >>> idx.size\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from pandas.core.base.IndexOpsMixin:\n",
      " |  \n",
      " |  __array_priority__ = 1000\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from pandas.core.arraylike.OpsMixin:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |      Get Addition of DataFrame and other, column-wise.\n",
      " |      \n",
      " |      Equivalent to ``DataFrame.add(other)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : scalar, sequence, Series, dict or DataFrame\n",
      " |          Object to be added to the DataFrame.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      DataFrame\n",
      " |          The result of adding ``other`` to DataFrame.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.add : Add a DataFrame and another object, with option for index-\n",
      " |          or column-oriented addition.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'height': [1.5, 2.6], 'weight': [500, 800]},\n",
      " |      ...                   index=['elk', 'moose'])\n",
      " |      >>> df\n",
      " |             height  weight\n",
      " |      elk       1.5     500\n",
      " |      moose     2.6     800\n",
      " |      \n",
      " |      Adding a scalar affects all rows and columns.\n",
      " |      \n",
      " |      >>> df[['height', 'weight']] + 1.5\n",
      " |             height  weight\n",
      " |      elk       3.0   501.5\n",
      " |      moose     4.1   801.5\n",
      " |      \n",
      " |      Each element of a list is added to a column of the DataFrame, in order.\n",
      " |      \n",
      " |      >>> df[['height', 'weight']] + [0.5, 1.5]\n",
      " |             height  weight\n",
      " |      elk       2.0   501.5\n",
      " |      moose     3.1   801.5\n",
      " |      \n",
      " |      Keys of a dictionary are aligned to the DataFrame, based on column names;\n",
      " |      each value in the dictionary is added to the corresponding column.\n",
      " |      \n",
      " |      >>> df[['height', 'weight']] + {'height': 0.5, 'weight': 1.5}\n",
      " |             height  weight\n",
      " |      elk       2.0   501.5\n",
      " |      moose     3.1   801.5\n",
      " |      \n",
      " |      When `other` is a :class:`Series`, the index of `other` is aligned with the\n",
      " |      columns of the DataFrame.\n",
      " |      \n",
      " |      >>> s1 = pd.Series([0.5, 1.5], index=['weight', 'height'])\n",
      " |      >>> df[['height', 'weight']] + s1\n",
      " |             height  weight\n",
      " |      elk       3.0   500.5\n",
      " |      moose     4.1   800.5\n",
      " |      \n",
      " |      Even when the index of `other` is the same as the index of the DataFrame,\n",
      " |      the :class:`Series` will not be reoriented. If index-wise alignment is desired,\n",
      " |      :meth:`DataFrame.add` should be used with `axis='index'`.\n",
      " |      \n",
      " |      >>> s2 = pd.Series([0.5, 1.5], index=['elk', 'moose'])\n",
      " |      >>> df[['height', 'weight']] + s2\n",
      " |             elk  height  moose  weight\n",
      " |      elk    NaN     NaN    NaN     NaN\n",
      " |      moose  NaN     NaN    NaN     NaN\n",
      " |      \n",
      " |      >>> df[['height', 'weight']].add(s2, axis='index')\n",
      " |             height  weight\n",
      " |      elk       2.0   500.5\n",
      " |      moose     4.1   801.5\n",
      " |      \n",
      " |      When `other` is a :class:`DataFrame`, both columns names and the\n",
      " |      index are aligned.\n",
      " |      \n",
      " |      >>> other = pd.DataFrame({'height': [0.2, 0.4, 0.6]},\n",
      " |      ...                      index=['elk', 'moose', 'deer'])\n",
      " |      >>> df[['height', 'weight']] + other\n",
      " |             height  weight\n",
      " |      deer      NaN     NaN\n",
      " |      elk       1.7     NaN\n",
      " |      moose     3.0     NaN\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pow__(self, other)\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rand__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __ror__(self, other)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __rxor__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from pandas.core.arraylike.OpsMixin:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from pandas.core.arraylike.OpsMixin:\n",
      " |  \n",
      " |  __hash__ = None\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from pandas.core.generic.NDFrame:\n",
      " |  \n",
      " |  __abs__(self) -> 'Self'\n",
      " |  \n",
      " |  __array_ufunc__(self, ufunc: 'np.ufunc', method: 'str', *inputs: 'Any', **kwargs: 'Any')\n",
      " |  \n",
      " |  __bool__ = __nonzero__(self) -> 'NoReturn'\n",
      " |  \n",
      " |  __contains__(self, key) -> 'bool_t'\n",
      " |      True if the key is in the info axis\n",
      " |  \n",
      " |  __copy__(self, deep: 'bool_t' = True) -> 'Self'\n",
      " |  \n",
      " |  __deepcopy__(self, memo=None) -> 'Self'\n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      memo, default None\n",
      " |          Standard signature. Unused\n",
      " |  \n",
      " |  __delitem__(self, key) -> 'None'\n",
      " |      Delete item\n",
      " |  \n",
      " |  __finalize__(self, other, method: 'str | None' = None, **kwargs) -> 'Self'\n",
      " |      Propagate metadata from other to self.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : the object from which to get the attributes that we are going\n",
      " |          to propagate\n",
      " |      method : str, optional\n",
      " |          A passed method name providing context on where ``__finalize__``\n",
      " |          was called.\n",
      " |      \n",
      " |          .. warning::\n",
      " |      \n",
      " |             The value passed as `method` are not currently considered\n",
      " |             stable across pandas releases.\n",
      " |  \n",
      " |  __getattr__(self, name: 'str')\n",
      " |      After regular attribute access, try looking up the name\n",
      " |      This allows simpler access to columns for interactive use.\n",
      " |  \n",
      " |  __getstate__(self) -> 'dict[str, Any]'\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __iadd__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __iand__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __ifloordiv__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __imod__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __imul__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __invert__(self) -> 'Self'\n",
      " |  \n",
      " |  __ior__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __ipow__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __isub__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __itruediv__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __ixor__(self, other) -> 'Self'\n",
      " |  \n",
      " |  __neg__(self) -> 'Self'\n",
      " |  \n",
      " |  __nonzero__(self) -> 'NoReturn'\n",
      " |  \n",
      " |  __pos__(self) -> 'Self'\n",
      " |  \n",
      " |  __round__(self, decimals: 'int' = 0) -> 'Self'\n",
      " |  \n",
      " |  __setattr__(self, name: 'str', value) -> 'None'\n",
      " |      After regular attribute access, try setting the name\n",
      " |      This allows simpler access to columns for interactive use.\n",
      " |  \n",
      " |  __setstate__(self, state) -> 'None'\n",
      " |  \n",
      " |  abs(self) -> 'Self'\n",
      " |      Return a Series/DataFrame with absolute numeric value of each element.\n",
      " |      \n",
      " |      This function only applies to elements that are all numeric.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      abs\n",
      " |          Series/DataFrame containing the absolute value of each element.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      numpy.absolute : Calculate the absolute value element-wise.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For ``complex`` inputs, ``1.2 + 1j``, the absolute value is\n",
      " |      :math:`\\sqrt{ a^2 + b^2 }`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Absolute numeric values in a Series.\n",
      " |      \n",
      " |      >>> s = pd.Series([-1.10, 2, -3.33, 4])\n",
      " |      >>> s.abs()\n",
      " |      0    1.10\n",
      " |      1    2.00\n",
      " |      2    3.33\n",
      " |      3    4.00\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Absolute numeric values in a Series with complex numbers.\n",
      " |      \n",
      " |      >>> s = pd.Series([1.2 + 1j])\n",
      " |      >>> s.abs()\n",
      " |      0    1.56205\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Absolute numeric values in a Series with a Timedelta element.\n",
      " |      \n",
      " |      >>> s = pd.Series([pd.Timedelta('1 days')])\n",
      " |      >>> s.abs()\n",
      " |      0   1 days\n",
      " |      dtype: timedelta64[ns]\n",
      " |      \n",
      " |      Select rows with data closest to certain value using argsort (from\n",
      " |      `StackOverflow <https://stackoverflow.com/a/17758115>`__).\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\n",
      " |      ...     'a': [4, 5, 6, 7],\n",
      " |      ...     'b': [10, 20, 30, 40],\n",
      " |      ...     'c': [100, 50, -30, -50]\n",
      " |      ... })\n",
      " |      >>> df\n",
      " |           a    b    c\n",
      " |      0    4   10  100\n",
      " |      1    5   20   50\n",
      " |      2    6   30  -30\n",
      " |      3    7   40  -50\n",
      " |      >>> df.loc[(df.c - 43).abs().argsort()]\n",
      " |           a    b    c\n",
      " |      1    5   20   50\n",
      " |      0    4   10  100\n",
      " |      2    6   30  -30\n",
      " |      3    7   40  -50\n",
      " |  \n",
      " |  add_prefix(self, prefix: 'str', axis: 'Axis | None' = None) -> 'Self'\n",
      " |      Prefix labels with string `prefix`.\n",
      " |      \n",
      " |      For Series, the row labels are prefixed.\n",
      " |      For DataFrame, the column labels are prefixed.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      prefix : str\n",
      " |          The string to add before each label.\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default None\n",
      " |          Axis to add prefix on\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          New Series or DataFrame with updated labels.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.add_suffix: Suffix row labels with string `suffix`.\n",
      " |      DataFrame.add_suffix: Suffix column labels with string `suffix`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4])\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.add_prefix('item_')\n",
      " |      item_0    1\n",
      " |      item_1    2\n",
      " |      item_2    3\n",
      " |      item_3    4\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})\n",
      " |      >>> df\n",
      " |         A  B\n",
      " |      0  1  3\n",
      " |      1  2  4\n",
      " |      2  3  5\n",
      " |      3  4  6\n",
      " |      \n",
      " |      >>> df.add_prefix('col_')\n",
      " |           col_A  col_B\n",
      " |      0       1       3\n",
      " |      1       2       4\n",
      " |      2       3       5\n",
      " |      3       4       6\n",
      " |  \n",
      " |  add_suffix(self, suffix: 'str', axis: 'Axis | None' = None) -> 'Self'\n",
      " |      Suffix labels with string `suffix`.\n",
      " |      \n",
      " |      For Series, the row labels are suffixed.\n",
      " |      For DataFrame, the column labels are suffixed.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      suffix : str\n",
      " |          The string to add after each label.\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default None\n",
      " |          Axis to add suffix on\n",
      " |      \n",
      " |          .. versionadded:: 2.0.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          New Series or DataFrame with updated labels.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.add_prefix: Prefix row labels with string `prefix`.\n",
      " |      DataFrame.add_prefix: Prefix column labels with string `prefix`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2, 3, 4])\n",
      " |      >>> s\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.add_suffix('_item')\n",
      " |      0_item    1\n",
      " |      1_item    2\n",
      " |      2_item    3\n",
      " |      3_item    4\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})\n",
      " |      >>> df\n",
      " |         A  B\n",
      " |      0  1  3\n",
      " |      1  2  4\n",
      " |      2  3  5\n",
      " |      3  4  6\n",
      " |      \n",
      " |      >>> df.add_suffix('_col')\n",
      " |           A_col  B_col\n",
      " |      0       1       3\n",
      " |      1       2       4\n",
      " |      2       3       5\n",
      " |      3       4       6\n",
      " |  \n",
      " |  align(self, other: 'NDFrameT', join: 'AlignJoin' = 'outer', axis: 'Axis | None' = None, level: 'Level | None' = None, copy: 'bool_t | None' = None, fill_value: 'Hashable | None' = None, method: 'FillnaOptions | None | lib.NoDefault' = <no_default>, limit: 'int | None | lib.NoDefault' = <no_default>, fill_axis: 'Axis | lib.NoDefault' = <no_default>, broadcast_axis: 'Axis | None | lib.NoDefault' = <no_default>) -> 'tuple[Self, NDFrameT]'\n",
      " |      Align two objects on their axes with the specified join method.\n",
      " |      \n",
      " |      Join method is specified for each axis Index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : DataFrame or Series\n",
      " |      join : {'outer', 'inner', 'left', 'right'}, default 'outer'\n",
      " |          Type of alignment to be performed.\n",
      " |      \n",
      " |          * left: use only keys from left frame, preserve key order.\n",
      " |          * right: use only keys from right frame, preserve key order.\n",
      " |          * outer: use union of keys from both frames, sort keys lexicographically.\n",
      " |          * inner: use intersection of keys from both frames,\n",
      " |            preserve the order of the left keys.\n",
      " |      \n",
      " |      axis : allowed axis of the other object, default None\n",
      " |          Align on index (0), columns (1), or both (None).\n",
      " |      level : int or level name, default None\n",
      " |          Broadcast across a level, matching Index values on the\n",
      " |          passed MultiIndex level.\n",
      " |      copy : bool, default True\n",
      " |          Always returns new objects. If copy=False and no reindexing is\n",
      " |          required then original objects are returned.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      fill_value : scalar, default np.nan\n",
      " |          Value to use for missing values. Defaults to NaN, but can be any\n",
      " |          \"compatible\" value.\n",
      " |      method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None\n",
      " |          Method to use for filling holes in reindexed Series:\n",
      " |      \n",
      " |          - pad / ffill: propagate last valid observation forward to next valid.\n",
      " |          - backfill / bfill: use NEXT valid observation to fill gap.\n",
      " |      \n",
      " |          .. deprecated:: 2.1\n",
      " |      \n",
      " |      limit : int, default None\n",
      " |          If method is specified, this is the maximum number of consecutive\n",
      " |          NaN values to forward/backward fill. In other words, if there is\n",
      " |          a gap with more than this number of consecutive NaNs, it will only\n",
      " |          be partially filled. If method is not specified, this is the\n",
      " |          maximum number of entries along the entire axis where NaNs will be\n",
      " |          filled. Must be greater than 0 if not None.\n",
      " |      \n",
      " |          .. deprecated:: 2.1\n",
      " |      \n",
      " |      fill_axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame, default 0\n",
      " |          Filling axis, method and limit.\n",
      " |      \n",
      " |          .. deprecated:: 2.1\n",
      " |      \n",
      " |      broadcast_axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame, default None\n",
      " |          Broadcast values along this axis, if aligning two objects of\n",
      " |          different dimensions.\n",
      " |      \n",
      " |          .. deprecated:: 2.1\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      tuple of (Series/DataFrame, type of other)\n",
      " |          Aligned objects.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame(\n",
      " |      ...     [[1, 2, 3, 4], [6, 7, 8, 9]], columns=[\"D\", \"B\", \"E\", \"A\"], index=[1, 2]\n",
      " |      ... )\n",
      " |      >>> other = pd.DataFrame(\n",
      " |      ...     [[10, 20, 30, 40], [60, 70, 80, 90], [600, 700, 800, 900]],\n",
      " |      ...     columns=[\"A\", \"B\", \"C\", \"D\"],\n",
      " |      ...     index=[2, 3, 4],\n",
      " |      ... )\n",
      " |      >>> df\n",
      " |         D  B  E  A\n",
      " |      1  1  2  3  4\n",
      " |      2  6  7  8  9\n",
      " |      >>> other\n",
      " |          A    B    C    D\n",
      " |      2   10   20   30   40\n",
      " |      3   60   70   80   90\n",
      " |      4  600  700  800  900\n",
      " |      \n",
      " |      Align on columns:\n",
      " |      \n",
      " |      >>> left, right = df.align(other, join=\"outer\", axis=1)\n",
      " |      >>> left\n",
      " |         A  B   C  D  E\n",
      " |      1  4  2 NaN  1  3\n",
      " |      2  9  7 NaN  6  8\n",
      " |      >>> right\n",
      " |          A    B    C    D   E\n",
      " |      2   10   20   30   40 NaN\n",
      " |      3   60   70   80   90 NaN\n",
      " |      4  600  700  800  900 NaN\n",
      " |      \n",
      " |      We can also align on the index:\n",
      " |      \n",
      " |      >>> left, right = df.align(other, join=\"outer\", axis=0)\n",
      " |      >>> left\n",
      " |          D    B    E    A\n",
      " |      1  1.0  2.0  3.0  4.0\n",
      " |      2  6.0  7.0  8.0  9.0\n",
      " |      3  NaN  NaN  NaN  NaN\n",
      " |      4  NaN  NaN  NaN  NaN\n",
      " |      >>> right\n",
      " |          A      B      C      D\n",
      " |      1    NaN    NaN    NaN    NaN\n",
      " |      2   10.0   20.0   30.0   40.0\n",
      " |      3   60.0   70.0   80.0   90.0\n",
      " |      4  600.0  700.0  800.0  900.0\n",
      " |      \n",
      " |      Finally, the default `axis=None` will align on both index and columns:\n",
      " |      \n",
      " |      >>> left, right = df.align(other, join=\"outer\", axis=None)\n",
      " |      >>> left\n",
      " |           A    B   C    D    E\n",
      " |      1  4.0  2.0 NaN  1.0  3.0\n",
      " |      2  9.0  7.0 NaN  6.0  8.0\n",
      " |      3  NaN  NaN NaN  NaN  NaN\n",
      " |      4  NaN  NaN NaN  NaN  NaN\n",
      " |      >>> right\n",
      " |             A      B      C      D   E\n",
      " |      1    NaN    NaN    NaN    NaN NaN\n",
      " |      2   10.0   20.0   30.0   40.0 NaN\n",
      " |      3   60.0   70.0   80.0   90.0 NaN\n",
      " |      4  600.0  700.0  800.0  900.0 NaN\n",
      " |  \n",
      " |  asfreq(self, freq: 'Frequency', method: 'FillnaOptions | None' = None, how: \"Literal['start', 'end'] | None\" = None, normalize: 'bool_t' = False, fill_value: 'Hashable | None' = None) -> 'Self'\n",
      " |      Convert time series to specified frequency.\n",
      " |      \n",
      " |      Returns the original data conformed to a new index with the specified\n",
      " |      frequency.\n",
      " |      \n",
      " |      If the index of this Series/DataFrame is a :class:`~pandas.PeriodIndex`, the new index\n",
      " |      is the result of transforming the original index with\n",
      " |      :meth:`PeriodIndex.asfreq <pandas.PeriodIndex.asfreq>` (so the original index\n",
      " |      will map one-to-one to the new index).\n",
      " |      \n",
      " |      Otherwise, the new index will be equivalent to ``pd.date_range(start, end,\n",
      " |      freq=freq)`` where ``start`` and ``end`` are, respectively, the first and\n",
      " |      last entries in the original index (see :func:`pandas.date_range`). The\n",
      " |      values corresponding to any timesteps in the new index which were not present\n",
      " |      in the original index will be null (``NaN``), unless a method for filling\n",
      " |      such unknowns is provided (see the ``method`` parameter below).\n",
      " |      \n",
      " |      The :meth:`resample` method is more appropriate if an operation on each group of\n",
      " |      timesteps (such as an aggregate) is necessary to represent the data at the new\n",
      " |      frequency.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      freq : DateOffset or str\n",
      " |          Frequency DateOffset or string.\n",
      " |      method : {'backfill'/'bfill', 'pad'/'ffill'}, default None\n",
      " |          Method to use for filling holes in reindexed Series (note this\n",
      " |          does not fill NaNs that already were present):\n",
      " |      \n",
      " |          * 'pad' / 'ffill': propagate last valid observation forward to next\n",
      " |            valid\n",
      " |          * 'backfill' / 'bfill': use NEXT valid observation to fill.\n",
      " |      how : {'start', 'end'}, default end\n",
      " |          For PeriodIndex only (see PeriodIndex.asfreq).\n",
      " |      normalize : bool, default False\n",
      " |          Whether to reset output index to midnight.\n",
      " |      fill_value : scalar, optional\n",
      " |          Value to use for missing values, applied during upsampling (note\n",
      " |          this does not fill NaNs that already were present).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame\n",
      " |          Series/DataFrame object reindexed to the specified frequency.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      reindex : Conform DataFrame to new index with optional filling logic.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      To learn more about the frequency strings, please see `this link\n",
      " |      <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Start by creating a series with 4 one minute timestamps.\n",
      " |      \n",
      " |      >>> index = pd.date_range('1/1/2000', periods=4, freq='min')\n",
      " |      >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index)\n",
      " |      >>> df = pd.DataFrame({'s': series})\n",
      " |      >>> df\n",
      " |                             s\n",
      " |      2000-01-01 00:00:00    0.0\n",
      " |      2000-01-01 00:01:00    NaN\n",
      " |      2000-01-01 00:02:00    2.0\n",
      " |      2000-01-01 00:03:00    3.0\n",
      " |      \n",
      " |      Upsample the series into 30 second bins.\n",
      " |      \n",
      " |      >>> df.asfreq(freq='30s')\n",
      " |                             s\n",
      " |      2000-01-01 00:00:00    0.0\n",
      " |      2000-01-01 00:00:30    NaN\n",
      " |      2000-01-01 00:01:00    NaN\n",
      " |      2000-01-01 00:01:30    NaN\n",
      " |      2000-01-01 00:02:00    2.0\n",
      " |      2000-01-01 00:02:30    NaN\n",
      " |      2000-01-01 00:03:00    3.0\n",
      " |      \n",
      " |      Upsample again, providing a ``fill value``.\n",
      " |      \n",
      " |      >>> df.asfreq(freq='30s', fill_value=9.0)\n",
      " |                             s\n",
      " |      2000-01-01 00:00:00    0.0\n",
      " |      2000-01-01 00:00:30    9.0\n",
      " |      2000-01-01 00:01:00    NaN\n",
      " |      2000-01-01 00:01:30    9.0\n",
      " |      2000-01-01 00:02:00    2.0\n",
      " |      2000-01-01 00:02:30    9.0\n",
      " |      2000-01-01 00:03:00    3.0\n",
      " |      \n",
      " |      Upsample again, providing a ``method``.\n",
      " |      \n",
      " |      >>> df.asfreq(freq='30s', method='bfill')\n",
      " |                             s\n",
      " |      2000-01-01 00:00:00    0.0\n",
      " |      2000-01-01 00:00:30    NaN\n",
      " |      2000-01-01 00:01:00    NaN\n",
      " |      2000-01-01 00:01:30    2.0\n",
      " |      2000-01-01 00:02:00    2.0\n",
      " |      2000-01-01 00:02:30    3.0\n",
      " |      2000-01-01 00:03:00    3.0\n",
      " |  \n",
      " |  asof(self, where, subset=None)\n",
      " |      Return the last row(s) without any NaNs before `where`.\n",
      " |      \n",
      " |      The last row (for each element in `where`, if list) without any\n",
      " |      NaN is taken.\n",
      " |      In case of a :class:`~pandas.DataFrame`, the last row without NaN\n",
      " |      considering only the subset of columns (if not `None`)\n",
      " |      \n",
      " |      If there is no good value, NaN is returned for a Series or\n",
      " |      a Series of NaN values for a DataFrame\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      where : date or array-like of dates\n",
      " |          Date(s) before which the last row(s) are returned.\n",
      " |      subset : str or array-like of str, default `None`\n",
      " |          For DataFrame, if not `None`, only use these columns to\n",
      " |          check for NaNs.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      scalar, Series, or DataFrame\n",
      " |      \n",
      " |          The return can be:\n",
      " |      \n",
      " |          * scalar : when `self` is a Series and `where` is a scalar\n",
      " |          * Series: when `self` is a Series and `where` is an array-like,\n",
      " |            or when `self` is a DataFrame and `where` is a scalar\n",
      " |          * DataFrame : when `self` is a DataFrame and `where` is an\n",
      " |            array-like\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      merge_asof : Perform an asof merge. Similar to left join.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Dates are assumed to be sorted. Raises if this is not the case.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      A Series and a scalar `where`.\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, np.nan, 4], index=[10, 20, 30, 40])\n",
      " |      >>> s\n",
      " |      10    1.0\n",
      " |      20    2.0\n",
      " |      30    NaN\n",
      " |      40    4.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.asof(20)\n",
      " |      2.0\n",
      " |      \n",
      " |      For a sequence `where`, a Series is returned. The first value is\n",
      " |      NaN, because the first element of `where` is before the first\n",
      " |      index value.\n",
      " |      \n",
      " |      >>> s.asof([5, 20])\n",
      " |      5     NaN\n",
      " |      20    2.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Missing values are not considered. The following is ``2.0``, not\n",
      " |      NaN, even though NaN is at the index location for ``30``.\n",
      " |      \n",
      " |      >>> s.asof(30)\n",
      " |      2.0\n",
      " |      \n",
      " |      Take all columns into consideration\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'a': [10., 20., 30., 40., 50.],\n",
      " |      ...                    'b': [None, None, None, None, 500]},\n",
      " |      ...                   index=pd.DatetimeIndex(['2018-02-27 09:01:00',\n",
      " |      ...                                           '2018-02-27 09:02:00',\n",
      " |      ...                                           '2018-02-27 09:03:00',\n",
      " |      ...                                           '2018-02-27 09:04:00',\n",
      " |      ...                                           '2018-02-27 09:05:00']))\n",
      " |      >>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',\n",
      " |      ...                           '2018-02-27 09:04:30']))\n",
      " |                            a   b\n",
      " |      2018-02-27 09:03:30 NaN NaN\n",
      " |      2018-02-27 09:04:30 NaN NaN\n",
      " |      \n",
      " |      Take a single column into consideration\n",
      " |      \n",
      " |      >>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',\n",
      " |      ...                           '2018-02-27 09:04:30']),\n",
      " |      ...         subset=['a'])\n",
      " |                              a   b\n",
      " |      2018-02-27 09:03:30  30.0 NaN\n",
      " |      2018-02-27 09:04:30  40.0 NaN\n",
      " |  \n",
      " |  astype(self, dtype, copy: 'bool_t | None' = None, errors: 'IgnoreRaise' = 'raise') -> 'Self'\n",
      " |      Cast a pandas object to a specified dtype ``dtype``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      dtype : str, data type, Series or Mapping of column name -> data type\n",
      " |          Use a str, numpy.dtype, pandas.ExtensionDtype or Python type to\n",
      " |          cast entire pandas object to the same type. Alternatively, use a\n",
      " |          mapping, e.g. {col: dtype, ...}, where col is a column label and dtype is\n",
      " |          a numpy.dtype or Python type to cast one or more of the DataFrame's\n",
      " |          columns to column-specific types.\n",
      " |      copy : bool, default True\n",
      " |          Return a copy when ``copy=True`` (be very careful setting\n",
      " |          ``copy=False`` as changes to values then may propagate to other\n",
      " |          pandas objects).\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      errors : {'raise', 'ignore'}, default 'raise'\n",
      " |          Control raising of exceptions on invalid data for provided dtype.\n",
      " |      \n",
      " |          - ``raise`` : allow exceptions to be raised\n",
      " |          - ``ignore`` : suppress exceptions. On error return original object.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as caller\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      to_datetime : Convert argument to datetime.\n",
      " |      to_timedelta : Convert argument to timedelta.\n",
      " |      to_numeric : Convert argument to a numeric type.\n",
      " |      numpy.ndarray.astype : Cast a numpy array to a specified type.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. versionchanged:: 2.0.0\n",
      " |      \n",
      " |          Using ``astype`` to convert from timezone-naive dtype to\n",
      " |          timezone-aware dtype will raise an exception.\n",
      " |          Use :meth:`Series.dt.tz_localize` instead.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Create a DataFrame:\n",
      " |      \n",
      " |      >>> d = {'col1': [1, 2], 'col2': [3, 4]}\n",
      " |      >>> df = pd.DataFrame(data=d)\n",
      " |      >>> df.dtypes\n",
      " |      col1    int64\n",
      " |      col2    int64\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Cast all columns to int32:\n",
      " |      \n",
      " |      >>> df.astype('int32').dtypes\n",
      " |      col1    int32\n",
      " |      col2    int32\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Cast col1 to int32 using a dictionary:\n",
      " |      \n",
      " |      >>> df.astype({'col1': 'int32'}).dtypes\n",
      " |      col1    int32\n",
      " |      col2    int64\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Create a series:\n",
      " |      \n",
      " |      >>> ser = pd.Series([1, 2], dtype='int32')\n",
      " |      >>> ser\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      dtype: int32\n",
      " |      >>> ser.astype('int64')\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Convert to categorical type:\n",
      " |      \n",
      " |      >>> ser.astype('category')\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      dtype: category\n",
      " |      Categories (2, int32): [1, 2]\n",
      " |      \n",
      " |      Convert to ordered categorical type with custom ordering:\n",
      " |      \n",
      " |      >>> from pandas.api.types import CategoricalDtype\n",
      " |      >>> cat_dtype = CategoricalDtype(\n",
      " |      ...     categories=[2, 1], ordered=True)\n",
      " |      >>> ser.astype(cat_dtype)\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      dtype: category\n",
      " |      Categories (2, int64): [2 < 1]\n",
      " |      \n",
      " |      Create a series of dates:\n",
      " |      \n",
      " |      >>> ser_date = pd.Series(pd.date_range('20200101', periods=3))\n",
      " |      >>> ser_date\n",
      " |      0   2020-01-01\n",
      " |      1   2020-01-02\n",
      " |      2   2020-01-03\n",
      " |      dtype: datetime64[ns]\n",
      " |  \n",
      " |  at_time(self, time, asof: 'bool_t' = False, axis: 'Axis | None' = None) -> 'Self'\n",
      " |      Select values at particular time of day (e.g., 9:30AM).\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      time : datetime.time or str\n",
      " |          The values to select.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |          If the index is not  a :class:`DatetimeIndex`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      between_time : Select values between particular times of the day.\n",
      " |      first : Select initial periods of time series based on a date offset.\n",
      " |      last : Select final periods of time series based on a date offset.\n",
      " |      DatetimeIndex.indexer_at_time : Get just the index locations for\n",
      " |          values at particular time of the day.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> i = pd.date_range('2018-04-09', periods=4, freq='12h')\n",
      " |      >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n",
      " |      >>> ts\n",
      " |                           A\n",
      " |      2018-04-09 00:00:00  1\n",
      " |      2018-04-09 12:00:00  2\n",
      " |      2018-04-10 00:00:00  3\n",
      " |      2018-04-10 12:00:00  4\n",
      " |      \n",
      " |      >>> ts.at_time('12:00')\n",
      " |                           A\n",
      " |      2018-04-09 12:00:00  2\n",
      " |      2018-04-10 12:00:00  4\n",
      " |  \n",
      " |  backfill(self, *, axis: 'None | Axis' = None, inplace: 'bool_t' = False, limit: 'None | int' = None, downcast: 'dict | None | lib.NoDefault' = <no_default>) -> 'Self | None'\n",
      " |      Fill NA/NaN values by using the next valid observation to fill the gap.\n",
      " |      \n",
      " |      .. deprecated:: 2.0\n",
      " |      \n",
      " |          Series/DataFrame.backfill is deprecated. Use Series/DataFrame.bfill instead.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame or None\n",
      " |          Object with missing values filled or None if ``inplace=True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Please see examples for :meth:`DataFrame.bfill` or :meth:`Series.bfill`.\n",
      " |  \n",
      " |  between_time(self, start_time, end_time, inclusive: 'IntervalClosedType' = 'both', axis: 'Axis | None' = None) -> 'Self'\n",
      " |      Select values between particular times of the day (e.g., 9:00-9:30 AM).\n",
      " |      \n",
      " |      By setting ``start_time`` to be later than ``end_time``,\n",
      " |      you can get the times that are *not* between the two times.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      start_time : datetime.time or str\n",
      " |          Initial time as a time filter limit.\n",
      " |      end_time : datetime.time or str\n",
      " |          End time as a time filter limit.\n",
      " |      inclusive : {\"both\", \"neither\", \"left\", \"right\"}, default \"both\"\n",
      " |          Include boundaries; whether to set each bound as closed or open.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          Determine range time on index or columns value.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          Data from the original object filtered to the specified dates range.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |          If the index is not  a :class:`DatetimeIndex`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      at_time : Select values at a particular time of the day.\n",
      " |      first : Select initial periods of time series based on a date offset.\n",
      " |      last : Select final periods of time series based on a date offset.\n",
      " |      DatetimeIndex.indexer_between_time : Get just the index locations for\n",
      " |          values between particular times of the day.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> i = pd.date_range('2018-04-09', periods=4, freq='1D20min')\n",
      " |      >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n",
      " |      >>> ts\n",
      " |                           A\n",
      " |      2018-04-09 00:00:00  1\n",
      " |      2018-04-10 00:20:00  2\n",
      " |      2018-04-11 00:40:00  3\n",
      " |      2018-04-12 01:00:00  4\n",
      " |      \n",
      " |      >>> ts.between_time('0:15', '0:45')\n",
      " |                           A\n",
      " |      2018-04-10 00:20:00  2\n",
      " |      2018-04-11 00:40:00  3\n",
      " |      \n",
      " |      You get the times that are *not* between two times by setting\n",
      " |      ``start_time`` later than ``end_time``:\n",
      " |      \n",
      " |      >>> ts.between_time('0:45', '0:15')\n",
      " |                           A\n",
      " |      2018-04-09 00:00:00  1\n",
      " |      2018-04-12 01:00:00  4\n",
      " |  \n",
      " |  bfill(self, *, axis: 'None | Axis' = None, inplace: 'bool_t' = False, limit: 'None | int' = None, limit_area: \"Literal['inside', 'outside'] | None\" = None, downcast: 'dict | None | lib.NoDefault' = <no_default>) -> 'Self | None'\n",
      " |      Fill NA/NaN values by using the next valid observation to fill the gap.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame\n",
      " |          Axis along which to fill missing values. For `Series`\n",
      " |          this parameter is unused and defaults to 0.\n",
      " |      inplace : bool, default False\n",
      " |          If True, fill in-place. Note: this will modify any\n",
      " |          other views on this object (e.g., a no-copy slice for a column in a\n",
      " |          DataFrame).\n",
      " |      limit : int, default None\n",
      " |          If method is specified, this is the maximum number of consecutive\n",
      " |          NaN values to forward/backward fill. In other words, if there is\n",
      " |          a gap with more than this number of consecutive NaNs, it will only\n",
      " |          be partially filled. If method is not specified, this is the\n",
      " |          maximum number of entries along the entire axis where NaNs will be\n",
      " |          filled. Must be greater than 0 if not None.\n",
      " |      limit_area : {`None`, 'inside', 'outside'}, default None\n",
      " |          If limit is specified, consecutive NaNs will be filled with this\n",
      " |          restriction.\n",
      " |      \n",
      " |          * ``None``: No fill restriction.\n",
      " |          * 'inside': Only fill NaNs surrounded by valid values\n",
      " |            (interpolate).\n",
      " |          * 'outside': Only fill NaNs outside valid values (extrapolate).\n",
      " |      \n",
      " |          .. versionadded:: 2.2.0\n",
      " |      \n",
      " |      downcast : dict, default is None\n",
      " |          A dict of item->dtype of what to downcast if possible,\n",
      " |          or the string 'infer' which will try to downcast to an appropriate\n",
      " |          equal type (e.g. float64 to int64 if possible).\n",
      " |      \n",
      " |          .. deprecated:: 2.2.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame or None\n",
      " |          Object with missing values filled or None if ``inplace=True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> s = pd.Series([1, None, None, 2])\n",
      " |      >>> s.bfill()\n",
      " |      0    1.0\n",
      " |      1    2.0\n",
      " |      2    2.0\n",
      " |      3    2.0\n",
      " |      dtype: float64\n",
      " |      >>> s.bfill(limit=1)\n",
      " |      0    1.0\n",
      " |      1    NaN\n",
      " |      2    2.0\n",
      " |      3    2.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      With DataFrame:\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [1, None, None, 4], 'B': [None, 5, None, 7]})\n",
      " |      >>> df\n",
      " |            A     B\n",
      " |      0   1.0   NaN\n",
      " |      1   NaN   5.0\n",
      " |      2   NaN   NaN\n",
      " |      3   4.0   7.0\n",
      " |      >>> df.bfill()\n",
      " |            A     B\n",
      " |      0   1.0   5.0\n",
      " |      1   4.0   5.0\n",
      " |      2   4.0   7.0\n",
      " |      3   4.0   7.0\n",
      " |      >>> df.bfill(limit=1)\n",
      " |            A     B\n",
      " |      0   1.0   5.0\n",
      " |      1   NaN   5.0\n",
      " |      2   4.0   7.0\n",
      " |      3   4.0   7.0\n",
      " |  \n",
      " |  bool(self) -> 'bool_t'\n",
      " |      Return the bool of a single element Series or DataFrame.\n",
      " |      \n",
      " |      .. deprecated:: 2.1.0\n",
      " |      \n",
      " |         bool is deprecated and will be removed in future version of pandas.\n",
      " |         For ``Series`` use ``pandas.Series.item``.\n",
      " |      \n",
      " |      This must be a boolean scalar value, either True or False. It will raise a\n",
      " |      ValueError if the Series or DataFrame does not have exactly 1 element, or that\n",
      " |      element is not boolean (integer values 0 and 1 will also raise an exception).\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool\n",
      " |          The value in the Series or DataFrame.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.astype : Change the data type of a Series, including to boolean.\n",
      " |      DataFrame.astype : Change the data type of a DataFrame, including to boolean.\n",
      " |      numpy.bool_ : NumPy boolean data type, used by pandas for boolean values.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      The method will only work for single element objects with a boolean value:\n",
      " |      \n",
      " |      >>> pd.Series([True]).bool()  # doctest: +SKIP\n",
      " |      True\n",
      " |      >>> pd.Series([False]).bool()  # doctest: +SKIP\n",
      " |      False\n",
      " |      \n",
      " |      >>> pd.DataFrame({'col': [True]}).bool()  # doctest: +SKIP\n",
      " |      True\n",
      " |      >>> pd.DataFrame({'col': [False]}).bool()  # doctest: +SKIP\n",
      " |      False\n",
      " |      \n",
      " |      This is an alternative method and will only work\n",
      " |      for single element objects with a boolean value:\n",
      " |      \n",
      " |      >>> pd.Series([True]).item()  # doctest: +SKIP\n",
      " |      True\n",
      " |      >>> pd.Series([False]).item()  # doctest: +SKIP\n",
      " |      False\n",
      " |  \n",
      " |  clip(self, lower=None, upper=None, *, axis: 'Axis | None' = None, inplace: 'bool_t' = False, **kwargs) -> 'Self | None'\n",
      " |      Trim values at input threshold(s).\n",
      " |      \n",
      " |      Assigns values outside boundary to boundary values. Thresholds\n",
      " |      can be singular values or array like, and in the latter case\n",
      " |      the clipping is performed element-wise in the specified axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      lower : float or array-like, default None\n",
      " |          Minimum threshold value. All values below this\n",
      " |          threshold will be set to it. A missing\n",
      " |          threshold (e.g `NA`) will not clip the value.\n",
      " |      upper : float or array-like, default None\n",
      " |          Maximum threshold value. All values above this\n",
      " |          threshold will be set to it. A missing\n",
      " |          threshold (e.g `NA`) will not clip the value.\n",
      " |      axis : {{0 or 'index', 1 or 'columns', None}}, default None\n",
      " |          Align object with lower and upper along the given axis.\n",
      " |          For `Series` this parameter is unused and defaults to `None`.\n",
      " |      inplace : bool, default False\n",
      " |          Whether to perform the operation in place on the data.\n",
      " |      *args, **kwargs\n",
      " |          Additional keywords have no effect but might be accepted\n",
      " |          for compatibility with numpy.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame or None\n",
      " |          Same type as calling object with the values outside the\n",
      " |          clip boundaries replaced or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.clip : Trim values at input threshold in series.\n",
      " |      DataFrame.clip : Trim values at input threshold in dataframe.\n",
      " |      numpy.clip : Clip (limit) the values in an array.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> data = {'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]}\n",
      " |      >>> df = pd.DataFrame(data)\n",
      " |      >>> df\n",
      " |         col_0  col_1\n",
      " |      0      9     -2\n",
      " |      1     -3     -7\n",
      " |      2      0      6\n",
      " |      3     -1      8\n",
      " |      4      5     -5\n",
      " |      \n",
      " |      Clips per column using lower and upper thresholds:\n",
      " |      \n",
      " |      >>> df.clip(-4, 6)\n",
      " |         col_0  col_1\n",
      " |      0      6     -2\n",
      " |      1     -3     -4\n",
      " |      2      0      6\n",
      " |      3     -1      6\n",
      " |      4      5     -4\n",
      " |      \n",
      " |      Clips using specific lower and upper thresholds per column:\n",
      " |      \n",
      " |      >>> df.clip([-2, -1], [4, 5])\n",
      " |          col_0  col_1\n",
      " |      0      4     -1\n",
      " |      1     -2     -1\n",
      " |      2      0      5\n",
      " |      3     -1      5\n",
      " |      4      4     -1\n",
      " |      \n",
      " |      Clips using specific lower and upper thresholds per column element:\n",
      " |      \n",
      " |      >>> t = pd.Series([2, -4, -1, 6, 3])\n",
      " |      >>> t\n",
      " |      0    2\n",
      " |      1   -4\n",
      " |      2   -1\n",
      " |      3    6\n",
      " |      4    3\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> df.clip(t, t + 4, axis=0)\n",
      " |         col_0  col_1\n",
      " |      0      6      2\n",
      " |      1     -3     -4\n",
      " |      2      0      3\n",
      " |      3      6      8\n",
      " |      4      5      3\n",
      " |      \n",
      " |      Clips using specific lower threshold per column element, with missing values:\n",
      " |      \n",
      " |      >>> t = pd.Series([2, -4, np.nan, 6, 3])\n",
      " |      >>> t\n",
      " |      0    2.0\n",
      " |      1   -4.0\n",
      " |      2    NaN\n",
      " |      3    6.0\n",
      " |      4    3.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> df.clip(t, axis=0)\n",
      " |      col_0  col_1\n",
      " |      0      9      2\n",
      " |      1     -3     -4\n",
      " |      2      0      6\n",
      " |      3      6      8\n",
      " |      4      5      3\n",
      " |  \n",
      " |  convert_dtypes(self, infer_objects: 'bool_t' = True, convert_string: 'bool_t' = True, convert_integer: 'bool_t' = True, convert_boolean: 'bool_t' = True, convert_floating: 'bool_t' = True, dtype_backend: 'DtypeBackend' = 'numpy_nullable') -> 'Self'\n",
      " |      Convert columns to the best possible dtypes using dtypes supporting ``pd.NA``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      infer_objects : bool, default True\n",
      " |          Whether object dtypes should be converted to the best possible types.\n",
      " |      convert_string : bool, default True\n",
      " |          Whether object dtypes should be converted to ``StringDtype()``.\n",
      " |      convert_integer : bool, default True\n",
      " |          Whether, if possible, conversion can be done to integer extension types.\n",
      " |      convert_boolean : bool, defaults True\n",
      " |          Whether object dtypes should be converted to ``BooleanDtypes()``.\n",
      " |      convert_floating : bool, defaults True\n",
      " |          Whether, if possible, conversion can be done to floating extension types.\n",
      " |          If `convert_integer` is also True, preference will be give to integer\n",
      " |          dtypes if the floats can be faithfully casted to integers.\n",
      " |      dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'\n",
      " |          Back-end data type applied to the resultant :class:`DataFrame`\n",
      " |          (still experimental). Behaviour is as follows:\n",
      " |      \n",
      " |          * ``\"numpy_nullable\"``: returns nullable-dtype-backed :class:`DataFrame`\n",
      " |            (default).\n",
      " |          * ``\"pyarrow\"``: returns pyarrow-backed nullable :class:`ArrowDtype`\n",
      " |            DataFrame.\n",
      " |      \n",
      " |          .. versionadded:: 2.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          Copy of input object with new dtype.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      infer_objects : Infer dtypes of objects.\n",
      " |      to_datetime : Convert argument to datetime.\n",
      " |      to_timedelta : Convert argument to timedelta.\n",
      " |      to_numeric : Convert argument to a numeric type.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      By default, ``convert_dtypes`` will attempt to convert a Series (or each\n",
      " |      Series in a DataFrame) to dtypes that support ``pd.NA``. By using the options\n",
      " |      ``convert_string``, ``convert_integer``, ``convert_boolean`` and\n",
      " |      ``convert_floating``, it is possible to turn off individual conversions\n",
      " |      to ``StringDtype``, the integer extension types, ``BooleanDtype``\n",
      " |      or floating extension types, respectively.\n",
      " |      \n",
      " |      For object-dtyped columns, if ``infer_objects`` is ``True``, use the inference\n",
      " |      rules as during normal Series/DataFrame construction.  Then, if possible,\n",
      " |      convert to ``StringDtype``, ``BooleanDtype`` or an appropriate integer\n",
      " |      or floating extension type, otherwise leave as ``object``.\n",
      " |      \n",
      " |      If the dtype is integer, convert to an appropriate integer extension type.\n",
      " |      \n",
      " |      If the dtype is numeric, and consists of all integers, convert to an\n",
      " |      appropriate integer extension type. Otherwise, convert to an\n",
      " |      appropriate floating extension type.\n",
      " |      \n",
      " |      In the future, as new dtypes are added that support ``pd.NA``, the results\n",
      " |      of this method will change to support those new dtypes.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame(\n",
      " |      ...     {\n",
      " |      ...         \"a\": pd.Series([1, 2, 3], dtype=np.dtype(\"int32\")),\n",
      " |      ...         \"b\": pd.Series([\"x\", \"y\", \"z\"], dtype=np.dtype(\"O\")),\n",
      " |      ...         \"c\": pd.Series([True, False, np.nan], dtype=np.dtype(\"O\")),\n",
      " |      ...         \"d\": pd.Series([\"h\", \"i\", np.nan], dtype=np.dtype(\"O\")),\n",
      " |      ...         \"e\": pd.Series([10, np.nan, 20], dtype=np.dtype(\"float\")),\n",
      " |      ...         \"f\": pd.Series([np.nan, 100.5, 200], dtype=np.dtype(\"float\")),\n",
      " |      ...     }\n",
      " |      ... )\n",
      " |      \n",
      " |      Start with a DataFrame with default dtypes.\n",
      " |      \n",
      " |      >>> df\n",
      " |         a  b      c    d     e      f\n",
      " |      0  1  x   True    h  10.0    NaN\n",
      " |      1  2  y  False    i   NaN  100.5\n",
      " |      2  3  z    NaN  NaN  20.0  200.0\n",
      " |      \n",
      " |      >>> df.dtypes\n",
      " |      a      int32\n",
      " |      b     object\n",
      " |      c     object\n",
      " |      d     object\n",
      " |      e    float64\n",
      " |      f    float64\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Convert the DataFrame to use best possible dtypes.\n",
      " |      \n",
      " |      >>> dfn = df.convert_dtypes()\n",
      " |      >>> dfn\n",
      " |         a  b      c     d     e      f\n",
      " |      0  1  x   True     h    10   <NA>\n",
      " |      1  2  y  False     i  <NA>  100.5\n",
      " |      2  3  z   <NA>  <NA>    20  200.0\n",
      " |      \n",
      " |      >>> dfn.dtypes\n",
      " |      a             Int32\n",
      " |      b    string[python]\n",
      " |      c           boolean\n",
      " |      d    string[python]\n",
      " |      e             Int64\n",
      " |      f           Float64\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Start with a Series of strings and missing data represented by ``np.nan``.\n",
      " |      \n",
      " |      >>> s = pd.Series([\"a\", \"b\", np.nan])\n",
      " |      >>> s\n",
      " |      0      a\n",
      " |      1      b\n",
      " |      2    NaN\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Obtain a Series with dtype ``StringDtype``.\n",
      " |      \n",
      " |      >>> s.convert_dtypes()\n",
      " |      0       a\n",
      " |      1       b\n",
      " |      2    <NA>\n",
      " |      dtype: string\n",
      " |  \n",
      " |  copy(self, deep: 'bool_t | None' = True) -> 'Self'\n",
      " |      Make a copy of this object's indices and data.\n",
      " |      \n",
      " |      When ``deep=True`` (default), a new object will be created with a\n",
      " |      copy of the calling object's data and indices. Modifications to\n",
      " |      the data or indices of the copy will not be reflected in the\n",
      " |      original object (see notes below).\n",
      " |      \n",
      " |      When ``deep=False``, a new object will be created without copying\n",
      " |      the calling object's data or index (only references to the data\n",
      " |      and index are copied). Any changes to the data of the original\n",
      " |      will be reflected in the shallow copy (and vice versa).\n",
      " |      \n",
      " |      .. note::\n",
      " |          The ``deep=False`` behaviour as described above will change\n",
      " |          in pandas 3.0. `Copy-on-Write\n",
      " |          <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |          will be enabled by default, which means that the \"shallow\" copy\n",
      " |          is that is returned with ``deep=False`` will still avoid making\n",
      " |          an eager copy, but changes to the data of the original will *no*\n",
      " |          longer be reflected in the shallow copy (or vice versa). Instead,\n",
      " |          it makes use of a lazy (deferred) copy mechanism that will copy\n",
      " |          the data only when any changes to the original or shallow copy is\n",
      " |          made.\n",
      " |      \n",
      " |          You can already get the future behavior and improvements through\n",
      " |          enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      deep : bool, default True\n",
      " |          Make a deep copy, including a copy of the data and the indices.\n",
      " |          With ``deep=False`` neither the indices nor the data are copied.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          Object type matches caller.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      When ``deep=True``, data is copied but actual Python objects\n",
      " |      will not be copied recursively, only the reference to the object.\n",
      " |      This is in contrast to `copy.deepcopy` in the Standard Library,\n",
      " |      which recursively copies object data (see examples below).\n",
      " |      \n",
      " |      While ``Index`` objects are copied when ``deep=True``, the underlying\n",
      " |      numpy array is not copied for performance reasons. Since ``Index`` is\n",
      " |      immutable, the underlying data can be safely shared and a copy\n",
      " |      is not needed.\n",
      " |      \n",
      " |      Since pandas is not thread safe, see the\n",
      " |      :ref:`gotchas <gotchas.thread-safety>` when copying in a threading\n",
      " |      environment.\n",
      " |      \n",
      " |      When ``copy_on_write`` in pandas config is set to ``True``, the\n",
      " |      ``copy_on_write`` config takes effect even when ``deep=False``.\n",
      " |      This means that any changes to the copied data would make a new copy\n",
      " |      of the data upon write (and vice versa). Changes made to either the\n",
      " |      original or copied variable would not be reflected in the counterpart.\n",
      " |      See :ref:`Copy_on_Write <copy_on_write>` for more information.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series([1, 2], index=[\"a\", \"b\"])\n",
      " |      >>> s\n",
      " |      a    1\n",
      " |      b    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s_copy = s.copy()\n",
      " |      >>> s_copy\n",
      " |      a    1\n",
      " |      b    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      **Shallow copy versus default (deep) copy:**\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2], index=[\"a\", \"b\"])\n",
      " |      >>> deep = s.copy()\n",
      " |      >>> shallow = s.copy(deep=False)\n",
      " |      \n",
      " |      Shallow copy shares data and index with original.\n",
      " |      \n",
      " |      >>> s is shallow\n",
      " |      False\n",
      " |      >>> s.values is shallow.values and s.index is shallow.index\n",
      " |      True\n",
      " |      \n",
      " |      Deep copy has own copy of data and index.\n",
      " |      \n",
      " |      >>> s is deep\n",
      " |      False\n",
      " |      >>> s.values is deep.values or s.index is deep.index\n",
      " |      False\n",
      " |      \n",
      " |      Updates to the data shared by shallow copy and original is reflected\n",
      " |      in both (NOTE: this will no longer be true for pandas >= 3.0);\n",
      " |      deep copy remains unchanged.\n",
      " |      \n",
      " |      >>> s.iloc[0] = 3\n",
      " |      >>> shallow.iloc[1] = 4\n",
      " |      >>> s\n",
      " |      a    3\n",
      " |      b    4\n",
      " |      dtype: int64\n",
      " |      >>> shallow\n",
      " |      a    3\n",
      " |      b    4\n",
      " |      dtype: int64\n",
      " |      >>> deep\n",
      " |      a    1\n",
      " |      b    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Note that when copying an object containing Python objects, a deep copy\n",
      " |      will copy the data, but will not do so recursively. Updating a nested\n",
      " |      data object will be reflected in the deep copy.\n",
      " |      \n",
      " |      >>> s = pd.Series([[1, 2], [3, 4]])\n",
      " |      >>> deep = s.copy()\n",
      " |      >>> s[0][0] = 10\n",
      " |      >>> s\n",
      " |      0    [10, 2]\n",
      " |      1     [3, 4]\n",
      " |      dtype: object\n",
      " |      >>> deep\n",
      " |      0    [10, 2]\n",
      " |      1     [3, 4]\n",
      " |      dtype: object\n",
      " |      \n",
      " |      **Copy-on-Write is set to true**, the shallow copy is not modified\n",
      " |      when the original data is changed:\n",
      " |      \n",
      " |      >>> with pd.option_context(\"mode.copy_on_write\", True):\n",
      " |      ...     s = pd.Series([1, 2], index=[\"a\", \"b\"])\n",
      " |      ...     copy = s.copy(deep=False)\n",
      " |      ...     s.iloc[0] = 100\n",
      " |      ...     s\n",
      " |      a    100\n",
      " |      b      2\n",
      " |      dtype: int64\n",
      " |      >>> copy\n",
      " |      a    1\n",
      " |      b    2\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  describe(self, percentiles=None, include=None, exclude=None) -> 'Self'\n",
      " |      Generate descriptive statistics.\n",
      " |      \n",
      " |      Descriptive statistics include those that summarize the central\n",
      " |      tendency, dispersion and shape of a\n",
      " |      dataset's distribution, excluding ``NaN`` values.\n",
      " |      \n",
      " |      Analyzes both numeric and object series, as well\n",
      " |      as ``DataFrame`` column sets of mixed data types. The output\n",
      " |      will vary depending on what is provided. Refer to the notes\n",
      " |      below for more detail.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      percentiles : list-like of numbers, optional\n",
      " |          The percentiles to include in the output. All should\n",
      " |          fall between 0 and 1. The default is\n",
      " |          ``[.25, .5, .75]``, which returns the 25th, 50th, and\n",
      " |          75th percentiles.\n",
      " |      include : 'all', list-like of dtypes or None (default), optional\n",
      " |          A white list of data types to include in the result. Ignored\n",
      " |          for ``Series``. Here are the options:\n",
      " |      \n",
      " |          - 'all' : All columns of the input will be included in the output.\n",
      " |          - A list-like of dtypes : Limits the results to the\n",
      " |            provided data types.\n",
      " |            To limit the result to numeric types submit\n",
      " |            ``numpy.number``. To limit it instead to object columns submit\n",
      " |            the ``numpy.object`` data type. Strings\n",
      " |            can also be used in the style of\n",
      " |            ``select_dtypes`` (e.g. ``df.describe(include=['O'])``). To\n",
      " |            select pandas categorical columns, use ``'category'``\n",
      " |          - None (default) : The result will include all numeric columns.\n",
      " |      exclude : list-like of dtypes or None (default), optional,\n",
      " |          A black list of data types to omit from the result. Ignored\n",
      " |          for ``Series``. Here are the options:\n",
      " |      \n",
      " |          - A list-like of dtypes : Excludes the provided data types\n",
      " |            from the result. To exclude numeric types submit\n",
      " |            ``numpy.number``. To exclude object columns submit the data\n",
      " |            type ``numpy.object``. Strings can also be used in the style of\n",
      " |            ``select_dtypes`` (e.g. ``df.describe(exclude=['O'])``). To\n",
      " |            exclude pandas categorical columns, use ``'category'``\n",
      " |          - None (default) : The result will exclude nothing.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          Summary statistics of the Series or Dataframe provided.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.count: Count number of non-NA/null observations.\n",
      " |      DataFrame.max: Maximum of the values in the object.\n",
      " |      DataFrame.min: Minimum of the values in the object.\n",
      " |      DataFrame.mean: Mean of the values.\n",
      " |      DataFrame.std: Standard deviation of the observations.\n",
      " |      DataFrame.select_dtypes: Subset of a DataFrame including/excluding\n",
      " |          columns based on their dtype.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For numeric data, the result's index will include ``count``,\n",
      " |      ``mean``, ``std``, ``min``, ``max`` as well as lower, ``50`` and\n",
      " |      upper percentiles. By default the lower percentile is ``25`` and the\n",
      " |      upper percentile is ``75``. The ``50`` percentile is the\n",
      " |      same as the median.\n",
      " |      \n",
      " |      For object data (e.g. strings or timestamps), the result's index\n",
      " |      will include ``count``, ``unique``, ``top``, and ``freq``. The ``top``\n",
      " |      is the most common value. The ``freq`` is the most common value's\n",
      " |      frequency. Timestamps also include the ``first`` and ``last`` items.\n",
      " |      \n",
      " |      If multiple object values have the highest count, then the\n",
      " |      ``count`` and ``top`` results will be arbitrarily chosen from\n",
      " |      among those with the highest count.\n",
      " |      \n",
      " |      For mixed data types provided via a ``DataFrame``, the default is to\n",
      " |      return only an analysis of numeric columns. If the dataframe consists\n",
      " |      only of object and categorical data without any numeric columns, the\n",
      " |      default is to return an analysis of both the object and categorical\n",
      " |      columns. If ``include='all'`` is provided as an option, the result\n",
      " |      will include a union of attributes of each type.\n",
      " |      \n",
      " |      The `include` and `exclude` parameters can be used to limit\n",
      " |      which columns in a ``DataFrame`` are analyzed for the output.\n",
      " |      The parameters are ignored when analyzing a ``Series``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Describing a numeric ``Series``.\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3])\n",
      " |      >>> s.describe()\n",
      " |      count    3.0\n",
      " |      mean     2.0\n",
      " |      std      1.0\n",
      " |      min      1.0\n",
      " |      25%      1.5\n",
      " |      50%      2.0\n",
      " |      75%      2.5\n",
      " |      max      3.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Describing a categorical ``Series``.\n",
      " |      \n",
      " |      >>> s = pd.Series(['a', 'a', 'b', 'c'])\n",
      " |      >>> s.describe()\n",
      " |      count     4\n",
      " |      unique    3\n",
      " |      top       a\n",
      " |      freq      2\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Describing a timestamp ``Series``.\n",
      " |      \n",
      " |      >>> s = pd.Series([\n",
      " |      ...     np.datetime64(\"2000-01-01\"),\n",
      " |      ...     np.datetime64(\"2010-01-01\"),\n",
      " |      ...     np.datetime64(\"2010-01-01\")\n",
      " |      ... ])\n",
      " |      >>> s.describe()\n",
      " |      count                      3\n",
      " |      mean     2006-09-01 08:00:00\n",
      " |      min      2000-01-01 00:00:00\n",
      " |      25%      2004-12-31 12:00:00\n",
      " |      50%      2010-01-01 00:00:00\n",
      " |      75%      2010-01-01 00:00:00\n",
      " |      max      2010-01-01 00:00:00\n",
      " |      dtype: object\n",
      " |      \n",
      " |      Describing a ``DataFrame``. By default only numeric fields\n",
      " |      are returned.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'categorical': pd.Categorical(['d', 'e', 'f']),\n",
      " |      ...                    'numeric': [1, 2, 3],\n",
      " |      ...                    'object': ['a', 'b', 'c']\n",
      " |      ...                    })\n",
      " |      >>> df.describe()\n",
      " |             numeric\n",
      " |      count      3.0\n",
      " |      mean       2.0\n",
      " |      std        1.0\n",
      " |      min        1.0\n",
      " |      25%        1.5\n",
      " |      50%        2.0\n",
      " |      75%        2.5\n",
      " |      max        3.0\n",
      " |      \n",
      " |      Describing all columns of a ``DataFrame`` regardless of data type.\n",
      " |      \n",
      " |      >>> df.describe(include='all')  # doctest: +SKIP\n",
      " |             categorical  numeric object\n",
      " |      count            3      3.0      3\n",
      " |      unique           3      NaN      3\n",
      " |      top              f      NaN      a\n",
      " |      freq             1      NaN      1\n",
      " |      mean           NaN      2.0    NaN\n",
      " |      std            NaN      1.0    NaN\n",
      " |      min            NaN      1.0    NaN\n",
      " |      25%            NaN      1.5    NaN\n",
      " |      50%            NaN      2.0    NaN\n",
      " |      75%            NaN      2.5    NaN\n",
      " |      max            NaN      3.0    NaN\n",
      " |      \n",
      " |      Describing a column from a ``DataFrame`` by accessing it as\n",
      " |      an attribute.\n",
      " |      \n",
      " |      >>> df.numeric.describe()\n",
      " |      count    3.0\n",
      " |      mean     2.0\n",
      " |      std      1.0\n",
      " |      min      1.0\n",
      " |      25%      1.5\n",
      " |      50%      2.0\n",
      " |      75%      2.5\n",
      " |      max      3.0\n",
      " |      Name: numeric, dtype: float64\n",
      " |      \n",
      " |      Including only numeric columns in a ``DataFrame`` description.\n",
      " |      \n",
      " |      >>> df.describe(include=[np.number])\n",
      " |             numeric\n",
      " |      count      3.0\n",
      " |      mean       2.0\n",
      " |      std        1.0\n",
      " |      min        1.0\n",
      " |      25%        1.5\n",
      " |      50%        2.0\n",
      " |      75%        2.5\n",
      " |      max        3.0\n",
      " |      \n",
      " |      Including only string columns in a ``DataFrame`` description.\n",
      " |      \n",
      " |      >>> df.describe(include=[object])  # doctest: +SKIP\n",
      " |             object\n",
      " |      count       3\n",
      " |      unique      3\n",
      " |      top         a\n",
      " |      freq        1\n",
      " |      \n",
      " |      Including only categorical columns from a ``DataFrame`` description.\n",
      " |      \n",
      " |      >>> df.describe(include=['category'])\n",
      " |             categorical\n",
      " |      count            3\n",
      " |      unique           3\n",
      " |      top              d\n",
      " |      freq             1\n",
      " |      \n",
      " |      Excluding numeric columns from a ``DataFrame`` description.\n",
      " |      \n",
      " |      >>> df.describe(exclude=[np.number])  # doctest: +SKIP\n",
      " |             categorical object\n",
      " |      count            3      3\n",
      " |      unique           3      3\n",
      " |      top              f      a\n",
      " |      freq             1      1\n",
      " |      \n",
      " |      Excluding object columns from a ``DataFrame`` description.\n",
      " |      \n",
      " |      >>> df.describe(exclude=[object])  # doctest: +SKIP\n",
      " |             categorical  numeric\n",
      " |      count            3      3.0\n",
      " |      unique           3      NaN\n",
      " |      top              f      NaN\n",
      " |      freq             1      NaN\n",
      " |      mean           NaN      2.0\n",
      " |      std            NaN      1.0\n",
      " |      min            NaN      1.0\n",
      " |      25%            NaN      1.5\n",
      " |      50%            NaN      2.0\n",
      " |      75%            NaN      2.5\n",
      " |      max            NaN      3.0\n",
      " |  \n",
      " |  droplevel(self, level: 'IndexLabel', axis: 'Axis' = 0) -> 'Self'\n",
      " |      Return Series/DataFrame with requested index / column level(s) removed.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      level : int, str, or list-like\n",
      " |          If a string is given, must be the name of a level\n",
      " |          If list-like, elements must be names or positional indexes\n",
      " |          of levels.\n",
      " |      \n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          Axis along which the level(s) is removed:\n",
      " |      \n",
      " |          * 0 or 'index': remove level(s) in column.\n",
      " |          * 1 or 'columns': remove level(s) in row.\n",
      " |      \n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame\n",
      " |          Series/DataFrame with requested index / column level(s) removed.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([\n",
      " |      ...     [1, 2, 3, 4],\n",
      " |      ...     [5, 6, 7, 8],\n",
      " |      ...     [9, 10, 11, 12]\n",
      " |      ... ]).set_index([0, 1]).rename_axis(['a', 'b'])\n",
      " |      \n",
      " |      >>> df.columns = pd.MultiIndex.from_tuples([\n",
      " |      ...     ('c', 'e'), ('d', 'f')\n",
      " |      ... ], names=['level_1', 'level_2'])\n",
      " |      \n",
      " |      >>> df\n",
      " |      level_1   c   d\n",
      " |      level_2   e   f\n",
      " |      a b\n",
      " |      1 2      3   4\n",
      " |      5 6      7   8\n",
      " |      9 10    11  12\n",
      " |      \n",
      " |      >>> df.droplevel('a')\n",
      " |      level_1   c   d\n",
      " |      level_2   e   f\n",
      " |      b\n",
      " |      2        3   4\n",
      " |      6        7   8\n",
      " |      10      11  12\n",
      " |      \n",
      " |      >>> df.droplevel('level_2', axis=1)\n",
      " |      level_1   c   d\n",
      " |      a b\n",
      " |      1 2      3   4\n",
      " |      5 6      7   8\n",
      " |      9 10    11  12\n",
      " |  \n",
      " |  equals(self, other: 'object') -> 'bool_t'\n",
      " |      Test whether two objects contain the same elements.\n",
      " |      \n",
      " |      This function allows two Series or DataFrames to be compared against\n",
      " |      each other to see if they have the same shape and elements. NaNs in\n",
      " |      the same location are considered equal.\n",
      " |      \n",
      " |      The row/column index do not need to have the same type, as long\n",
      " |      as the values are considered equal. Corresponding columns and\n",
      " |      index must be of the same dtype.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Series or DataFrame\n",
      " |          The other Series or DataFrame to be compared with the first.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      bool\n",
      " |          True if all elements are the same in both objects, False\n",
      " |          otherwise.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.eq : Compare two Series objects of the same length\n",
      " |          and return a Series where each element is True if the element\n",
      " |          in each Series is equal, False otherwise.\n",
      " |      DataFrame.eq : Compare two DataFrame objects of the same shape and\n",
      " |          return a DataFrame where each element is True if the respective\n",
      " |          element in each DataFrame is equal, False otherwise.\n",
      " |      testing.assert_series_equal : Raises an AssertionError if left and\n",
      " |          right are not equal. Provides an easy interface to ignore\n",
      " |          inequality in dtypes, indexes and precision among others.\n",
      " |      testing.assert_frame_equal : Like assert_series_equal, but targets\n",
      " |          DataFrames.\n",
      " |      numpy.array_equal : Return True if two arrays have the same shape\n",
      " |          and elements, False otherwise.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({1: [10], 2: [20]})\n",
      " |      >>> df\n",
      " |          1   2\n",
      " |      0  10  20\n",
      " |      \n",
      " |      DataFrames df and exactly_equal have the same types and values for\n",
      " |      their elements and column labels, which will return True.\n",
      " |      \n",
      " |      >>> exactly_equal = pd.DataFrame({1: [10], 2: [20]})\n",
      " |      >>> exactly_equal\n",
      " |          1   2\n",
      " |      0  10  20\n",
      " |      >>> df.equals(exactly_equal)\n",
      " |      True\n",
      " |      \n",
      " |      DataFrames df and different_column_type have the same element\n",
      " |      types and values, but have different types for the column labels,\n",
      " |      which will still return True.\n",
      " |      \n",
      " |      >>> different_column_type = pd.DataFrame({1.0: [10], 2.0: [20]})\n",
      " |      >>> different_column_type\n",
      " |         1.0  2.0\n",
      " |      0   10   20\n",
      " |      >>> df.equals(different_column_type)\n",
      " |      True\n",
      " |      \n",
      " |      DataFrames df and different_data_type have different types for the\n",
      " |      same values for their elements, and will return False even though\n",
      " |      their column labels are the same values and types.\n",
      " |      \n",
      " |      >>> different_data_type = pd.DataFrame({1: [10.0], 2: [20.0]})\n",
      " |      >>> different_data_type\n",
      " |            1     2\n",
      " |      0  10.0  20.0\n",
      " |      >>> df.equals(different_data_type)\n",
      " |      False\n",
      " |  \n",
      " |  ewm(self, com: 'float | None' = None, span: 'float | None' = None, halflife: 'float | TimedeltaConvertibleTypes | None' = None, alpha: 'float | None' = None, min_periods: 'int | None' = 0, adjust: 'bool_t' = True, ignore_na: 'bool_t' = False, axis: 'Axis | lib.NoDefault' = <no_default>, times: 'np.ndarray | DataFrame | Series | None' = None, method: \"Literal['single', 'table']\" = 'single') -> 'ExponentialMovingWindow'\n",
      " |      Provide exponentially weighted (EW) calculations.\n",
      " |      \n",
      " |      Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be\n",
      " |      provided if ``times`` is not provided. If ``times`` is provided,\n",
      " |      ``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      com : float, optional\n",
      " |          Specify decay in terms of center of mass\n",
      " |      \n",
      " |          :math:`\\alpha = 1 / (1 + com)`, for :math:`com \\geq 0`.\n",
      " |      \n",
      " |      span : float, optional\n",
      " |          Specify decay in terms of span\n",
      " |      \n",
      " |          :math:`\\alpha = 2 / (span + 1)`, for :math:`span \\geq 1`.\n",
      " |      \n",
      " |      halflife : float, str, timedelta, optional\n",
      " |          Specify decay in terms of half-life\n",
      " |      \n",
      " |          :math:`\\alpha = 1 - \\exp\\left(-\\ln(2) / halflife\\right)`, for\n",
      " |          :math:`halflife > 0`.\n",
      " |      \n",
      " |          If ``times`` is specified, a timedelta convertible unit over which an\n",
      " |          observation decays to half its value. Only applicable to ``mean()``,\n",
      " |          and halflife value will not apply to the other functions.\n",
      " |      \n",
      " |      alpha : float, optional\n",
      " |          Specify smoothing factor :math:`\\alpha` directly\n",
      " |      \n",
      " |          :math:`0 < \\alpha \\leq 1`.\n",
      " |      \n",
      " |      min_periods : int, default 0\n",
      " |          Minimum number of observations in window required to have a value;\n",
      " |          otherwise, result is ``np.nan``.\n",
      " |      \n",
      " |      adjust : bool, default True\n",
      " |          Divide by decaying adjustment factor in beginning periods to account\n",
      " |          for imbalance in relative weightings (viewing EWMA as a moving average).\n",
      " |      \n",
      " |          - When ``adjust=True`` (default), the EW function is calculated using weights\n",
      " |            :math:`w_i = (1 - \\alpha)^i`. For example, the EW moving average of the series\n",
      " |            [:math:`x_0, x_1, ..., x_t`] would be:\n",
      " |      \n",
      " |          .. math::\n",
      " |              y_t = \\frac{x_t + (1 - \\alpha)x_{t-1} + (1 - \\alpha)^2 x_{t-2} + ... + (1 -\n",
      " |              \\alpha)^t x_0}{1 + (1 - \\alpha) + (1 - \\alpha)^2 + ... + (1 - \\alpha)^t}\n",
      " |      \n",
      " |          - When ``adjust=False``, the exponentially weighted function is calculated\n",
      " |            recursively:\n",
      " |      \n",
      " |          .. math::\n",
      " |              \\begin{split}\n",
      " |                  y_0 &= x_0\\\\\n",
      " |                  y_t &= (1 - \\alpha) y_{t-1} + \\alpha x_t,\n",
      " |              \\end{split}\n",
      " |      ignore_na : bool, default False\n",
      " |          Ignore missing values when calculating weights.\n",
      " |      \n",
      " |          - When ``ignore_na=False`` (default), weights are based on absolute positions.\n",
      " |            For example, the weights of :math:`x_0` and :math:`x_2` used in calculating\n",
      " |            the final weighted average of [:math:`x_0`, None, :math:`x_2`] are\n",
      " |            :math:`(1-\\alpha)^2` and :math:`1` if ``adjust=True``, and\n",
      " |            :math:`(1-\\alpha)^2` and :math:`\\alpha` if ``adjust=False``.\n",
      " |      \n",
      " |          - When ``ignore_na=True``, weights are based\n",
      " |            on relative positions. For example, the weights of :math:`x_0` and :math:`x_2`\n",
      " |            used in calculating the final weighted average of\n",
      " |            [:math:`x_0`, None, :math:`x_2`] are :math:`1-\\alpha` and :math:`1` if\n",
      " |            ``adjust=True``, and :math:`1-\\alpha` and :math:`\\alpha` if ``adjust=False``.\n",
      " |      \n",
      " |      axis : {0, 1}, default 0\n",
      " |          If ``0`` or ``'index'``, calculate across the rows.\n",
      " |      \n",
      " |          If ``1`` or ``'columns'``, calculate across the columns.\n",
      " |      \n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |      times : np.ndarray, Series, default None\n",
      " |      \n",
      " |          Only applicable to ``mean()``.\n",
      " |      \n",
      " |          Times corresponding to the observations. Must be monotonically increasing and\n",
      " |          ``datetime64[ns]`` dtype.\n",
      " |      \n",
      " |          If 1-D array like, a sequence with the same shape as the observations.\n",
      " |      \n",
      " |      method : str {'single', 'table'}, default 'single'\n",
      " |          .. versionadded:: 1.4.0\n",
      " |      \n",
      " |          Execute the rolling operation per single column or row (``'single'``)\n",
      " |          or over the entire object (``'table'``).\n",
      " |      \n",
      " |          This argument is only implemented when specifying ``engine='numba'``\n",
      " |          in the method call.\n",
      " |      \n",
      " |          Only applicable to ``mean()``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      pandas.api.typing.ExponentialMovingWindow\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      rolling : Provides rolling window calculations.\n",
      " |      expanding : Provides expanding transformations.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See :ref:`Windowing Operations <window.exponentially_weighted>`\n",
      " |      for further usage details and examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})\n",
      " |      >>> df\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      1  1.0\n",
      " |      2  2.0\n",
      " |      3  NaN\n",
      " |      4  4.0\n",
      " |      \n",
      " |      >>> df.ewm(com=0.5).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.750000\n",
      " |      2  1.615385\n",
      " |      3  1.615385\n",
      " |      4  3.670213\n",
      " |      >>> df.ewm(alpha=2 / 3).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.750000\n",
      " |      2  1.615385\n",
      " |      3  1.615385\n",
      " |      4  3.670213\n",
      " |      \n",
      " |      **adjust**\n",
      " |      \n",
      " |      >>> df.ewm(com=0.5, adjust=True).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.750000\n",
      " |      2  1.615385\n",
      " |      3  1.615385\n",
      " |      4  3.670213\n",
      " |      >>> df.ewm(com=0.5, adjust=False).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.666667\n",
      " |      2  1.555556\n",
      " |      3  1.555556\n",
      " |      4  3.650794\n",
      " |      \n",
      " |      **ignore_na**\n",
      " |      \n",
      " |      >>> df.ewm(com=0.5, ignore_na=True).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.750000\n",
      " |      2  1.615385\n",
      " |      3  1.615385\n",
      " |      4  3.225000\n",
      " |      >>> df.ewm(com=0.5, ignore_na=False).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.750000\n",
      " |      2  1.615385\n",
      " |      3  1.615385\n",
      " |      4  3.670213\n",
      " |      \n",
      " |      **times**\n",
      " |      \n",
      " |      Exponentially weighted mean with weights calculated with a timedelta ``halflife``\n",
      " |      relative to ``times``.\n",
      " |      \n",
      " |      >>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17']\n",
      " |      >>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean()\n",
      " |                B\n",
      " |      0  0.000000\n",
      " |      1  0.585786\n",
      " |      2  1.523889\n",
      " |      3  1.523889\n",
      " |      4  3.233686\n",
      " |  \n",
      " |  expanding(self, min_periods: 'int' = 1, axis: 'Axis | lib.NoDefault' = <no_default>, method: \"Literal['single', 'table']\" = 'single') -> 'Expanding'\n",
      " |      Provide expanding window calculations.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      min_periods : int, default 1\n",
      " |          Minimum number of observations in window required to have a value;\n",
      " |          otherwise, result is ``np.nan``.\n",
      " |      \n",
      " |      axis : int or str, default 0\n",
      " |          If ``0`` or ``'index'``, roll across the rows.\n",
      " |      \n",
      " |          If ``1`` or ``'columns'``, roll across the columns.\n",
      " |      \n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |      method : str {'single', 'table'}, default 'single'\n",
      " |          Execute the rolling operation per single column or row (``'single'``)\n",
      " |          or over the entire object (``'table'``).\n",
      " |      \n",
      " |          This argument is only implemented when specifying ``engine='numba'``\n",
      " |          in the method call.\n",
      " |      \n",
      " |          .. versionadded:: 1.3.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      pandas.api.typing.Expanding\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      rolling : Provides rolling window calculations.\n",
      " |      ewm : Provides exponential weighted functions.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See :ref:`Windowing Operations <window.expanding>` for further usage details\n",
      " |      and examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({\"B\": [0, 1, 2, np.nan, 4]})\n",
      " |      >>> df\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      1  1.0\n",
      " |      2  2.0\n",
      " |      3  NaN\n",
      " |      4  4.0\n",
      " |      \n",
      " |      **min_periods**\n",
      " |      \n",
      " |      Expanding sum with 1 vs 3 observations needed to calculate a value.\n",
      " |      \n",
      " |      >>> df.expanding(1).sum()\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      1  1.0\n",
      " |      2  3.0\n",
      " |      3  3.0\n",
      " |      4  7.0\n",
      " |      >>> df.expanding(3).sum()\n",
      " |           B\n",
      " |      0  NaN\n",
      " |      1  NaN\n",
      " |      2  3.0\n",
      " |      3  3.0\n",
      " |      4  7.0\n",
      " |  \n",
      " |  ffill(self, *, axis: 'None | Axis' = None, inplace: 'bool_t' = False, limit: 'None | int' = None, limit_area: \"Literal['inside', 'outside'] | None\" = None, downcast: 'dict | None | lib.NoDefault' = <no_default>) -> 'Self | None'\n",
      " |      Fill NA/NaN values by propagating the last valid observation to next valid.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame\n",
      " |          Axis along which to fill missing values. For `Series`\n",
      " |          this parameter is unused and defaults to 0.\n",
      " |      inplace : bool, default False\n",
      " |          If True, fill in-place. Note: this will modify any\n",
      " |          other views on this object (e.g., a no-copy slice for a column in a\n",
      " |          DataFrame).\n",
      " |      limit : int, default None\n",
      " |          If method is specified, this is the maximum number of consecutive\n",
      " |          NaN values to forward/backward fill. In other words, if there is\n",
      " |          a gap with more than this number of consecutive NaNs, it will only\n",
      " |          be partially filled. If method is not specified, this is the\n",
      " |          maximum number of entries along the entire axis where NaNs will be\n",
      " |          filled. Must be greater than 0 if not None.\n",
      " |      limit_area : {`None`, 'inside', 'outside'}, default None\n",
      " |          If limit is specified, consecutive NaNs will be filled with this\n",
      " |          restriction.\n",
      " |      \n",
      " |          * ``None``: No fill restriction.\n",
      " |          * 'inside': Only fill NaNs surrounded by valid values\n",
      " |            (interpolate).\n",
      " |          * 'outside': Only fill NaNs outside valid values (extrapolate).\n",
      " |      \n",
      " |          .. versionadded:: 2.2.0\n",
      " |      \n",
      " |      downcast : dict, default is None\n",
      " |          A dict of item->dtype of what to downcast if possible,\n",
      " |          or the string 'infer' which will try to downcast to an appropriate\n",
      " |          equal type (e.g. float64 to int64 if possible).\n",
      " |      \n",
      " |          .. deprecated:: 2.2.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame or None\n",
      " |          Object with missing values filled or None if ``inplace=True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],\n",
      " |      ...                    [3, 4, np.nan, 1],\n",
      " |      ...                    [np.nan, np.nan, np.nan, np.nan],\n",
      " |      ...                    [np.nan, 3, np.nan, 4]],\n",
      " |      ...                   columns=list(\"ABCD\"))\n",
      " |      >>> df\n",
      " |           A    B   C    D\n",
      " |      0  NaN  2.0 NaN  0.0\n",
      " |      1  3.0  4.0 NaN  1.0\n",
      " |      2  NaN  NaN NaN  NaN\n",
      " |      3  NaN  3.0 NaN  4.0\n",
      " |      \n",
      " |      >>> df.ffill()\n",
      " |           A    B   C    D\n",
      " |      0  NaN  2.0 NaN  0.0\n",
      " |      1  3.0  4.0 NaN  1.0\n",
      " |      2  3.0  4.0 NaN  1.0\n",
      " |      3  3.0  3.0 NaN  4.0\n",
      " |      \n",
      " |      >>> ser = pd.Series([1, np.nan, 2, 3])\n",
      " |      >>> ser.ffill()\n",
      " |      0   1.0\n",
      " |      1   1.0\n",
      " |      2   2.0\n",
      " |      3   3.0\n",
      " |      dtype: float64\n",
      " |  \n",
      " |  fillna(self, value: 'Hashable | Mapping | Series | DataFrame | None' = None, *, method: 'FillnaOptions | None' = None, axis: 'Axis | None' = None, inplace: 'bool_t' = False, limit: 'int | None' = None, downcast: 'dict | None | lib.NoDefault' = <no_default>) -> 'Self | None'\n",
      " |      Fill NA/NaN values using the specified method.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      value : scalar, dict, Series, or DataFrame\n",
      " |          Value to use to fill holes (e.g. 0), alternately a\n",
      " |          dict/Series/DataFrame of values specifying which value to use for\n",
      " |          each index (for a Series) or column (for a DataFrame).  Values not\n",
      " |          in the dict/Series/DataFrame will not be filled. This value cannot\n",
      " |          be a list.\n",
      " |      method : {'backfill', 'bfill', 'ffill', None}, default None\n",
      " |          Method to use for filling holes in reindexed Series:\n",
      " |      \n",
      " |          * ffill: propagate last valid observation forward to next valid.\n",
      " |          * backfill / bfill: use next valid observation to fill gap.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |              Use ffill or bfill instead.\n",
      " |      \n",
      " |      axis : {0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame\n",
      " |          Axis along which to fill missing values. For `Series`\n",
      " |          this parameter is unused and defaults to 0.\n",
      " |      inplace : bool, default False\n",
      " |          If True, fill in-place. Note: this will modify any\n",
      " |          other views on this object (e.g., a no-copy slice for a column in a\n",
      " |          DataFrame).\n",
      " |      limit : int, default None\n",
      " |          If method is specified, this is the maximum number of consecutive\n",
      " |          NaN values to forward/backward fill. In other words, if there is\n",
      " |          a gap with more than this number of consecutive NaNs, it will only\n",
      " |          be partially filled. If method is not specified, this is the\n",
      " |          maximum number of entries along the entire axis where NaNs will be\n",
      " |          filled. Must be greater than 0 if not None.\n",
      " |      downcast : dict, default is None\n",
      " |          A dict of item->dtype of what to downcast if possible,\n",
      " |          or the string 'infer' which will try to downcast to an appropriate\n",
      " |          equal type (e.g. float64 to int64 if possible).\n",
      " |      \n",
      " |          .. deprecated:: 2.2.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame or None\n",
      " |          Object with missing values filled or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      ffill : Fill values by propagating the last valid observation to next valid.\n",
      " |      bfill : Fill values by using the next valid observation to fill the gap.\n",
      " |      interpolate : Fill NaN values using interpolation.\n",
      " |      reindex : Conform object to new index.\n",
      " |      asfreq : Convert TimeSeries to specified frequency.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],\n",
      " |      ...                    [3, 4, np.nan, 1],\n",
      " |      ...                    [np.nan, np.nan, np.nan, np.nan],\n",
      " |      ...                    [np.nan, 3, np.nan, 4]],\n",
      " |      ...                   columns=list(\"ABCD\"))\n",
      " |      >>> df\n",
      " |           A    B   C    D\n",
      " |      0  NaN  2.0 NaN  0.0\n",
      " |      1  3.0  4.0 NaN  1.0\n",
      " |      2  NaN  NaN NaN  NaN\n",
      " |      3  NaN  3.0 NaN  4.0\n",
      " |      \n",
      " |      Replace all NaN elements with 0s.\n",
      " |      \n",
      " |      >>> df.fillna(0)\n",
      " |           A    B    C    D\n",
      " |      0  0.0  2.0  0.0  0.0\n",
      " |      1  3.0  4.0  0.0  1.0\n",
      " |      2  0.0  0.0  0.0  0.0\n",
      " |      3  0.0  3.0  0.0  4.0\n",
      " |      \n",
      " |      Replace all NaN elements in column 'A', 'B', 'C', and 'D', with 0, 1,\n",
      " |      2, and 3 respectively.\n",
      " |      \n",
      " |      >>> values = {\"A\": 0, \"B\": 1, \"C\": 2, \"D\": 3}\n",
      " |      >>> df.fillna(value=values)\n",
      " |           A    B    C    D\n",
      " |      0  0.0  2.0  2.0  0.0\n",
      " |      1  3.0  4.0  2.0  1.0\n",
      " |      2  0.0  1.0  2.0  3.0\n",
      " |      3  0.0  3.0  2.0  4.0\n",
      " |      \n",
      " |      Only replace the first NaN element.\n",
      " |      \n",
      " |      >>> df.fillna(value=values, limit=1)\n",
      " |           A    B    C    D\n",
      " |      0  0.0  2.0  2.0  0.0\n",
      " |      1  3.0  4.0  NaN  1.0\n",
      " |      2  NaN  1.0  NaN  3.0\n",
      " |      3  NaN  3.0  NaN  4.0\n",
      " |      \n",
      " |      When filling using a DataFrame, replacement happens along\n",
      " |      the same column names and same indices\n",
      " |      \n",
      " |      >>> df2 = pd.DataFrame(np.zeros((4, 4)), columns=list(\"ABCE\"))\n",
      " |      >>> df.fillna(df2)\n",
      " |           A    B    C    D\n",
      " |      0  0.0  2.0  0.0  0.0\n",
      " |      1  3.0  4.0  0.0  1.0\n",
      " |      2  0.0  0.0  0.0  NaN\n",
      " |      3  0.0  3.0  0.0  4.0\n",
      " |      \n",
      " |      Note that column D is not affected since it is not present in df2.\n",
      " |  \n",
      " |  filter(self, items=None, like: 'str | None' = None, regex: 'str | None' = None, axis: 'Axis | None' = None) -> 'Self'\n",
      " |      Subset the dataframe rows or columns according to the specified index labels.\n",
      " |      \n",
      " |      Note that this routine does not filter a dataframe on its\n",
      " |      contents. The filter is applied to the labels of the index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      items : list-like\n",
      " |          Keep labels from axis which are in items.\n",
      " |      like : str\n",
      " |          Keep labels from axis for which \"like in label == True\".\n",
      " |      regex : str (regular expression)\n",
      " |          Keep labels from axis for which re.search(regex, label) == True.\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default None\n",
      " |          The axis to filter on, expressed either as an index (int)\n",
      " |          or axis name (str). By default this is the info axis, 'columns' for\n",
      " |          DataFrame. For `Series` this parameter is unused and defaults to `None`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as input object\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.loc : Access a group of rows and columns\n",
      " |          by label(s) or a boolean array.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The ``items``, ``like``, and ``regex`` parameters are\n",
      " |      enforced to be mutually exclusive.\n",
      " |      \n",
      " |      ``axis`` defaults to the info axis that is used when indexing\n",
      " |      with ``[]``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame(np.array(([1, 2, 3], [4, 5, 6])),\n",
      " |      ...                   index=['mouse', 'rabbit'],\n",
      " |      ...                   columns=['one', 'two', 'three'])\n",
      " |      >>> df\n",
      " |              one  two  three\n",
      " |      mouse     1    2      3\n",
      " |      rabbit    4    5      6\n",
      " |      \n",
      " |      >>> # select columns by name\n",
      " |      >>> df.filter(items=['one', 'three'])\n",
      " |               one  three\n",
      " |      mouse     1      3\n",
      " |      rabbit    4      6\n",
      " |      \n",
      " |      >>> # select columns by regular expression\n",
      " |      >>> df.filter(regex='e$', axis=1)\n",
      " |               one  three\n",
      " |      mouse     1      3\n",
      " |      rabbit    4      6\n",
      " |      \n",
      " |      >>> # select rows containing 'bbi'\n",
      " |      >>> df.filter(like='bbi', axis=0)\n",
      " |               one  two  three\n",
      " |      rabbit    4    5      6\n",
      " |  \n",
      " |  first(self, offset) -> 'Self'\n",
      " |      Select initial periods of time series data based on a date offset.\n",
      " |      \n",
      " |      .. deprecated:: 2.1\n",
      " |          :meth:`.first` is deprecated and will be removed in a future version.\n",
      " |          Please create a mask and filter using `.loc` instead.\n",
      " |      \n",
      " |      For a DataFrame with a sorted DatetimeIndex, this function can\n",
      " |      select the first few rows based on a date offset.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      offset : str, DateOffset or dateutil.relativedelta\n",
      " |          The offset length of the data that will be selected. For instance,\n",
      " |          '1ME' will display all the rows having their index within the first month.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          A subset of the caller.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |          If the index is not  a :class:`DatetimeIndex`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      last : Select final periods of time series based on a date offset.\n",
      " |      at_time : Select values at a particular time of the day.\n",
      " |      between_time : Select values between particular times of the day.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> i = pd.date_range('2018-04-09', periods=4, freq='2D')\n",
      " |      >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n",
      " |      >>> ts\n",
      " |                  A\n",
      " |      2018-04-09  1\n",
      " |      2018-04-11  2\n",
      " |      2018-04-13  3\n",
      " |      2018-04-15  4\n",
      " |      \n",
      " |      Get the rows for the first 3 days:\n",
      " |      \n",
      " |      >>> ts.first('3D')\n",
      " |                  A\n",
      " |      2018-04-09  1\n",
      " |      2018-04-11  2\n",
      " |      \n",
      " |      Notice the data for 3 first calendar days were returned, not the first\n",
      " |      3 days observed in the dataset, and therefore data for 2018-04-13 was\n",
      " |      not returned.\n",
      " |  \n",
      " |  first_valid_index(self) -> 'Hashable | None'\n",
      " |      Return index for first non-NA value or None, if no non-NA value is found.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      type of index\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> s = pd.Series([None, 3, 4])\n",
      " |      >>> s.first_valid_index()\n",
      " |      1\n",
      " |      >>> s.last_valid_index()\n",
      " |      2\n",
      " |      \n",
      " |      >>> s = pd.Series([None, None])\n",
      " |      >>> print(s.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(s.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If all elements in Series are NA/null, returns None.\n",
      " |      \n",
      " |      >>> s = pd.Series()\n",
      " |      >>> print(s.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(s.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If Series is empty, returns None.\n",
      " |      \n",
      " |      For DataFrame:\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [None, None, 2], 'B': [None, 3, 4]})\n",
      " |      >>> df\n",
      " |           A      B\n",
      " |      0  NaN    NaN\n",
      " |      1  NaN    3.0\n",
      " |      2  2.0    4.0\n",
      " |      >>> df.first_valid_index()\n",
      " |      1\n",
      " |      >>> df.last_valid_index()\n",
      " |      2\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [None, None, None], 'B': [None, None, None]})\n",
      " |      >>> df\n",
      " |           A      B\n",
      " |      0  None   None\n",
      " |      1  None   None\n",
      " |      2  None   None\n",
      " |      >>> print(df.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(df.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If all elements in DataFrame are NA/null, returns None.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame()\n",
      " |      >>> df\n",
      " |      Empty DataFrame\n",
      " |      Columns: []\n",
      " |      Index: []\n",
      " |      >>> print(df.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(df.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If DataFrame is empty, returns None.\n",
      " |  \n",
      " |  get(self, key, default=None)\n",
      " |      Get item from object for given key (ex: DataFrame column).\n",
      " |      \n",
      " |      Returns default value if not found.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      key : object\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as items contained in object\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame(\n",
      " |      ...     [\n",
      " |      ...         [24.3, 75.7, \"high\"],\n",
      " |      ...         [31, 87.8, \"high\"],\n",
      " |      ...         [22, 71.6, \"medium\"],\n",
      " |      ...         [35, 95, \"medium\"],\n",
      " |      ...     ],\n",
      " |      ...     columns=[\"temp_celsius\", \"temp_fahrenheit\", \"windspeed\"],\n",
      " |      ...     index=pd.date_range(start=\"2014-02-12\", end=\"2014-02-15\", freq=\"D\"),\n",
      " |      ... )\n",
      " |      \n",
      " |      >>> df\n",
      " |                  temp_celsius  temp_fahrenheit windspeed\n",
      " |      2014-02-12          24.3             75.7      high\n",
      " |      2014-02-13          31.0             87.8      high\n",
      " |      2014-02-14          22.0             71.6    medium\n",
      " |      2014-02-15          35.0             95.0    medium\n",
      " |      \n",
      " |      >>> df.get([\"temp_celsius\", \"windspeed\"])\n",
      " |                  temp_celsius windspeed\n",
      " |      2014-02-12          24.3      high\n",
      " |      2014-02-13          31.0      high\n",
      " |      2014-02-14          22.0    medium\n",
      " |      2014-02-15          35.0    medium\n",
      " |      \n",
      " |      >>> ser = df['windspeed']\n",
      " |      >>> ser.get('2014-02-13')\n",
      " |      'high'\n",
      " |      \n",
      " |      If the key isn't found, the default value will be used.\n",
      " |      \n",
      " |      >>> df.get([\"temp_celsius\", \"temp_kelvin\"], default=\"default_value\")\n",
      " |      'default_value'\n",
      " |      \n",
      " |      >>> ser.get('2014-02-10', '[unknown]')\n",
      " |      '[unknown]'\n",
      " |  \n",
      " |  head(self, n: 'int' = 5) -> 'Self'\n",
      " |      Return the first `n` rows.\n",
      " |      \n",
      " |      This function returns the first `n` rows for the object based\n",
      " |      on position. It is useful for quickly testing if your object\n",
      " |      has the right type of data in it.\n",
      " |      \n",
      " |      For negative values of `n`, this function returns all rows except\n",
      " |      the last `|n|` rows, equivalent to ``df[:n]``.\n",
      " |      \n",
      " |      If n is larger than the number of rows, this function returns all rows.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      n : int, default 5\n",
      " |          Number of rows to select.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as caller\n",
      " |          The first `n` rows of the caller object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.tail: Returns the last `n` rows.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',\n",
      " |      ...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})\n",
      " |      >>> df\n",
      " |            animal\n",
      " |      0  alligator\n",
      " |      1        bee\n",
      " |      2     falcon\n",
      " |      3       lion\n",
      " |      4     monkey\n",
      " |      5     parrot\n",
      " |      6      shark\n",
      " |      7      whale\n",
      " |      8      zebra\n",
      " |      \n",
      " |      Viewing the first 5 lines\n",
      " |      \n",
      " |      >>> df.head()\n",
      " |            animal\n",
      " |      0  alligator\n",
      " |      1        bee\n",
      " |      2     falcon\n",
      " |      3       lion\n",
      " |      4     monkey\n",
      " |      \n",
      " |      Viewing the first `n` lines (three in this case)\n",
      " |      \n",
      " |      >>> df.head(3)\n",
      " |            animal\n",
      " |      0  alligator\n",
      " |      1        bee\n",
      " |      2     falcon\n",
      " |      \n",
      " |      For negative values of `n`\n",
      " |      \n",
      " |      >>> df.head(-3)\n",
      " |            animal\n",
      " |      0  alligator\n",
      " |      1        bee\n",
      " |      2     falcon\n",
      " |      3       lion\n",
      " |      4     monkey\n",
      " |      5     parrot\n",
      " |  \n",
      " |  infer_objects(self, copy: 'bool_t | None' = None) -> 'Self'\n",
      " |      Attempt to infer better dtypes for object columns.\n",
      " |      \n",
      " |      Attempts soft conversion of object-dtyped\n",
      " |      columns, leaving non-object and unconvertible\n",
      " |      columns unchanged. The inference rules are the\n",
      " |      same as during normal Series/DataFrame construction.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      copy : bool, default True\n",
      " |          Whether to make a copy for non-object or non-inferable columns\n",
      " |          or Series.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as input object\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      to_datetime : Convert argument to datetime.\n",
      " |      to_timedelta : Convert argument to timedelta.\n",
      " |      to_numeric : Convert argument to numeric type.\n",
      " |      convert_dtypes : Convert argument to best possible dtype.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({\"A\": [\"a\", 1, 2, 3]})\n",
      " |      >>> df = df.iloc[1:]\n",
      " |      >>> df\n",
      " |         A\n",
      " |      1  1\n",
      " |      2  2\n",
      " |      3  3\n",
      " |      \n",
      " |      >>> df.dtypes\n",
      " |      A    object\n",
      " |      dtype: object\n",
      " |      \n",
      " |      >>> df.infer_objects().dtypes\n",
      " |      A    int64\n",
      " |      dtype: object\n",
      " |  \n",
      " |  interpolate(self, method: 'InterpolateOptions' = 'linear', *, axis: 'Axis' = 0, limit: 'int | None' = None, inplace: 'bool_t' = False, limit_direction: \"Literal['forward', 'backward', 'both'] | None\" = None, limit_area: \"Literal['inside', 'outside'] | None\" = None, downcast: \"Literal['infer'] | None | lib.NoDefault\" = <no_default>, **kwargs) -> 'Self | None'\n",
      " |      Fill NaN values using an interpolation method.\n",
      " |      \n",
      " |      Please note that only ``method='linear'`` is supported for\n",
      " |      DataFrame/Series with a MultiIndex.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      method : str, default 'linear'\n",
      " |          Interpolation technique to use. One of:\n",
      " |      \n",
      " |          * 'linear': Ignore the index and treat the values as equally\n",
      " |            spaced. This is the only method supported on MultiIndexes.\n",
      " |          * 'time': Works on daily and higher resolution data to interpolate\n",
      " |            given length of interval.\n",
      " |          * 'index', 'values': use the actual numerical values of the index.\n",
      " |          * 'pad': Fill in NaNs using existing values.\n",
      " |          * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',\n",
      " |            'barycentric', 'polynomial': Passed to\n",
      " |            `scipy.interpolate.interp1d`, whereas 'spline' is passed to\n",
      " |            `scipy.interpolate.UnivariateSpline`. These methods use the numerical\n",
      " |            values of the index.  Both 'polynomial' and 'spline' require that\n",
      " |            you also specify an `order` (int), e.g.\n",
      " |            ``df.interpolate(method='polynomial', order=5)``. Note that,\n",
      " |            `slinear` method in Pandas refers to the Scipy first order `spline`\n",
      " |            instead of Pandas first order `spline`.\n",
      " |          * 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima',\n",
      " |            'cubicspline': Wrappers around the SciPy interpolation methods of\n",
      " |            similar names. See `Notes`.\n",
      " |          * 'from_derivatives': Refers to\n",
      " |            `scipy.interpolate.BPoly.from_derivatives`.\n",
      " |      \n",
      " |      axis : {{0 or 'index', 1 or 'columns', None}}, default None\n",
      " |          Axis to interpolate along. For `Series` this parameter is unused\n",
      " |          and defaults to 0.\n",
      " |      limit : int, optional\n",
      " |          Maximum number of consecutive NaNs to fill. Must be greater than\n",
      " |          0.\n",
      " |      inplace : bool, default False\n",
      " |          Update the data in place if possible.\n",
      " |      limit_direction : {{'forward', 'backward', 'both'}}, Optional\n",
      " |          Consecutive NaNs will be filled in this direction.\n",
      " |      \n",
      " |          If limit is specified:\n",
      " |              * If 'method' is 'pad' or 'ffill', 'limit_direction' must be 'forward'.\n",
      " |              * If 'method' is 'backfill' or 'bfill', 'limit_direction' must be\n",
      " |                'backwards'.\n",
      " |      \n",
      " |          If 'limit' is not specified:\n",
      " |              * If 'method' is 'backfill' or 'bfill', the default is 'backward'\n",
      " |              * else the default is 'forward'\n",
      " |      \n",
      " |          raises ValueError if `limit_direction` is 'forward' or 'both' and\n",
      " |              method is 'backfill' or 'bfill'.\n",
      " |          raises ValueError if `limit_direction` is 'backward' or 'both' and\n",
      " |              method is 'pad' or 'ffill'.\n",
      " |      \n",
      " |      limit_area : {{`None`, 'inside', 'outside'}}, default None\n",
      " |          If limit is specified, consecutive NaNs will be filled with this\n",
      " |          restriction.\n",
      " |      \n",
      " |          * ``None``: No fill restriction.\n",
      " |          * 'inside': Only fill NaNs surrounded by valid values\n",
      " |            (interpolate).\n",
      " |          * 'outside': Only fill NaNs outside valid values (extrapolate).\n",
      " |      \n",
      " |      downcast : optional, 'infer' or None, defaults to None\n",
      " |          Downcast dtypes if possible.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |      \n",
      " |      ``**kwargs`` : optional\n",
      " |          Keyword arguments to pass on to the interpolating function.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame or None\n",
      " |          Returns the same object type as the caller, interpolated at\n",
      " |          some or all ``NaN`` values or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      fillna : Fill missing values using different methods.\n",
      " |      scipy.interpolate.Akima1DInterpolator : Piecewise cubic polynomials\n",
      " |          (Akima interpolator).\n",
      " |      scipy.interpolate.BPoly.from_derivatives : Piecewise polynomial in the\n",
      " |          Bernstein basis.\n",
      " |      scipy.interpolate.interp1d : Interpolate a 1-D function.\n",
      " |      scipy.interpolate.KroghInterpolator : Interpolate polynomial (Krogh\n",
      " |          interpolator).\n",
      " |      scipy.interpolate.PchipInterpolator : PCHIP 1-d monotonic cubic\n",
      " |          interpolation.\n",
      " |      scipy.interpolate.CubicSpline : Cubic spline data interpolator.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The 'krogh', 'piecewise_polynomial', 'spline', 'pchip' and 'akima'\n",
      " |      methods are wrappers around the respective SciPy implementations of\n",
      " |      similar names. These use the actual numerical values of the index.\n",
      " |      For more information on their behavior, see the\n",
      " |      `SciPy documentation\n",
      " |      <https://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Filling in ``NaN`` in a :class:`~pandas.Series` via linear\n",
      " |      interpolation.\n",
      " |      \n",
      " |      >>> s = pd.Series([0, 1, np.nan, 3])\n",
      " |      >>> s\n",
      " |      0    0.0\n",
      " |      1    1.0\n",
      " |      2    NaN\n",
      " |      3    3.0\n",
      " |      dtype: float64\n",
      " |      >>> s.interpolate()\n",
      " |      0    0.0\n",
      " |      1    1.0\n",
      " |      2    2.0\n",
      " |      3    3.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Filling in ``NaN`` in a Series via polynomial interpolation or splines:\n",
      " |      Both 'polynomial' and 'spline' methods require that you also specify\n",
      " |      an ``order`` (int).\n",
      " |      \n",
      " |      >>> s = pd.Series([0, 2, np.nan, 8])\n",
      " |      >>> s.interpolate(method='polynomial', order=2)\n",
      " |      0    0.000000\n",
      " |      1    2.000000\n",
      " |      2    4.666667\n",
      " |      3    8.000000\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      Fill the DataFrame forward (that is, going down) along each column\n",
      " |      using linear interpolation.\n",
      " |      \n",
      " |      Note how the last entry in column 'a' is interpolated differently,\n",
      " |      because there is no entry after it to use for interpolation.\n",
      " |      Note how the first entry in column 'b' remains ``NaN``, because there\n",
      " |      is no entry before it to use for interpolation.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),\n",
      " |      ...                    (np.nan, 2.0, np.nan, np.nan),\n",
      " |      ...                    (2.0, 3.0, np.nan, 9.0),\n",
      " |      ...                    (np.nan, 4.0, -4.0, 16.0)],\n",
      " |      ...                   columns=list('abcd'))\n",
      " |      >>> df\n",
      " |           a    b    c     d\n",
      " |      0  0.0  NaN -1.0   1.0\n",
      " |      1  NaN  2.0  NaN   NaN\n",
      " |      2  2.0  3.0  NaN   9.0\n",
      " |      3  NaN  4.0 -4.0  16.0\n",
      " |      >>> df.interpolate(method='linear', limit_direction='forward', axis=0)\n",
      " |           a    b    c     d\n",
      " |      0  0.0  NaN -1.0   1.0\n",
      " |      1  1.0  2.0 -2.0   5.0\n",
      " |      2  2.0  3.0 -3.0   9.0\n",
      " |      3  2.0  4.0 -4.0  16.0\n",
      " |      \n",
      " |      Using polynomial interpolation.\n",
      " |      \n",
      " |      >>> df['d'].interpolate(method='polynomial', order=2)\n",
      " |      0     1.0\n",
      " |      1     4.0\n",
      " |      2     9.0\n",
      " |      3    16.0\n",
      " |      Name: d, dtype: float64\n",
      " |  \n",
      " |  last(self, offset) -> 'Self'\n",
      " |      Select final periods of time series data based on a date offset.\n",
      " |      \n",
      " |      .. deprecated:: 2.1\n",
      " |          :meth:`.last` is deprecated and will be removed in a future version.\n",
      " |          Please create a mask and filter using `.loc` instead.\n",
      " |      \n",
      " |      For a DataFrame with a sorted DatetimeIndex, this function\n",
      " |      selects the last few rows based on a date offset.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      offset : str, DateOffset, dateutil.relativedelta\n",
      " |          The offset length of the data that will be selected. For instance,\n",
      " |          '3D' will display all the rows having their index within the last 3 days.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          A subset of the caller.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |          If the index is not  a :class:`DatetimeIndex`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      first : Select initial periods of time series based on a date offset.\n",
      " |      at_time : Select values at a particular time of the day.\n",
      " |      between_time : Select values between particular times of the day.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      .. deprecated:: 2.1.0\n",
      " |          Please create a mask and filter using `.loc` instead\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> i = pd.date_range('2018-04-09', periods=4, freq='2D')\n",
      " |      >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)\n",
      " |      >>> ts\n",
      " |                  A\n",
      " |      2018-04-09  1\n",
      " |      2018-04-11  2\n",
      " |      2018-04-13  3\n",
      " |      2018-04-15  4\n",
      " |      \n",
      " |      Get the rows for the last 3 days:\n",
      " |      \n",
      " |      >>> ts.last('3D')  # doctest: +SKIP\n",
      " |                  A\n",
      " |      2018-04-13  3\n",
      " |      2018-04-15  4\n",
      " |      \n",
      " |      Notice the data for 3 last calendar days were returned, not the last\n",
      " |      3 observed days in the dataset, and therefore data for 2018-04-11 was\n",
      " |      not returned.\n",
      " |  \n",
      " |  last_valid_index(self) -> 'Hashable | None'\n",
      " |      Return index for last non-NA value or None, if no non-NA value is found.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      type of index\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> s = pd.Series([None, 3, 4])\n",
      " |      >>> s.first_valid_index()\n",
      " |      1\n",
      " |      >>> s.last_valid_index()\n",
      " |      2\n",
      " |      \n",
      " |      >>> s = pd.Series([None, None])\n",
      " |      >>> print(s.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(s.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If all elements in Series are NA/null, returns None.\n",
      " |      \n",
      " |      >>> s = pd.Series()\n",
      " |      >>> print(s.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(s.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If Series is empty, returns None.\n",
      " |      \n",
      " |      For DataFrame:\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [None, None, 2], 'B': [None, 3, 4]})\n",
      " |      >>> df\n",
      " |           A      B\n",
      " |      0  NaN    NaN\n",
      " |      1  NaN    3.0\n",
      " |      2  2.0    4.0\n",
      " |      >>> df.first_valid_index()\n",
      " |      1\n",
      " |      >>> df.last_valid_index()\n",
      " |      2\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [None, None, None], 'B': [None, None, None]})\n",
      " |      >>> df\n",
      " |           A      B\n",
      " |      0  None   None\n",
      " |      1  None   None\n",
      " |      2  None   None\n",
      " |      >>> print(df.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(df.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If all elements in DataFrame are NA/null, returns None.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame()\n",
      " |      >>> df\n",
      " |      Empty DataFrame\n",
      " |      Columns: []\n",
      " |      Index: []\n",
      " |      >>> print(df.first_valid_index())\n",
      " |      None\n",
      " |      >>> print(df.last_valid_index())\n",
      " |      None\n",
      " |      \n",
      " |      If DataFrame is empty, returns None.\n",
      " |  \n",
      " |  mask(self, cond, other=<no_default>, *, inplace: 'bool_t' = False, axis: 'Axis | None' = None, level: 'Level | None' = None) -> 'Self | None'\n",
      " |      Replace values where the condition is True.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      cond : bool Series/DataFrame, array-like, or callable\n",
      " |          Where `cond` is False, keep the original value. Where\n",
      " |          True, replace with corresponding value from `other`.\n",
      " |          If `cond` is callable, it is computed on the Series/DataFrame and\n",
      " |          should return boolean Series/DataFrame or array. The callable must\n",
      " |          not change input Series/DataFrame (though pandas doesn't check it).\n",
      " |      other : scalar, Series/DataFrame, or callable\n",
      " |          Entries where `cond` is True are replaced with\n",
      " |          corresponding value from `other`.\n",
      " |          If other is callable, it is computed on the Series/DataFrame and\n",
      " |          should return scalar or Series/DataFrame. The callable must not\n",
      " |          change input Series/DataFrame (though pandas doesn't check it).\n",
      " |          If not specified, entries will be filled with the corresponding\n",
      " |          NULL value (``np.nan`` for numpy dtypes, ``pd.NA`` for extension\n",
      " |          dtypes).\n",
      " |      inplace : bool, default False\n",
      " |          Whether to perform the operation in place on the data.\n",
      " |      axis : int, default None\n",
      " |          Alignment axis if needed. For `Series` this parameter is\n",
      " |          unused and defaults to 0.\n",
      " |      level : int, default None\n",
      " |          Alignment level if needed.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Same type as caller or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      :func:`DataFrame.where` : Return an object of same shape as\n",
      " |          self.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The mask method is an application of the if-then idiom. For each\n",
      " |      element in the calling DataFrame, if ``cond`` is ``False`` the\n",
      " |      element is used; otherwise the corresponding element from the DataFrame\n",
      " |      ``other`` is used. If the axis of ``other`` does not align with axis of\n",
      " |      ``cond`` Series/DataFrame, the misaligned index positions will be filled with\n",
      " |      True.\n",
      " |      \n",
      " |      The signature for :func:`DataFrame.where` differs from\n",
      " |      :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to\n",
      " |      ``np.where(m, df1, df2)``.\n",
      " |      \n",
      " |      For further details and examples see the ``mask`` documentation in\n",
      " |      :ref:`indexing <indexing.where_mask>`.\n",
      " |      \n",
      " |      The dtype of the object takes precedence. The fill value is casted to\n",
      " |      the object's dtype, if this can be done losslessly.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(range(5))\n",
      " |      >>> s.where(s > 0)\n",
      " |      0    NaN\n",
      " |      1    1.0\n",
      " |      2    2.0\n",
      " |      3    3.0\n",
      " |      4    4.0\n",
      " |      dtype: float64\n",
      " |      >>> s.mask(s > 0)\n",
      " |      0    0.0\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s = pd.Series(range(5))\n",
      " |      >>> t = pd.Series([True, False])\n",
      " |      >>> s.where(t, 99)\n",
      " |      0     0\n",
      " |      1    99\n",
      " |      2    99\n",
      " |      3    99\n",
      " |      4    99\n",
      " |      dtype: int64\n",
      " |      >>> s.mask(t, 99)\n",
      " |      0    99\n",
      " |      1     1\n",
      " |      2    99\n",
      " |      3    99\n",
      " |      4    99\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.where(s > 1, 10)\n",
      " |      0    10\n",
      " |      1    10\n",
      " |      2    2\n",
      " |      3    3\n",
      " |      4    4\n",
      " |      dtype: int64\n",
      " |      >>> s.mask(s > 1, 10)\n",
      " |      0     0\n",
      " |      1     1\n",
      " |      2    10\n",
      " |      3    10\n",
      " |      4    10\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])\n",
      " |      >>> df\n",
      " |         A  B\n",
      " |      0  0  1\n",
      " |      1  2  3\n",
      " |      2  4  5\n",
      " |      3  6  7\n",
      " |      4  8  9\n",
      " |      >>> m = df % 3 == 0\n",
      " |      >>> df.where(m, -df)\n",
      " |         A  B\n",
      " |      0  0 -1\n",
      " |      1 -2  3\n",
      " |      2 -4 -5\n",
      " |      3  6 -7\n",
      " |      4 -8  9\n",
      " |      >>> df.where(m, -df) == np.where(m, df, -df)\n",
      " |            A     B\n",
      " |      0  True  True\n",
      " |      1  True  True\n",
      " |      2  True  True\n",
      " |      3  True  True\n",
      " |      4  True  True\n",
      " |      >>> df.where(m, -df) == df.mask(~m, -df)\n",
      " |            A     B\n",
      " |      0  True  True\n",
      " |      1  True  True\n",
      " |      2  True  True\n",
      " |      3  True  True\n",
      " |      4  True  True\n",
      " |  \n",
      " |  pad(self, *, axis: 'None | Axis' = None, inplace: 'bool_t' = False, limit: 'None | int' = None, downcast: 'dict | None | lib.NoDefault' = <no_default>) -> 'Self | None'\n",
      " |      Fill NA/NaN values by propagating the last valid observation to next valid.\n",
      " |      \n",
      " |      .. deprecated:: 2.0\n",
      " |      \n",
      " |          Series/DataFrame.pad is deprecated. Use Series/DataFrame.ffill instead.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame or None\n",
      " |          Object with missing values filled or None if ``inplace=True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Please see examples for :meth:`DataFrame.ffill` or :meth:`Series.ffill`.\n",
      " |  \n",
      " |  pct_change(self, periods: 'int' = 1, fill_method: 'FillnaOptions | None | lib.NoDefault' = <no_default>, limit: 'int | None | lib.NoDefault' = <no_default>, freq=None, **kwargs) -> 'Self'\n",
      " |      Fractional change between the current and a prior element.\n",
      " |      \n",
      " |      Computes the fractional change from the immediately previous row by\n",
      " |      default. This is useful in comparing the fraction of change in a time\n",
      " |      series of elements.\n",
      " |      \n",
      " |      .. note::\n",
      " |      \n",
      " |          Despite the name of this method, it calculates fractional change\n",
      " |          (also known as per unit change or relative change) and not\n",
      " |          percentage change. If you need the percentage change, multiply\n",
      " |          these values by 100.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      periods : int, default 1\n",
      " |          Periods to shift for forming percent change.\n",
      " |      fill_method : {'backfill', 'bfill', 'pad', 'ffill', None}, default 'pad'\n",
      " |          How to handle NAs **before** computing percent changes.\n",
      " |      \n",
      " |          .. deprecated:: 2.1\n",
      " |              All options of `fill_method` are deprecated except `fill_method=None`.\n",
      " |      \n",
      " |      limit : int, default None\n",
      " |          The number of consecutive NAs to fill before stopping.\n",
      " |      \n",
      " |          .. deprecated:: 2.1\n",
      " |      \n",
      " |      freq : DateOffset, timedelta, or str, optional\n",
      " |          Increment to use from time series API (e.g. 'ME' or BDay()).\n",
      " |      **kwargs\n",
      " |          Additional keyword arguments are passed into\n",
      " |          `DataFrame.shift` or `Series.shift`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          The same type as the calling object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.diff : Compute the difference of two elements in a Series.\n",
      " |      DataFrame.diff : Compute the difference of two elements in a DataFrame.\n",
      " |      Series.shift : Shift the index by some number of periods.\n",
      " |      DataFrame.shift : Shift the index by some number of periods.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Series**\n",
      " |      \n",
      " |      >>> s = pd.Series([90, 91, 85])\n",
      " |      >>> s\n",
      " |      0    90\n",
      " |      1    91\n",
      " |      2    85\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.pct_change()\n",
      " |      0         NaN\n",
      " |      1    0.011111\n",
      " |      2   -0.065934\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.pct_change(periods=2)\n",
      " |      0         NaN\n",
      " |      1         NaN\n",
      " |      2   -0.055556\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      See the percentage change in a Series where filling NAs with last\n",
      " |      valid observation forward to next valid.\n",
      " |      \n",
      " |      >>> s = pd.Series([90, 91, None, 85])\n",
      " |      >>> s\n",
      " |      0    90.0\n",
      " |      1    91.0\n",
      " |      2     NaN\n",
      " |      3    85.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s.ffill().pct_change()\n",
      " |      0         NaN\n",
      " |      1    0.011111\n",
      " |      2    0.000000\n",
      " |      3   -0.065934\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      **DataFrame**\n",
      " |      \n",
      " |      Percentage change in French franc, Deutsche Mark, and Italian lira from\n",
      " |      1980-01-01 to 1980-03-01.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\n",
      " |      ...     'FR': [4.0405, 4.0963, 4.3149],\n",
      " |      ...     'GR': [1.7246, 1.7482, 1.8519],\n",
      " |      ...     'IT': [804.74, 810.01, 860.13]},\n",
      " |      ...     index=['1980-01-01', '1980-02-01', '1980-03-01'])\n",
      " |      >>> df\n",
      " |                      FR      GR      IT\n",
      " |      1980-01-01  4.0405  1.7246  804.74\n",
      " |      1980-02-01  4.0963  1.7482  810.01\n",
      " |      1980-03-01  4.3149  1.8519  860.13\n",
      " |      \n",
      " |      >>> df.pct_change()\n",
      " |                        FR        GR        IT\n",
      " |      1980-01-01       NaN       NaN       NaN\n",
      " |      1980-02-01  0.013810  0.013684  0.006549\n",
      " |      1980-03-01  0.053365  0.059318  0.061876\n",
      " |      \n",
      " |      Percentage of change in GOOG and APPL stock volume. Shows computing\n",
      " |      the percentage change between columns.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\n",
      " |      ...     '2016': [1769950, 30586265],\n",
      " |      ...     '2015': [1500923, 40912316],\n",
      " |      ...     '2014': [1371819, 41403351]},\n",
      " |      ...     index=['GOOG', 'APPL'])\n",
      " |      >>> df\n",
      " |                2016      2015      2014\n",
      " |      GOOG   1769950   1500923   1371819\n",
      " |      APPL  30586265  40912316  41403351\n",
      " |      \n",
      " |      >>> df.pct_change(axis='columns', periods=-1)\n",
      " |                2016      2015  2014\n",
      " |      GOOG  0.179241  0.094112   NaN\n",
      " |      APPL -0.252395 -0.011860   NaN\n",
      " |  \n",
      " |  pipe(self, func: 'Callable[..., T] | tuple[Callable[..., T], str]', *args, **kwargs) -> 'T'\n",
      " |      Apply chainable functions that expect Series or DataFrames.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      func : function\n",
      " |          Function to apply to the Series/DataFrame.\n",
      " |          ``args``, and ``kwargs`` are passed into ``func``.\n",
      " |          Alternatively a ``(callable, data_keyword)`` tuple where\n",
      " |          ``data_keyword`` is a string indicating the keyword of\n",
      " |          ``callable`` that expects the Series/DataFrame.\n",
      " |      *args : iterable, optional\n",
      " |          Positional arguments passed into ``func``.\n",
      " |      **kwargs : mapping, optional\n",
      " |          A dictionary of keyword arguments passed into ``func``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      the return type of ``func``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.apply : Apply a function along input axis of DataFrame.\n",
      " |      DataFrame.map : Apply a function elementwise on a whole DataFrame.\n",
      " |      Series.map : Apply a mapping correspondence on a\n",
      " |          :class:`~pandas.Series`.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Use ``.pipe`` when chaining together functions that expect\n",
      " |      Series, DataFrames or GroupBy objects.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Constructing a income DataFrame from a dictionary.\n",
      " |      \n",
      " |      >>> data = [[8000, 1000], [9500, np.nan], [5000, 2000]]\n",
      " |      >>> df = pd.DataFrame(data, columns=['Salary', 'Others'])\n",
      " |      >>> df\n",
      " |         Salary  Others\n",
      " |      0    8000  1000.0\n",
      " |      1    9500     NaN\n",
      " |      2    5000  2000.0\n",
      " |      \n",
      " |      Functions that perform tax reductions on an income DataFrame.\n",
      " |      \n",
      " |      >>> def subtract_federal_tax(df):\n",
      " |      ...     return df * 0.9\n",
      " |      >>> def subtract_state_tax(df, rate):\n",
      " |      ...     return df * (1 - rate)\n",
      " |      >>> def subtract_national_insurance(df, rate, rate_increase):\n",
      " |      ...     new_rate = rate + rate_increase\n",
      " |      ...     return df * (1 - new_rate)\n",
      " |      \n",
      " |      Instead of writing\n",
      " |      \n",
      " |      >>> subtract_national_insurance(\n",
      " |      ...     subtract_state_tax(subtract_federal_tax(df), rate=0.12),\n",
      " |      ...     rate=0.05,\n",
      " |      ...     rate_increase=0.02)  # doctest: +SKIP\n",
      " |      \n",
      " |      You can write\n",
      " |      \n",
      " |      >>> (\n",
      " |      ...     df.pipe(subtract_federal_tax)\n",
      " |      ...     .pipe(subtract_state_tax, rate=0.12)\n",
      " |      ...     .pipe(subtract_national_insurance, rate=0.05, rate_increase=0.02)\n",
      " |      ... )\n",
      " |          Salary   Others\n",
      " |      0  5892.48   736.56\n",
      " |      1  6997.32      NaN\n",
      " |      2  3682.80  1473.12\n",
      " |      \n",
      " |      If you have a function that takes the data as (say) the second\n",
      " |      argument, pass a tuple indicating which keyword expects the\n",
      " |      data. For example, suppose ``national_insurance`` takes its data as ``df``\n",
      " |      in the second argument:\n",
      " |      \n",
      " |      >>> def subtract_national_insurance(rate, df, rate_increase):\n",
      " |      ...     new_rate = rate + rate_increase\n",
      " |      ...     return df * (1 - new_rate)\n",
      " |      >>> (\n",
      " |      ...     df.pipe(subtract_federal_tax)\n",
      " |      ...     .pipe(subtract_state_tax, rate=0.12)\n",
      " |      ...     .pipe(\n",
      " |      ...         (subtract_national_insurance, 'df'),\n",
      " |      ...         rate=0.05,\n",
      " |      ...         rate_increase=0.02\n",
      " |      ...     )\n",
      " |      ... )\n",
      " |          Salary   Others\n",
      " |      0  5892.48   736.56\n",
      " |      1  6997.32      NaN\n",
      " |      2  3682.80  1473.12\n",
      " |  \n",
      " |  rank(self, axis: 'Axis' = 0, method: \"Literal['average', 'min', 'max', 'first', 'dense']\" = 'average', numeric_only: 'bool_t' = False, na_option: \"Literal['keep', 'top', 'bottom']\" = 'keep', ascending: 'bool_t' = True, pct: 'bool_t' = False) -> 'Self'\n",
      " |      Compute numerical data ranks (1 through n) along axis.\n",
      " |      \n",
      " |      By default, equal values are assigned a rank that is the average of the\n",
      " |      ranks of those values.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          Index to direct ranking.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'\n",
      " |          How to rank the group of records that have the same value (i.e. ties):\n",
      " |      \n",
      " |          * average: average rank of the group\n",
      " |          * min: lowest rank in the group\n",
      " |          * max: highest rank in the group\n",
      " |          * first: ranks assigned in order they appear in the array\n",
      " |          * dense: like 'min', but rank always increases by 1 between groups.\n",
      " |      \n",
      " |      numeric_only : bool, default False\n",
      " |          For DataFrame objects, rank only numeric columns if set to True.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |              The default value of ``numeric_only`` is now ``False``.\n",
      " |      \n",
      " |      na_option : {'keep', 'top', 'bottom'}, default 'keep'\n",
      " |          How to rank NaN values:\n",
      " |      \n",
      " |          * keep: assign NaN rank to NaN values\n",
      " |          * top: assign lowest rank to NaN values\n",
      " |          * bottom: assign highest rank to NaN values\n",
      " |      \n",
      " |      ascending : bool, default True\n",
      " |          Whether or not the elements should be ranked in ascending order.\n",
      " |      pct : bool, default False\n",
      " |          Whether or not to display the returned rankings in percentile\n",
      " |          form.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as caller\n",
      " |          Return a Series or DataFrame with data ranks as values.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      core.groupby.DataFrameGroupBy.rank : Rank of values within each group.\n",
      " |      core.groupby.SeriesGroupBy.rank : Rank of values within each group.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame(data={'Animal': ['cat', 'penguin', 'dog',\n",
      " |      ...                                    'spider', 'snake'],\n",
      " |      ...                         'Number_legs': [4, 2, 4, 8, np.nan]})\n",
      " |      >>> df\n",
      " |          Animal  Number_legs\n",
      " |      0      cat          4.0\n",
      " |      1  penguin          2.0\n",
      " |      2      dog          4.0\n",
      " |      3   spider          8.0\n",
      " |      4    snake          NaN\n",
      " |      \n",
      " |      Ties are assigned the mean of the ranks (by default) for the group.\n",
      " |      \n",
      " |      >>> s = pd.Series(range(5), index=list(\"abcde\"))\n",
      " |      >>> s[\"d\"] = s[\"b\"]\n",
      " |      >>> s.rank()\n",
      " |      a    1.0\n",
      " |      b    2.5\n",
      " |      c    4.0\n",
      " |      d    2.5\n",
      " |      e    5.0\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      The following example shows how the method behaves with the above\n",
      " |      parameters:\n",
      " |      \n",
      " |      * default_rank: this is the default behaviour obtained without using\n",
      " |        any parameter.\n",
      " |      * max_rank: setting ``method = 'max'`` the records that have the\n",
      " |        same values are ranked using the highest rank (e.g.: since 'cat'\n",
      " |        and 'dog' are both in the 2nd and 3rd position, rank 3 is assigned.)\n",
      " |      * NA_bottom: choosing ``na_option = 'bottom'``, if there are records\n",
      " |        with NaN values they are placed at the bottom of the ranking.\n",
      " |      * pct_rank: when setting ``pct = True``, the ranking is expressed as\n",
      " |        percentile rank.\n",
      " |      \n",
      " |      >>> df['default_rank'] = df['Number_legs'].rank()\n",
      " |      >>> df['max_rank'] = df['Number_legs'].rank(method='max')\n",
      " |      >>> df['NA_bottom'] = df['Number_legs'].rank(na_option='bottom')\n",
      " |      >>> df['pct_rank'] = df['Number_legs'].rank(pct=True)\n",
      " |      >>> df\n",
      " |          Animal  Number_legs  default_rank  max_rank  NA_bottom  pct_rank\n",
      " |      0      cat          4.0           2.5       3.0        2.5     0.625\n",
      " |      1  penguin          2.0           1.0       1.0        1.0     0.250\n",
      " |      2      dog          4.0           2.5       3.0        2.5     0.625\n",
      " |      3   spider          8.0           4.0       4.0        4.0     1.000\n",
      " |      4    snake          NaN           NaN       NaN        5.0       NaN\n",
      " |  \n",
      " |  reindex_like(self, other, method: \"Literal['backfill', 'bfill', 'pad', 'ffill', 'nearest'] | None\" = None, copy: 'bool_t | None' = None, limit: 'int | None' = None, tolerance=None) -> 'Self'\n",
      " |      Return an object with matching indices as other object.\n",
      " |      \n",
      " |      Conform the object to the same index on all axes. Optional\n",
      " |      filling logic, placing NaN in locations having no value\n",
      " |      in the previous index. A new object is produced unless the\n",
      " |      new index is equivalent to the current one and copy=False.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      other : Object of the same data type\n",
      " |          Its row and column indices are used to define the new indices\n",
      " |          of this object.\n",
      " |      method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}\n",
      " |          Method to use for filling holes in reindexed DataFrame.\n",
      " |          Please note: this is only applicable to DataFrames/Series with a\n",
      " |          monotonically increasing/decreasing index.\n",
      " |      \n",
      " |          * None (default): don't fill gaps\n",
      " |          * pad / ffill: propagate last valid observation forward to next\n",
      " |            valid\n",
      " |          * backfill / bfill: use next valid observation to fill gap\n",
      " |          * nearest: use nearest valid observations to fill gap.\n",
      " |      \n",
      " |      copy : bool, default True\n",
      " |          Return a new object, even if the passed indexes are the same.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      limit : int, default None\n",
      " |          Maximum number of consecutive labels to fill for inexact matches.\n",
      " |      tolerance : optional\n",
      " |          Maximum distance between original and new labels for inexact\n",
      " |          matches. The values of the index at the matching locations must\n",
      " |          satisfy the equation ``abs(index[indexer] - target) <= tolerance``.\n",
      " |      \n",
      " |          Tolerance may be a scalar value, which applies the same tolerance\n",
      " |          to all values, or list-like, which applies variable tolerance per\n",
      " |          element. List-like includes list, tuple, array, Series, and must be\n",
      " |          the same size as the index and its dtype must exactly match the\n",
      " |          index's type.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          Same type as caller, but with changed indices on each axis.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.set_index : Set row labels.\n",
      " |      DataFrame.reset_index : Remove row labels or move them to new columns.\n",
      " |      DataFrame.reindex : Change to new indices or expand indices.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Same as calling\n",
      " |      ``.reindex(index=other.index, columns=other.columns,...)``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df1 = pd.DataFrame([[24.3, 75.7, 'high'],\n",
      " |      ...                     [31, 87.8, 'high'],\n",
      " |      ...                     [22, 71.6, 'medium'],\n",
      " |      ...                     [35, 95, 'medium']],\n",
      " |      ...                    columns=['temp_celsius', 'temp_fahrenheit',\n",
      " |      ...                             'windspeed'],\n",
      " |      ...                    index=pd.date_range(start='2014-02-12',\n",
      " |      ...                                        end='2014-02-15', freq='D'))\n",
      " |      \n",
      " |      >>> df1\n",
      " |                  temp_celsius  temp_fahrenheit windspeed\n",
      " |      2014-02-12          24.3             75.7      high\n",
      " |      2014-02-13          31.0             87.8      high\n",
      " |      2014-02-14          22.0             71.6    medium\n",
      " |      2014-02-15          35.0             95.0    medium\n",
      " |      \n",
      " |      >>> df2 = pd.DataFrame([[28, 'low'],\n",
      " |      ...                     [30, 'low'],\n",
      " |      ...                     [35.1, 'medium']],\n",
      " |      ...                    columns=['temp_celsius', 'windspeed'],\n",
      " |      ...                    index=pd.DatetimeIndex(['2014-02-12', '2014-02-13',\n",
      " |      ...                                            '2014-02-15']))\n",
      " |      \n",
      " |      >>> df2\n",
      " |                  temp_celsius windspeed\n",
      " |      2014-02-12          28.0       low\n",
      " |      2014-02-13          30.0       low\n",
      " |      2014-02-15          35.1    medium\n",
      " |      \n",
      " |      >>> df2.reindex_like(df1)\n",
      " |                  temp_celsius  temp_fahrenheit windspeed\n",
      " |      2014-02-12          28.0              NaN       low\n",
      " |      2014-02-13          30.0              NaN       low\n",
      " |      2014-02-14           NaN              NaN       NaN\n",
      " |      2014-02-15          35.1              NaN    medium\n",
      " |  \n",
      " |  replace(self, to_replace=None, value=<no_default>, *, inplace: 'bool_t' = False, limit: 'int | None' = None, regex: 'bool_t' = False, method: \"Literal['pad', 'ffill', 'bfill'] | lib.NoDefault\" = <no_default>) -> 'Self | None'\n",
      " |      Replace values given in `to_replace` with `value`.\n",
      " |      \n",
      " |      Values of the Series/DataFrame are replaced with other values dynamically.\n",
      " |      This differs from updating with ``.loc`` or ``.iloc``, which require\n",
      " |      you to specify a location to update with some value.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      to_replace : str, regex, list, dict, Series, int, float, or None\n",
      " |          How to find the values that will be replaced.\n",
      " |      \n",
      " |          * numeric, str or regex:\n",
      " |      \n",
      " |              - numeric: numeric values equal to `to_replace` will be\n",
      " |                replaced with `value`\n",
      " |              - str: string exactly matching `to_replace` will be replaced\n",
      " |                with `value`\n",
      " |              - regex: regexs matching `to_replace` will be replaced with\n",
      " |                `value`\n",
      " |      \n",
      " |          * list of str, regex, or numeric:\n",
      " |      \n",
      " |              - First, if `to_replace` and `value` are both lists, they\n",
      " |                **must** be the same length.\n",
      " |              - Second, if ``regex=True`` then all of the strings in **both**\n",
      " |                lists will be interpreted as regexs otherwise they will match\n",
      " |                directly. This doesn't matter much for `value` since there\n",
      " |                are only a few possible substitution regexes you can use.\n",
      " |              - str, regex and numeric rules apply as above.\n",
      " |      \n",
      " |          * dict:\n",
      " |      \n",
      " |              - Dicts can be used to specify different replacement values\n",
      " |                for different existing values. For example,\n",
      " |                ``{'a': 'b', 'y': 'z'}`` replaces the value 'a' with 'b' and\n",
      " |                'y' with 'z'. To use a dict in this way, the optional `value`\n",
      " |                parameter should not be given.\n",
      " |              - For a DataFrame a dict can specify that different values\n",
      " |                should be replaced in different columns. For example,\n",
      " |                ``{'a': 1, 'b': 'z'}`` looks for the value 1 in column 'a'\n",
      " |                and the value 'z' in column 'b' and replaces these values\n",
      " |                with whatever is specified in `value`. The `value` parameter\n",
      " |                should not be ``None`` in this case. You can treat this as a\n",
      " |                special case of passing two lists except that you are\n",
      " |                specifying the column to search in.\n",
      " |              - For a DataFrame nested dictionaries, e.g.,\n",
      " |                ``{'a': {'b': np.nan}}``, are read as follows: look in column\n",
      " |                'a' for the value 'b' and replace it with NaN. The optional `value`\n",
      " |                parameter should not be specified to use a nested dict in this\n",
      " |                way. You can nest regular expressions as well. Note that\n",
      " |                column names (the top-level dictionary keys in a nested\n",
      " |                dictionary) **cannot** be regular expressions.\n",
      " |      \n",
      " |          * None:\n",
      " |      \n",
      " |              - This means that the `regex` argument must be a string,\n",
      " |                compiled regular expression, or list, dict, ndarray or\n",
      " |                Series of such elements. If `value` is also ``None`` then\n",
      " |                this **must** be a nested dictionary or Series.\n",
      " |      \n",
      " |          See the examples section for examples of each of these.\n",
      " |      value : scalar, dict, list, str, regex, default None\n",
      " |          Value to replace any values matching `to_replace` with.\n",
      " |          For a DataFrame a dict of values can be used to specify which\n",
      " |          value to use for each column (columns not in the dict will not be\n",
      " |          filled). Regular expressions, strings and lists or dicts of such\n",
      " |          objects are also allowed.\n",
      " |      \n",
      " |      inplace : bool, default False\n",
      " |          If True, performs operation inplace and returns None.\n",
      " |      limit : int, default None\n",
      " |          Maximum size gap to forward or backward fill.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |      regex : bool or same types as `to_replace`, default False\n",
      " |          Whether to interpret `to_replace` and/or `value` as regular\n",
      " |          expressions. Alternatively, this could be a regular expression or a\n",
      " |          list, dict, or array of regular expressions in which case\n",
      " |          `to_replace` must be ``None``.\n",
      " |      method : {'pad', 'ffill', 'bfill'}\n",
      " |          The method to use when for replacement, when `to_replace` is a\n",
      " |          scalar, list or tuple and `value` is ``None``.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame\n",
      " |          Object after replacement.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      AssertionError\n",
      " |          * If `regex` is not a ``bool`` and `to_replace` is not\n",
      " |            ``None``.\n",
      " |      \n",
      " |      TypeError\n",
      " |          * If `to_replace` is not a scalar, array-like, ``dict``, or ``None``\n",
      " |          * If `to_replace` is a ``dict`` and `value` is not a ``list``,\n",
      " |            ``dict``, ``ndarray``, or ``Series``\n",
      " |          * If `to_replace` is ``None`` and `regex` is not compilable\n",
      " |            into a regular expression or is a list, dict, ndarray, or\n",
      " |            Series.\n",
      " |          * When replacing multiple ``bool`` or ``datetime64`` objects and\n",
      " |            the arguments to `to_replace` does not match the type of the\n",
      " |            value being replaced\n",
      " |      \n",
      " |      ValueError\n",
      " |          * If a ``list`` or an ``ndarray`` is passed to `to_replace` and\n",
      " |            `value` but they are not the same length.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.fillna : Fill NA values.\n",
      " |      DataFrame.fillna : Fill NA values.\n",
      " |      Series.where : Replace values based on boolean condition.\n",
      " |      DataFrame.where : Replace values based on boolean condition.\n",
      " |      DataFrame.map: Apply a function to a Dataframe elementwise.\n",
      " |      Series.map: Map values of Series according to an input mapping or function.\n",
      " |      Series.str.replace : Simple string replacement.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      * Regex substitution is performed under the hood with ``re.sub``. The\n",
      " |        rules for substitution for ``re.sub`` are the same.\n",
      " |      * Regular expressions will only substitute on strings, meaning you\n",
      " |        cannot provide, for example, a regular expression matching floating\n",
      " |        point numbers and expect the columns in your frame that have a\n",
      " |        numeric dtype to be matched. However, if those floating point\n",
      " |        numbers *are* strings, then you can do this.\n",
      " |      * This method has *a lot* of options. You are encouraged to experiment\n",
      " |        and play with this method to gain intuition about how it works.\n",
      " |      * When dict is used as the `to_replace` value, it is like\n",
      " |        key(s) in the dict are the to_replace part and\n",
      " |        value(s) in the dict are the value parameter.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      \n",
      " |      **Scalar `to_replace` and `value`**\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3, 4, 5])\n",
      " |      >>> s.replace(1, 5)\n",
      " |      0    5\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      4    5\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],\n",
      " |      ...                    'B': [5, 6, 7, 8, 9],\n",
      " |      ...                    'C': ['a', 'b', 'c', 'd', 'e']})\n",
      " |      >>> df.replace(0, 5)\n",
      " |          A  B  C\n",
      " |      0  5  5  a\n",
      " |      1  1  6  b\n",
      " |      2  2  7  c\n",
      " |      3  3  8  d\n",
      " |      4  4  9  e\n",
      " |      \n",
      " |      **List-like `to_replace`**\n",
      " |      \n",
      " |      >>> df.replace([0, 1, 2, 3], 4)\n",
      " |          A  B  C\n",
      " |      0  4  5  a\n",
      " |      1  4  6  b\n",
      " |      2  4  7  c\n",
      " |      3  4  8  d\n",
      " |      4  4  9  e\n",
      " |      \n",
      " |      >>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])\n",
      " |          A  B  C\n",
      " |      0  4  5  a\n",
      " |      1  3  6  b\n",
      " |      2  2  7  c\n",
      " |      3  1  8  d\n",
      " |      4  4  9  e\n",
      " |      \n",
      " |      >>> s.replace([1, 2], method='bfill')\n",
      " |      0    3\n",
      " |      1    3\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      4    5\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      **dict-like `to_replace`**\n",
      " |      \n",
      " |      >>> df.replace({0: 10, 1: 100})\n",
      " |              A  B  C\n",
      " |      0   10  5  a\n",
      " |      1  100  6  b\n",
      " |      2    2  7  c\n",
      " |      3    3  8  d\n",
      " |      4    4  9  e\n",
      " |      \n",
      " |      >>> df.replace({'A': 0, 'B': 5}, 100)\n",
      " |              A    B  C\n",
      " |      0  100  100  a\n",
      " |      1    1    6  b\n",
      " |      2    2    7  c\n",
      " |      3    3    8  d\n",
      " |      4    4    9  e\n",
      " |      \n",
      " |      >>> df.replace({'A': {0: 100, 4: 400}})\n",
      " |              A  B  C\n",
      " |      0  100  5  a\n",
      " |      1    1  6  b\n",
      " |      2    2  7  c\n",
      " |      3    3  8  d\n",
      " |      4  400  9  e\n",
      " |      \n",
      " |      **Regular expression `to_replace`**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': ['bat', 'foo', 'bait'],\n",
      " |      ...                    'B': ['abc', 'bar', 'xyz']})\n",
      " |      >>> df.replace(to_replace=r'^ba.$', value='new', regex=True)\n",
      " |              A    B\n",
      " |      0   new  abc\n",
      " |      1   foo  new\n",
      " |      2  bait  xyz\n",
      " |      \n",
      " |      >>> df.replace({'A': r'^ba.$'}, {'A': 'new'}, regex=True)\n",
      " |              A    B\n",
      " |      0   new  abc\n",
      " |      1   foo  bar\n",
      " |      2  bait  xyz\n",
      " |      \n",
      " |      >>> df.replace(regex=r'^ba.$', value='new')\n",
      " |              A    B\n",
      " |      0   new  abc\n",
      " |      1   foo  new\n",
      " |      2  bait  xyz\n",
      " |      \n",
      " |      >>> df.replace(regex={r'^ba.$': 'new', 'foo': 'xyz'})\n",
      " |              A    B\n",
      " |      0   new  abc\n",
      " |      1   xyz  new\n",
      " |      2  bait  xyz\n",
      " |      \n",
      " |      >>> df.replace(regex=[r'^ba.$', 'foo'], value='new')\n",
      " |              A    B\n",
      " |      0   new  abc\n",
      " |      1   new  new\n",
      " |      2  bait  xyz\n",
      " |      \n",
      " |      Compare the behavior of ``s.replace({'a': None})`` and\n",
      " |      ``s.replace('a', None)`` to understand the peculiarities\n",
      " |      of the `to_replace` parameter:\n",
      " |      \n",
      " |      >>> s = pd.Series([10, 'a', 'a', 'b', 'a'])\n",
      " |      \n",
      " |      When one uses a dict as the `to_replace` value, it is like the\n",
      " |      value(s) in the dict are equal to the `value` parameter.\n",
      " |      ``s.replace({'a': None})`` is equivalent to\n",
      " |      ``s.replace(to_replace={'a': None}, value=None, method=None)``:\n",
      " |      \n",
      " |      >>> s.replace({'a': None})\n",
      " |      0      10\n",
      " |      1    None\n",
      " |      2    None\n",
      " |      3       b\n",
      " |      4    None\n",
      " |      dtype: object\n",
      " |      \n",
      " |      When ``value`` is not explicitly passed and `to_replace` is a scalar, list\n",
      " |      or tuple, `replace` uses the method parameter (default 'pad') to do the\n",
      " |      replacement. So this is why the 'a' values are being replaced by 10\n",
      " |      in rows 1 and 2 and 'b' in row 4 in this case.\n",
      " |      \n",
      " |      >>> s.replace('a')\n",
      " |      0    10\n",
      " |      1    10\n",
      " |      2    10\n",
      " |      3     b\n",
      " |      4     b\n",
      " |      dtype: object\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |              The 'method' parameter and padding behavior are deprecated.\n",
      " |      \n",
      " |      On the other hand, if ``None`` is explicitly passed for ``value``, it will\n",
      " |      be respected:\n",
      " |      \n",
      " |      >>> s.replace('a', None)\n",
      " |      0      10\n",
      " |      1    None\n",
      " |      2    None\n",
      " |      3       b\n",
      " |      4    None\n",
      " |      dtype: object\n",
      " |      \n",
      " |          .. versionchanged:: 1.4.0\n",
      " |              Previously the explicit ``None`` was silently ignored.\n",
      " |      \n",
      " |      When ``regex=True``, ``value`` is not ``None`` and `to_replace` is a string,\n",
      " |      the replacement will be applied in all columns of the DataFrame.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [0, 1, 2, 3, 4],\n",
      " |      ...                    'B': ['a', 'b', 'c', 'd', 'e'],\n",
      " |      ...                    'C': ['f', 'g', 'h', 'i', 'j']})\n",
      " |      \n",
      " |      >>> df.replace(to_replace='^[a-g]', value='e', regex=True)\n",
      " |          A  B  C\n",
      " |      0  0  e  e\n",
      " |      1  1  e  e\n",
      " |      2  2  e  h\n",
      " |      3  3  e  i\n",
      " |      4  4  e  j\n",
      " |      \n",
      " |      If ``value`` is not ``None`` and `to_replace` is a dictionary, the dictionary\n",
      " |      keys will be the DataFrame columns that the replacement will be applied.\n",
      " |      \n",
      " |      >>> df.replace(to_replace={'B': '^[a-c]', 'C': '^[h-j]'}, value='e', regex=True)\n",
      " |          A  B  C\n",
      " |      0  0  e  f\n",
      " |      1  1  e  g\n",
      " |      2  2  e  e\n",
      " |      3  3  d  e\n",
      " |      4  4  e  e\n",
      " |  \n",
      " |  resample(self, rule, axis: 'Axis | lib.NoDefault' = <no_default>, closed: \"Literal['right', 'left'] | None\" = None, label: \"Literal['right', 'left'] | None\" = None, convention: \"Literal['start', 'end', 's', 'e'] | lib.NoDefault\" = <no_default>, kind: \"Literal['timestamp', 'period'] | None | lib.NoDefault\" = <no_default>, on: 'Level | None' = None, level: 'Level | None' = None, origin: 'str | TimestampConvertibleTypes' = 'start_day', offset: 'TimedeltaConvertibleTypes | None' = None, group_keys: 'bool_t' = False) -> 'Resampler'\n",
      " |      Resample time-series data.\n",
      " |      \n",
      " |      Convenience method for frequency conversion and resampling of time series.\n",
      " |      The object must have a datetime-like index (`DatetimeIndex`, `PeriodIndex`,\n",
      " |      or `TimedeltaIndex`), or the caller must pass the label of a datetime-like\n",
      " |      series/index to the ``on``/``level`` keyword parameter.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      rule : DateOffset, Timedelta or str\n",
      " |          The offset string or object representing target conversion.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          Which axis to use for up- or down-sampling. For `Series` this parameter\n",
      " |          is unused and defaults to 0. Must be\n",
      " |          `DatetimeIndex`, `TimedeltaIndex` or `PeriodIndex`.\n",
      " |      \n",
      " |          .. deprecated:: 2.0.0\n",
      " |              Use frame.T.resample(...) instead.\n",
      " |      closed : {'right', 'left'}, default None\n",
      " |          Which side of bin interval is closed. The default is 'left'\n",
      " |          for all frequency offsets except for 'ME', 'YE', 'QE', 'BME',\n",
      " |          'BA', 'BQE', and 'W' which all have a default of 'right'.\n",
      " |      label : {'right', 'left'}, default None\n",
      " |          Which bin edge label to label bucket with. The default is 'left'\n",
      " |          for all frequency offsets except for 'ME', 'YE', 'QE', 'BME',\n",
      " |          'BA', 'BQE', and 'W' which all have a default of 'right'.\n",
      " |      convention : {'start', 'end', 's', 'e'}, default 'start'\n",
      " |          For `PeriodIndex` only, controls whether to use the start or\n",
      " |          end of `rule`.\n",
      " |      \n",
      " |          .. deprecated:: 2.2.0\n",
      " |              Convert PeriodIndex to DatetimeIndex before resampling instead.\n",
      " |      kind : {'timestamp', 'period'}, optional, default None\n",
      " |          Pass 'timestamp' to convert the resulting index to a\n",
      " |          `DateTimeIndex` or 'period' to convert it to a `PeriodIndex`.\n",
      " |          By default the input representation is retained.\n",
      " |      \n",
      " |          .. deprecated:: 2.2.0\n",
      " |              Convert index to desired type explicitly instead.\n",
      " |      \n",
      " |      on : str, optional\n",
      " |          For a DataFrame, column to use instead of index for resampling.\n",
      " |          Column must be datetime-like.\n",
      " |      level : str or int, optional\n",
      " |          For a MultiIndex, level (name or number) to use for\n",
      " |          resampling. `level` must be datetime-like.\n",
      " |      origin : Timestamp or str, default 'start_day'\n",
      " |          The timestamp on which to adjust the grouping. The timezone of origin\n",
      " |          must match the timezone of the index.\n",
      " |          If string, must be one of the following:\n",
      " |      \n",
      " |          - 'epoch': `origin` is 1970-01-01\n",
      " |          - 'start': `origin` is the first value of the timeseries\n",
      " |          - 'start_day': `origin` is the first day at midnight of the timeseries\n",
      " |      \n",
      " |          - 'end': `origin` is the last value of the timeseries\n",
      " |          - 'end_day': `origin` is the ceiling midnight of the last day\n",
      " |      \n",
      " |          .. versionadded:: 1.3.0\n",
      " |      \n",
      " |          .. note::\n",
      " |      \n",
      " |              Only takes effect for Tick-frequencies (i.e. fixed frequencies like\n",
      " |              days, hours, and minutes, rather than months or quarters).\n",
      " |      offset : Timedelta or str, default is None\n",
      " |          An offset timedelta added to the origin.\n",
      " |      \n",
      " |      group_keys : bool, default False\n",
      " |          Whether to include the group keys in the result index when using\n",
      " |          ``.apply()`` on the resampled object.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |      \n",
      " |              Not specifying ``group_keys`` will retain values-dependent behavior\n",
      " |              from pandas 1.4 and earlier (see :ref:`pandas 1.5.0 Release notes\n",
      " |              <whatsnew_150.enhancements.resample_group_keys>` for examples).\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |      \n",
      " |              ``group_keys`` now defaults to ``False``.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      pandas.api.typing.Resampler\n",
      " |          :class:`~pandas.core.Resampler` object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.resample : Resample a Series.\n",
      " |      DataFrame.resample : Resample a DataFrame.\n",
      " |      groupby : Group Series/DataFrame by mapping, function, label, or list of labels.\n",
      " |      asfreq : Reindex a Series/DataFrame with the given frequency without grouping.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See the `user guide\n",
      " |      <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#resampling>`__\n",
      " |      for more.\n",
      " |      \n",
      " |      To learn more about the offset strings, please see `this link\n",
      " |      <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects>`__.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Start by creating a series with 9 one minute timestamps.\n",
      " |      \n",
      " |      >>> index = pd.date_range('1/1/2000', periods=9, freq='min')\n",
      " |      >>> series = pd.Series(range(9), index=index)\n",
      " |      >>> series\n",
      " |      2000-01-01 00:00:00    0\n",
      " |      2000-01-01 00:01:00    1\n",
      " |      2000-01-01 00:02:00    2\n",
      " |      2000-01-01 00:03:00    3\n",
      " |      2000-01-01 00:04:00    4\n",
      " |      2000-01-01 00:05:00    5\n",
      " |      2000-01-01 00:06:00    6\n",
      " |      2000-01-01 00:07:00    7\n",
      " |      2000-01-01 00:08:00    8\n",
      " |      Freq: min, dtype: int64\n",
      " |      \n",
      " |      Downsample the series into 3 minute bins and sum the values\n",
      " |      of the timestamps falling into a bin.\n",
      " |      \n",
      " |      >>> series.resample('3min').sum()\n",
      " |      2000-01-01 00:00:00     3\n",
      " |      2000-01-01 00:03:00    12\n",
      " |      2000-01-01 00:06:00    21\n",
      " |      Freq: 3min, dtype: int64\n",
      " |      \n",
      " |      Downsample the series into 3 minute bins as above, but label each\n",
      " |      bin using the right edge instead of the left. Please note that the\n",
      " |      value in the bucket used as the label is not included in the bucket,\n",
      " |      which it labels. For example, in the original series the\n",
      " |      bucket ``2000-01-01 00:03:00`` contains the value 3, but the summed\n",
      " |      value in the resampled bucket with the label ``2000-01-01 00:03:00``\n",
      " |      does not include 3 (if it did, the summed value would be 6, not 3).\n",
      " |      \n",
      " |      >>> series.resample('3min', label='right').sum()\n",
      " |      2000-01-01 00:03:00     3\n",
      " |      2000-01-01 00:06:00    12\n",
      " |      2000-01-01 00:09:00    21\n",
      " |      Freq: 3min, dtype: int64\n",
      " |      \n",
      " |      To include this value close the right side of the bin interval,\n",
      " |      as shown below.\n",
      " |      \n",
      " |      >>> series.resample('3min', label='right', closed='right').sum()\n",
      " |      2000-01-01 00:00:00     0\n",
      " |      2000-01-01 00:03:00     6\n",
      " |      2000-01-01 00:06:00    15\n",
      " |      2000-01-01 00:09:00    15\n",
      " |      Freq: 3min, dtype: int64\n",
      " |      \n",
      " |      Upsample the series into 30 second bins.\n",
      " |      \n",
      " |      >>> series.resample('30s').asfreq()[0:5]   # Select first 5 rows\n",
      " |      2000-01-01 00:00:00   0.0\n",
      " |      2000-01-01 00:00:30   NaN\n",
      " |      2000-01-01 00:01:00   1.0\n",
      " |      2000-01-01 00:01:30   NaN\n",
      " |      2000-01-01 00:02:00   2.0\n",
      " |      Freq: 30s, dtype: float64\n",
      " |      \n",
      " |      Upsample the series into 30 second bins and fill the ``NaN``\n",
      " |      values using the ``ffill`` method.\n",
      " |      \n",
      " |      >>> series.resample('30s').ffill()[0:5]\n",
      " |      2000-01-01 00:00:00    0\n",
      " |      2000-01-01 00:00:30    0\n",
      " |      2000-01-01 00:01:00    1\n",
      " |      2000-01-01 00:01:30    1\n",
      " |      2000-01-01 00:02:00    2\n",
      " |      Freq: 30s, dtype: int64\n",
      " |      \n",
      " |      Upsample the series into 30 second bins and fill the\n",
      " |      ``NaN`` values using the ``bfill`` method.\n",
      " |      \n",
      " |      >>> series.resample('30s').bfill()[0:5]\n",
      " |      2000-01-01 00:00:00    0\n",
      " |      2000-01-01 00:00:30    1\n",
      " |      2000-01-01 00:01:00    1\n",
      " |      2000-01-01 00:01:30    2\n",
      " |      2000-01-01 00:02:00    2\n",
      " |      Freq: 30s, dtype: int64\n",
      " |      \n",
      " |      Pass a custom function via ``apply``\n",
      " |      \n",
      " |      >>> def custom_resampler(arraylike):\n",
      " |      ...     return np.sum(arraylike) + 5\n",
      " |      ...\n",
      " |      >>> series.resample('3min').apply(custom_resampler)\n",
      " |      2000-01-01 00:00:00     8\n",
      " |      2000-01-01 00:03:00    17\n",
      " |      2000-01-01 00:06:00    26\n",
      " |      Freq: 3min, dtype: int64\n",
      " |      \n",
      " |      For DataFrame objects, the keyword `on` can be used to specify the\n",
      " |      column instead of the index for resampling.\n",
      " |      \n",
      " |      >>> d = {'price': [10, 11, 9, 13, 14, 18, 17, 19],\n",
      " |      ...      'volume': [50, 60, 40, 100, 50, 100, 40, 50]}\n",
      " |      >>> df = pd.DataFrame(d)\n",
      " |      >>> df['week_starting'] = pd.date_range('01/01/2018',\n",
      " |      ...                                     periods=8,\n",
      " |      ...                                     freq='W')\n",
      " |      >>> df\n",
      " |         price  volume week_starting\n",
      " |      0     10      50    2018-01-07\n",
      " |      1     11      60    2018-01-14\n",
      " |      2      9      40    2018-01-21\n",
      " |      3     13     100    2018-01-28\n",
      " |      4     14      50    2018-02-04\n",
      " |      5     18     100    2018-02-11\n",
      " |      6     17      40    2018-02-18\n",
      " |      7     19      50    2018-02-25\n",
      " |      >>> df.resample('ME', on='week_starting').mean()\n",
      " |                     price  volume\n",
      " |      week_starting\n",
      " |      2018-01-31     10.75    62.5\n",
      " |      2018-02-28     17.00    60.0\n",
      " |      \n",
      " |      For a DataFrame with MultiIndex, the keyword `level` can be used to\n",
      " |      specify on which level the resampling needs to take place.\n",
      " |      \n",
      " |      >>> days = pd.date_range('1/1/2000', periods=4, freq='D')\n",
      " |      >>> d2 = {'price': [10, 11, 9, 13, 14, 18, 17, 19],\n",
      " |      ...       'volume': [50, 60, 40, 100, 50, 100, 40, 50]}\n",
      " |      >>> df2 = pd.DataFrame(\n",
      " |      ...     d2,\n",
      " |      ...     index=pd.MultiIndex.from_product(\n",
      " |      ...         [days, ['morning', 'afternoon']]\n",
      " |      ...     )\n",
      " |      ... )\n",
      " |      >>> df2\n",
      " |                            price  volume\n",
      " |      2000-01-01 morning       10      50\n",
      " |                 afternoon     11      60\n",
      " |      2000-01-02 morning        9      40\n",
      " |                 afternoon     13     100\n",
      " |      2000-01-03 morning       14      50\n",
      " |                 afternoon     18     100\n",
      " |      2000-01-04 morning       17      40\n",
      " |                 afternoon     19      50\n",
      " |      >>> df2.resample('D', level=0).sum()\n",
      " |                  price  volume\n",
      " |      2000-01-01     21     110\n",
      " |      2000-01-02     22     140\n",
      " |      2000-01-03     32     150\n",
      " |      2000-01-04     36      90\n",
      " |      \n",
      " |      If you want to adjust the start of the bins based on a fixed timestamp:\n",
      " |      \n",
      " |      >>> start, end = '2000-10-01 23:30:00', '2000-10-02 00:30:00'\n",
      " |      >>> rng = pd.date_range(start, end, freq='7min')\n",
      " |      >>> ts = pd.Series(np.arange(len(rng)) * 3, index=rng)\n",
      " |      >>> ts\n",
      " |      2000-10-01 23:30:00     0\n",
      " |      2000-10-01 23:37:00     3\n",
      " |      2000-10-01 23:44:00     6\n",
      " |      2000-10-01 23:51:00     9\n",
      " |      2000-10-01 23:58:00    12\n",
      " |      2000-10-02 00:05:00    15\n",
      " |      2000-10-02 00:12:00    18\n",
      " |      2000-10-02 00:19:00    21\n",
      " |      2000-10-02 00:26:00    24\n",
      " |      Freq: 7min, dtype: int64\n",
      " |      \n",
      " |      >>> ts.resample('17min').sum()\n",
      " |      2000-10-01 23:14:00     0\n",
      " |      2000-10-01 23:31:00     9\n",
      " |      2000-10-01 23:48:00    21\n",
      " |      2000-10-02 00:05:00    54\n",
      " |      2000-10-02 00:22:00    24\n",
      " |      Freq: 17min, dtype: int64\n",
      " |      \n",
      " |      >>> ts.resample('17min', origin='epoch').sum()\n",
      " |      2000-10-01 23:18:00     0\n",
      " |      2000-10-01 23:35:00    18\n",
      " |      2000-10-01 23:52:00    27\n",
      " |      2000-10-02 00:09:00    39\n",
      " |      2000-10-02 00:26:00    24\n",
      " |      Freq: 17min, dtype: int64\n",
      " |      \n",
      " |      >>> ts.resample('17min', origin='2000-01-01').sum()\n",
      " |      2000-10-01 23:24:00     3\n",
      " |      2000-10-01 23:41:00    15\n",
      " |      2000-10-01 23:58:00    45\n",
      " |      2000-10-02 00:15:00    45\n",
      " |      Freq: 17min, dtype: int64\n",
      " |      \n",
      " |      If you want to adjust the start of the bins with an `offset` Timedelta, the two\n",
      " |      following lines are equivalent:\n",
      " |      \n",
      " |      >>> ts.resample('17min', origin='start').sum()\n",
      " |      2000-10-01 23:30:00     9\n",
      " |      2000-10-01 23:47:00    21\n",
      " |      2000-10-02 00:04:00    54\n",
      " |      2000-10-02 00:21:00    24\n",
      " |      Freq: 17min, dtype: int64\n",
      " |      \n",
      " |      >>> ts.resample('17min', offset='23h30min').sum()\n",
      " |      2000-10-01 23:30:00     9\n",
      " |      2000-10-01 23:47:00    21\n",
      " |      2000-10-02 00:04:00    54\n",
      " |      2000-10-02 00:21:00    24\n",
      " |      Freq: 17min, dtype: int64\n",
      " |      \n",
      " |      If you want to take the largest Timestamp as the end of the bins:\n",
      " |      \n",
      " |      >>> ts.resample('17min', origin='end').sum()\n",
      " |      2000-10-01 23:35:00     0\n",
      " |      2000-10-01 23:52:00    18\n",
      " |      2000-10-02 00:09:00    27\n",
      " |      2000-10-02 00:26:00    63\n",
      " |      Freq: 17min, dtype: int64\n",
      " |      \n",
      " |      In contrast with the `start_day`, you can use `end_day` to take the ceiling\n",
      " |      midnight of the largest Timestamp as the end of the bins and drop the bins\n",
      " |      not containing data:\n",
      " |      \n",
      " |      >>> ts.resample('17min', origin='end_day').sum()\n",
      " |      2000-10-01 23:38:00     3\n",
      " |      2000-10-01 23:55:00    15\n",
      " |      2000-10-02 00:12:00    45\n",
      " |      2000-10-02 00:29:00    45\n",
      " |      Freq: 17min, dtype: int64\n",
      " |  \n",
      " |  rolling(self, window: 'int | dt.timedelta | str | BaseOffset | BaseIndexer', min_periods: 'int | None' = None, center: 'bool_t' = False, win_type: 'str | None' = None, on: 'str | None' = None, axis: 'Axis | lib.NoDefault' = <no_default>, closed: 'IntervalClosedType | None' = None, step: 'int | None' = None, method: 'str' = 'single') -> 'Window | Rolling'\n",
      " |      Provide rolling window calculations.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      window : int, timedelta, str, offset, or BaseIndexer subclass\n",
      " |          Size of the moving window.\n",
      " |      \n",
      " |          If an integer, the fixed number of observations used for\n",
      " |          each window.\n",
      " |      \n",
      " |          If a timedelta, str, or offset, the time period of each window. Each\n",
      " |          window will be a variable sized based on the observations included in\n",
      " |          the time-period. This is only valid for datetimelike indexes.\n",
      " |          To learn more about the offsets & frequency strings, please see `this link\n",
      " |          <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.\n",
      " |      \n",
      " |          If a BaseIndexer subclass, the window boundaries\n",
      " |          based on the defined ``get_window_bounds`` method. Additional rolling\n",
      " |          keyword arguments, namely ``min_periods``, ``center``, ``closed`` and\n",
      " |          ``step`` will be passed to ``get_window_bounds``.\n",
      " |      \n",
      " |      min_periods : int, default None\n",
      " |          Minimum number of observations in window required to have a value;\n",
      " |          otherwise, result is ``np.nan``.\n",
      " |      \n",
      " |          For a window that is specified by an offset, ``min_periods`` will default to 1.\n",
      " |      \n",
      " |          For a window that is specified by an integer, ``min_periods`` will default\n",
      " |          to the size of the window.\n",
      " |      \n",
      " |      center : bool, default False\n",
      " |          If False, set the window labels as the right edge of the window index.\n",
      " |      \n",
      " |          If True, set the window labels as the center of the window index.\n",
      " |      \n",
      " |      win_type : str, default None\n",
      " |          If ``None``, all points are evenly weighted.\n",
      " |      \n",
      " |          If a string, it must be a valid `scipy.signal window function\n",
      " |          <https://docs.scipy.org/doc/scipy/reference/signal.windows.html#module-scipy.signal.windows>`__.\n",
      " |      \n",
      " |          Certain Scipy window types require additional parameters to be passed\n",
      " |          in the aggregation function. The additional parameters must match\n",
      " |          the keywords specified in the Scipy window type method signature.\n",
      " |      \n",
      " |      on : str, optional\n",
      " |          For a DataFrame, a column label or Index level on which\n",
      " |          to calculate the rolling window, rather than the DataFrame's index.\n",
      " |      \n",
      " |          Provided integer column is ignored and excluded from result since\n",
      " |          an integer index is not used to calculate the rolling window.\n",
      " |      \n",
      " |      axis : int or str, default 0\n",
      " |          If ``0`` or ``'index'``, roll across the rows.\n",
      " |      \n",
      " |          If ``1`` or ``'columns'``, roll across the columns.\n",
      " |      \n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      \n",
      " |          .. deprecated:: 2.1.0\n",
      " |      \n",
      " |              The axis keyword is deprecated. For ``axis=1``,\n",
      " |              transpose the DataFrame first instead.\n",
      " |      \n",
      " |      closed : str, default None\n",
      " |          If ``'right'``, the first point in the window is excluded from calculations.\n",
      " |      \n",
      " |          If ``'left'``, the last point in the window is excluded from calculations.\n",
      " |      \n",
      " |          If ``'both'``, the no points in the window are excluded from calculations.\n",
      " |      \n",
      " |          If ``'neither'``, the first and last points in the window are excluded\n",
      " |          from calculations.\n",
      " |      \n",
      " |          Default ``None`` (``'right'``).\n",
      " |      \n",
      " |      step : int, default None\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |      \n",
      " |          Evaluate the window at every ``step`` result, equivalent to slicing as\n",
      " |          ``[::step]``. ``window`` must be an integer. Using a step argument other\n",
      " |          than None or 1 will produce a result with a different shape than the input.\n",
      " |      \n",
      " |      method : str {'single', 'table'}, default 'single'\n",
      " |      \n",
      " |          .. versionadded:: 1.3.0\n",
      " |      \n",
      " |          Execute the rolling operation per single column or row (``'single'``)\n",
      " |          or over the entire object (``'table'``).\n",
      " |      \n",
      " |          This argument is only implemented when specifying ``engine='numba'``\n",
      " |          in the method call.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      pandas.api.typing.Window or pandas.api.typing.Rolling\n",
      " |          An instance of Window is returned if ``win_type`` is passed. Otherwise,\n",
      " |          an instance of Rolling is returned.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      expanding : Provides expanding transformations.\n",
      " |      ewm : Provides exponential weighted functions.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See :ref:`Windowing Operations <window.generic>` for further usage details\n",
      " |      and examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})\n",
      " |      >>> df\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      1  1.0\n",
      " |      2  2.0\n",
      " |      3  NaN\n",
      " |      4  4.0\n",
      " |      \n",
      " |      **window**\n",
      " |      \n",
      " |      Rolling sum with a window length of 2 observations.\n",
      " |      \n",
      " |      >>> df.rolling(2).sum()\n",
      " |           B\n",
      " |      0  NaN\n",
      " |      1  1.0\n",
      " |      2  3.0\n",
      " |      3  NaN\n",
      " |      4  NaN\n",
      " |      \n",
      " |      Rolling sum with a window span of 2 seconds.\n",
      " |      \n",
      " |      >>> df_time = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]},\n",
      " |      ...                        index=[pd.Timestamp('20130101 09:00:00'),\n",
      " |      ...                               pd.Timestamp('20130101 09:00:02'),\n",
      " |      ...                               pd.Timestamp('20130101 09:00:03'),\n",
      " |      ...                               pd.Timestamp('20130101 09:00:05'),\n",
      " |      ...                               pd.Timestamp('20130101 09:00:06')])\n",
      " |      \n",
      " |      >>> df_time\n",
      " |                             B\n",
      " |      2013-01-01 09:00:00  0.0\n",
      " |      2013-01-01 09:00:02  1.0\n",
      " |      2013-01-01 09:00:03  2.0\n",
      " |      2013-01-01 09:00:05  NaN\n",
      " |      2013-01-01 09:00:06  4.0\n",
      " |      \n",
      " |      >>> df_time.rolling('2s').sum()\n",
      " |                             B\n",
      " |      2013-01-01 09:00:00  0.0\n",
      " |      2013-01-01 09:00:02  1.0\n",
      " |      2013-01-01 09:00:03  3.0\n",
      " |      2013-01-01 09:00:05  NaN\n",
      " |      2013-01-01 09:00:06  4.0\n",
      " |      \n",
      " |      Rolling sum with forward looking windows with 2 observations.\n",
      " |      \n",
      " |      >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2)\n",
      " |      >>> df.rolling(window=indexer, min_periods=1).sum()\n",
      " |           B\n",
      " |      0  1.0\n",
      " |      1  3.0\n",
      " |      2  2.0\n",
      " |      3  4.0\n",
      " |      4  4.0\n",
      " |      \n",
      " |      **min_periods**\n",
      " |      \n",
      " |      Rolling sum with a window length of 2 observations, but only needs a minimum of 1\n",
      " |      observation to calculate a value.\n",
      " |      \n",
      " |      >>> df.rolling(2, min_periods=1).sum()\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      1  1.0\n",
      " |      2  3.0\n",
      " |      3  2.0\n",
      " |      4  4.0\n",
      " |      \n",
      " |      **center**\n",
      " |      \n",
      " |      Rolling sum with the result assigned to the center of the window index.\n",
      " |      \n",
      " |      >>> df.rolling(3, min_periods=1, center=True).sum()\n",
      " |           B\n",
      " |      0  1.0\n",
      " |      1  3.0\n",
      " |      2  3.0\n",
      " |      3  6.0\n",
      " |      4  4.0\n",
      " |      \n",
      " |      >>> df.rolling(3, min_periods=1, center=False).sum()\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      1  1.0\n",
      " |      2  3.0\n",
      " |      3  3.0\n",
      " |      4  6.0\n",
      " |      \n",
      " |      **step**\n",
      " |      \n",
      " |      Rolling sum with a window length of 2 observations, minimum of 1 observation to\n",
      " |      calculate a value, and a step of 2.\n",
      " |      \n",
      " |      >>> df.rolling(2, min_periods=1, step=2).sum()\n",
      " |           B\n",
      " |      0  0.0\n",
      " |      2  3.0\n",
      " |      4  4.0\n",
      " |      \n",
      " |      **win_type**\n",
      " |      \n",
      " |      Rolling sum with a window length of 2, using the Scipy ``'gaussian'``\n",
      " |      window type. ``std`` is required in the aggregation function.\n",
      " |      \n",
      " |      >>> df.rolling(2, win_type='gaussian').sum(std=3)\n",
      " |                B\n",
      " |      0       NaN\n",
      " |      1  0.986207\n",
      " |      2  2.958621\n",
      " |      3       NaN\n",
      " |      4       NaN\n",
      " |      \n",
      " |      **on**\n",
      " |      \n",
      " |      Rolling sum with a window length of 2 days.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\n",
      " |      ...     'A': [pd.to_datetime('2020-01-01'),\n",
      " |      ...           pd.to_datetime('2020-01-01'),\n",
      " |      ...           pd.to_datetime('2020-01-02'),],\n",
      " |      ...     'B': [1, 2, 3], },\n",
      " |      ...     index=pd.date_range('2020', periods=3))\n",
      " |      \n",
      " |      >>> df\n",
      " |                          A  B\n",
      " |      2020-01-01 2020-01-01  1\n",
      " |      2020-01-02 2020-01-01  2\n",
      " |      2020-01-03 2020-01-02  3\n",
      " |      \n",
      " |      >>> df.rolling('2D', on='A').sum()\n",
      " |                          A    B\n",
      " |      2020-01-01 2020-01-01  1.0\n",
      " |      2020-01-02 2020-01-01  3.0\n",
      " |      2020-01-03 2020-01-02  6.0\n",
      " |  \n",
      " |  sample(self, n: 'int | None' = None, frac: 'float | None' = None, replace: 'bool_t' = False, weights=None, random_state: 'RandomState | None' = None, axis: 'Axis | None' = None, ignore_index: 'bool_t' = False) -> 'Self'\n",
      " |      Return a random sample of items from an axis of object.\n",
      " |      \n",
      " |      You can use `random_state` for reproducibility.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      n : int, optional\n",
      " |          Number of items from axis to return. Cannot be used with `frac`.\n",
      " |          Default = 1 if `frac` = None.\n",
      " |      frac : float, optional\n",
      " |          Fraction of axis items to return. Cannot be used with `n`.\n",
      " |      replace : bool, default False\n",
      " |          Allow or disallow sampling of the same row more than once.\n",
      " |      weights : str or ndarray-like, optional\n",
      " |          Default 'None' results in equal probability weighting.\n",
      " |          If passed a Series, will align with target object on index. Index\n",
      " |          values in weights not found in sampled object will be ignored and\n",
      " |          index values in sampled object not in weights will be assigned\n",
      " |          weights of zero.\n",
      " |          If called on a DataFrame, will accept the name of a column\n",
      " |          when axis = 0.\n",
      " |          Unless weights are a Series, weights must be same length as axis\n",
      " |          being sampled.\n",
      " |          If weights do not sum to 1, they will be normalized to sum to 1.\n",
      " |          Missing values in the weights column will be treated as zero.\n",
      " |          Infinite values not allowed.\n",
      " |      random_state : int, array-like, BitGenerator, np.random.RandomState, np.random.Generator, optional\n",
      " |          If int, array-like, or BitGenerator, seed for random number generator.\n",
      " |          If np.random.RandomState or np.random.Generator, use as given.\n",
      " |      \n",
      " |          .. versionchanged:: 1.4.0\n",
      " |      \n",
      " |              np.random.Generator objects now accepted\n",
      " |      \n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default None\n",
      " |          Axis to sample. Accepts axis number or name. Default is stat axis\n",
      " |          for given data type. For `Series` this parameter is unused and defaults to `None`.\n",
      " |      ignore_index : bool, default False\n",
      " |          If True, the resulting index will be labeled 0, 1, …, n - 1.\n",
      " |      \n",
      " |          .. versionadded:: 1.3.0\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          A new object of same type as caller containing `n` items randomly\n",
      " |          sampled from the caller object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrameGroupBy.sample: Generates random samples from each group of a\n",
      " |          DataFrame object.\n",
      " |      SeriesGroupBy.sample: Generates random samples from each group of a\n",
      " |          Series object.\n",
      " |      numpy.random.choice: Generates a random sample from a given 1-D numpy\n",
      " |          array.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      If `frac` > 1, `replacement` should be set to `True`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'num_legs': [2, 4, 8, 0],\n",
      " |      ...                    'num_wings': [2, 0, 0, 0],\n",
      " |      ...                    'num_specimen_seen': [10, 2, 1, 8]},\n",
      " |      ...                   index=['falcon', 'dog', 'spider', 'fish'])\n",
      " |      >>> df\n",
      " |              num_legs  num_wings  num_specimen_seen\n",
      " |      falcon         2          2                 10\n",
      " |      dog            4          0                  2\n",
      " |      spider         8          0                  1\n",
      " |      fish           0          0                  8\n",
      " |      \n",
      " |      Extract 3 random elements from the ``Series`` ``df['num_legs']``:\n",
      " |      Note that we use `random_state` to ensure the reproducibility of\n",
      " |      the examples.\n",
      " |      \n",
      " |      >>> df['num_legs'].sample(n=3, random_state=1)\n",
      " |      fish      0\n",
      " |      spider    8\n",
      " |      falcon    2\n",
      " |      Name: num_legs, dtype: int64\n",
      " |      \n",
      " |      A random 50% sample of the ``DataFrame`` with replacement:\n",
      " |      \n",
      " |      >>> df.sample(frac=0.5, replace=True, random_state=1)\n",
      " |            num_legs  num_wings  num_specimen_seen\n",
      " |      dog          4          0                  2\n",
      " |      fish         0          0                  8\n",
      " |      \n",
      " |      An upsample sample of the ``DataFrame`` with replacement:\n",
      " |      Note that `replace` parameter has to be `True` for `frac` parameter > 1.\n",
      " |      \n",
      " |      >>> df.sample(frac=2, replace=True, random_state=1)\n",
      " |              num_legs  num_wings  num_specimen_seen\n",
      " |      dog            4          0                  2\n",
      " |      fish           0          0                  8\n",
      " |      falcon         2          2                 10\n",
      " |      falcon         2          2                 10\n",
      " |      fish           0          0                  8\n",
      " |      dog            4          0                  2\n",
      " |      fish           0          0                  8\n",
      " |      dog            4          0                  2\n",
      " |      \n",
      " |      Using a DataFrame column as weights. Rows with larger value in the\n",
      " |      `num_specimen_seen` column are more likely to be sampled.\n",
      " |      \n",
      " |      >>> df.sample(n=2, weights='num_specimen_seen', random_state=1)\n",
      " |              num_legs  num_wings  num_specimen_seen\n",
      " |      falcon         2          2                 10\n",
      " |      fish           0          0                  8\n",
      " |  \n",
      " |  set_flags(self, *, copy: 'bool_t' = False, allows_duplicate_labels: 'bool_t | None' = None) -> 'Self'\n",
      " |      Return a new object with updated flags.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      copy : bool, default False\n",
      " |          Specify if a copy of the object should be made.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      allows_duplicate_labels : bool, optional\n",
      " |          Whether the returned object allows duplicate labels.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          The same type as the caller.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.attrs : Global metadata applying to this dataset.\n",
      " |      DataFrame.flags : Global flags applying to this object.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      This method returns a new object that's a view on the same data\n",
      " |      as the input. Mutating the input or the output values will be reflected\n",
      " |      in the other.\n",
      " |      \n",
      " |      This method is intended to be used in method chains.\n",
      " |      \n",
      " |      \"Flags\" differ from \"metadata\". Flags reflect properties of the\n",
      " |      pandas object (the Series or DataFrame). Metadata refer to properties\n",
      " |      of the dataset, and should be stored in :attr:`DataFrame.attrs`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({\"A\": [1, 2]})\n",
      " |      >>> df.flags.allows_duplicate_labels\n",
      " |      True\n",
      " |      >>> df2 = df.set_flags(allows_duplicate_labels=False)\n",
      " |      >>> df2.flags.allows_duplicate_labels\n",
      " |      False\n",
      " |  \n",
      " |  shift(self, periods: 'int | Sequence[int]' = 1, freq=None, axis: 'Axis' = 0, fill_value: 'Hashable' = <no_default>, suffix: 'str | None' = None) -> 'Self | DataFrame'\n",
      " |      Shift index by desired number of periods with an optional time `freq`.\n",
      " |      \n",
      " |      When `freq` is not passed, shift the index without realigning the data.\n",
      " |      If `freq` is passed (in this case, the index must be date or datetime,\n",
      " |      or it will raise a `NotImplementedError`), the index will be\n",
      " |      increased using the periods and the `freq`. `freq` can be inferred\n",
      " |      when specified as \"infer\" as long as either freq or inferred_freq\n",
      " |      attribute is set in the index.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      periods : int or Sequence\n",
      " |          Number of periods to shift. Can be positive or negative.\n",
      " |          If an iterable of ints, the data will be shifted once by each int.\n",
      " |          This is equivalent to shifting by one value at a time and\n",
      " |          concatenating all resulting frames. The resulting columns will have\n",
      " |          the shift suffixed to their column names. For multiple periods,\n",
      " |          axis must not be 1.\n",
      " |      freq : DateOffset, tseries.offsets, timedelta, or str, optional\n",
      " |          Offset to use from the tseries module or time rule (e.g. 'EOM').\n",
      " |          If `freq` is specified then the index values are shifted but the\n",
      " |          data is not realigned. That is, use `freq` if you would like to\n",
      " |          extend the index when shifting and preserve the original data.\n",
      " |          If `freq` is specified as \"infer\" then it will be inferred from\n",
      " |          the freq or inferred_freq attributes of the index. If neither of\n",
      " |          those attributes exist, a ValueError is thrown.\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default None\n",
      " |          Shift direction. For `Series` this parameter is unused and defaults to 0.\n",
      " |      fill_value : object, optional\n",
      " |          The scalar value to use for newly introduced missing values.\n",
      " |          the default depends on the dtype of `self`.\n",
      " |          For numeric data, ``np.nan`` is used.\n",
      " |          For datetime, timedelta, or period data, etc. :attr:`NaT` is used.\n",
      " |          For extension dtypes, ``self.dtype.na_value`` is used.\n",
      " |      suffix : str, optional\n",
      " |          If str and periods is an iterable, this is added after the column\n",
      " |          name and before the shift value for each shifted column name.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame\n",
      " |          Copy of input object, shifted.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Index.shift : Shift values of Index.\n",
      " |      DatetimeIndex.shift : Shift values of DatetimeIndex.\n",
      " |      PeriodIndex.shift : Shift values of PeriodIndex.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({\"Col1\": [10, 20, 15, 30, 45],\n",
      " |      ...                    \"Col2\": [13, 23, 18, 33, 48],\n",
      " |      ...                    \"Col3\": [17, 27, 22, 37, 52]},\n",
      " |      ...                   index=pd.date_range(\"2020-01-01\", \"2020-01-05\"))\n",
      " |      >>> df\n",
      " |                  Col1  Col2  Col3\n",
      " |      2020-01-01    10    13    17\n",
      " |      2020-01-02    20    23    27\n",
      " |      2020-01-03    15    18    22\n",
      " |      2020-01-04    30    33    37\n",
      " |      2020-01-05    45    48    52\n",
      " |      \n",
      " |      >>> df.shift(periods=3)\n",
      " |                  Col1  Col2  Col3\n",
      " |      2020-01-01   NaN   NaN   NaN\n",
      " |      2020-01-02   NaN   NaN   NaN\n",
      " |      2020-01-03   NaN   NaN   NaN\n",
      " |      2020-01-04  10.0  13.0  17.0\n",
      " |      2020-01-05  20.0  23.0  27.0\n",
      " |      \n",
      " |      >>> df.shift(periods=1, axis=\"columns\")\n",
      " |                  Col1  Col2  Col3\n",
      " |      2020-01-01   NaN    10    13\n",
      " |      2020-01-02   NaN    20    23\n",
      " |      2020-01-03   NaN    15    18\n",
      " |      2020-01-04   NaN    30    33\n",
      " |      2020-01-05   NaN    45    48\n",
      " |      \n",
      " |      >>> df.shift(periods=3, fill_value=0)\n",
      " |                  Col1  Col2  Col3\n",
      " |      2020-01-01     0     0     0\n",
      " |      2020-01-02     0     0     0\n",
      " |      2020-01-03     0     0     0\n",
      " |      2020-01-04    10    13    17\n",
      " |      2020-01-05    20    23    27\n",
      " |      \n",
      " |      >>> df.shift(periods=3, freq=\"D\")\n",
      " |                  Col1  Col2  Col3\n",
      " |      2020-01-04    10    13    17\n",
      " |      2020-01-05    20    23    27\n",
      " |      2020-01-06    15    18    22\n",
      " |      2020-01-07    30    33    37\n",
      " |      2020-01-08    45    48    52\n",
      " |      \n",
      " |      >>> df.shift(periods=3, freq=\"infer\")\n",
      " |                  Col1  Col2  Col3\n",
      " |      2020-01-04    10    13    17\n",
      " |      2020-01-05    20    23    27\n",
      " |      2020-01-06    15    18    22\n",
      " |      2020-01-07    30    33    37\n",
      " |      2020-01-08    45    48    52\n",
      " |      \n",
      " |      >>> df['Col1'].shift(periods=[0, 1, 2])\n",
      " |                  Col1_0  Col1_1  Col1_2\n",
      " |      2020-01-01      10     NaN     NaN\n",
      " |      2020-01-02      20    10.0     NaN\n",
      " |      2020-01-03      15    20.0    10.0\n",
      " |      2020-01-04      30    15.0    20.0\n",
      " |      2020-01-05      45    30.0    15.0\n",
      " |  \n",
      " |  squeeze(self, axis: 'Axis | None' = None)\n",
      " |      Squeeze 1 dimensional axis objects into scalars.\n",
      " |      \n",
      " |      Series or DataFrames with a single element are squeezed to a scalar.\n",
      " |      DataFrames with a single column or a single row are squeezed to a\n",
      " |      Series. Otherwise the object is unchanged.\n",
      " |      \n",
      " |      This method is most useful when you don't know if your\n",
      " |      object is a Series or DataFrame, but you do know it has just a single\n",
      " |      column. In that case you can safely call `squeeze` to ensure you have a\n",
      " |      Series.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default None\n",
      " |          A specific axis to squeeze. By default, all length-1 axes are\n",
      " |          squeezed. For `Series` this parameter is unused and defaults to `None`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      DataFrame, Series, or scalar\n",
      " |          The projection after squeezing `axis` or all the axes.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Series.iloc : Integer-location based indexing for selecting scalars.\n",
      " |      DataFrame.iloc : Integer-location based indexing for selecting Series.\n",
      " |      Series.to_frame : Inverse of DataFrame.squeeze for a\n",
      " |          single-column DataFrame.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> primes = pd.Series([2, 3, 5, 7])\n",
      " |      \n",
      " |      Slicing might produce a Series with a single value:\n",
      " |      \n",
      " |      >>> even_primes = primes[primes % 2 == 0]\n",
      " |      >>> even_primes\n",
      " |      0    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> even_primes.squeeze()\n",
      " |      2\n",
      " |      \n",
      " |      Squeezing objects with more than one value in every axis does nothing:\n",
      " |      \n",
      " |      >>> odd_primes = primes[primes % 2 == 1]\n",
      " |      >>> odd_primes\n",
      " |      1    3\n",
      " |      2    5\n",
      " |      3    7\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> odd_primes.squeeze()\n",
      " |      1    3\n",
      " |      2    5\n",
      " |      3    7\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Squeezing is even more effective when used with DataFrames.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])\n",
      " |      >>> df\n",
      " |         a  b\n",
      " |      0  1  2\n",
      " |      1  3  4\n",
      " |      \n",
      " |      Slicing a single column will produce a DataFrame with the columns\n",
      " |      having only one value:\n",
      " |      \n",
      " |      >>> df_a = df[['a']]\n",
      " |      >>> df_a\n",
      " |         a\n",
      " |      0  1\n",
      " |      1  3\n",
      " |      \n",
      " |      So the columns can be squeezed down, resulting in a Series:\n",
      " |      \n",
      " |      >>> df_a.squeeze('columns')\n",
      " |      0    1\n",
      " |      1    3\n",
      " |      Name: a, dtype: int64\n",
      " |      \n",
      " |      Slicing a single row from a single column will produce a single\n",
      " |      scalar DataFrame:\n",
      " |      \n",
      " |      >>> df_0a = df.loc[df.index < 1, ['a']]\n",
      " |      >>> df_0a\n",
      " |         a\n",
      " |      0  1\n",
      " |      \n",
      " |      Squeezing the rows produces a single scalar Series:\n",
      " |      \n",
      " |      >>> df_0a.squeeze('rows')\n",
      " |      a    1\n",
      " |      Name: 0, dtype: int64\n",
      " |      \n",
      " |      Squeezing all axes will project directly into a scalar:\n",
      " |      \n",
      " |      >>> df_0a.squeeze()\n",
      " |      1\n",
      " |  \n",
      " |  swapaxes(self, axis1: 'Axis', axis2: 'Axis', copy: 'bool_t | None' = None) -> 'Self'\n",
      " |      Interchange axes and swap values axes appropriately.\n",
      " |      \n",
      " |      .. deprecated:: 2.1.0\n",
      " |          ``swapaxes`` is deprecated and will be removed.\n",
      " |          Please use ``transpose`` instead.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same as input\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Please see examples for :meth:`DataFrame.transpose`.\n",
      " |  \n",
      " |  tail(self, n: 'int' = 5) -> 'Self'\n",
      " |      Return the last `n` rows.\n",
      " |      \n",
      " |      This function returns last `n` rows from the object based on\n",
      " |      position. It is useful for quickly verifying data, for example,\n",
      " |      after sorting or appending rows.\n",
      " |      \n",
      " |      For negative values of `n`, this function returns all rows except\n",
      " |      the first `|n|` rows, equivalent to ``df[|n|:]``.\n",
      " |      \n",
      " |      If n is larger than the number of rows, this function returns all rows.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      n : int, default 5\n",
      " |          Number of rows to select.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      type of caller\n",
      " |          The last `n` rows of the caller object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.head : The first `n` rows of the caller object.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',\n",
      " |      ...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})\n",
      " |      >>> df\n",
      " |            animal\n",
      " |      0  alligator\n",
      " |      1        bee\n",
      " |      2     falcon\n",
      " |      3       lion\n",
      " |      4     monkey\n",
      " |      5     parrot\n",
      " |      6      shark\n",
      " |      7      whale\n",
      " |      8      zebra\n",
      " |      \n",
      " |      Viewing the last 5 lines\n",
      " |      \n",
      " |      >>> df.tail()\n",
      " |         animal\n",
      " |      4  monkey\n",
      " |      5  parrot\n",
      " |      6   shark\n",
      " |      7   whale\n",
      " |      8   zebra\n",
      " |      \n",
      " |      Viewing the last `n` lines (three in this case)\n",
      " |      \n",
      " |      >>> df.tail(3)\n",
      " |        animal\n",
      " |      6  shark\n",
      " |      7  whale\n",
      " |      8  zebra\n",
      " |      \n",
      " |      For negative values of `n`\n",
      " |      \n",
      " |      >>> df.tail(-3)\n",
      " |         animal\n",
      " |      3    lion\n",
      " |      4  monkey\n",
      " |      5  parrot\n",
      " |      6   shark\n",
      " |      7   whale\n",
      " |      8   zebra\n",
      " |  \n",
      " |  take(self, indices, axis: 'Axis' = 0, **kwargs) -> 'Self'\n",
      " |      Return the elements in the given *positional* indices along an axis.\n",
      " |      \n",
      " |      This means that we are not indexing according to actual values in\n",
      " |      the index attribute of the object. We are indexing according to the\n",
      " |      actual position of the element in the object.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      indices : array-like\n",
      " |          An array of ints indicating which positions to take.\n",
      " |      axis : {0 or 'index', 1 or 'columns', None}, default 0\n",
      " |          The axis on which to select elements. ``0`` means that we are\n",
      " |          selecting rows, ``1`` means that we are selecting columns.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      **kwargs\n",
      " |          For compatibility with :meth:`numpy.take`. Has no effect on the\n",
      " |          output.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      same type as caller\n",
      " |          An array-like containing the elements taken from the object.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.loc : Select a subset of a DataFrame by labels.\n",
      " |      DataFrame.iloc : Select a subset of a DataFrame by positions.\n",
      " |      numpy.take : Take elements from an array along an axis.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([('falcon', 'bird', 389.0),\n",
      " |      ...                    ('parrot', 'bird', 24.0),\n",
      " |      ...                    ('lion', 'mammal', 80.5),\n",
      " |      ...                    ('monkey', 'mammal', np.nan)],\n",
      " |      ...                   columns=['name', 'class', 'max_speed'],\n",
      " |      ...                   index=[0, 2, 3, 1])\n",
      " |      >>> df\n",
      " |           name   class  max_speed\n",
      " |      0  falcon    bird      389.0\n",
      " |      2  parrot    bird       24.0\n",
      " |      3    lion  mammal       80.5\n",
      " |      1  monkey  mammal        NaN\n",
      " |      \n",
      " |      Take elements at positions 0 and 3 along the axis 0 (default).\n",
      " |      \n",
      " |      Note how the actual indices selected (0 and 1) do not correspond to\n",
      " |      our selected indices 0 and 3. That's because we are selecting the 0th\n",
      " |      and 3rd rows, not rows whose indices equal 0 and 3.\n",
      " |      \n",
      " |      >>> df.take([0, 3])\n",
      " |           name   class  max_speed\n",
      " |      0  falcon    bird      389.0\n",
      " |      1  monkey  mammal        NaN\n",
      " |      \n",
      " |      Take elements at indices 1 and 2 along the axis 1 (column selection).\n",
      " |      \n",
      " |      >>> df.take([1, 2], axis=1)\n",
      " |          class  max_speed\n",
      " |      0    bird      389.0\n",
      " |      2    bird       24.0\n",
      " |      3  mammal       80.5\n",
      " |      1  mammal        NaN\n",
      " |      \n",
      " |      We may take elements using negative integers for positive indices,\n",
      " |      starting from the end of the object, just like with Python lists.\n",
      " |      \n",
      " |      >>> df.take([-1, -2])\n",
      " |           name   class  max_speed\n",
      " |      1  monkey  mammal        NaN\n",
      " |      3    lion  mammal       80.5\n",
      " |  \n",
      " |  to_clipboard(self, *, excel: 'bool_t' = True, sep: 'str | None' = None, **kwargs) -> 'None'\n",
      " |      Copy object to the system clipboard.\n",
      " |      \n",
      " |      Write a text representation of object to the system clipboard.\n",
      " |      This can be pasted into Excel, for example.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      excel : bool, default True\n",
      " |          Produce output in a csv format for easy pasting into excel.\n",
      " |      \n",
      " |          - True, use the provided separator for csv pasting.\n",
      " |          - False, write a string representation of the object to the clipboard.\n",
      " |      \n",
      " |      sep : str, default ``'\\t'``\n",
      " |          Field delimiter.\n",
      " |      **kwargs\n",
      " |          These parameters will be passed to DataFrame.to_csv.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.to_csv : Write a DataFrame to a comma-separated values\n",
      " |          (csv) file.\n",
      " |      read_clipboard : Read text from clipboard and pass to read_csv.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Requirements for your platform.\n",
      " |      \n",
      " |        - Linux : `xclip`, or `xsel` (with `PyQt4` modules)\n",
      " |        - Windows : none\n",
      " |        - macOS : none\n",
      " |      \n",
      " |      This method uses the processes developed for the package `pyperclip`. A\n",
      " |      solution to render any output string format is given in the examples.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Copy the contents of a DataFrame to the clipboard.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])\n",
      " |      \n",
      " |      >>> df.to_clipboard(sep=',')  # doctest: +SKIP\n",
      " |      ... # Wrote the following to the system clipboard:\n",
      " |      ... # ,A,B,C\n",
      " |      ... # 0,1,2,3\n",
      " |      ... # 1,4,5,6\n",
      " |      \n",
      " |      We can omit the index by passing the keyword `index` and setting\n",
      " |      it to false.\n",
      " |      \n",
      " |      >>> df.to_clipboard(sep=',', index=False)  # doctest: +SKIP\n",
      " |      ... # Wrote the following to the system clipboard:\n",
      " |      ... # A,B,C\n",
      " |      ... # 1,2,3\n",
      " |      ... # 4,5,6\n",
      " |      \n",
      " |      Using the original `pyperclip` package for any string output format.\n",
      " |      \n",
      " |      .. code-block:: python\n",
      " |      \n",
      " |         import pyperclip\n",
      " |         html = df.style.to_html()\n",
      " |         pyperclip.copy(html)\n",
      " |  \n",
      " |  to_csv(self, path_or_buf: 'FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None' = None, *, sep: 'str' = ',', na_rep: 'str' = '', float_format: 'str | Callable | None' = None, columns: 'Sequence[Hashable] | None' = None, header: 'bool_t | list[str]' = True, index: 'bool_t' = True, index_label: 'IndexLabel | None' = None, mode: 'str' = 'w', encoding: 'str | None' = None, compression: 'CompressionOptions' = 'infer', quoting: 'int | None' = None, quotechar: 'str' = '\"', lineterminator: 'str | None' = None, chunksize: 'int | None' = None, date_format: 'str | None' = None, doublequote: 'bool_t' = True, escapechar: 'str | None' = None, decimal: 'str' = '.', errors: 'OpenFileErrors' = 'strict', storage_options: 'StorageOptions | None' = None) -> 'str | None'\n",
      " |      Write object to a comma-separated values (csv) file.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      path_or_buf : str, path object, file-like object, or None, default None\n",
      " |          String, path object (implementing os.PathLike[str]), or file-like\n",
      " |          object implementing a write() function. If None, the result is\n",
      " |          returned as a string. If a non-binary file object is passed, it should\n",
      " |          be opened with `newline=''`, disabling universal newlines. If a binary\n",
      " |          file object is passed, `mode` might need to contain a `'b'`.\n",
      " |      sep : str, default ','\n",
      " |          String of length 1. Field delimiter for the output file.\n",
      " |      na_rep : str, default ''\n",
      " |          Missing data representation.\n",
      " |      float_format : str, Callable, default None\n",
      " |          Format string for floating point numbers. If a Callable is given, it takes\n",
      " |          precedence over other numeric formatting parameters, like decimal.\n",
      " |      columns : sequence, optional\n",
      " |          Columns to write.\n",
      " |      header : bool or list of str, default True\n",
      " |          Write out the column names. If a list of strings is given it is\n",
      " |          assumed to be aliases for the column names.\n",
      " |      index : bool, default True\n",
      " |          Write row names (index).\n",
      " |      index_label : str or sequence, or False, default None\n",
      " |          Column label for index column(s) if desired. If None is given, and\n",
      " |          `header` and `index` are True, then the index names are used. A\n",
      " |          sequence should be given if the object uses MultiIndex. If\n",
      " |          False do not print fields for index names. Use index_label=False\n",
      " |          for easier importing in R.\n",
      " |      mode : {'w', 'x', 'a'}, default 'w'\n",
      " |          Forwarded to either `open(mode=)` or `fsspec.open(mode=)` to control\n",
      " |          the file opening. Typical values include:\n",
      " |      \n",
      " |          - 'w', truncate the file first.\n",
      " |          - 'x', exclusive creation, failing if the file already exists.\n",
      " |          - 'a', append to the end of file if it exists.\n",
      " |      \n",
      " |      encoding : str, optional\n",
      " |          A string representing the encoding to use in the output file,\n",
      " |          defaults to 'utf-8'. `encoding` is not supported if `path_or_buf`\n",
      " |          is a non-binary file object.\n",
      " |      compression : str or dict, default 'infer'\n",
      " |          For on-the-fly compression of the output data. If 'infer' and 'path_or_buf' is\n",
      " |          path-like, then detect compression from the following extensions: '.gz',\n",
      " |          '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n",
      " |          (otherwise no compression).\n",
      " |          Set to ``None`` for no compression.\n",
      " |          Can also be a dict with key ``'method'`` set\n",
      " |          to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and\n",
      " |          other key-value pairs are forwarded to\n",
      " |          ``zipfile.ZipFile``, ``gzip.GzipFile``,\n",
      " |          ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or\n",
      " |          ``tarfile.TarFile``, respectively.\n",
      " |          As an example, the following could be passed for faster compression and to create\n",
      " |          a reproducible gzip archive:\n",
      " |          ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |              Added support for `.tar` files.\n",
      " |      \n",
      " |             May be a dict with key 'method' as compression mode\n",
      " |             and other entries as additional compression options if\n",
      " |             compression mode is 'zip'.\n",
      " |      \n",
      " |             Passing compression options as keys in dict is\n",
      " |             supported for compression modes 'gzip', 'bz2', 'zstd', and 'zip'.\n",
      " |      quoting : optional constant from csv module\n",
      " |          Defaults to csv.QUOTE_MINIMAL. If you have set a `float_format`\n",
      " |          then floats are converted to strings and thus csv.QUOTE_NONNUMERIC\n",
      " |          will treat them as non-numeric.\n",
      " |      quotechar : str, default '\\\"'\n",
      " |          String of length 1. Character used to quote fields.\n",
      " |      lineterminator : str, optional\n",
      " |          The newline character or character sequence to use in the output\n",
      " |          file. Defaults to `os.linesep`, which depends on the OS in which\n",
      " |          this method is called ('\\\\n' for linux, '\\\\r\\\\n' for Windows, i.e.).\n",
      " |      \n",
      " |          .. versionchanged:: 1.5.0\n",
      " |      \n",
      " |              Previously was line_terminator, changed for consistency with\n",
      " |              read_csv and the standard library 'csv' module.\n",
      " |      \n",
      " |      chunksize : int or None\n",
      " |          Rows to write at a time.\n",
      " |      date_format : str, default None\n",
      " |          Format string for datetime objects.\n",
      " |      doublequote : bool, default True\n",
      " |          Control quoting of `quotechar` inside a field.\n",
      " |      escapechar : str, default None\n",
      " |          String of length 1. Character used to escape `sep` and `quotechar`\n",
      " |          when appropriate.\n",
      " |      decimal : str, default '.'\n",
      " |          Character recognized as decimal separator. E.g. use ',' for\n",
      " |          European data.\n",
      " |      errors : str, default 'strict'\n",
      " |          Specifies how encoding and decoding errors are to be handled.\n",
      " |          See the errors argument for :func:`open` for a full list\n",
      " |          of options.\n",
      " |      \n",
      " |      storage_options : dict, optional\n",
      " |          Extra options that make sense for a particular storage connection, e.g.\n",
      " |          host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n",
      " |          are forwarded to ``urllib.request.Request`` as header options. For other\n",
      " |          URLs (e.g. starting with \"s3://\", and \"gcs://\") the key-value pairs are\n",
      " |          forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n",
      " |          details, and for more examples on storage options refer `here\n",
      " |          <https://pandas.pydata.org/docs/user_guide/io.html?\n",
      " |          highlight=storage_options#reading-writing-remote-files>`_.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None or str\n",
      " |          If path_or_buf is None, returns the resulting csv format as a\n",
      " |          string. Otherwise returns None.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      read_csv : Load a CSV file into a DataFrame.\n",
      " |      to_excel : Write DataFrame to an Excel file.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Create 'out.csv' containing 'df' without indices\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'name': ['Raphael', 'Donatello'],\n",
      " |      ...                    'mask': ['red', 'purple'],\n",
      " |      ...                    'weapon': ['sai', 'bo staff']})\n",
      " |      >>> df.to_csv('out.csv', index=False)  # doctest: +SKIP\n",
      " |      \n",
      " |      Create 'out.zip' containing 'out.csv'\n",
      " |      \n",
      " |      >>> df.to_csv(index=False)\n",
      " |      'name,mask,weapon\\nRaphael,red,sai\\nDonatello,purple,bo staff\\n'\n",
      " |      >>> compression_opts = dict(method='zip',\n",
      " |      ...                         archive_name='out.csv')  # doctest: +SKIP\n",
      " |      >>> df.to_csv('out.zip', index=False,\n",
      " |      ...           compression=compression_opts)  # doctest: +SKIP\n",
      " |      \n",
      " |      To write a csv file to a new folder or nested folder you will first\n",
      " |      need to create it using either Pathlib or os:\n",
      " |      \n",
      " |      >>> from pathlib import Path  # doctest: +SKIP\n",
      " |      >>> filepath = Path('folder/subfolder/out.csv')  # doctest: +SKIP\n",
      " |      >>> filepath.parent.mkdir(parents=True, exist_ok=True)  # doctest: +SKIP\n",
      " |      >>> df.to_csv(filepath)  # doctest: +SKIP\n",
      " |      \n",
      " |      >>> import os  # doctest: +SKIP\n",
      " |      >>> os.makedirs('folder/subfolder', exist_ok=True)  # doctest: +SKIP\n",
      " |      >>> df.to_csv('folder/subfolder/out.csv')  # doctest: +SKIP\n",
      " |  \n",
      " |  to_excel(self, excel_writer: 'FilePath | WriteExcelBuffer | ExcelWriter', *, sheet_name: 'str' = 'Sheet1', na_rep: 'str' = '', float_format: 'str | None' = None, columns: 'Sequence[Hashable] | None' = None, header: 'Sequence[Hashable] | bool_t' = True, index: 'bool_t' = True, index_label: 'IndexLabel | None' = None, startrow: 'int' = 0, startcol: 'int' = 0, engine: \"Literal['openpyxl', 'xlsxwriter'] | None\" = None, merge_cells: 'bool_t' = True, inf_rep: 'str' = 'inf', freeze_panes: 'tuple[int, int] | None' = None, storage_options: 'StorageOptions | None' = None, engine_kwargs: 'dict[str, Any] | None' = None) -> 'None'\n",
      " |      Write object to an Excel sheet.\n",
      " |      \n",
      " |      To write a single object to an Excel .xlsx file it is only necessary to\n",
      " |      specify a target file name. To write to multiple sheets it is necessary to\n",
      " |      create an `ExcelWriter` object with a target file name, and specify a sheet\n",
      " |      in the file to write to.\n",
      " |      \n",
      " |      Multiple sheets may be written to by specifying unique `sheet_name`.\n",
      " |      With all data written to the file it is necessary to save the changes.\n",
      " |      Note that creating an `ExcelWriter` object with a file name that already\n",
      " |      exists will result in the contents of the existing file being erased.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      excel_writer : path-like, file-like, or ExcelWriter object\n",
      " |          File path or existing ExcelWriter.\n",
      " |      sheet_name : str, default 'Sheet1'\n",
      " |          Name of sheet which will contain DataFrame.\n",
      " |      na_rep : str, default ''\n",
      " |          Missing data representation.\n",
      " |      float_format : str, optional\n",
      " |          Format string for floating point numbers. For example\n",
      " |          ``float_format=\"%.2f\"`` will format 0.1234 to 0.12.\n",
      " |      columns : sequence or list of str, optional\n",
      " |          Columns to write.\n",
      " |      header : bool or list of str, default True\n",
      " |          Write out the column names. If a list of string is given it is\n",
      " |          assumed to be aliases for the column names.\n",
      " |      index : bool, default True\n",
      " |          Write row names (index).\n",
      " |      index_label : str or sequence, optional\n",
      " |          Column label for index column(s) if desired. If not specified, and\n",
      " |          `header` and `index` are True, then the index names are used. A\n",
      " |          sequence should be given if the DataFrame uses MultiIndex.\n",
      " |      startrow : int, default 0\n",
      " |          Upper left cell row to dump data frame.\n",
      " |      startcol : int, default 0\n",
      " |          Upper left cell column to dump data frame.\n",
      " |      engine : str, optional\n",
      " |          Write engine to use, 'openpyxl' or 'xlsxwriter'. You can also set this\n",
      " |          via the options ``io.excel.xlsx.writer`` or\n",
      " |          ``io.excel.xlsm.writer``.\n",
      " |      \n",
      " |      merge_cells : bool, default True\n",
      " |          Write MultiIndex and Hierarchical Rows as merged cells.\n",
      " |      inf_rep : str, default 'inf'\n",
      " |          Representation for infinity (there is no native representation for\n",
      " |          infinity in Excel).\n",
      " |      freeze_panes : tuple of int (length 2), optional\n",
      " |          Specifies the one-based bottommost row and rightmost column that\n",
      " |          is to be frozen.\n",
      " |      storage_options : dict, optional\n",
      " |          Extra options that make sense for a particular storage connection, e.g.\n",
      " |          host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n",
      " |          are forwarded to ``urllib.request.Request`` as header options. For other\n",
      " |          URLs (e.g. starting with \"s3://\", and \"gcs://\") the key-value pairs are\n",
      " |          forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n",
      " |          details, and for more examples on storage options refer `here\n",
      " |          <https://pandas.pydata.org/docs/user_guide/io.html?\n",
      " |          highlight=storage_options#reading-writing-remote-files>`_.\n",
      " |      \n",
      " |          .. versionadded:: 1.2.0\n",
      " |      engine_kwargs : dict, optional\n",
      " |          Arbitrary keyword arguments passed to excel engine.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      to_csv : Write DataFrame to a comma-separated values (csv) file.\n",
      " |      ExcelWriter : Class for writing DataFrame objects into excel sheets.\n",
      " |      read_excel : Read an Excel file into a pandas DataFrame.\n",
      " |      read_csv : Read a comma-separated values (csv) file into DataFrame.\n",
      " |      io.formats.style.Styler.to_excel : Add styles to Excel sheet.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      For compatibility with :meth:`~DataFrame.to_csv`,\n",
      " |      to_excel serializes lists and dicts to strings before writing.\n",
      " |      \n",
      " |      Once a workbook has been saved it is not possible to write further\n",
      " |      data without rewriting the whole workbook.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      \n",
      " |      Create, write to and save a workbook:\n",
      " |      \n",
      " |      >>> df1 = pd.DataFrame([['a', 'b'], ['c', 'd']],\n",
      " |      ...                    index=['row 1', 'row 2'],\n",
      " |      ...                    columns=['col 1', 'col 2'])\n",
      " |      >>> df1.to_excel(\"output.xlsx\")  # doctest: +SKIP\n",
      " |      \n",
      " |      To specify the sheet name:\n",
      " |      \n",
      " |      >>> df1.to_excel(\"output.xlsx\",\n",
      " |      ...              sheet_name='Sheet_name_1')  # doctest: +SKIP\n",
      " |      \n",
      " |      If you wish to write to more than one sheet in the workbook, it is\n",
      " |      necessary to specify an ExcelWriter object:\n",
      " |      \n",
      " |      >>> df2 = df1.copy()\n",
      " |      >>> with pd.ExcelWriter('output.xlsx') as writer:  # doctest: +SKIP\n",
      " |      ...     df1.to_excel(writer, sheet_name='Sheet_name_1')\n",
      " |      ...     df2.to_excel(writer, sheet_name='Sheet_name_2')\n",
      " |      \n",
      " |      ExcelWriter can also be used to append to an existing Excel file:\n",
      " |      \n",
      " |      >>> with pd.ExcelWriter('output.xlsx',\n",
      " |      ...                     mode='a') as writer:  # doctest: +SKIP\n",
      " |      ...     df1.to_excel(writer, sheet_name='Sheet_name_3')\n",
      " |      \n",
      " |      To set the library that is used to write the Excel file,\n",
      " |      you can pass the `engine` keyword (the default engine is\n",
      " |      automatically chosen depending on the file extension):\n",
      " |      \n",
      " |      >>> df1.to_excel('output1.xlsx', engine='xlsxwriter')  # doctest: +SKIP\n",
      " |  \n",
      " |  to_hdf(self, path_or_buf: 'FilePath | HDFStore', *, key: 'str', mode: \"Literal['a', 'w', 'r+']\" = 'a', complevel: 'int | None' = None, complib: \"Literal['zlib', 'lzo', 'bzip2', 'blosc'] | None\" = None, append: 'bool_t' = False, format: \"Literal['fixed', 'table'] | None\" = None, index: 'bool_t' = True, min_itemsize: 'int | dict[str, int] | None' = None, nan_rep=None, dropna: 'bool_t | None' = None, data_columns: 'Literal[True] | list[str] | None' = None, errors: 'OpenFileErrors' = 'strict', encoding: 'str' = 'UTF-8') -> 'None'\n",
      " |      Write the contained data to an HDF5 file using HDFStore.\n",
      " |      \n",
      " |      Hierarchical Data Format (HDF) is self-describing, allowing an\n",
      " |      application to interpret the structure and contents of a file with\n",
      " |      no outside information. One HDF file can hold a mix of related objects\n",
      " |      which can be accessed as a group or as individual objects.\n",
      " |      \n",
      " |      In order to add another DataFrame or Series to an existing HDF file\n",
      " |      please use append mode and a different a key.\n",
      " |      \n",
      " |      .. warning::\n",
      " |      \n",
      " |         One can store a subclass of ``DataFrame`` or ``Series`` to HDF5,\n",
      " |         but the type of the subclass is lost upon storing.\n",
      " |      \n",
      " |      For more information see the :ref:`user guide <io.hdf5>`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      path_or_buf : str or pandas.HDFStore\n",
      " |          File path or HDFStore object.\n",
      " |      key : str\n",
      " |          Identifier for the group in the store.\n",
      " |      mode : {'a', 'w', 'r+'}, default 'a'\n",
      " |          Mode to open file:\n",
      " |      \n",
      " |          - 'w': write, a new file is created (an existing file with\n",
      " |            the same name would be deleted).\n",
      " |          - 'a': append, an existing file is opened for reading and\n",
      " |            writing, and if the file does not exist it is created.\n",
      " |          - 'r+': similar to 'a', but the file must already exist.\n",
      " |      complevel : {0-9}, default None\n",
      " |          Specifies a compression level for data.\n",
      " |          A value of 0 or None disables compression.\n",
      " |      complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default 'zlib'\n",
      " |          Specifies the compression library to be used.\n",
      " |          These additional compressors for Blosc are supported\n",
      " |          (default if no compressor specified: 'blosc:blosclz'):\n",
      " |          {'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc', 'blosc:snappy',\n",
      " |          'blosc:zlib', 'blosc:zstd'}.\n",
      " |          Specifying a compression library which is not available issues\n",
      " |          a ValueError.\n",
      " |      append : bool, default False\n",
      " |          For Table formats, append the input data to the existing.\n",
      " |      format : {'fixed', 'table', None}, default 'fixed'\n",
      " |          Possible values:\n",
      " |      \n",
      " |          - 'fixed': Fixed format. Fast writing/reading. Not-appendable,\n",
      " |            nor searchable.\n",
      " |          - 'table': Table format. Write as a PyTables Table structure\n",
      " |            which may perform worse but allow more flexible operations\n",
      " |            like searching / selecting subsets of the data.\n",
      " |          - If None, pd.get_option('io.hdf.default_format') is checked,\n",
      " |            followed by fallback to \"fixed\".\n",
      " |      index : bool, default True\n",
      " |          Write DataFrame index as a column.\n",
      " |      min_itemsize : dict or int, optional\n",
      " |          Map column names to minimum string sizes for columns.\n",
      " |      nan_rep : Any, optional\n",
      " |          How to represent null values as str.\n",
      " |          Not allowed with append=True.\n",
      " |      dropna : bool, default False, optional\n",
      " |          Remove missing values.\n",
      " |      data_columns : list of columns or True, optional\n",
      " |          List of columns to create as indexed data columns for on-disk\n",
      " |          queries, or True to use all columns. By default only the axes\n",
      " |          of the object are indexed. See\n",
      " |          :ref:`Query via data columns<io.hdf5-query-data-columns>`. for\n",
      " |          more information.\n",
      " |          Applicable only to format='table'.\n",
      " |      errors : str, default 'strict'\n",
      " |          Specifies how encoding and decoding errors are to be handled.\n",
      " |          See the errors argument for :func:`open` for a full list\n",
      " |          of options.\n",
      " |      encoding : str, default \"UTF-8\"\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      read_hdf : Read from HDF file.\n",
      " |      DataFrame.to_orc : Write a DataFrame to the binary orc format.\n",
      " |      DataFrame.to_parquet : Write a DataFrame to the binary parquet format.\n",
      " |      DataFrame.to_sql : Write to a SQL table.\n",
      " |      DataFrame.to_feather : Write out feather-format for DataFrames.\n",
      " |      DataFrame.to_csv : Write out to a csv file.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]},\n",
      " |      ...                   index=['a', 'b', 'c'])  # doctest: +SKIP\n",
      " |      >>> df.to_hdf('data.h5', key='df', mode='w')  # doctest: +SKIP\n",
      " |      \n",
      " |      We can add another object to the same file:\n",
      " |      \n",
      " |      >>> s = pd.Series([1, 2, 3, 4])  # doctest: +SKIP\n",
      " |      >>> s.to_hdf('data.h5', key='s')  # doctest: +SKIP\n",
      " |      \n",
      " |      Reading from HDF file:\n",
      " |      \n",
      " |      >>> pd.read_hdf('data.h5', 'df')  # doctest: +SKIP\n",
      " |      A  B\n",
      " |      a  1  4\n",
      " |      b  2  5\n",
      " |      c  3  6\n",
      " |      >>> pd.read_hdf('data.h5', 's')  # doctest: +SKIP\n",
      " |      0    1\n",
      " |      1    2\n",
      " |      2    3\n",
      " |      3    4\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  to_json(self, path_or_buf: 'FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None' = None, *, orient: \"Literal['split', 'records', 'index', 'table', 'columns', 'values'] | None\" = None, date_format: 'str | None' = None, double_precision: 'int' = 10, force_ascii: 'bool_t' = True, date_unit: 'TimeUnit' = 'ms', default_handler: 'Callable[[Any], JSONSerializable] | None' = None, lines: 'bool_t' = False, compression: 'CompressionOptions' = 'infer', index: 'bool_t | None' = None, indent: 'int | None' = None, storage_options: 'StorageOptions | None' = None, mode: \"Literal['a', 'w']\" = 'w') -> 'str | None'\n",
      " |      Convert the object to a JSON string.\n",
      " |      \n",
      " |      Note NaN's and None will be converted to null and datetime objects\n",
      " |      will be converted to UNIX timestamps.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      path_or_buf : str, path object, file-like object, or None, default None\n",
      " |          String, path object (implementing os.PathLike[str]), or file-like\n",
      " |          object implementing a write() function. If None, the result is\n",
      " |          returned as a string.\n",
      " |      orient : str\n",
      " |          Indication of expected JSON string format.\n",
      " |      \n",
      " |          * Series:\n",
      " |      \n",
      " |              - default is 'index'\n",
      " |              - allowed values are: {'split', 'records', 'index', 'table'}.\n",
      " |      \n",
      " |          * DataFrame:\n",
      " |      \n",
      " |              - default is 'columns'\n",
      " |              - allowed values are: {'split', 'records', 'index', 'columns',\n",
      " |                'values', 'table'}.\n",
      " |      \n",
      " |          * The format of the JSON string:\n",
      " |      \n",
      " |              - 'split' : dict like {'index' -> [index], 'columns' -> [columns],\n",
      " |                'data' -> [values]}\n",
      " |              - 'records' : list like [{column -> value}, ... , {column -> value}]\n",
      " |              - 'index' : dict like {index -> {column -> value}}\n",
      " |              - 'columns' : dict like {column -> {index -> value}}\n",
      " |              - 'values' : just the values array\n",
      " |              - 'table' : dict like {'schema': {schema}, 'data': {data}}\n",
      " |      \n",
      " |              Describing the data, where data component is like ``orient='records'``.\n",
      " |      \n",
      " |      date_format : {None, 'epoch', 'iso'}\n",
      " |          Type of date conversion. 'epoch' = epoch milliseconds,\n",
      " |          'iso' = ISO8601. The default depends on the `orient`. For\n",
      " |          ``orient='table'``, the default is 'iso'. For all other orients,\n",
      " |          the default is 'epoch'.\n",
      " |      double_precision : int, default 10\n",
      " |          The number of decimal places to use when encoding\n",
      " |          floating point values. The possible maximal value is 15.\n",
      " |          Passing double_precision greater than 15 will raise a ValueError.\n",
      " |      force_ascii : bool, default True\n",
      " |          Force encoded string to be ASCII.\n",
      " |      date_unit : str, default 'ms' (milliseconds)\n",
      " |          The time unit to encode to, governs timestamp and ISO8601\n",
      " |          precision.  One of 's', 'ms', 'us', 'ns' for second, millisecond,\n",
      " |          microsecond, and nanosecond respectively.\n",
      " |      default_handler : callable, default None\n",
      " |          Handler to call if object cannot otherwise be converted to a\n",
      " |          suitable format for JSON. Should receive a single argument which is\n",
      " |          the object to convert and return a serialisable object.\n",
      " |      lines : bool, default False\n",
      " |          If 'orient' is 'records' write out line-delimited json format. Will\n",
      " |          throw ValueError if incorrect 'orient' since others are not\n",
      " |          list-like.\n",
      " |      compression : str or dict, default 'infer'\n",
      " |          For on-the-fly compression of the output data. If 'infer' and 'path_or_buf' is\n",
      " |          path-like, then detect compression from the following extensions: '.gz',\n",
      " |          '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n",
      " |          (otherwise no compression).\n",
      " |          Set to ``None`` for no compression.\n",
      " |          Can also be a dict with key ``'method'`` set\n",
      " |          to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and\n",
      " |          other key-value pairs are forwarded to\n",
      " |          ``zipfile.ZipFile``, ``gzip.GzipFile``,\n",
      " |          ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or\n",
      " |          ``tarfile.TarFile``, respectively.\n",
      " |          As an example, the following could be passed for faster compression and to create\n",
      " |          a reproducible gzip archive:\n",
      " |          ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |              Added support for `.tar` files.\n",
      " |      \n",
      " |          .. versionchanged:: 1.4.0 Zstandard support.\n",
      " |      \n",
      " |      index : bool or None, default None\n",
      " |          The index is only used when 'orient' is 'split', 'index', 'column',\n",
      " |          or 'table'. Of these, 'index' and 'column' do not support\n",
      " |          `index=False`.\n",
      " |      \n",
      " |      indent : int, optional\n",
      " |         Length of whitespace used to indent each record.\n",
      " |      \n",
      " |      storage_options : dict, optional\n",
      " |          Extra options that make sense for a particular storage connection, e.g.\n",
      " |          host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n",
      " |          are forwarded to ``urllib.request.Request`` as header options. For other\n",
      " |          URLs (e.g. starting with \"s3://\", and \"gcs://\") the key-value pairs are\n",
      " |          forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n",
      " |          details, and for more examples on storage options refer `here\n",
      " |          <https://pandas.pydata.org/docs/user_guide/io.html?\n",
      " |          highlight=storage_options#reading-writing-remote-files>`_.\n",
      " |      \n",
      " |      mode : str, default 'w' (writing)\n",
      " |          Specify the IO mode for output when supplying a path_or_buf.\n",
      " |          Accepted args are 'w' (writing) and 'a' (append) only.\n",
      " |          mode='a' is only supported when lines is True and orient is 'records'.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None or str\n",
      " |          If path_or_buf is None, returns the resulting json format as a\n",
      " |          string. Otherwise returns None.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      read_json : Convert a JSON string to pandas object.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The behavior of ``indent=0`` varies from the stdlib, which does not\n",
      " |      indent the output but does insert newlines. Currently, ``indent=0``\n",
      " |      and the default ``indent=None`` are equivalent in pandas, though this\n",
      " |      may change in a future release.\n",
      " |      \n",
      " |      ``orient='table'`` contains a 'pandas_version' field under 'schema'.\n",
      " |      This stores the version of `pandas` used in the latest revision of the\n",
      " |      schema.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> from json import loads, dumps\n",
      " |      >>> df = pd.DataFrame(\n",
      " |      ...     [[\"a\", \"b\"], [\"c\", \"d\"]],\n",
      " |      ...     index=[\"row 1\", \"row 2\"],\n",
      " |      ...     columns=[\"col 1\", \"col 2\"],\n",
      " |      ... )\n",
      " |      \n",
      " |      >>> result = df.to_json(orient=\"split\")\n",
      " |      >>> parsed = loads(result)\n",
      " |      >>> dumps(parsed, indent=4)  # doctest: +SKIP\n",
      " |      {\n",
      " |          \"columns\": [\n",
      " |              \"col 1\",\n",
      " |              \"col 2\"\n",
      " |          ],\n",
      " |          \"index\": [\n",
      " |              \"row 1\",\n",
      " |              \"row 2\"\n",
      " |          ],\n",
      " |          \"data\": [\n",
      " |              [\n",
      " |                  \"a\",\n",
      " |                  \"b\"\n",
      " |              ],\n",
      " |              [\n",
      " |                  \"c\",\n",
      " |                  \"d\"\n",
      " |              ]\n",
      " |          ]\n",
      " |      }\n",
      " |      \n",
      " |      Encoding/decoding a Dataframe using ``'records'`` formatted JSON.\n",
      " |      Note that index labels are not preserved with this encoding.\n",
      " |      \n",
      " |      >>> result = df.to_json(orient=\"records\")\n",
      " |      >>> parsed = loads(result)\n",
      " |      >>> dumps(parsed, indent=4)  # doctest: +SKIP\n",
      " |      [\n",
      " |          {\n",
      " |              \"col 1\": \"a\",\n",
      " |              \"col 2\": \"b\"\n",
      " |          },\n",
      " |          {\n",
      " |              \"col 1\": \"c\",\n",
      " |              \"col 2\": \"d\"\n",
      " |          }\n",
      " |      ]\n",
      " |      \n",
      " |      Encoding/decoding a Dataframe using ``'index'`` formatted JSON:\n",
      " |      \n",
      " |      >>> result = df.to_json(orient=\"index\")\n",
      " |      >>> parsed = loads(result)\n",
      " |      >>> dumps(parsed, indent=4)  # doctest: +SKIP\n",
      " |      {\n",
      " |          \"row 1\": {\n",
      " |              \"col 1\": \"a\",\n",
      " |              \"col 2\": \"b\"\n",
      " |          },\n",
      " |          \"row 2\": {\n",
      " |              \"col 1\": \"c\",\n",
      " |              \"col 2\": \"d\"\n",
      " |          }\n",
      " |      }\n",
      " |      \n",
      " |      Encoding/decoding a Dataframe using ``'columns'`` formatted JSON:\n",
      " |      \n",
      " |      >>> result = df.to_json(orient=\"columns\")\n",
      " |      >>> parsed = loads(result)\n",
      " |      >>> dumps(parsed, indent=4)  # doctest: +SKIP\n",
      " |      {\n",
      " |          \"col 1\": {\n",
      " |              \"row 1\": \"a\",\n",
      " |              \"row 2\": \"c\"\n",
      " |          },\n",
      " |          \"col 2\": {\n",
      " |              \"row 1\": \"b\",\n",
      " |              \"row 2\": \"d\"\n",
      " |          }\n",
      " |      }\n",
      " |      \n",
      " |      Encoding/decoding a Dataframe using ``'values'`` formatted JSON:\n",
      " |      \n",
      " |      >>> result = df.to_json(orient=\"values\")\n",
      " |      >>> parsed = loads(result)\n",
      " |      >>> dumps(parsed, indent=4)  # doctest: +SKIP\n",
      " |      [\n",
      " |          [\n",
      " |              \"a\",\n",
      " |              \"b\"\n",
      " |          ],\n",
      " |          [\n",
      " |              \"c\",\n",
      " |              \"d\"\n",
      " |          ]\n",
      " |      ]\n",
      " |      \n",
      " |      Encoding with Table Schema:\n",
      " |      \n",
      " |      >>> result = df.to_json(orient=\"table\")\n",
      " |      >>> parsed = loads(result)\n",
      " |      >>> dumps(parsed, indent=4)  # doctest: +SKIP\n",
      " |      {\n",
      " |          \"schema\": {\n",
      " |              \"fields\": [\n",
      " |                  {\n",
      " |                      \"name\": \"index\",\n",
      " |                      \"type\": \"string\"\n",
      " |                  },\n",
      " |                  {\n",
      " |                      \"name\": \"col 1\",\n",
      " |                      \"type\": \"string\"\n",
      " |                  },\n",
      " |                  {\n",
      " |                      \"name\": \"col 2\",\n",
      " |                      \"type\": \"string\"\n",
      " |                  }\n",
      " |              ],\n",
      " |              \"primaryKey\": [\n",
      " |                  \"index\"\n",
      " |              ],\n",
      " |              \"pandas_version\": \"1.4.0\"\n",
      " |          },\n",
      " |          \"data\": [\n",
      " |              {\n",
      " |                  \"index\": \"row 1\",\n",
      " |                  \"col 1\": \"a\",\n",
      " |                  \"col 2\": \"b\"\n",
      " |              },\n",
      " |              {\n",
      " |                  \"index\": \"row 2\",\n",
      " |                  \"col 1\": \"c\",\n",
      " |                  \"col 2\": \"d\"\n",
      " |              }\n",
      " |          ]\n",
      " |      }\n",
      " |  \n",
      " |  to_latex(self, buf: 'FilePath | WriteBuffer[str] | None' = None, *, columns: 'Sequence[Hashable] | None' = None, header: 'bool_t | SequenceNotStr[str]' = True, index: 'bool_t' = True, na_rep: 'str' = 'NaN', formatters: 'FormattersType | None' = None, float_format: 'FloatFormatType | None' = None, sparsify: 'bool_t | None' = None, index_names: 'bool_t' = True, bold_rows: 'bool_t' = False, column_format: 'str | None' = None, longtable: 'bool_t | None' = None, escape: 'bool_t | None' = None, encoding: 'str | None' = None, decimal: 'str' = '.', multicolumn: 'bool_t | None' = None, multicolumn_format: 'str | None' = None, multirow: 'bool_t | None' = None, caption: 'str | tuple[str, str] | None' = None, label: 'str | None' = None, position: 'str | None' = None) -> 'str | None'\n",
      " |      Render object to a LaTeX tabular, longtable, or nested table.\n",
      " |      \n",
      " |      Requires ``\\usepackage{{booktabs}}``.  The output can be copy/pasted\n",
      " |      into a main LaTeX document or read from an external file\n",
      " |      with ``\\input{{table.tex}}``.\n",
      " |      \n",
      " |      .. versionchanged:: 2.0.0\n",
      " |         Refactored to use the Styler implementation via jinja2 templating.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      buf : str, Path or StringIO-like, optional, default None\n",
      " |          Buffer to write to. If None, the output is returned as a string.\n",
      " |      columns : list of label, optional\n",
      " |          The subset of columns to write. Writes all columns by default.\n",
      " |      header : bool or list of str, default True\n",
      " |          Write out the column names. If a list of strings is given,\n",
      " |          it is assumed to be aliases for the column names.\n",
      " |      index : bool, default True\n",
      " |          Write row names (index).\n",
      " |      na_rep : str, default 'NaN'\n",
      " |          Missing data representation.\n",
      " |      formatters : list of functions or dict of {{str: function}}, optional\n",
      " |          Formatter functions to apply to columns' elements by position or\n",
      " |          name. The result of each function must be a unicode string.\n",
      " |          List must be of length equal to the number of columns.\n",
      " |      float_format : one-parameter function or str, optional, default None\n",
      " |          Formatter for floating point numbers. For example\n",
      " |          ``float_format=\"%.2f\"`` and ``float_format=\"{{:0.2f}}\".format`` will\n",
      " |          both result in 0.1234 being formatted as 0.12.\n",
      " |      sparsify : bool, optional\n",
      " |          Set to False for a DataFrame with a hierarchical index to print\n",
      " |          every multiindex key at each row. By default, the value will be\n",
      " |          read from the config module.\n",
      " |      index_names : bool, default True\n",
      " |          Prints the names of the indexes.\n",
      " |      bold_rows : bool, default False\n",
      " |          Make the row labels bold in the output.\n",
      " |      column_format : str, optional\n",
      " |          The columns format as specified in `LaTeX table format\n",
      " |          <https://en.wikibooks.org/wiki/LaTeX/Tables>`__ e.g. 'rcl' for 3\n",
      " |          columns. By default, 'l' will be used for all columns except\n",
      " |          columns of numbers, which default to 'r'.\n",
      " |      longtable : bool, optional\n",
      " |          Use a longtable environment instead of tabular. Requires\n",
      " |          adding a \\usepackage{{longtable}} to your LaTeX preamble.\n",
      " |          By default, the value will be read from the pandas config\n",
      " |          module, and set to `True` if the option ``styler.latex.environment`` is\n",
      " |          `\"longtable\"`.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |             The pandas option affecting this argument has changed.\n",
      " |      escape : bool, optional\n",
      " |          By default, the value will be read from the pandas config\n",
      " |          module and set to `True` if the option ``styler.format.escape`` is\n",
      " |          `\"latex\"`. When set to False prevents from escaping latex special\n",
      " |          characters in column names.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |             The pandas option affecting this argument has changed, as has the\n",
      " |             default value to `False`.\n",
      " |      encoding : str, optional\n",
      " |          A string representing the encoding to use in the output file,\n",
      " |          defaults to 'utf-8'.\n",
      " |      decimal : str, default '.'\n",
      " |          Character recognized as decimal separator, e.g. ',' in Europe.\n",
      " |      multicolumn : bool, default True\n",
      " |          Use \\multicolumn to enhance MultiIndex columns.\n",
      " |          The default will be read from the config module, and is set\n",
      " |          as the option ``styler.sparse.columns``.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |             The pandas option affecting this argument has changed.\n",
      " |      multicolumn_format : str, default 'r'\n",
      " |          The alignment for multicolumns, similar to `column_format`\n",
      " |          The default will be read from the config module, and is set as the option\n",
      " |          ``styler.latex.multicol_align``.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |             The pandas option affecting this argument has changed, as has the\n",
      " |             default value to \"r\".\n",
      " |      multirow : bool, default True\n",
      " |          Use \\multirow to enhance MultiIndex rows. Requires adding a\n",
      " |          \\usepackage{{multirow}} to your LaTeX preamble. Will print\n",
      " |          centered labels (instead of top-aligned) across the contained\n",
      " |          rows, separating groups via clines. The default will be read\n",
      " |          from the pandas config module, and is set as the option\n",
      " |          ``styler.sparse.index``.\n",
      " |      \n",
      " |          .. versionchanged:: 2.0.0\n",
      " |             The pandas option affecting this argument has changed, as has the\n",
      " |             default value to `True`.\n",
      " |      caption : str or tuple, optional\n",
      " |          Tuple (full_caption, short_caption),\n",
      " |          which results in ``\\caption[short_caption]{{full_caption}}``;\n",
      " |          if a single string is passed, no short caption will be set.\n",
      " |      label : str, optional\n",
      " |          The LaTeX label to be placed inside ``\\label{{}}`` in the output.\n",
      " |          This is used with ``\\ref{{}}`` in the main ``.tex`` file.\n",
      " |      \n",
      " |      position : str, optional\n",
      " |          The LaTeX positional argument for tables, to be placed after\n",
      " |          ``\\begin{{}}`` in the output.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      str or None\n",
      " |          If buf is None, returns the result as a string. Otherwise returns None.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      io.formats.style.Styler.to_latex : Render a DataFrame to LaTeX\n",
      " |          with conditional formatting.\n",
      " |      DataFrame.to_string : Render a DataFrame to a console-friendly\n",
      " |          tabular output.\n",
      " |      DataFrame.to_html : Render a DataFrame as an HTML table.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      As of v2.0.0 this method has changed to use the Styler implementation as\n",
      " |      part of :meth:`.Styler.to_latex` via ``jinja2`` templating. This means\n",
      " |      that ``jinja2`` is a requirement, and needs to be installed, for this method\n",
      " |      to function. It is advised that users switch to using Styler, since that\n",
      " |      implementation is more frequently updated and contains much more\n",
      " |      flexibility with the output.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Convert a general DataFrame to LaTeX with formatting:\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(dict(name=['Raphael', 'Donatello'],\n",
      " |      ...                        age=[26, 45],\n",
      " |      ...                        height=[181.23, 177.65]))\n",
      " |      >>> print(df.to_latex(index=False,\n",
      " |      ...                   formatters={\"name\": str.upper},\n",
      " |      ...                   float_format=\"{:.1f}\".format,\n",
      " |      ... ))  # doctest: +SKIP\n",
      " |      \\begin{tabular}{lrr}\n",
      " |      \\toprule\n",
      " |      name & age & height \\\\\n",
      " |      \\midrule\n",
      " |      RAPHAEL & 26 & 181.2 \\\\\n",
      " |      DONATELLO & 45 & 177.7 \\\\\n",
      " |      \\bottomrule\n",
      " |      \\end{tabular}\n",
      " |  \n",
      " |  to_pickle(self, path: 'FilePath | WriteBuffer[bytes]', *, compression: 'CompressionOptions' = 'infer', protocol: 'int' = 5, storage_options: 'StorageOptions | None' = None) -> 'None'\n",
      " |      Pickle (serialize) object to file.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      path : str, path object, or file-like object\n",
      " |          String, path object (implementing ``os.PathLike[str]``), or file-like\n",
      " |          object implementing a binary ``write()`` function. File path where\n",
      " |          the pickled object will be stored.\n",
      " |      compression : str or dict, default 'infer'\n",
      " |          For on-the-fly compression of the output data. If 'infer' and 'path' is\n",
      " |          path-like, then detect compression from the following extensions: '.gz',\n",
      " |          '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n",
      " |          (otherwise no compression).\n",
      " |          Set to ``None`` for no compression.\n",
      " |          Can also be a dict with key ``'method'`` set\n",
      " |          to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and\n",
      " |          other key-value pairs are forwarded to\n",
      " |          ``zipfile.ZipFile``, ``gzip.GzipFile``,\n",
      " |          ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or\n",
      " |          ``tarfile.TarFile``, respectively.\n",
      " |          As an example, the following could be passed for faster compression and to create\n",
      " |          a reproducible gzip archive:\n",
      " |          ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.\n",
      " |      \n",
      " |          .. versionadded:: 1.5.0\n",
      " |              Added support for `.tar` files.\n",
      " |      protocol : int\n",
      " |          Int which indicates which protocol should be used by the pickler,\n",
      " |          default HIGHEST_PROTOCOL (see [1]_ paragraph 12.1.2). The possible\n",
      " |          values are 0, 1, 2, 3, 4, 5. A negative value for the protocol\n",
      " |          parameter is equivalent to setting its value to HIGHEST_PROTOCOL.\n",
      " |      \n",
      " |          .. [1] https://docs.python.org/3/library/pickle.html.\n",
      " |      \n",
      " |      storage_options : dict, optional\n",
      " |          Extra options that make sense for a particular storage connection, e.g.\n",
      " |          host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n",
      " |          are forwarded to ``urllib.request.Request`` as header options. For other\n",
      " |          URLs (e.g. starting with \"s3://\", and \"gcs://\") the key-value pairs are\n",
      " |          forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n",
      " |          details, and for more examples on storage options refer `here\n",
      " |          <https://pandas.pydata.org/docs/user_guide/io.html?\n",
      " |          highlight=storage_options#reading-writing-remote-files>`_.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      read_pickle : Load pickled pandas object (or any object) from file.\n",
      " |      DataFrame.to_hdf : Write DataFrame to an HDF5 file.\n",
      " |      DataFrame.to_sql : Write DataFrame to a SQL database.\n",
      " |      DataFrame.to_parquet : Write a DataFrame to the binary parquet format.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> original_df = pd.DataFrame({\"foo\": range(5), \"bar\": range(5, 10)})  # doctest: +SKIP\n",
      " |      >>> original_df  # doctest: +SKIP\n",
      " |         foo  bar\n",
      " |      0    0    5\n",
      " |      1    1    6\n",
      " |      2    2    7\n",
      " |      3    3    8\n",
      " |      4    4    9\n",
      " |      >>> original_df.to_pickle(\"./dummy.pkl\")  # doctest: +SKIP\n",
      " |      \n",
      " |      >>> unpickled_df = pd.read_pickle(\"./dummy.pkl\")  # doctest: +SKIP\n",
      " |      >>> unpickled_df  # doctest: +SKIP\n",
      " |         foo  bar\n",
      " |      0    0    5\n",
      " |      1    1    6\n",
      " |      2    2    7\n",
      " |      3    3    8\n",
      " |      4    4    9\n",
      " |  \n",
      " |  to_sql(self, name: 'str', con, *, schema: 'str | None' = None, if_exists: \"Literal['fail', 'replace', 'append']\" = 'fail', index: 'bool_t' = True, index_label: 'IndexLabel | None' = None, chunksize: 'int | None' = None, dtype: 'DtypeArg | None' = None, method: \"Literal['multi'] | Callable | None\" = None) -> 'int | None'\n",
      " |      Write records stored in a DataFrame to a SQL database.\n",
      " |      \n",
      " |      Databases supported by SQLAlchemy [1]_ are supported. Tables can be\n",
      " |      newly created, appended to, or overwritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      name : str\n",
      " |          Name of SQL table.\n",
      " |      con : sqlalchemy.engine.(Engine or Connection) or sqlite3.Connection\n",
      " |          Using SQLAlchemy makes it possible to use any DB supported by that\n",
      " |          library. Legacy support is provided for sqlite3.Connection objects. The user\n",
      " |          is responsible for engine disposal and connection closure for the SQLAlchemy\n",
      " |          connectable. See `here                 <https://docs.sqlalchemy.org/en/20/core/connections.html>`_.\n",
      " |          If passing a sqlalchemy.engine.Connection which is already in a transaction,\n",
      " |          the transaction will not be committed.  If passing a sqlite3.Connection,\n",
      " |          it will not be possible to roll back the record insertion.\n",
      " |      \n",
      " |      schema : str, optional\n",
      " |          Specify the schema (if database flavor supports this). If None, use\n",
      " |          default schema.\n",
      " |      if_exists : {'fail', 'replace', 'append'}, default 'fail'\n",
      " |          How to behave if the table already exists.\n",
      " |      \n",
      " |          * fail: Raise a ValueError.\n",
      " |          * replace: Drop the table before inserting new values.\n",
      " |          * append: Insert new values to the existing table.\n",
      " |      \n",
      " |      index : bool, default True\n",
      " |          Write DataFrame index as a column. Uses `index_label` as the column\n",
      " |          name in the table. Creates a table index for this column.\n",
      " |      index_label : str or sequence, default None\n",
      " |          Column label for index column(s). If None is given (default) and\n",
      " |          `index` is True, then the index names are used.\n",
      " |          A sequence should be given if the DataFrame uses MultiIndex.\n",
      " |      chunksize : int, optional\n",
      " |          Specify the number of rows in each batch to be written at a time.\n",
      " |          By default, all rows will be written at once.\n",
      " |      dtype : dict or scalar, optional\n",
      " |          Specifying the datatype for columns. If a dictionary is used, the\n",
      " |          keys should be the column names and the values should be the\n",
      " |          SQLAlchemy types or strings for the sqlite3 legacy mode. If a\n",
      " |          scalar is provided, it will be applied to all columns.\n",
      " |      method : {None, 'multi', callable}, optional\n",
      " |          Controls the SQL insertion clause used:\n",
      " |      \n",
      " |          * None : Uses standard SQL ``INSERT`` clause (one per row).\n",
      " |          * 'multi': Pass multiple values in a single ``INSERT`` clause.\n",
      " |          * callable with signature ``(pd_table, conn, keys, data_iter)``.\n",
      " |      \n",
      " |          Details and a sample callable implementation can be found in the\n",
      " |          section :ref:`insert method <io.sql.method>`.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      None or int\n",
      " |          Number of rows affected by to_sql. None is returned if the callable\n",
      " |          passed into ``method`` does not return an integer number of rows.\n",
      " |      \n",
      " |          The number of returned rows affected is the sum of the ``rowcount``\n",
      " |          attribute of ``sqlite3.Cursor`` or SQLAlchemy connectable which may not\n",
      " |          reflect the exact number of written rows as stipulated in the\n",
      " |          `sqlite3 <https://docs.python.org/3/library/sqlite3.html#sqlite3.Cursor.rowcount>`__ or\n",
      " |          `SQLAlchemy <https://docs.sqlalchemy.org/en/20/core/connections.html#sqlalchemy.engine.CursorResult.rowcount>`__.\n",
      " |      \n",
      " |          .. versionadded:: 1.4.0\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      ValueError\n",
      " |          When the table already exists and `if_exists` is 'fail' (the\n",
      " |          default).\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      read_sql : Read a DataFrame from a table.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Timezone aware datetime columns will be written as\n",
      " |      ``Timestamp with timezone`` type with SQLAlchemy if supported by the\n",
      " |      database. Otherwise, the datetimes will be stored as timezone unaware\n",
      " |      timestamps local to the original timezone.\n",
      " |      \n",
      " |      Not all datastores support ``method=\"multi\"``. Oracle, for example,\n",
      " |      does not support multi-value insert.\n",
      " |      \n",
      " |      References\n",
      " |      ----------\n",
      " |      .. [1] https://docs.sqlalchemy.org\n",
      " |      .. [2] https://www.python.org/dev/peps/pep-0249/\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Create an in-memory SQLite database.\n",
      " |      \n",
      " |      >>> from sqlalchemy import create_engine\n",
      " |      >>> engine = create_engine('sqlite://', echo=False)\n",
      " |      \n",
      " |      Create a table from scratch with 3 rows.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})\n",
      " |      >>> df\n",
      " |           name\n",
      " |      0  User 1\n",
      " |      1  User 2\n",
      " |      2  User 3\n",
      " |      \n",
      " |      >>> df.to_sql(name='users', con=engine)\n",
      " |      3\n",
      " |      >>> from sqlalchemy import text\n",
      " |      >>> with engine.connect() as conn:\n",
      " |      ...    conn.execute(text(\"SELECT * FROM users\")).fetchall()\n",
      " |      [(0, 'User 1'), (1, 'User 2'), (2, 'User 3')]\n",
      " |      \n",
      " |      An `sqlalchemy.engine.Connection` can also be passed to `con`:\n",
      " |      \n",
      " |      >>> with engine.begin() as connection:\n",
      " |      ...     df1 = pd.DataFrame({'name' : ['User 4', 'User 5']})\n",
      " |      ...     df1.to_sql(name='users', con=connection, if_exists='append')\n",
      " |      2\n",
      " |      \n",
      " |      This is allowed to support operations that require that the same\n",
      " |      DBAPI connection is used for the entire operation.\n",
      " |      \n",
      " |      >>> df2 = pd.DataFrame({'name' : ['User 6', 'User 7']})\n",
      " |      >>> df2.to_sql(name='users', con=engine, if_exists='append')\n",
      " |      2\n",
      " |      >>> with engine.connect() as conn:\n",
      " |      ...    conn.execute(text(\"SELECT * FROM users\")).fetchall()\n",
      " |      [(0, 'User 1'), (1, 'User 2'), (2, 'User 3'),\n",
      " |       (0, 'User 4'), (1, 'User 5'), (0, 'User 6'),\n",
      " |       (1, 'User 7')]\n",
      " |      \n",
      " |      Overwrite the table with just ``df2``.\n",
      " |      \n",
      " |      >>> df2.to_sql(name='users', con=engine, if_exists='replace',\n",
      " |      ...            index_label='id')\n",
      " |      2\n",
      " |      >>> with engine.connect() as conn:\n",
      " |      ...    conn.execute(text(\"SELECT * FROM users\")).fetchall()\n",
      " |      [(0, 'User 6'), (1, 'User 7')]\n",
      " |      \n",
      " |      Use ``method`` to define a callable insertion method to do nothing\n",
      " |      if there's a primary key conflict on a table in a PostgreSQL database.\n",
      " |      \n",
      " |      >>> from sqlalchemy.dialects.postgresql import insert\n",
      " |      >>> def insert_on_conflict_nothing(table, conn, keys, data_iter):\n",
      " |      ...     # \"a\" is the primary key in \"conflict_table\"\n",
      " |      ...     data = [dict(zip(keys, row)) for row in data_iter]\n",
      " |      ...     stmt = insert(table.table).values(data).on_conflict_do_nothing(index_elements=[\"a\"])\n",
      " |      ...     result = conn.execute(stmt)\n",
      " |      ...     return result.rowcount\n",
      " |      >>> df_conflict.to_sql(name=\"conflict_table\", con=conn, if_exists=\"append\", method=insert_on_conflict_nothing)  # doctest: +SKIP\n",
      " |      0\n",
      " |      \n",
      " |      For MySQL, a callable to update columns ``b`` and ``c`` if there's a conflict\n",
      " |      on a primary key.\n",
      " |      \n",
      " |      >>> from sqlalchemy.dialects.mysql import insert\n",
      " |      >>> def insert_on_conflict_update(table, conn, keys, data_iter):\n",
      " |      ...     # update columns \"b\" and \"c\" on primary key conflict\n",
      " |      ...     data = [dict(zip(keys, row)) for row in data_iter]\n",
      " |      ...     stmt = (\n",
      " |      ...         insert(table.table)\n",
      " |      ...         .values(data)\n",
      " |      ...     )\n",
      " |      ...     stmt = stmt.on_duplicate_key_update(b=stmt.inserted.b, c=stmt.inserted.c)\n",
      " |      ...     result = conn.execute(stmt)\n",
      " |      ...     return result.rowcount\n",
      " |      >>> df_conflict.to_sql(name=\"conflict_table\", con=conn, if_exists=\"append\", method=insert_on_conflict_update)  # doctest: +SKIP\n",
      " |      2\n",
      " |      \n",
      " |      Specify the dtype (especially useful for integers with missing values).\n",
      " |      Notice that while pandas is forced to store the data as floating point,\n",
      " |      the database supports nullable integers. When fetching the data with\n",
      " |      Python, we get back integer scalars.\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({\"A\": [1, None, 2]})\n",
      " |      >>> df\n",
      " |           A\n",
      " |      0  1.0\n",
      " |      1  NaN\n",
      " |      2  2.0\n",
      " |      \n",
      " |      >>> from sqlalchemy.types import Integer\n",
      " |      >>> df.to_sql(name='integers', con=engine, index=False,\n",
      " |      ...           dtype={\"A\": Integer()})\n",
      " |      3\n",
      " |      \n",
      " |      >>> with engine.connect() as conn:\n",
      " |      ...   conn.execute(text(\"SELECT * FROM integers\")).fetchall()\n",
      " |      [(1,), (None,), (2,)]\n",
      " |  \n",
      " |  to_xarray(self)\n",
      " |      Return an xarray object from the pandas object.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      xarray.DataArray or xarray.Dataset\n",
      " |          Data in the pandas structure converted to Dataset if the object is\n",
      " |          a DataFrame, or a DataArray if the object is a Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.to_hdf : Write DataFrame to an HDF5 file.\n",
      " |      DataFrame.to_parquet : Write a DataFrame to the binary parquet format.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See the `xarray docs <https://xarray.pydata.org/en/stable/>`__\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([('falcon', 'bird', 389.0, 2),\n",
      " |      ...                    ('parrot', 'bird', 24.0, 2),\n",
      " |      ...                    ('lion', 'mammal', 80.5, 4),\n",
      " |      ...                    ('monkey', 'mammal', np.nan, 4)],\n",
      " |      ...                   columns=['name', 'class', 'max_speed',\n",
      " |      ...                            'num_legs'])\n",
      " |      >>> df\n",
      " |           name   class  max_speed  num_legs\n",
      " |      0  falcon    bird      389.0         2\n",
      " |      1  parrot    bird       24.0         2\n",
      " |      2    lion  mammal       80.5         4\n",
      " |      3  monkey  mammal        NaN         4\n",
      " |      \n",
      " |      >>> df.to_xarray()  # doctest: +SKIP\n",
      " |      <xarray.Dataset>\n",
      " |      Dimensions:    (index: 4)\n",
      " |      Coordinates:\n",
      " |        * index      (index) int64 32B 0 1 2 3\n",
      " |      Data variables:\n",
      " |          name       (index) object 32B 'falcon' 'parrot' 'lion' 'monkey'\n",
      " |          class      (index) object 32B 'bird' 'bird' 'mammal' 'mammal'\n",
      " |          max_speed  (index) float64 32B 389.0 24.0 80.5 nan\n",
      " |          num_legs   (index) int64 32B 2 2 4 4\n",
      " |      \n",
      " |      >>> df['max_speed'].to_xarray()  # doctest: +SKIP\n",
      " |      <xarray.DataArray 'max_speed' (index: 4)>\n",
      " |      array([389. ,  24. ,  80.5,   nan])\n",
      " |      Coordinates:\n",
      " |        * index    (index) int64 0 1 2 3\n",
      " |      \n",
      " |      >>> dates = pd.to_datetime(['2018-01-01', '2018-01-01',\n",
      " |      ...                         '2018-01-02', '2018-01-02'])\n",
      " |      >>> df_multiindex = pd.DataFrame({'date': dates,\n",
      " |      ...                               'animal': ['falcon', 'parrot',\n",
      " |      ...                                          'falcon', 'parrot'],\n",
      " |      ...                               'speed': [350, 18, 361, 15]})\n",
      " |      >>> df_multiindex = df_multiindex.set_index(['date', 'animal'])\n",
      " |      \n",
      " |      >>> df_multiindex\n",
      " |                         speed\n",
      " |      date       animal\n",
      " |      2018-01-01 falcon    350\n",
      " |                 parrot     18\n",
      " |      2018-01-02 falcon    361\n",
      " |                 parrot     15\n",
      " |      \n",
      " |      >>> df_multiindex.to_xarray()  # doctest: +SKIP\n",
      " |      <xarray.Dataset>\n",
      " |      Dimensions:  (date: 2, animal: 2)\n",
      " |      Coordinates:\n",
      " |        * date     (date) datetime64[ns] 2018-01-01 2018-01-02\n",
      " |        * animal   (animal) object 'falcon' 'parrot'\n",
      " |      Data variables:\n",
      " |          speed    (date, animal) int64 350 18 361 15\n",
      " |  \n",
      " |  truncate(self, before=None, after=None, axis: 'Axis | None' = None, copy: 'bool_t | None' = None) -> 'Self'\n",
      " |      Truncate a Series or DataFrame before and after some index value.\n",
      " |      \n",
      " |      This is a useful shorthand for boolean indexing based on index\n",
      " |      values above or below certain thresholds.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      before : date, str, int\n",
      " |          Truncate all rows before this index value.\n",
      " |      after : date, str, int\n",
      " |          Truncate all rows after this index value.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, optional\n",
      " |          Axis to truncate. Truncates the index (rows) by default.\n",
      " |          For `Series` this parameter is unused and defaults to 0.\n",
      " |      copy : bool, default is True,\n",
      " |          Return a copy of the truncated section.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      type of caller\n",
      " |          The truncated Series or DataFrame.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.loc : Select a subset of a DataFrame by label.\n",
      " |      DataFrame.iloc : Select a subset of a DataFrame by position.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      If the index being truncated contains only datetime values,\n",
      " |      `before` and `after` may be specified as strings instead of\n",
      " |      Timestamps.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({'A': ['a', 'b', 'c', 'd', 'e'],\n",
      " |      ...                    'B': ['f', 'g', 'h', 'i', 'j'],\n",
      " |      ...                    'C': ['k', 'l', 'm', 'n', 'o']},\n",
      " |      ...                   index=[1, 2, 3, 4, 5])\n",
      " |      >>> df\n",
      " |         A  B  C\n",
      " |      1  a  f  k\n",
      " |      2  b  g  l\n",
      " |      3  c  h  m\n",
      " |      4  d  i  n\n",
      " |      5  e  j  o\n",
      " |      \n",
      " |      >>> df.truncate(before=2, after=4)\n",
      " |         A  B  C\n",
      " |      2  b  g  l\n",
      " |      3  c  h  m\n",
      " |      4  d  i  n\n",
      " |      \n",
      " |      The columns of a DataFrame can be truncated.\n",
      " |      \n",
      " |      >>> df.truncate(before=\"A\", after=\"B\", axis=\"columns\")\n",
      " |         A  B\n",
      " |      1  a  f\n",
      " |      2  b  g\n",
      " |      3  c  h\n",
      " |      4  d  i\n",
      " |      5  e  j\n",
      " |      \n",
      " |      For Series, only rows can be truncated.\n",
      " |      \n",
      " |      >>> df['A'].truncate(before=2, after=4)\n",
      " |      2    b\n",
      " |      3    c\n",
      " |      4    d\n",
      " |      Name: A, dtype: object\n",
      " |      \n",
      " |      The index values in ``truncate`` can be datetimes or string\n",
      " |      dates.\n",
      " |      \n",
      " |      >>> dates = pd.date_range('2016-01-01', '2016-02-01', freq='s')\n",
      " |      >>> df = pd.DataFrame(index=dates, data={'A': 1})\n",
      " |      >>> df.tail()\n",
      " |                           A\n",
      " |      2016-01-31 23:59:56  1\n",
      " |      2016-01-31 23:59:57  1\n",
      " |      2016-01-31 23:59:58  1\n",
      " |      2016-01-31 23:59:59  1\n",
      " |      2016-02-01 00:00:00  1\n",
      " |      \n",
      " |      >>> df.truncate(before=pd.Timestamp('2016-01-05'),\n",
      " |      ...             after=pd.Timestamp('2016-01-10')).tail()\n",
      " |                           A\n",
      " |      2016-01-09 23:59:56  1\n",
      " |      2016-01-09 23:59:57  1\n",
      " |      2016-01-09 23:59:58  1\n",
      " |      2016-01-09 23:59:59  1\n",
      " |      2016-01-10 00:00:00  1\n",
      " |      \n",
      " |      Because the index is a DatetimeIndex containing only dates, we can\n",
      " |      specify `before` and `after` as strings. They will be coerced to\n",
      " |      Timestamps before truncation.\n",
      " |      \n",
      " |      >>> df.truncate('2016-01-05', '2016-01-10').tail()\n",
      " |                           A\n",
      " |      2016-01-09 23:59:56  1\n",
      " |      2016-01-09 23:59:57  1\n",
      " |      2016-01-09 23:59:58  1\n",
      " |      2016-01-09 23:59:59  1\n",
      " |      2016-01-10 00:00:00  1\n",
      " |      \n",
      " |      Note that ``truncate`` assumes a 0 value for any unspecified time\n",
      " |      component (midnight). This differs from partial string slicing, which\n",
      " |      returns any partially matching dates.\n",
      " |      \n",
      " |      >>> df.loc['2016-01-05':'2016-01-10', :].tail()\n",
      " |                           A\n",
      " |      2016-01-10 23:59:55  1\n",
      " |      2016-01-10 23:59:56  1\n",
      " |      2016-01-10 23:59:57  1\n",
      " |      2016-01-10 23:59:58  1\n",
      " |      2016-01-10 23:59:59  1\n",
      " |  \n",
      " |  tz_convert(self, tz, axis: 'Axis' = 0, level=None, copy: 'bool_t | None' = None) -> 'Self'\n",
      " |      Convert tz-aware axis to target time zone.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      tz : str or tzinfo object or None\n",
      " |          Target time zone. Passing ``None`` will convert to\n",
      " |          UTC and remove the timezone information.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The axis to convert\n",
      " |      level : int, str, default None\n",
      " |          If axis is a MultiIndex, convert a specific level. Otherwise\n",
      " |          must be None.\n",
      " |      copy : bool, default True\n",
      " |          Also make a copy of the underlying data.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame\n",
      " |          Object with time zone converted axis.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |          If the axis is tz-naive.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Change to another time zone:\n",
      " |      \n",
      " |      >>> s = pd.Series(\n",
      " |      ...     [1],\n",
      " |      ...     index=pd.DatetimeIndex(['2018-09-15 01:30:00+02:00']),\n",
      " |      ... )\n",
      " |      >>> s.tz_convert('Asia/Shanghai')\n",
      " |      2018-09-15 07:30:00+08:00    1\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Pass None to convert to UTC and get a tz-naive index:\n",
      " |      \n",
      " |      >>> s = pd.Series([1],\n",
      " |      ...               index=pd.DatetimeIndex(['2018-09-15 01:30:00+02:00']))\n",
      " |      >>> s.tz_convert(None)\n",
      " |      2018-09-14 23:30:00    1\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  tz_localize(self, tz, axis: 'Axis' = 0, level=None, copy: 'bool_t | None' = None, ambiguous: 'TimeAmbiguous' = 'raise', nonexistent: 'TimeNonexistent' = 'raise') -> 'Self'\n",
      " |      Localize tz-naive index of a Series or DataFrame to target time zone.\n",
      " |      \n",
      " |      This operation localizes the Index. To localize the values in a\n",
      " |      timezone-naive Series, use :meth:`Series.dt.tz_localize`.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      tz : str or tzinfo or None\n",
      " |          Time zone to localize. Passing ``None`` will remove the\n",
      " |          time zone information and preserve local time.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          The axis to localize\n",
      " |      level : int, str, default None\n",
      " |          If axis ia a MultiIndex, localize a specific level. Otherwise\n",
      " |          must be None.\n",
      " |      copy : bool, default True\n",
      " |          Also make a copy of the underlying data.\n",
      " |      \n",
      " |          .. note::\n",
      " |              The `copy` keyword will change behavior in pandas 3.0.\n",
      " |              `Copy-on-Write\n",
      " |              <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n",
      " |              will be enabled by default, which means that all methods with a\n",
      " |              `copy` keyword will use a lazy copy mechanism to defer the copy and\n",
      " |              ignore the `copy` keyword. The `copy` keyword will be removed in a\n",
      " |              future version of pandas.\n",
      " |      \n",
      " |              You can already get the future behavior and improvements through\n",
      " |              enabling copy on write ``pd.options.mode.copy_on_write = True``\n",
      " |      ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'\n",
      " |          When clocks moved backward due to DST, ambiguous times may arise.\n",
      " |          For example in Central European Time (UTC+01), when going from\n",
      " |          03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at\n",
      " |          00:30:00 UTC and at 01:30:00 UTC. In such a situation, the\n",
      " |          `ambiguous` parameter dictates how ambiguous times should be\n",
      " |          handled.\n",
      " |      \n",
      " |          - 'infer' will attempt to infer fall dst-transition hours based on\n",
      " |            order\n",
      " |          - bool-ndarray where True signifies a DST time, False designates\n",
      " |            a non-DST time (note that this flag is only applicable for\n",
      " |            ambiguous times)\n",
      " |          - 'NaT' will return NaT where there are ambiguous times\n",
      " |          - 'raise' will raise an AmbiguousTimeError if there are ambiguous\n",
      " |            times.\n",
      " |      nonexistent : str, default 'raise'\n",
      " |          A nonexistent time does not exist in a particular timezone\n",
      " |          where clocks moved forward due to DST. Valid values are:\n",
      " |      \n",
      " |          - 'shift_forward' will shift the nonexistent time forward to the\n",
      " |            closest existing time\n",
      " |          - 'shift_backward' will shift the nonexistent time backward to the\n",
      " |            closest existing time\n",
      " |          - 'NaT' will return NaT where there are nonexistent times\n",
      " |          - timedelta objects will shift nonexistent times by the timedelta\n",
      " |          - 'raise' will raise an NonExistentTimeError if there are\n",
      " |            nonexistent times.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series/DataFrame\n",
      " |          Same type as the input.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      TypeError\n",
      " |          If the TimeSeries is tz-aware and tz is not None.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      Localize local times:\n",
      " |      \n",
      " |      >>> s = pd.Series(\n",
      " |      ...     [1],\n",
      " |      ...     index=pd.DatetimeIndex(['2018-09-15 01:30:00']),\n",
      " |      ... )\n",
      " |      >>> s.tz_localize('CET')\n",
      " |      2018-09-15 01:30:00+02:00    1\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Pass None to convert to tz-naive index and preserve local time:\n",
      " |      \n",
      " |      >>> s = pd.Series([1],\n",
      " |      ...               index=pd.DatetimeIndex(['2018-09-15 01:30:00+02:00']))\n",
      " |      >>> s.tz_localize(None)\n",
      " |      2018-09-15 01:30:00    1\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      Be careful with DST changes. When there is sequential data, pandas\n",
      " |      can infer the DST time:\n",
      " |      \n",
      " |      >>> s = pd.Series(range(7),\n",
      " |      ...               index=pd.DatetimeIndex(['2018-10-28 01:30:00',\n",
      " |      ...                                       '2018-10-28 02:00:00',\n",
      " |      ...                                       '2018-10-28 02:30:00',\n",
      " |      ...                                       '2018-10-28 02:00:00',\n",
      " |      ...                                       '2018-10-28 02:30:00',\n",
      " |      ...                                       '2018-10-28 03:00:00',\n",
      " |      ...                                       '2018-10-28 03:30:00']))\n",
      " |      >>> s.tz_localize('CET', ambiguous='infer')\n",
      " |      2018-10-28 01:30:00+02:00    0\n",
      " |      2018-10-28 02:00:00+02:00    1\n",
      " |      2018-10-28 02:30:00+02:00    2\n",
      " |      2018-10-28 02:00:00+01:00    3\n",
      " |      2018-10-28 02:30:00+01:00    4\n",
      " |      2018-10-28 03:00:00+01:00    5\n",
      " |      2018-10-28 03:30:00+01:00    6\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      In some cases, inferring the DST is impossible. In such cases, you can\n",
      " |      pass an ndarray to the ambiguous parameter to set the DST explicitly\n",
      " |      \n",
      " |      >>> s = pd.Series(range(3),\n",
      " |      ...               index=pd.DatetimeIndex(['2018-10-28 01:20:00',\n",
      " |      ...                                       '2018-10-28 02:36:00',\n",
      " |      ...                                       '2018-10-28 03:46:00']))\n",
      " |      >>> s.tz_localize('CET', ambiguous=np.array([True, True, False]))\n",
      " |      2018-10-28 01:20:00+02:00    0\n",
      " |      2018-10-28 02:36:00+02:00    1\n",
      " |      2018-10-28 03:46:00+01:00    2\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      If the DST transition causes nonexistent times, you can shift these\n",
      " |      dates forward or backward with a timedelta object or `'shift_forward'`\n",
      " |      or `'shift_backward'`.\n",
      " |      \n",
      " |      >>> s = pd.Series(range(2),\n",
      " |      ...               index=pd.DatetimeIndex(['2015-03-29 02:30:00',\n",
      " |      ...                                       '2015-03-29 03:30:00']))\n",
      " |      >>> s.tz_localize('Europe/Warsaw', nonexistent='shift_forward')\n",
      " |      2015-03-29 03:00:00+02:00    0\n",
      " |      2015-03-29 03:30:00+02:00    1\n",
      " |      dtype: int64\n",
      " |      >>> s.tz_localize('Europe/Warsaw', nonexistent='shift_backward')\n",
      " |      2015-03-29 01:59:59.999999999+01:00    0\n",
      " |      2015-03-29 03:30:00+02:00              1\n",
      " |      dtype: int64\n",
      " |      >>> s.tz_localize('Europe/Warsaw', nonexistent=pd.Timedelta('1h'))\n",
      " |      2015-03-29 03:30:00+02:00    0\n",
      " |      2015-03-29 03:30:00+02:00    1\n",
      " |      dtype: int64\n",
      " |  \n",
      " |  where(self, cond, other=nan, *, inplace: 'bool_t' = False, axis: 'Axis | None' = None, level: 'Level | None' = None) -> 'Self | None'\n",
      " |      Replace values where the condition is False.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      cond : bool Series/DataFrame, array-like, or callable\n",
      " |          Where `cond` is True, keep the original value. Where\n",
      " |          False, replace with corresponding value from `other`.\n",
      " |          If `cond` is callable, it is computed on the Series/DataFrame and\n",
      " |          should return boolean Series/DataFrame or array. The callable must\n",
      " |          not change input Series/DataFrame (though pandas doesn't check it).\n",
      " |      other : scalar, Series/DataFrame, or callable\n",
      " |          Entries where `cond` is False are replaced with\n",
      " |          corresponding value from `other`.\n",
      " |          If other is callable, it is computed on the Series/DataFrame and\n",
      " |          should return scalar or Series/DataFrame. The callable must not\n",
      " |          change input Series/DataFrame (though pandas doesn't check it).\n",
      " |          If not specified, entries will be filled with the corresponding\n",
      " |          NULL value (``np.nan`` for numpy dtypes, ``pd.NA`` for extension\n",
      " |          dtypes).\n",
      " |      inplace : bool, default False\n",
      " |          Whether to perform the operation in place on the data.\n",
      " |      axis : int, default None\n",
      " |          Alignment axis if needed. For `Series` this parameter is\n",
      " |          unused and defaults to 0.\n",
      " |      level : int, default None\n",
      " |          Alignment level if needed.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Same type as caller or None if ``inplace=True``.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      :func:`DataFrame.mask` : Return an object of same shape as\n",
      " |          self.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      The where method is an application of the if-then idiom. For each\n",
      " |      element in the calling DataFrame, if ``cond`` is ``True`` the\n",
      " |      element is used; otherwise the corresponding element from the DataFrame\n",
      " |      ``other`` is used. If the axis of ``other`` does not align with axis of\n",
      " |      ``cond`` Series/DataFrame, the misaligned index positions will be filled with\n",
      " |      False.\n",
      " |      \n",
      " |      The signature for :func:`DataFrame.where` differs from\n",
      " |      :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to\n",
      " |      ``np.where(m, df1, df2)``.\n",
      " |      \n",
      " |      For further details and examples see the ``where`` documentation in\n",
      " |      :ref:`indexing <indexing.where_mask>`.\n",
      " |      \n",
      " |      The dtype of the object takes precedence. The fill value is casted to\n",
      " |      the object's dtype, if this can be done losslessly.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> s = pd.Series(range(5))\n",
      " |      >>> s.where(s > 0)\n",
      " |      0    NaN\n",
      " |      1    1.0\n",
      " |      2    2.0\n",
      " |      3    3.0\n",
      " |      4    4.0\n",
      " |      dtype: float64\n",
      " |      >>> s.mask(s > 0)\n",
      " |      0    0.0\n",
      " |      1    NaN\n",
      " |      2    NaN\n",
      " |      3    NaN\n",
      " |      4    NaN\n",
      " |      dtype: float64\n",
      " |      \n",
      " |      >>> s = pd.Series(range(5))\n",
      " |      >>> t = pd.Series([True, False])\n",
      " |      >>> s.where(t, 99)\n",
      " |      0     0\n",
      " |      1    99\n",
      " |      2    99\n",
      " |      3    99\n",
      " |      4    99\n",
      " |      dtype: int64\n",
      " |      >>> s.mask(t, 99)\n",
      " |      0    99\n",
      " |      1     1\n",
      " |      2    99\n",
      " |      3    99\n",
      " |      4    99\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> s.where(s > 1, 10)\n",
      " |      0    10\n",
      " |      1    10\n",
      " |      2    2\n",
      " |      3    3\n",
      " |      4    4\n",
      " |      dtype: int64\n",
      " |      >>> s.mask(s > 1, 10)\n",
      " |      0     0\n",
      " |      1     1\n",
      " |      2    10\n",
      " |      3    10\n",
      " |      4    10\n",
      " |      dtype: int64\n",
      " |      \n",
      " |      >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])\n",
      " |      >>> df\n",
      " |         A  B\n",
      " |      0  0  1\n",
      " |      1  2  3\n",
      " |      2  4  5\n",
      " |      3  6  7\n",
      " |      4  8  9\n",
      " |      >>> m = df % 3 == 0\n",
      " |      >>> df.where(m, -df)\n",
      " |         A  B\n",
      " |      0  0 -1\n",
      " |      1 -2  3\n",
      " |      2 -4 -5\n",
      " |      3  6 -7\n",
      " |      4 -8  9\n",
      " |      >>> df.where(m, -df) == np.where(m, df, -df)\n",
      " |            A     B\n",
      " |      0  True  True\n",
      " |      1  True  True\n",
      " |      2  True  True\n",
      " |      3  True  True\n",
      " |      4  True  True\n",
      " |      >>> df.where(m, -df) == df.mask(~m, -df)\n",
      " |            A     B\n",
      " |      0  True  True\n",
      " |      1  True  True\n",
      " |      2  True  True\n",
      " |      3  True  True\n",
      " |      4  True  True\n",
      " |  \n",
      " |  xs(self, key: 'IndexLabel', axis: 'Axis' = 0, level: 'IndexLabel | None' = None, drop_level: 'bool_t' = True) -> 'Self'\n",
      " |      Return cross-section from the Series/DataFrame.\n",
      " |      \n",
      " |      This method takes a `key` argument to select data at a particular\n",
      " |      level of a MultiIndex.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      key : label or tuple of label\n",
      " |          Label contained in the index, or partially in a MultiIndex.\n",
      " |      axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      " |          Axis to retrieve cross-section on.\n",
      " |      level : object, defaults to first n levels (n=1 or len(key))\n",
      " |          In case of a key partially contained in a MultiIndex, indicate\n",
      " |          which levels are used. Levels can be referred by label or position.\n",
      " |      drop_level : bool, default True\n",
      " |          If False, returns object with same levels as self.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Series or DataFrame\n",
      " |          Cross-section from the original Series or DataFrame\n",
      " |          corresponding to the selected index levels.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.loc : Access a group of rows and columns\n",
      " |          by label(s) or a boolean array.\n",
      " |      DataFrame.iloc : Purely integer-location based indexing\n",
      " |          for selection by position.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      `xs` can not be used to set values.\n",
      " |      \n",
      " |      MultiIndex Slicers is a generic way to get/set values on\n",
      " |      any level or levels.\n",
      " |      It is a superset of `xs` functionality, see\n",
      " |      :ref:`MultiIndex Slicers <advanced.mi_slicers>`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> d = {'num_legs': [4, 4, 2, 2],\n",
      " |      ...      'num_wings': [0, 0, 2, 2],\n",
      " |      ...      'class': ['mammal', 'mammal', 'mammal', 'bird'],\n",
      " |      ...      'animal': ['cat', 'dog', 'bat', 'penguin'],\n",
      " |      ...      'locomotion': ['walks', 'walks', 'flies', 'walks']}\n",
      " |      >>> df = pd.DataFrame(data=d)\n",
      " |      >>> df = df.set_index(['class', 'animal', 'locomotion'])\n",
      " |      >>> df\n",
      " |                                 num_legs  num_wings\n",
      " |      class  animal  locomotion\n",
      " |      mammal cat     walks              4          0\n",
      " |             dog     walks              4          0\n",
      " |             bat     flies              2          2\n",
      " |      bird   penguin walks              2          2\n",
      " |      \n",
      " |      Get values at specified index\n",
      " |      \n",
      " |      >>> df.xs('mammal')\n",
      " |                         num_legs  num_wings\n",
      " |      animal locomotion\n",
      " |      cat    walks              4          0\n",
      " |      dog    walks              4          0\n",
      " |      bat    flies              2          2\n",
      " |      \n",
      " |      Get values at several indexes\n",
      " |      \n",
      " |      >>> df.xs(('mammal', 'dog', 'walks'))\n",
      " |      num_legs     4\n",
      " |      num_wings    0\n",
      " |      Name: (mammal, dog, walks), dtype: int64\n",
      " |      \n",
      " |      Get values at specified index and level\n",
      " |      \n",
      " |      >>> df.xs('cat', level=1)\n",
      " |                         num_legs  num_wings\n",
      " |      class  locomotion\n",
      " |      mammal walks              4          0\n",
      " |      \n",
      " |      Get values at several indexes and levels\n",
      " |      \n",
      " |      >>> df.xs(('bird', 'walks'),\n",
      " |      ...       level=[0, 'locomotion'])\n",
      " |               num_legs  num_wings\n",
      " |      animal\n",
      " |      penguin         2          2\n",
      " |      \n",
      " |      Get values at specified column and axis\n",
      " |      \n",
      " |      >>> df.xs('num_wings', axis=1)\n",
      " |      class   animal   locomotion\n",
      " |      mammal  cat      walks         0\n",
      " |              dog      walks         0\n",
      " |              bat      flies         2\n",
      " |      bird    penguin  walks         2\n",
      " |      Name: num_wings, dtype: int64\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from pandas.core.generic.NDFrame:\n",
      " |  \n",
      " |  flags\n",
      " |      Get the properties associated with this pandas object.\n",
      " |      \n",
      " |      The available flags are\n",
      " |      \n",
      " |      * :attr:`Flags.allows_duplicate_labels`\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      Flags : Flags that apply to pandas objects.\n",
      " |      DataFrame.attrs : Global metadata applying to this dataset.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      \"Flags\" differ from \"metadata\". Flags reflect properties of the\n",
      " |      pandas object (the Series or DataFrame). Metadata refer to properties\n",
      " |      of the dataset, and should be stored in :attr:`DataFrame.attrs`.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame({\"A\": [1, 2]})\n",
      " |      >>> df.flags\n",
      " |      <Flags(allows_duplicate_labels=True)>\n",
      " |      \n",
      " |      Flags can be get or set using ``.``\n",
      " |      \n",
      " |      >>> df.flags.allows_duplicate_labels\n",
      " |      True\n",
      " |      >>> df.flags.allows_duplicate_labels = False\n",
      " |      \n",
      " |      Or by slicing with a key\n",
      " |      \n",
      " |      >>> df.flags[\"allows_duplicate_labels\"]\n",
      " |      False\n",
      " |      >>> df.flags[\"allows_duplicate_labels\"] = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from pandas.core.generic.NDFrame:\n",
      " |  \n",
      " |  attrs\n",
      " |      Dictionary of global attributes of this dataset.\n",
      " |      \n",
      " |      .. warning::\n",
      " |      \n",
      " |         attrs is experimental and may change without warning.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.flags : Global flags applying to this object.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Many operations that create new datasets will copy ``attrs``. Copies\n",
      " |      are always deep so that changing ``attrs`` will only affect the\n",
      " |      present dataset. ``pandas.concat`` copies ``attrs`` only if all input\n",
      " |      datasets have the same ``attrs``.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      For Series:\n",
      " |      \n",
      " |      >>> ser = pd.Series([1, 2, 3])\n",
      " |      >>> ser.attrs = {\"A\": [10, 20, 30]}\n",
      " |      >>> ser.attrs\n",
      " |      {'A': [10, 20, 30]}\n",
      " |      \n",
      " |      For DataFrame:\n",
      " |      \n",
      " |      >>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})\n",
      " |      >>> df.attrs = {\"A\": [10, 20, 30]}\n",
      " |      >>> df.attrs\n",
      " |      {'A': [10, 20, 30]}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from pandas.core.base.PandasObject:\n",
      " |  \n",
      " |  __sizeof__(self) -> 'int'\n",
      " |      Generates the total memory usage for an object that returns\n",
      " |      either a value or Series of values\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from pandas.core.accessor.DirNamesMixin:\n",
      " |  \n",
      " |  __dir__(self) -> 'list[str]'\n",
      " |      Provide method name lookup and completion.\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      Only provide 'public' methods.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from pandas.core.indexing.IndexingMixin:\n",
      " |  \n",
      " |  at\n",
      " |      Access a single value for a row/column label pair.\n",
      " |      \n",
      " |      Similar to ``loc``, in that both provide label-based lookups. Use\n",
      " |      ``at`` if you only need to get or set a single value in a DataFrame\n",
      " |      or Series.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      KeyError\n",
      " |          If getting a value and 'label' does not exist in a DataFrame or Series.\n",
      " |      \n",
      " |      ValueError\n",
      " |          If row/column label pair is not a tuple or if any label\n",
      " |          from the pair is not a scalar for DataFrame.\n",
      " |          If label is list-like (*excluding* NamedTuple) for Series.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.at : Access a single value for a row/column pair by label.\n",
      " |      DataFrame.iat : Access a single value for a row/column pair by integer\n",
      " |          position.\n",
      " |      DataFrame.loc : Access a group of rows and columns by label(s).\n",
      " |      DataFrame.iloc : Access a group of rows and columns by integer\n",
      " |          position(s).\n",
      " |      Series.at : Access a single value by label.\n",
      " |      Series.iat : Access a single value by integer position.\n",
      " |      Series.loc : Access a group of rows by label(s).\n",
      " |      Series.iloc : Access a group of rows by integer position(s).\n",
      " |      \n",
      " |      Notes\n",
      " |      -----\n",
      " |      See :ref:`Fast scalar value getting and setting <indexing.basics.get_value>`\n",
      " |      for more details.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],\n",
      " |      ...                   index=[4, 5, 6], columns=['A', 'B', 'C'])\n",
      " |      >>> df\n",
      " |          A   B   C\n",
      " |      4   0   2   3\n",
      " |      5   0   4   1\n",
      " |      6  10  20  30\n",
      " |      \n",
      " |      Get value at specified row/column pair\n",
      " |      \n",
      " |      >>> df.at[4, 'B']\n",
      " |      2\n",
      " |      \n",
      " |      Set value at specified row/column pair\n",
      " |      \n",
      " |      >>> df.at[4, 'B'] = 10\n",
      " |      >>> df.at[4, 'B']\n",
      " |      10\n",
      " |      \n",
      " |      Get value within a Series\n",
      " |      \n",
      " |      >>> df.loc[5].at['B']\n",
      " |      4\n",
      " |  \n",
      " |  iat\n",
      " |      Access a single value for a row/column pair by integer position.\n",
      " |      \n",
      " |      Similar to ``iloc``, in that both provide integer-based lookups. Use\n",
      " |      ``iat`` if you only need to get or set a single value in a DataFrame\n",
      " |      or Series.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      IndexError\n",
      " |          When integer position is out of bounds.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.at : Access a single value for a row/column label pair.\n",
      " |      DataFrame.loc : Access a group of rows and columns by label(s).\n",
      " |      DataFrame.iloc : Access a group of rows and columns by integer position(s).\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],\n",
      " |      ...                   columns=['A', 'B', 'C'])\n",
      " |      >>> df\n",
      " |          A   B   C\n",
      " |      0   0   2   3\n",
      " |      1   0   4   1\n",
      " |      2  10  20  30\n",
      " |      \n",
      " |      Get value at specified row/column pair\n",
      " |      \n",
      " |      >>> df.iat[1, 2]\n",
      " |      1\n",
      " |      \n",
      " |      Set value at specified row/column pair\n",
      " |      \n",
      " |      >>> df.iat[1, 2] = 10\n",
      " |      >>> df.iat[1, 2]\n",
      " |      10\n",
      " |      \n",
      " |      Get value within a series\n",
      " |      \n",
      " |      >>> df.loc[0].iat[1]\n",
      " |      2\n",
      " |  \n",
      " |  iloc\n",
      " |      Purely integer-location based indexing for selection by position.\n",
      " |      \n",
      " |      .. deprecated:: 2.2.0\n",
      " |      \n",
      " |         Returning a tuple from a callable is deprecated.\n",
      " |      \n",
      " |      ``.iloc[]`` is primarily integer position based (from ``0`` to\n",
      " |      ``length-1`` of the axis), but may also be used with a boolean\n",
      " |      array.\n",
      " |      \n",
      " |      Allowed inputs are:\n",
      " |      \n",
      " |      - An integer, e.g. ``5``.\n",
      " |      - A list or array of integers, e.g. ``[4, 3, 0]``.\n",
      " |      - A slice object with ints, e.g. ``1:7``.\n",
      " |      - A boolean array.\n",
      " |      - A ``callable`` function with one argument (the calling Series or\n",
      " |        DataFrame) and that returns valid output for indexing (one of the above).\n",
      " |        This is useful in method chains, when you don't have a reference to the\n",
      " |        calling object, but would like to base your selection on\n",
      " |        some value.\n",
      " |      - A tuple of row and column indexes. The tuple elements consist of one of the\n",
      " |        above inputs, e.g. ``(0, 1)``.\n",
      " |      \n",
      " |      ``.iloc`` will raise ``IndexError`` if a requested indexer is\n",
      " |      out-of-bounds, except *slice* indexers which allow out-of-bounds\n",
      " |      indexing (this conforms with python/numpy *slice* semantics).\n",
      " |      \n",
      " |      See more at :ref:`Selection by Position <indexing.integer>`.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.iat : Fast integer location scalar accessor.\n",
      " |      DataFrame.loc : Purely label-location based indexer for selection by label.\n",
      " |      Series.iloc : Purely integer-location based indexing for\n",
      " |                     selection by position.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},\n",
      " |      ...           {'a': 100, 'b': 200, 'c': 300, 'd': 400},\n",
      " |      ...           {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}]\n",
      " |      >>> df = pd.DataFrame(mydict)\n",
      " |      >>> df\n",
      " |            a     b     c     d\n",
      " |      0     1     2     3     4\n",
      " |      1   100   200   300   400\n",
      " |      2  1000  2000  3000  4000\n",
      " |      \n",
      " |      **Indexing just the rows**\n",
      " |      \n",
      " |      With a scalar integer.\n",
      " |      \n",
      " |      >>> type(df.iloc[0])\n",
      " |      <class 'pandas.core.series.Series'>\n",
      " |      >>> df.iloc[0]\n",
      " |      a    1\n",
      " |      b    2\n",
      " |      c    3\n",
      " |      d    4\n",
      " |      Name: 0, dtype: int64\n",
      " |      \n",
      " |      With a list of integers.\n",
      " |      \n",
      " |      >>> df.iloc[[0]]\n",
      " |         a  b  c  d\n",
      " |      0  1  2  3  4\n",
      " |      >>> type(df.iloc[[0]])\n",
      " |      <class 'pandas.core.frame.DataFrame'>\n",
      " |      \n",
      " |      >>> df.iloc[[0, 1]]\n",
      " |           a    b    c    d\n",
      " |      0    1    2    3    4\n",
      " |      1  100  200  300  400\n",
      " |      \n",
      " |      With a `slice` object.\n",
      " |      \n",
      " |      >>> df.iloc[:3]\n",
      " |            a     b     c     d\n",
      " |      0     1     2     3     4\n",
      " |      1   100   200   300   400\n",
      " |      2  1000  2000  3000  4000\n",
      " |      \n",
      " |      With a boolean mask the same length as the index.\n",
      " |      \n",
      " |      >>> df.iloc[[True, False, True]]\n",
      " |            a     b     c     d\n",
      " |      0     1     2     3     4\n",
      " |      2  1000  2000  3000  4000\n",
      " |      \n",
      " |      With a callable, useful in method chains. The `x` passed\n",
      " |      to the ``lambda`` is the DataFrame being sliced. This selects\n",
      " |      the rows whose index label even.\n",
      " |      \n",
      " |      >>> df.iloc[lambda x: x.index % 2 == 0]\n",
      " |            a     b     c     d\n",
      " |      0     1     2     3     4\n",
      " |      2  1000  2000  3000  4000\n",
      " |      \n",
      " |      **Indexing both axes**\n",
      " |      \n",
      " |      You can mix the indexer types for the index and columns. Use ``:`` to\n",
      " |      select the entire axis.\n",
      " |      \n",
      " |      With scalar integers.\n",
      " |      \n",
      " |      >>> df.iloc[0, 1]\n",
      " |      2\n",
      " |      \n",
      " |      With lists of integers.\n",
      " |      \n",
      " |      >>> df.iloc[[0, 2], [1, 3]]\n",
      " |            b     d\n",
      " |      0     2     4\n",
      " |      2  2000  4000\n",
      " |      \n",
      " |      With `slice` objects.\n",
      " |      \n",
      " |      >>> df.iloc[1:3, 0:3]\n",
      " |            a     b     c\n",
      " |      1   100   200   300\n",
      " |      2  1000  2000  3000\n",
      " |      \n",
      " |      With a boolean array whose length matches the columns.\n",
      " |      \n",
      " |      >>> df.iloc[:, [True, False, True, False]]\n",
      " |            a     c\n",
      " |      0     1     3\n",
      " |      1   100   300\n",
      " |      2  1000  3000\n",
      " |      \n",
      " |      With a callable function that expects the Series or DataFrame.\n",
      " |      \n",
      " |      >>> df.iloc[:, lambda df: [0, 2]]\n",
      " |            a     c\n",
      " |      0     1     3\n",
      " |      1   100   300\n",
      " |      2  1000  3000\n",
      " |  \n",
      " |  loc\n",
      " |      Access a group of rows and columns by label(s) or a boolean array.\n",
      " |      \n",
      " |      ``.loc[]`` is primarily label based, but may also be used with a\n",
      " |      boolean array.\n",
      " |      \n",
      " |      Allowed inputs are:\n",
      " |      \n",
      " |      - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is\n",
      " |        interpreted as a *label* of the index, and **never** as an\n",
      " |        integer position along the index).\n",
      " |      - A list or array of labels, e.g. ``['a', 'b', 'c']``.\n",
      " |      - A slice object with labels, e.g. ``'a':'f'``.\n",
      " |      \n",
      " |        .. warning:: Note that contrary to usual python slices, **both** the\n",
      " |            start and the stop are included\n",
      " |      \n",
      " |      - A boolean array of the same length as the axis being sliced,\n",
      " |        e.g. ``[True, False, True]``.\n",
      " |      - An alignable boolean Series. The index of the key will be aligned before\n",
      " |        masking.\n",
      " |      - An alignable Index. The Index of the returned selection will be the input.\n",
      " |      - A ``callable`` function with one argument (the calling Series or\n",
      " |        DataFrame) and that returns valid output for indexing (one of the above)\n",
      " |      \n",
      " |      See more at :ref:`Selection by Label <indexing.label>`.\n",
      " |      \n",
      " |      Raises\n",
      " |      ------\n",
      " |      KeyError\n",
      " |          If any items are not found.\n",
      " |      IndexingError\n",
      " |          If an indexed key is passed and its index is unalignable to the frame index.\n",
      " |      \n",
      " |      See Also\n",
      " |      --------\n",
      " |      DataFrame.at : Access a single value for a row/column label pair.\n",
      " |      DataFrame.iloc : Access group of rows and columns by integer position(s).\n",
      " |      DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the\n",
      " |                     Series/DataFrame.\n",
      " |      Series.loc : Access group of values using labels.\n",
      " |      \n",
      " |      Examples\n",
      " |      --------\n",
      " |      **Getting values**\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],\n",
      " |      ...                   index=['cobra', 'viper', 'sidewinder'],\n",
      " |      ...                   columns=['max_speed', 'shield'])\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra               1       2\n",
      " |      viper               4       5\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      Single label. Note this returns the row as a Series.\n",
      " |      \n",
      " |      >>> df.loc['viper']\n",
      " |      max_speed    4\n",
      " |      shield       5\n",
      " |      Name: viper, dtype: int64\n",
      " |      \n",
      " |      List of labels. Note using ``[[]]`` returns a DataFrame.\n",
      " |      \n",
      " |      >>> df.loc[['viper', 'sidewinder']]\n",
      " |                  max_speed  shield\n",
      " |      viper               4       5\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      Single label for row and column\n",
      " |      \n",
      " |      >>> df.loc['cobra', 'shield']\n",
      " |      2\n",
      " |      \n",
      " |      Slice with labels for row and single label for column. As mentioned\n",
      " |      above, note that both the start and stop of the slice are included.\n",
      " |      \n",
      " |      >>> df.loc['cobra':'viper', 'max_speed']\n",
      " |      cobra    1\n",
      " |      viper    4\n",
      " |      Name: max_speed, dtype: int64\n",
      " |      \n",
      " |      Boolean list with the same length as the row axis\n",
      " |      \n",
      " |      >>> df.loc[[False, False, True]]\n",
      " |                  max_speed  shield\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      Alignable boolean Series:\n",
      " |      \n",
      " |      >>> df.loc[pd.Series([False, True, False],\n",
      " |      ...                  index=['viper', 'sidewinder', 'cobra'])]\n",
      " |                           max_speed  shield\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      Index (same behavior as ``df.reindex``)\n",
      " |      \n",
      " |      >>> df.loc[pd.Index([\"cobra\", \"viper\"], name=\"foo\")]\n",
      " |             max_speed  shield\n",
      " |      foo\n",
      " |      cobra          1       2\n",
      " |      viper          4       5\n",
      " |      \n",
      " |      Conditional that returns a boolean Series\n",
      " |      \n",
      " |      >>> df.loc[df['shield'] > 6]\n",
      " |                  max_speed  shield\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      Conditional that returns a boolean Series with column labels specified\n",
      " |      \n",
      " |      >>> df.loc[df['shield'] > 6, ['max_speed']]\n",
      " |                  max_speed\n",
      " |      sidewinder          7\n",
      " |      \n",
      " |      Multiple conditional using ``&`` that returns a boolean Series\n",
      " |      \n",
      " |      >>> df.loc[(df['max_speed'] > 1) & (df['shield'] < 8)]\n",
      " |                  max_speed  shield\n",
      " |      viper          4       5\n",
      " |      \n",
      " |      Multiple conditional using ``|`` that returns a boolean Series\n",
      " |      \n",
      " |      >>> df.loc[(df['max_speed'] > 4) | (df['shield'] < 5)]\n",
      " |                  max_speed  shield\n",
      " |      cobra               1       2\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      Please ensure that each condition is wrapped in parentheses ``()``.\n",
      " |      See the :ref:`user guide<indexing.boolean>`\n",
      " |      for more details and explanations of Boolean indexing.\n",
      " |      \n",
      " |      .. note::\n",
      " |          If you find yourself using 3 or more conditionals in ``.loc[]``,\n",
      " |          consider using :ref:`advanced indexing<advanced.advanced_hierarchical>`.\n",
      " |      \n",
      " |          See below for using ``.loc[]`` on MultiIndex DataFrames.\n",
      " |      \n",
      " |      Callable that returns a boolean Series\n",
      " |      \n",
      " |      >>> df.loc[lambda df: df['shield'] == 8]\n",
      " |                  max_speed  shield\n",
      " |      sidewinder          7       8\n",
      " |      \n",
      " |      **Setting values**\n",
      " |      \n",
      " |      Set value for all items matching the list of labels\n",
      " |      \n",
      " |      >>> df.loc[['viper', 'sidewinder'], ['shield']] = 50\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra               1       2\n",
      " |      viper               4      50\n",
      " |      sidewinder          7      50\n",
      " |      \n",
      " |      Set value for an entire row\n",
      " |      \n",
      " |      >>> df.loc['cobra'] = 10\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra              10      10\n",
      " |      viper               4      50\n",
      " |      sidewinder          7      50\n",
      " |      \n",
      " |      Set value for an entire column\n",
      " |      \n",
      " |      >>> df.loc[:, 'max_speed'] = 30\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra              30      10\n",
      " |      viper              30      50\n",
      " |      sidewinder         30      50\n",
      " |      \n",
      " |      Set value for rows matching callable condition\n",
      " |      \n",
      " |      >>> df.loc[df['shield'] > 35] = 0\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra              30      10\n",
      " |      viper               0       0\n",
      " |      sidewinder          0       0\n",
      " |      \n",
      " |      Add value matching location\n",
      " |      \n",
      " |      >>> df.loc[\"viper\", \"shield\"] += 5\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra              30      10\n",
      " |      viper               0       5\n",
      " |      sidewinder          0       0\n",
      " |      \n",
      " |      Setting using a ``Series`` or a ``DataFrame`` sets the values matching the\n",
      " |      index labels, not the index positions.\n",
      " |      \n",
      " |      >>> shuffled_df = df.loc[[\"viper\", \"cobra\", \"sidewinder\"]]\n",
      " |      >>> df.loc[:] += shuffled_df\n",
      " |      >>> df\n",
      " |                  max_speed  shield\n",
      " |      cobra              60      20\n",
      " |      viper               0      10\n",
      " |      sidewinder          0       0\n",
      " |      \n",
      " |      **Getting values on a DataFrame with an index that has integer labels**\n",
      " |      \n",
      " |      Another example using integers for the index\n",
      " |      \n",
      " |      >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],\n",
      " |      ...                   index=[7, 8, 9], columns=['max_speed', 'shield'])\n",
      " |      >>> df\n",
      " |         max_speed  shield\n",
      " |      7          1       2\n",
      " |      8          4       5\n",
      " |      9          7       8\n",
      " |      \n",
      " |      Slice with integer labels for rows. As mentioned above, note that both\n",
      " |      the start and stop of the slice are included.\n",
      " |      \n",
      " |      >>> df.loc[7:9]\n",
      " |         max_speed  shield\n",
      " |      7          1       2\n",
      " |      8          4       5\n",
      " |      9          7       8\n",
      " |      \n",
      " |      **Getting values with a MultiIndex**\n",
      " |      \n",
      " |      A number of examples using a DataFrame with a MultiIndex\n",
      " |      \n",
      " |      >>> tuples = [\n",
      " |      ...     ('cobra', 'mark i'), ('cobra', 'mark ii'),\n",
      " |      ...     ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),\n",
      " |      ...     ('viper', 'mark ii'), ('viper', 'mark iii')\n",
      " |      ... ]\n",
      " |      >>> index = pd.MultiIndex.from_tuples(tuples)\n",
      " |      >>> values = [[12, 2], [0, 4], [10, 20],\n",
      " |      ...           [1, 4], [7, 1], [16, 36]]\n",
      " |      >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)\n",
      " |      >>> df\n",
      " |                           max_speed  shield\n",
      " |      cobra      mark i           12       2\n",
      " |                 mark ii           0       4\n",
      " |      sidewinder mark i           10      20\n",
      " |                 mark ii           1       4\n",
      " |      viper      mark ii           7       1\n",
      " |                 mark iii         16      36\n",
      " |      \n",
      " |      Single label. Note this returns a DataFrame with a single index.\n",
      " |      \n",
      " |      >>> df.loc['cobra']\n",
      " |               max_speed  shield\n",
      " |      mark i          12       2\n",
      " |      mark ii          0       4\n",
      " |      \n",
      " |      Single index tuple. Note this returns a Series.\n",
      " |      \n",
      " |      >>> df.loc[('cobra', 'mark ii')]\n",
      " |      max_speed    0\n",
      " |      shield       4\n",
      " |      Name: (cobra, mark ii), dtype: int64\n",
      " |      \n",
      " |      Single label for row and column. Similar to passing in a tuple, this\n",
      " |      returns a Series.\n",
      " |      \n",
      " |      >>> df.loc['cobra', 'mark i']\n",
      " |      max_speed    12\n",
      " |      shield        2\n",
      " |      Name: (cobra, mark i), dtype: int64\n",
      " |      \n",
      " |      Single tuple. Note using ``[[]]`` returns a DataFrame.\n",
      " |      \n",
      " |      >>> df.loc[[('cobra', 'mark ii')]]\n",
      " |                     max_speed  shield\n",
      " |      cobra mark ii          0       4\n",
      " |      \n",
      " |      Single tuple for the index with a single label for the column\n",
      " |      \n",
      " |      >>> df.loc[('cobra', 'mark i'), 'shield']\n",
      " |      2\n",
      " |      \n",
      " |      Slice from index tuple to single label\n",
      " |      \n",
      " |      >>> df.loc[('cobra', 'mark i'):'viper']\n",
      " |                           max_speed  shield\n",
      " |      cobra      mark i           12       2\n",
      " |                 mark ii           0       4\n",
      " |      sidewinder mark i           10      20\n",
      " |                 mark ii           1       4\n",
      " |      viper      mark ii           7       1\n",
      " |                 mark iii         16      36\n",
      " |      \n",
      " |      Slice from index tuple to index tuple\n",
      " |      \n",
      " |      >>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')]\n",
      " |                          max_speed  shield\n",
      " |      cobra      mark i          12       2\n",
      " |                 mark ii          0       4\n",
      " |      sidewinder mark i          10      20\n",
      " |                 mark ii          1       4\n",
      " |      viper      mark ii          7       1\n",
      " |      \n",
      " |      Please see the :ref:`user guide<advanced.advanced_hierarchical>`\n",
      " |      for more details and explanations of advanced indexing.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(pd.Series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;31mInit signature:\u001b[0m\n",
      "\u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mSeries\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n",
      "\u001b[0m    \u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
      "\u001b[0m    \u001b[0mindex\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
      "\u001b[0m    \u001b[0mdtype\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'Dtype | None'\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
      "\u001b[0m    \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
      "\u001b[0m    \u001b[0mcopy\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'bool | None'\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
      "\u001b[0m    \u001b[0mfastpath\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'bool | lib.NoDefault'\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m<\u001b[0m\u001b[0mno_default\u001b[0m\u001b[1;33m>\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
      "\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;34m'None'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mDocstring:\u001b[0m     \n",
      "One-dimensional ndarray with axis labels (including time series).\n",
      "\n",
      "Labels need not be unique but must be a hashable type. The object\n",
      "supports both integer- and label-based indexing and provides a host of\n",
      "methods for performing operations involving the index. Statistical\n",
      "methods from ndarray have been overridden to automatically exclude\n",
      "missing data (currently represented as NaN).\n",
      "\n",
      "Operations between Series (+, -, /, \\*, \\*\\*) align values based on their\n",
      "associated index values-- they need not be the same length. The result\n",
      "index will be the sorted union of the two indexes.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "data : array-like, Iterable, dict, or scalar value\n",
      "    Contains data stored in Series. If data is a dict, argument order is\n",
      "    maintained.\n",
      "index : array-like or Index (1d)\n",
      "    Values must be hashable and have the same length as `data`.\n",
      "    Non-unique index values are allowed. Will default to\n",
      "    RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like\n",
      "    and index is None, then the keys in the data are used as the index. If the\n",
      "    index is not None, the resulting Series is reindexed with the index values.\n",
      "dtype : str, numpy.dtype, or ExtensionDtype, optional\n",
      "    Data type for the output Series. If not specified, this will be\n",
      "    inferred from `data`.\n",
      "    See the :ref:`user guide <basics.dtypes>` for more usages.\n",
      "name : Hashable, default None\n",
      "    The name to give to the Series.\n",
      "copy : bool, default False\n",
      "    Copy input data. Only affects Series or 1d ndarray input. See examples.\n",
      "\n",
      "Notes\n",
      "-----\n",
      "Please reference the :ref:`User Guide <basics.series>` for more information.\n",
      "\n",
      "Examples\n",
      "--------\n",
      "Constructing Series from a dictionary with an Index specified\n",
      "\n",
      ">>> d = {'a': 1, 'b': 2, 'c': 3}\n",
      ">>> ser = pd.Series(data=d, index=['a', 'b', 'c'])\n",
      ">>> ser\n",
      "a   1\n",
      "b   2\n",
      "c   3\n",
      "dtype: int64\n",
      "\n",
      "The keys of the dictionary match with the Index values, hence the Index\n",
      "values have no effect.\n",
      "\n",
      ">>> d = {'a': 1, 'b': 2, 'c': 3}\n",
      ">>> ser = pd.Series(data=d, index=['x', 'y', 'z'])\n",
      ">>> ser\n",
      "x   NaN\n",
      "y   NaN\n",
      "z   NaN\n",
      "dtype: float64\n",
      "\n",
      "Note that the Index is first build with the keys from the dictionary.\n",
      "After this the Series is reindexed with the given Index values, hence we\n",
      "get all NaN as a result.\n",
      "\n",
      "Constructing Series from a list with `copy=False`.\n",
      "\n",
      ">>> r = [1, 2]\n",
      ">>> ser = pd.Series(r, copy=False)\n",
      ">>> ser.iloc[0] = 999\n",
      ">>> r\n",
      "[1, 2]\n",
      ">>> ser\n",
      "0    999\n",
      "1      2\n",
      "dtype: int64\n",
      "\n",
      "Due to input data type the Series has a `copy` of\n",
      "the original data even though `copy=False`, so\n",
      "the data is unchanged.\n",
      "\n",
      "Constructing Series from a 1d ndarray with `copy=False`.\n",
      "\n",
      ">>> r = np.array([1, 2])\n",
      ">>> ser = pd.Series(r, copy=False)\n",
      ">>> ser.iloc[0] = 999\n",
      ">>> r\n",
      "array([999,   2])\n",
      ">>> ser\n",
      "0    999\n",
      "1      2\n",
      "dtype: int64\n",
      "\n",
      "Due to input data type the Series has a `view` on\n",
      "the original data, so\n",
      "the data is changed as well.\n",
      "\u001b[1;31mFile:\u001b[0m           c:\\users\\duman\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages\\pandas\\core\\series.py\n",
      "\u001b[1;31mType:\u001b[0m           type\n",
      "\u001b[1;31mSubclasses:\u001b[0m     SubclassedSeries"
     ]
    }
   ],
   "source": [
    "?pd.Series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-04T02:25:24.096368Z",
     "start_time": "2023-04-04T02:25:24.083371Z"
    }
   },
   "source": [
    "# <font color='green'> <b>Pandas Series </b><font color='black'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='blue'> <b>Creating a Pandas Series</b><font color='black'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can hold many types of data, including objects, floats, strings, and integers.\n",
    "\n",
    "You can create a series by calling pandas.Series().\n",
    "\n",
    "A list, numpy array, and dictionary can be converted to a pandas series.\n",
    "\n",
    "Axis labels are collectively referred to as the index.\n",
    "\n",
    "Let's not forget that the difference between pandas series and numpy arrays is that pandas series hold values along with their indices.\n",
    "\n",
    "[SOURCE01](https://pandas.pydata.org/docs/reference/api/pandas.Series.html), \n",
    "[SOURCE02](https://www.datasciencemadesimple.com/create-series-in-python-pandas/), \n",
    "[SOURCE03](https://www.geeksforgeeks.org/creating-a-pandas-series/),\n",
    "[SOURCE04](https://towardsdatascience.com/pandas-series-a-lightweight-intro-b7963a0d62a2), \n",
    "[SOURCE05](https://www.educba.com/pandas-series/), \n",
    "[SOURCE06](http://www.rebellionrider.com/python-pandas-series-in-detail-part-1/), \n",
    "[SOURCE07](https://www.javatpoint.com/python-pandas-series), \n",
    "[SOURCE08](https://towardsdatascience.com/20-examples-to-master-pandas-series-bc4c68200324) &\n",
    "[SOURCE09](https://pythonbasics.org/pandas-series/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='blue'> <b> Using Lists</b><font color='black'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_1 = [\"Mustafa\", \"Sedat\", \"Metehan\", \"Tulay\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Mustafa\n",
       "1      Sedat\n",
       "2    Metehan\n",
       "3      Tulay\n",
       "dtype: object"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(liste_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    Mustafa\n",
       "1      Sedat\n",
       "2    Metehan\n",
       "3      Tulay\n",
       "dtype: object"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_1 = pd.Series(liste_1)\n",
    "seri_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(seri_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('O')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_1.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1.5', '3', 'orkun'], dtype='<U32')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([1.5, 3, \"orkun\"])\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      1.5\n",
       "1        3\n",
       "2    orkun\n",
       "dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_2 = pd.Series(arr1)\n",
    "seri_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1.5\n",
       "1    3.0\n",
       "2    4.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_3 = pd.Series([1.5, 3, 4.5])\n",
    "seri_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    3\n",
       "2    4\n",
       "dtype: int32"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_4 = pd.Series([1.5, 3, 4.5]).astype(int)\n",
    "seri_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sıfır    1.5\n",
       "bir      3.0\n",
       "iki      4.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_5 = pd.Series([1.5, 3, 4.5], index= [\"sıfır\", \"bir\", \"iki\"])\n",
    "seri_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Length of values (3) does not match length of index (4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[17], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSeries\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4.5\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msıfır\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mbir\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43miki\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43müç\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m#4 index verdiğimiz için hata aldık\u001b[39;00m\n",
      "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python311\\site-packages\\pandas\\core\\series.py:575\u001b[0m, in \u001b[0;36mSeries.__init__\u001b[1;34m(self, data, index, dtype, name, copy, fastpath)\u001b[0m\n\u001b[0;32m    573\u001b[0m     index \u001b[38;5;241m=\u001b[39m default_index(\u001b[38;5;28mlen\u001b[39m(data))\n\u001b[0;32m    574\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_list_like(data):\n\u001b[1;32m--> 575\u001b[0m     \u001b[43mcom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequire_length_match\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    577\u001b[0m \u001b[38;5;66;03m# create/copy the manager\u001b[39;00m\n\u001b[0;32m    578\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(data, (SingleBlockManager, SingleArrayManager)):\n",
      "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python311\\site-packages\\pandas\\core\\common.py:573\u001b[0m, in \u001b[0;36mrequire_length_match\u001b[1;34m(data, index)\u001b[0m\n\u001b[0;32m    569\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    570\u001b[0m \u001b[38;5;124;03mCheck the length of data matches the length of the index.\u001b[39;00m\n\u001b[0;32m    571\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    572\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(data) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(index):\n\u001b[1;32m--> 573\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    574\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLength of values \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    575\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m(\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(data)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m) \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    576\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdoes not match length of index \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    577\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m(\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(index)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    578\u001b[0m     )\n",
      "\u001b[1;31mValueError\u001b[0m: Length of values (3) does not match length of index (4)"
     ]
    }
   ],
   "source": [
    "pd.Series([1.5, 3, 4.5], index= [\"sıfır\", \"bir\", \"iki\", \"üç\"])  #We received an error because we provided 4 indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sıfır    1.5\n",
       "bir      3.0\n",
       "bir      4.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([1.5, 3, 4.5], index= [\"sıfır\", \"bir\", \"bir\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='blue'> <b>Using NumPy Arrays</b><font color='black'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8,  9],\n",
       "       [10, 11, 12]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2 = np.arange(1,13).reshape(4,3)\n",
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Data must be 1-dimensional",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[25], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSeries\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr2\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\a\\anaconda3\\lib\\site-packages\\pandas\\core\\series.py:470\u001b[0m, in \u001b[0;36mSeries.__init__\u001b[1;34m(self, data, index, dtype, name, copy, fastpath)\u001b[0m\n\u001b[0;32m    468\u001b[0m         data \u001b[38;5;241m=\u001b[39m data\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m    469\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 470\u001b[0m     data \u001b[38;5;241m=\u001b[39m \u001b[43msanitize_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    472\u001b[0m     manager \u001b[38;5;241m=\u001b[39m get_option(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmode.data_manager\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m    473\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m manager \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mblock\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n",
      "File \u001b[1;32mc:\\Users\\a\\anaconda3\\lib\\site-packages\\pandas\\core\\construction.py:647\u001b[0m, in \u001b[0;36msanitize_array\u001b[1;34m(data, index, dtype, copy, raise_cast_failure, allow_2d)\u001b[0m\n\u001b[0;32m    644\u001b[0m             subarr \u001b[38;5;241m=\u001b[39m cast(np\u001b[38;5;241m.\u001b[39mndarray, subarr)\n\u001b[0;32m    645\u001b[0m             subarr \u001b[38;5;241m=\u001b[39m maybe_infer_to_datetimelike(subarr)\n\u001b[1;32m--> 647\u001b[0m subarr \u001b[38;5;241m=\u001b[39m \u001b[43m_sanitize_ndim\u001b[49m\u001b[43m(\u001b[49m\u001b[43msubarr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallow_2d\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mallow_2d\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    649\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(subarr, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[0;32m    650\u001b[0m     \u001b[38;5;66;03m# at this point we should have dtype be None or subarr.dtype == dtype\u001b[39;00m\n\u001b[0;32m    651\u001b[0m     dtype \u001b[38;5;241m=\u001b[39m cast(np\u001b[38;5;241m.\u001b[39mdtype, dtype)\n",
      "File \u001b[1;32mc:\\Users\\a\\anaconda3\\lib\\site-packages\\pandas\\core\\construction.py:698\u001b[0m, in \u001b[0;36m_sanitize_ndim\u001b[1;34m(result, data, dtype, index, allow_2d)\u001b[0m\n\u001b[0;32m    696\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m allow_2d:\n\u001b[0;32m    697\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m result\n\u001b[1;32m--> 698\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mData must be 1-dimensional\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m    699\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_object_dtype(dtype) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(dtype, ExtensionDtype):\n\u001b[0;32m    700\u001b[0m     \u001b[38;5;66;03m# i.e. PandasDtype(\"O\")\u001b[39;00m\n\u001b[0;32m    702\u001b[0m     result \u001b[38;5;241m=\u001b[39m com\u001b[38;5;241m.\u001b[39masarray_tuplesafe(data, dtype\u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39mdtype(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n",
      "\u001b[1;31mValueError\u001b[0m: Data must be 1-dimensional"
     ]
    }
   ],
   "source": [
    "pd.Series(arr2)  #series should be 1 dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8,  9],\n",
       "       [10, 11, 12]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    0   1   2\n",
       "0   1   2   3\n",
       "1   4   5   6\n",
       "2   7   8   9\n",
       "3  10  11  12"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='blue'> <b>Using Dictionaries</b><font color='black'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Aslan': 24, 'Mustafa': 35, 'Şeyda': 30}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1 = {\"Aslan\": 24, \"Mustafa\": 35, \"Şeyda\": 30}\n",
    "dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aslan      24\n",
       "Mustafa    35\n",
       "Şeyda      30\n",
       "dtype: int64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "aa   NaN\n",
       "bb   NaN\n",
       "cc   NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_1, index= [\"aa\", \"bb\",\"cc\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aslan      24\n",
       "Mustafa    35\n",
       "Şeyda      30\n",
       "dtype: int64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_1, index= [\"Aslan\", \"Mustafa\", \"Şeyda\"]) #It will take the values as long as it finds the keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aslan    24\n",
       "Şeyda    30\n",
       "dtype: int64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_1, index= [\"Aslan\", \"Şeyda\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Aslan': 24, 'Mustafa': 35, 'Şeyda': 30}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'irem', 'age': 35, 'note': 4.8}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_2 = {\"name\": \"irem\", \"age\": 35, \"note\": 4.8}\n",
    "dict_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name    irem\n",
       "age       35\n",
       "note     4.8\n",
       "dtype: object"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name    irem\n",
       "age       35\n",
       "note     4.8\n",
       "job      NaN\n",
       "dtype: object"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_2, index = [\"name\", \"age\", \"note\", \"job\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name    irem\n",
       "age       35\n",
       "note     4.8\n",
       "5        NaN\n",
       "dtype: object"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(dict_2, index = [\"name\", \"age\", \"note\", 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='blue'> <b>Using Scalar Value</b><font color='black'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scalars are single values representing a data unit, such as an integer or a boolean, as opposed to data structures like lists or tuples composed of scalars.\n",
    "\n",
    "If the data is a scalar value, an index must be provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    10\n",
       "1    10\n",
       "2    10\n",
       "dtype: int64"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series([10,10,10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    10\n",
       "2    10\n",
       "3    10\n",
       "dtype: int64"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(10, index=[1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1     10\n",
       "2     10\n",
       "3     10\n",
       "4     10\n",
       "5     10\n",
       "6     10\n",
       "7     10\n",
       "8     10\n",
       "9     10\n",
       "10    10\n",
       "dtype: int64"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(10, index=range(1,11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <font color='blue'> <b>Creating a series by combining two series</b><font color='black'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      1.5\n",
       "1        3\n",
       "2    orkun\n",
       "dtype: object"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      1.5\n",
       "1        3\n",
       "2    orkun\n",
       "0      1.5\n",
       "1        3\n",
       "2    orkun\n",
       "dtype: object"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([seri_2, seri_2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sıfır    1.5\n",
       "bir      3.0\n",
       "iki      4.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0          1.5\n",
       "1            3\n",
       "2        orkun\n",
       "0          1.5\n",
       "1            3\n",
       "2        orkun\n",
       "sıfır      1.5\n",
       "bir        3.0\n",
       "iki        4.5\n",
       "dtype: object"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([seri_2, seri_2, seri_5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='blue'> <b>Indexing and Slicing with Pandas Series</b><font color='black'>"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Audi        1\n",
       "Bmw         2\n",
       "Renault     3\n",
       "Mercedes    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6 = pd.Series([1,2,3,4], index = [\"Audi\", \"Bmw\", \"Renault\", \"Mercedes\"])\n",
    "seri_6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Bmw        2\n",
       "Renault    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[\"Audi\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Audi        1\n",
       "Bmw         2\n",
       "Renault     3\n",
       "Mercedes    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[\"Audi\": \"Mercedes\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Bmw         2\n",
       "Renault     3\n",
       "Mercedes    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[\"Bmw\":]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Audi       1\n",
       "Renault    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[\"Audi\": \"Mercedes\" :2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Audi        1\n",
       "Mercedes    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_6[[\"Audi\", \"Mercedes\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'key of type tuple not found and not a MultiIndex'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[59], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mseri_6\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mAudi\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mMercedes\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\a\\anaconda3\\lib\\site-packages\\pandas\\core\\series.py:1007\u001b[0m, in \u001b[0;36mSeries.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   1004\u001b[0m     key \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39masarray(key, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mbool\u001b[39m)\n\u001b[0;32m   1005\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_values(key)\n\u001b[1;32m-> 1007\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_with\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\Users\\a\\anaconda3\\lib\\site-packages\\pandas\\core\\series.py:1022\u001b[0m, in \u001b[0;36mSeries._get_with\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   1017\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[0;32m   1018\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIndexing a Series with DataFrame is not \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1019\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msupported, use the appropriate DataFrame column\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1020\u001b[0m     )\n\u001b[0;32m   1021\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(key, \u001b[38;5;28mtuple\u001b[39m):\n\u001b[1;32m-> 1022\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_values_tuple\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1024\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_list_like(key):\n\u001b[0;32m   1025\u001b[0m     \u001b[38;5;66;03m# e.g. scalars that aren't recognized by lib.is_scalar, GH#32684\u001b[39;00m\n\u001b[0;32m   1026\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloc[key]\n",
      "File \u001b[1;32mc:\\Users\\a\\anaconda3\\lib\\site-packages\\pandas\\core\\series.py:1060\u001b[0m, in \u001b[0;36mSeries._get_values_tuple\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   1057\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m result\n\u001b[0;32m   1059\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex, MultiIndex):\n\u001b[1;32m-> 1060\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mkey of type tuple not found and not a MultiIndex\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m   1062\u001b[0m \u001b[38;5;66;03m# If key is contained, would have returned by now\u001b[39;00m\n\u001b[0;32m   1063\u001b[0m indexer, new_index \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mindex\u001b[38;5;241m.\u001b[39mget_loc_level(key)\n",
      "\u001b[1;31mKeyError\u001b[0m: 'key of type tuple not found and not a MultiIndex'"
     ]
    }
   ],
   "source": [
    "seri_6[\"Audi\", \"Mercedes\"]  #It doesn't accept with a single square bracket."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='blue'> <b>Basic Attributes & Methods of Series</b><font color='black'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SOME COMMON ATTRIBUTES** [Official Pandas API Document](https://pandas.pydata.org/docs/reference/api/pandas.Series.html)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Series.values:** Returns the values of the series as a Numpy array.\n",
    "\n",
    "**Series.index:** Returns the indices of the series.\n",
    "\n",
    "**Series.dtype:** Returns the data type of the series.\n",
    "\n",
    "**Series.size:** Returns the number of elements in the series.\n",
    "\n",
    "**Series.shape:** Returns the dimensions of the series.\n",
    "\n",
    "**Series.ndim:** Returns the number of dimensions of the series.\n",
    "\n",
    "**Series.head():** Returns the first n elements of the series.\n",
    "\n",
    "**Series.tail():** Returns the last n elements of the series.\n",
    "\n",
    "**Series.sample():** Returns a random n elements from the series.\n",
    "\n",
    "**Series.describe():** Returns the statistical summary of the series.\n",
    "\n",
    "**Series.sort_index:** Sorts the series by its indices.\n",
    "\n",
    "**Series.sort_values():** Sorts the series by its values.\n",
    "\n",
    "**Series.isnull():** Checks whether each element in the series is null (None).\n",
    "\n",
    "**Series.fillna():** Fills null values with a specified value.\n",
    "\n",
    "**Series.dropna():** Removes null values from the series.\n",
    "\n",
    "**Series.isin():** Checks whether the elements in the series are present in the given values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    34\n",
       "1    43\n",
       "2    42\n",
       "3    22\n",
       "4     5\n",
       "5    36\n",
       "6     6\n",
       "7    12\n",
       "dtype: int32"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(34)\n",
    "\n",
    "seri_7 = pd.Series(np.random.randint(1,51,8))\n",
    "seri_7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'numpy.ndarray' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[19], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mseri_7\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalues\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'numpy.ndarray' object is not callable"
     ]
    }
   ],
   "source": [
    "seri_7.values()  #We cannot call values by opening parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([34, 43, 42, 22,  5, 36,  6, 12])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_7.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=8, step=1)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_7.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bir    2\n",
       "iki    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_8 = pd.Series([2,5], index = [\"bir\", \"iki\"])\n",
    "seri_8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['bir', 'iki'], dtype='object')"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_8.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    34\n",
       "1    43\n",
       "2    42\n",
       "3    22\n",
       "4     5\n",
       "5    36\n",
       "6     6\n",
       "7    12\n",
       "dtype: int32"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_7.index[5]  #It outputs the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bir    2\n",
       "iki    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bir'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_8.index[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_7.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seri_7.size"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "341px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}